feat: mechanism to fingerprint arbitrary data

internal/fingerprint/fingerprint.go

@@ -0,0 +1,108 @@
+// Unless explicitly stated otherwise all files in this repository are licensed
+// under the Apache License Version 2.0.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2023-present Datadog, Inc.
+
+package fingerprint
+
+import (
+	"crypto/sha512"
+	"encoding/base64"
+	"hash"
+	"io"
+	"strconv"
+	"sync"
+)
+
+type Hasher struct {
+	hash hash.Hash
+}
+
+type Hashable interface {
+	Hash(h *Hasher) error
+}
+
+var pool = sync.Pool{New: func() any { return &Hasher{hash: sha512.New()} }}
+
+// New returns a [Hasher] from the pool, ready to use.
+func New() *Hasher {
+	h, _ := pool.Get().(*Hasher)
+	return h
+}
+
+// Close returns this [Hasher] to the pool.
+func (h *Hasher) Close() {
+	h.hash.Reset()
+	pool.Put(h)
+}
+
+// Finish obtains this [Hasher]'s current fingerprint. It does not change the
+// underlying state of the [Hasher].
+func (h *Hasher) Finish() string {
+	var buf [sha512.Size]byte
+	return base64.URLEncoding.EncodeToString(h.hash.Sum(buf[:0]))
+}
+
+// Named hashes a named list of values. This creates explicit grouping of the
+// values, avoiding that the concatenation of two things has a different hash
+// than those same two things one after the other.
+func (h *Hasher) Named(name string, vals ...Hashable) error {
+	var (
+		soh = []byte{0x01} // Start of key-value-pair beacon
+		sot = []byte{0x02} // Start of value & end of key beacon
+		etx = []byte{0x03} // End of key-value-pair beacon
+	)
+
+	if _, err := h.hash.Write(soh); err != nil {
+		return err
+	}
+
+	if _, err := io.WriteString(h.hash, name); err != nil {
+		return err
+	}
+
+	if _, err := h.hash.Write(sot); err != nil {
+		return err
+	}
+
+	for idx, val := range vals {
+		if _, err := h.hash.Write(soh); err != nil {
+			return err
+		}
+		if _, err := io.WriteString(h.hash, strconv.Itoa(idx)); err != nil {
+			return err
+		}
+		if _, err := h.hash.Write(sot); err != nil {
+			return err
+		}
+		if err := val.Hash(h); err != nil {
+			return err
+		}
+		if _, err := h.hash.Write(etx); err != nil {
+			return err
+		}
+	}
+
+	if _, err := h.hash.Write(etx); err != nil {
+		return err
+	}
+
+	_, err := io.WriteString(h.hash, name)
+	return err
+}
+
+// Fingerprint is a short-hand for creating a new [Hasher], calling
+// [Hashable.Hash] on the provided value (unless it is nil), and then returning
+// the [Hasher.Finish] result.
+func Fingerprint(val Hashable) (string, error) {
+	h := New()
+	defer h.Close()
+
+	if val != nil {
+		if err := val.Hash(h); err != nil {
+			return "", err
+		}
+	}
+
+	return h.Finish(), nil
+}

internal/fingerprint/fingerprint_test.go

@@ -0,0 +1,80 @@
+// Unless explicitly stated otherwise all files in this repository are licensed
+// under the Apache License Version 2.0.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2023-present Datadog, Inc.
+
+package fingerprint_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/DataDog/orchestrion/internal/fingerprint"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCast(t *testing.T) {
+	type mySlice []int
+	require.Equal(
+		t,
+		fingerprint.List[fingerprint.Int]{0, -1, -2},
+		fingerprint.Cast(mySlice{0, 1, 2}, func(i int) fingerprint.Int { return fingerprint.Int(-i) }),
+	)
+}
+
+func TestFingerprint(t *testing.T) {
+	cases := map[string]struct {
+		hashable fingerprint.Hashable
+		hash     string
+	}{
+		"nil": {
+			hashable: nil,
+			hash:     "z4PhNX7vuL3xVChQ1m2AB9Yg5AULVxXcg_SpIdNs6c5H0NE8XYXysP-DGNKHfuwvY7kxvUdBeoGlODJ6-SfaPg==",
+		},
+		"bool.true": {
+			hashable: fingerprint.Bool(true),
+			hash:     "kSDNX67wegjpcf8CSj_L6h46a0QUKm2CyijGxC5PhSWVvPU9gdd28QVBBFq9t8N5UGKUFdDcZsjYbGSlYG0y3g==",
+		},
+		"bool.false": {
+			hashable: fingerprint.Bool(false),
+			hash:     "cZ-mfu9JxLKiuD8MYr3diMEGqq234hrgV8iAK3AONvgf4_FEgS2LBdZtxmPZCLJWReFTJiz21FeqNOaEr54yjQ==",
+		},
+		"int": {
+			hashable: fingerprint.Int(0),
+			hash:     "MbygIJTreBJqUXsgaojHPPqexvcExwMNGCEsrOgg8CXwC_DqaNvz86VDbKY7U797-ArY1d59g1nQt_7Z28OrmQ==",
+		},
+		"string.empty": {
+			hashable: fingerprint.String(""),
+			hash:     "z4PhNX7vuL3xVChQ1m2AB9Yg5AULVxXcg_SpIdNs6c5H0NE8XYXysP-DGNKHfuwvY7kxvUdBeoGlODJ6-SfaPg==",
+		},
+		"string.test": {
+			hashable: fingerprint.String("test"),
+			hash:     "7iaw3Ur350mqGo7jwQrpkj9hiYB3Lkc_iBml1JQODbJ6wYX4oOHV-E-IvIh_1nsUNzLDBMxfqa2Ob1f1ACio_w==",
+		},
+		"list.empty": {
+			hashable: fingerprint.List[fingerprint.Hashable]{},
+			hash:     "694_EPPzcQS8IJWmv4sxWZrSlHzcKAJoolH265TUzk5OE1HPYVrIkRPsOHTn3ZIgYz8wuIqBln5yfhTio_MFqg==",
+		},
+		"list.items": {
+			hashable: fingerprint.List[fingerprint.Hashable]{fingerprint.Bool(true), fingerprint.Int(0), fingerprint.String("test")},
+			hash:     "RhBvcI5pNAl8TwC67UQypsmZTcj-Hbc9Zh2rAkTklU_rb4G8cORxp2dJHc1cPXq218SkkCCqPM4lU0te3a4Ufg==",
+		},
+		"map": {
+			hashable: fingerprint.Map(
+				map[int]bool{1: true, 2: false},
+				func(k int, v bool) (string, fingerprint.Bool) {
+					return fmt.Sprintf("key-%d", k), fingerprint.Bool(v)
+				},
+			),
+			hash: "X27oOwHUqLYTjDj82abW23Q5n1zyH2LnrHtzFE0vQfMUZcq5u-rUOuMKvrNxWd8GnvcJVLHc-lc8OJZhw07nFA==",
+		},
+	}
+
+	for name, tc := range cases {
+		t.Run(name, func(t *testing.T) {
+			hash, err := fingerprint.Fingerprint(tc.hashable)
+			require.NoError(t, err)
+			require.Equal(t, tc.hash, hash)
+		})
+	}
+}

internal/fingerprint/types.go

@@ -0,0 +1,91 @@
+// Unless explicitly stated otherwise all files in this repository are licensed
+// under the Apache License Version 2.0.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2023-present Datadog, Inc.
+
+package fingerprint
+
+import (
+	"io"
+	"slices"
+	"strconv"
+	"strings"
+)
+
+type Bool bool
+
+func (b Bool) Hash(h *Hasher) error {
+	_, err := io.WriteString(h.hash, strconv.FormatBool(bool(b)))
+	return err
+}
+
+type Int int
+
+func (i Int) Hash(h *Hasher) error {
+	_, err := io.WriteString(h.hash, strconv.Itoa(int(i)))
+	return err
+}
+
+type List[T Hashable] []T
+
+func (l List[T]) Hash(h *Hasher) error {
+	list := make([]Hashable, len(l)+1)
+	list[0] = Int(len(l))
+	for idx, val := range l {
+		list[idx+1] = val
+	}
+
+	return h.Named("list", list...)
+}
+
+type String string
+
+func (s String) Hash(h *Hasher) error {
+	_, err := io.WriteString(h.hash, string(s))
+	return err
+}
+
+func Cast[E any, T ~[]E, H Hashable](slice T, fn func(E) H) List[H] {
+	res := make(List[H], len(slice))
+	for idx, val := range slice {
+		res[idx] = fn(val)
+	}
+	return res
+}
+
+type (
+	mapped[T Hashable]     []mappedItem[T]
+	mappedItem[T Hashable] struct {
+		key string
+		val T
+	}
+)
+
+func Map[K comparable, V any, H Hashable](m map[K]V, fn func(K, V) (string, H)) mapped[H] {
+	res := make(mapped[H], 0, len(m))
+
+	for key, val := range m {
+		mkey, mval := fn(key, val)
+		res = append(res, mappedItem[H]{mkey, mval})
+	}
+
+	slices.SortFunc(res, func(l mappedItem[H], r mappedItem[H]) int {
+		return strings.Compare(l.key, r.key)
+	})
+
+	return res
+}
+
+func (m mapped[T]) Hash(h *Hasher) error {
+	list := make([]Hashable, len(m)+1)
+	list[0] = Int(len(m))
+	for idx, item := range m {
+		list[idx+1] = item
+	}
+
+	return h.Named("map", list...)
+}
+
+func (m mappedItem[T]) Hash(h *Hasher) error {
+	return h.Named(m.key, m.val)
+}

internal/injector/aspect/advice/advice.go

@@ -8,6 +8,7 @@
 package advice
 
 import (
+	"github.com/DataDog/orchestrion/internal/fingerprint"
 	"github.com/DataDog/orchestrion/internal/injector/aspect/context"
 	"github.com/dave/jennifer/jen"
 )
@@ -29,4 +30,6 @@ type Advice interface {
 	// short-circuit and not do anything; e.g. import injection may be skipped if
 	// the import already exists).
 	Apply(context.AdviceContext) (bool, error)
+
+	fingerprint.Hashable
 }

internal/injector/aspect/advice/assign.go

@@ -8,6 +8,7 @@
 import (
 	"fmt"
 
+	"github.com/DataDog/orchestrion/internal/fingerprint"
 	"github.com/DataDog/orchestrion/internal/injector/aspect/advice/code"
 	"github.com/DataDog/orchestrion/internal/injector/aspect/context"
 	"github.com/dave/dst"
@@ -16,10 +17,10 @@
 )
 
 type assignValue struct {
-	Template code.Template
+	Template *code.Template
 }
 
-func AssignValue(template code.Template) *assignValue {
+func AssignValue(template *code.Template) *assignValue {
 	return &assignValue{template}
 }
 
@@ -52,9 +53,13 @@
 	return jen.Qual(pkgPath, "AssignValue").Call(a.Template.AsCode())
 }
 
+func (a *assignValue) Hash(h *fingerprint.Hasher) error {
+	return h.Named("assign-value", a.Template)
+}
+
 func init() {
 	unmarshalers["assign-value"] = func(node *yaml.Node) (Advice, error) {
-		var template code.Template
+		var template *code.Template
 		if err := node.Decode(&template); err != nil {
 			return nil, err
 		}

internal/injector/aspect/advice/block.go

@@ -8,6 +8,7 @@
 import (
 	"fmt"
 
+	"github.com/DataDog/orchestrion/internal/fingerprint"
 	"github.com/DataDog/orchestrion/internal/injector/aspect/advice/code"
 	"github.com/DataDog/orchestrion/internal/injector/aspect/context"
 	"github.com/dave/dst"
@@ -16,13 +17,13 @@
 )
 
 type prependStatements struct {
-	Template code.Template
+	Template *code.Template
 }
 
 // PrependStmts prepends statements to the matched *dst.BlockStmt. This action
 // can only be used if the selector matches on a *dst.BlockStmt. The prepended
 // statements are wrapped in a new block statement to prevent scope leakage.
-func PrependStmts(template code.Template) *prependStatements {
+func PrependStmts(template *code.Template) *prependStatements {
 	return &prependStatements{Template: template}
 }
 
@@ -51,13 +52,17 @@
 	return jen.Qual(pkgPath, "PrependStmts").Call(a.Template.AsCode())
 }
 
+func (a *prependStatements) Hash(h *fingerprint.Hasher) error {
+	return h.Named("prepend-statements", a.Template)
+}
+
 func (a *prependStatements) AddedImports() []string {
 	return a.Template.AddedImports()
 }
 
 func init() {
 	unmarshalers["prepend-statements"] = func(node *yaml.Node) (Advice, error) {
-		var template code.Template
+		var template *code.Template
 		if err := node.Decode(&template); err != nil {
 			return nil, err
 		}