feat: generate semantic convention families

.github/workflows/goci.yaml

@@ -53,6 +53,21 @@ jobs:
     with:
       PRIMUS_REF: main
       GO_VERSION: 1.24
+  semconv-generated:
+    if: |
+      github.event_name == 'merge_group' ||
+      (github.event_name == 'pull_request' && ! github.event.pull_request.head.repo.fork && github.event.pull_request.user.login != 'dependabot[bot]' && ! contains(github.event.pull_request.labels.*.name, 'safe-to-test')) ||
+      (github.event_name == 'pull_request_target' && contains(github.event.pull_request.labels.*.name, 'safe-to-test'))
+    runs-on: ubuntu-latest
+    steps:
+      - name: self-checkout
+        uses: actions/checkout@v4
+      - name: go-install
+        uses: actions/setup-go@v5
+        with:
+          go-version: "1.24"
+      - name: check-semconv-generated-files
+        run: go run ./scripts/semconv -check
   build:
     if: |
       github.event_name == 'merge_group' ||

Makefile

@@ -233,6 +233,10 @@ py-clean: ## Clear all pycache and pytest cache from tests directory recursively
 ##############################################################
 # generate commands
 ##############################################################
+.PHONY: semconv-generate
+semconv-generate: ## Regenerate semantic-convention families for Go and TypeScript
+	@go run ./scripts/semconv
+
 .PHONY: gen-mocks
 gen-mocks:
 	@echo ">> Generating mocks"

frontend/src/constants/generated/semconvFamilies.gen.ts

@@ -0,0 +1,32 @@
+// Code generated by scripts/semconv. DO NOT EDIT.
+
+export type SemconvFamily = {
+	readonly current: string;
+	readonly old: readonly string[];
+	readonly kind: 'attribute' | 'metric';
+	readonly contexts: readonly string[];
+	readonly signals: readonly string[];
+	readonly applyToMetrics: readonly string[];
+	readonly valueMap: Readonly<Record<string, string>>;
+};
+
+export const SEMCONV_FAMILIES: readonly SemconvFamily[] = [
+	{
+		current: 'db.system.name',
+		old: ['db.system'],
+		kind: 'attribute',
+		contexts: [],
+		signals: [],
+		applyToMetrics: [],
+		valueMap: {},
+	},
+	{
+		current: 'deployment.environment.name',
+		old: ['deployment.environment'],
+		kind: 'attribute',
+		contexts: [],
+		signals: [],
+		applyToMetrics: [],
+		valueMap: {},
+	},
+] as const;

pkg/semconv/families_gen.go

@@ -0,0 +1,22 @@
+// Code generated by scripts/semconv. DO NOT EDIT.
+
+package semconv
+
+var families = []Family{
+	{
+		Current:        "db.system.name",
+		Old:            []string{"db.system"},
+		Kind:           KindAttribute,
+		Contexts:       nil,
+		Signals:        nil,
+		ApplyToMetrics: nil,
+	},
+	{
+		Current:        "deployment.environment.name",
+		Old:            []string{"deployment.environment"},
+		Kind:           KindAttribute,
+		Contexts:       nil,
+		Signals:        nil,
+		ApplyToMetrics: nil,
+	},
+}

pkg/semconv/semconv.go

@@ -0,0 +1,127 @@
+package semconv
+
+import (
+	"slices"
+
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+//go:generate go run ../../scripts/semconv
+
+// Kind identifies whether a family describes an attribute or a metric name.
+type Kind struct {
+	valuer.String
+}
+
+// Family is one logical telemetry field. Old is ordered from the most recent
+// predecessor to the oldest one and therefore also defines fallback order.
+type Family struct {
+	Current        string
+	Old            []string
+	Kind           Kind
+	Contexts       []telemetrytypes.FieldContext
+	Signals        []telemetrytypes.Signal
+	ApplyToMetrics []string
+	ValueMap       map[string]string
+}
+
+var (
+	KindAttribute = Kind{String: valuer.NewString("attribute")}
+	KindMetric    = Kind{String: valuer.NewString("metric")}
+)
+
+var memberToFamilies, familyMembers = buildIndexes()
+
+// Enum returns the acceptable values for Kind.
+func (Kind) Enum() []any {
+	return []any{KindAttribute, KindMetric}
+}
+
+// Lookup returns the enabled family containing selector.Name for kind. The
+// returned family must not be modified.
+func Lookup(kind Kind, selector telemetrytypes.FieldKeySelector) (Family, bool) {
+	idx, ok := lookupIndex(kind, selector)
+	if !ok {
+		return Family{}, false
+	}
+	return families[idx], true
+}
+
+// Members returns the current name first, followed by historical names in
+// fallback order. A name outside an enabled family is returned unchanged. The
+// returned slice must not be modified.
+func Members(kind Kind, selector telemetrytypes.FieldKeySelector) []string {
+	idx, ok := lookupIndex(kind, selector)
+	if !ok {
+		return []string{selector.Name}
+	}
+	return familyMembers[idx]
+}
+
+// Current returns the current name for selector.Name, or the input name when
+// it does not belong to an enabled family.
+func Current(kind Kind, selector telemetrytypes.FieldKeySelector) string {
+	idx, ok := lookupIndex(kind, selector)
+	if !ok {
+		return selector.Name
+	}
+	return families[idx].Current
+}
+
+// All returns every enabled family. The returned slice and families must not be
+// modified.
+func All() []Family {
+	return families
+}
+
+func buildIndexes() (map[string][]int, [][]string) {
+	index := make(map[string][]int)
+	members := make([][]string, len(families))
+	for i, family := range families {
+		members[i] = make([]string, 0, len(family.Old)+1)
+		members[i] = append(members[i], family.Current)
+		members[i] = append(members[i], family.Old...)
+		index[family.Current] = append(index[family.Current], i)
+		for _, old := range family.Old {
+			index[old] = append(index[old], i)
+		}
+	}
+	return index, members
+}
+
+func lookupIndex(kind Kind, selector telemetrytypes.FieldKeySelector) (int, bool) {
+	for _, idx := range memberToFamilies[selector.Name] {
+		if matchesSelector(families[idx], kind, selector) {
+			return idx, true
+		}
+	}
+	return 0, false
+}
+
+func matchesSelector(family Family, kind Kind, selector telemetrytypes.FieldKeySelector) bool {
+	if family.Kind != kind {
+		return false
+	}
+
+	if selector.Signal != telemetrytypes.SignalUnspecified && len(family.Signals) > 0 {
+		if !slices.Contains(family.Signals, selector.Signal) {
+			return false
+		}
+	}
+
+	if selector.FieldContext != telemetrytypes.FieldContextUnspecified && len(family.Contexts) > 0 {
+		if !slices.Contains(family.Contexts, selector.FieldContext) {
+			return false
+		}
+	}
+
+	if selector.Signal == telemetrytypes.SignalMetrics && len(family.ApplyToMetrics) > 0 {
+		if selector.MetricContext == nil {
+			return false
+		}
+		return slices.Contains(family.ApplyToMetrics, selector.MetricContext.MetricName)
+	}
+
+	return true
+}

pkg/semconv/semconv_test.go

@@ -0,0 +1,49 @@
+package semconv
+
+import (
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMembersReturnsCurrentBeforeHistoricalName(t *testing.T) {
+	selector := telemetrytypes.FieldKeySelector{
+		Name:         "deployment.environment",
+		Signal:       telemetrytypes.SignalTraces,
+		FieldContext: telemetrytypes.FieldContextResource,
+	}
+
+	assert.Equal(t,
+		[]string{"deployment.environment.name", "deployment.environment"},
+		Members(KindAttribute, selector),
+		"members should use current-first fallback order",
+	)
+}
+
+func TestCurrentReturnsCanonicalName(t *testing.T) {
+	selector := telemetrytypes.FieldKeySelector{
+		Name:         "deployment.environment",
+		Signal:       telemetrytypes.SignalTraces,
+		FieldContext: telemetrytypes.FieldContextResource,
+	}
+
+	assert.Equal(t,
+		"deployment.environment.name",
+		Current(KindAttribute, selector),
+		"historical name should resolve to the current family name",
+	)
+}
+
+func TestMembersReturnsInputWhenKindDoesNotMatch(t *testing.T) {
+	selector := telemetrytypes.FieldKeySelector{
+		Name:   "deployment.environment",
+		Signal: telemetrytypes.SignalTraces,
+	}
+
+	assert.Equal(t,
+		[]string{"deployment.environment"},
+		Members(KindMetric, selector),
+		"an attribute family must not match a metric-name lookup",
+	)
+}

scripts/semconv/generate.go

@@ -0,0 +1,721 @@
+package main
+
+import (
+	"bytes"
+	"errors"
+	"flag"
+	"fmt"
+	"go/format"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+
+	"gopkg.in/yaml.v3"
+)
+
+const (
+	kindAttribute = "attribute"
+	kindMetric    = "metric"
+)
+
+type stringListFlag []string
+
+func (f *stringListFlag) String() string { return strings.Join(*f, ",") }
+func (f *stringListFlag) Set(value string) error {
+	*f = append(*f, value)
+	return nil
+}
+
+type schemaFile struct {
+	FileFormat string                   `yaml:"file_format"`
+	SchemaURL  string                   `yaml:"schema_url"`
+	Versions   map[string]schemaVersion `yaml:"versions"`
+}
+
+type schemaVersion struct {
+	All       changeSection `yaml:"all"`
+	Resources changeSection `yaml:"resources"`
+	Spans     changeSection `yaml:"spans"`
+	Logs      changeSection `yaml:"logs"`
+	Metrics   changeSection `yaml:"metrics"`
+}
+
+type changeSection struct {
+	Changes []schemaChange `yaml:"changes"`
+}
+
+type schemaChange struct {
+	RenameAttributes *attributeRename  `yaml:"rename_attributes"`
+	RenameMetrics    map[string]string `yaml:"rename_metrics"`
+}
+
+type attributeRename struct {
+	AttributeMap   map[string]string `yaml:"attribute_map"`
+	ApplyToMetrics []string          `yaml:"apply_to_metrics"`
+}
+
+type overlayFile struct {
+	DefaultEnabled bool `yaml:"default_enabled"`
+	// Families is keyed only by current name. One name cannot carry separate
+	// policies for attribute and metric families; set kind explicitly whenever
+	// a metric-name family is configured.
+	Families map[string]overlayFamily `yaml:"families"`
+}
+
+type overlayFamily struct {
+	Enabled           *bool             `yaml:"enabled"`
+	Kind              string            `yaml:"kind"`
+	Old               []string          `yaml:"old"`
+	AddOld            []string          `yaml:"add_old"`
+	ExcludeOld        []string          `yaml:"exclude_old"`
+	Contexts          []string          `yaml:"contexts"`
+	Signals           []string          `yaml:"signals"`
+	AddContexts       []string          `yaml:"add_contexts"`
+	AddSignals        []string          `yaml:"add_signals"`
+	ApplyToMetrics    []string          `yaml:"apply_to_metrics"`
+	AddApplyToMetrics []string          `yaml:"add_apply_to_metrics"`
+	ValueMap          map[string]string `yaml:"value_map"`
+}
+
+type edge struct {
+	old            string
+	current        string
+	kind           string
+	contexts       []string
+	signals        []string
+	allContexts    bool
+	allSignals     bool
+	applyToMetrics []string
+}
+
+type graphKey struct{ kind, name string }
+
+type generatedFamily struct {
+	Current        string
+	Old            []string
+	Kind           string
+	Contexts       []string
+	Signals        []string
+	ApplyToMetrics []string
+	ValueMap       map[string]string
+}
+
+func main() {
+	root, err := findRepoRoot()
+	if err != nil {
+		fatal(err)
+	}
+
+	var schemaPaths stringListFlag
+	flag.Var(&schemaPaths, "schema", "schema source (repeatable)")
+	overlayPath := flag.String("overlay", filepath.Join(root, "scripts/semconv/overlay.yaml"), "SigNoz overlay")
+	goOutput := flag.String("go-out", filepath.Join(root, "pkg/semconv/families_gen.go"), "generated Go output")
+	tsOutput := flag.String("ts-out", filepath.Join(root, "frontend/src/constants/generated/semconvFamilies.gen.ts"), "generated TypeScript output")
+	check := flag.Bool("check", false, "fail if generated files are stale")
+	flag.Parse()
+
+	if len(schemaPaths) == 0 {
+		schemaPaths = append(schemaPaths, filepath.Join(root, "scripts/semconv/schema-1.42.0.yaml"))
+	}
+
+	families, err := generate(schemaPaths, *overlayPath)
+	if err != nil {
+		fatal(err)
+	}
+	goBytes, err := renderGo(families)
+	if err != nil {
+		fatal(err)
+	}
+	tsBytes := renderTypeScript(families)
+
+	if *check {
+		if err := checkFile(*goOutput, goBytes); err != nil {
+			fatal(err)
+		}
+		if err := checkFile(*tsOutput, tsBytes); err != nil {
+			fatal(err)
+		}
+		return
+	}
+
+	if err := os.WriteFile(*goOutput, goBytes, 0o644); err != nil {
+		fatal(err)
+	}
+	if err := os.WriteFile(*tsOutput, tsBytes, 0o644); err != nil {
+		fatal(err)
+	}
+}
+
+func fatal(err error) {
+	fmt.Fprintln(os.Stderr, err)
+	os.Exit(1)
+}
+
+func findRepoRoot() (string, error) {
+	dir, err := os.Getwd()
+	if err != nil {
+		return "", err
+	}
+	for {
+		if _, err := os.Stat(filepath.Join(dir, "go.mod")); err == nil {
+			return dir, nil
+		}
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			return "", errors.New("could not find repository root")
+		}
+		dir = parent
+	}
+}
+
+func generate(schemaPaths []string, overlayPath string) ([]generatedFamily, error) {
+	var schemas []schemaFile
+	for _, path := range schemaPaths {
+		data, err := os.ReadFile(path)
+		if err != nil {
+			return nil, fmt.Errorf("read schema %s: %w", path, err)
+		}
+		var schema schemaFile
+		if err := decodeKnownFields(data, &schema); err != nil {
+			return nil, fmt.Errorf("parse schema %s: %w", path, err)
+		}
+		schemas = append(schemas, schema)
+	}
+
+	overlayData, err := os.ReadFile(overlayPath)
+	if err != nil {
+		return nil, fmt.Errorf("read overlay: %w", err)
+	}
+	var overlay overlayFile
+	if err := decodeKnownFields(overlayData, &overlay); err != nil {
+		return nil, fmt.Errorf("parse overlay: %w", err)
+	}
+
+	return buildFamilies(schemas, overlay)
+}
+
+func decodeKnownFields(data []byte, target any) error {
+	decoder := yaml.NewDecoder(bytes.NewReader(data))
+	decoder.KnownFields(true)
+	return decoder.Decode(target)
+}
+
+func collectEdges(schemas []schemaFile) ([]edge, error) {
+	var edges []edge
+	for _, schema := range schemas {
+		versions := make([]string, 0, len(schema.Versions))
+		versionParts := make(map[string][3]int, len(schema.Versions))
+		for version := range schema.Versions {
+			parts, err := parseSchemaVersion(version)
+			if err != nil {
+				return nil, err
+			}
+			versions = append(versions, version)
+			versionParts[version] = parts
+		}
+		sort.Slice(versions, func(i, j int) bool {
+			return compareVersionParts(versionParts[versions[i]], versionParts[versions[j]]) < 0
+		})
+		for _, versionName := range versions {
+			version := schema.Versions[versionName]
+			var versionEdges []edge
+			sections := []struct {
+				name    string
+				section changeSection
+			}{
+				{name: "all", section: version.All},
+				{name: "resources", section: version.Resources},
+				{name: "spans", section: version.Spans},
+				{name: "logs", section: version.Logs},
+				{name: "metrics", section: version.Metrics},
+			}
+			for _, scoped := range sections {
+				contexts, signals, allContexts, allSignals, err := scopeForSection(scoped.name)
+				if err != nil {
+					return nil, err
+				}
+				for _, change := range scoped.section.Changes {
+					if change.RenameAttributes != nil {
+						for _, old := range sortedMapKeys(change.RenameAttributes.AttributeMap) {
+							versionEdges = append(versionEdges, edge{
+								old: old, current: change.RenameAttributes.AttributeMap[old], kind: kindAttribute,
+								contexts: contexts, signals: signals,
+								allContexts: allContexts, allSignals: allSignals,
+								applyToMetrics: change.RenameAttributes.ApplyToMetrics,
+							})
+						}
+					}
+					for _, old := range sortedMapKeys(change.RenameMetrics) {
+						versionEdges = append(versionEdges, edge{
+							old: old, current: change.RenameMetrics[old], kind: kindMetric,
+							contexts: []string{"metric"}, signals: []string{"metrics"},
+						})
+					}
+				}
+			}
+			if err := rejectSameVersionChains(versionName, versionEdges); err != nil {
+				return nil, err
+			}
+			edges = append(edges, versionEdges...)
+		}
+	}
+	return edges, nil
+}
+
+func rejectSameVersionChains(version string, edges []edge) error {
+	oldNames := make(map[graphKey]struct{}, len(edges))
+	for _, item := range edges {
+		oldNames[graphKey{kind: item.kind, name: item.old}] = struct{}{}
+	}
+	for _, item := range edges {
+		if _, ok := oldNames[graphKey{kind: item.kind, name: item.current}]; ok {
+			return fmt.Errorf(
+				"schema version %q contains a same-version %s rename chain through %q",
+				version,
+				item.kind,
+				item.current,
+			)
+		}
+	}
+	return nil
+}
+
+func parseSchemaVersion(version string) ([3]int, error) {
+	parts := strings.Split(version, ".")
+	if len(parts) != 3 {
+		return [3]int{}, fmt.Errorf("schema version %q must contain major, minor, and patch numbers", version)
+	}
+
+	var parsed [3]int
+	for i, part := range parts {
+		value, err := strconv.Atoi(part)
+		if err != nil || value < 0 {
+			return [3]int{}, fmt.Errorf("schema version %q contains invalid numeric component %q", version, part)
+		}
+		parsed[i] = value
+	}
+	return parsed, nil
+}
+
+func compareVersionParts(left, right [3]int) int {
+	for i := range left {
+		if left[i] < right[i] {
+			return -1
+		}
+		if left[i] > right[i] {
+			return 1
+		}
+	}
+	return 0
+}
+
+func scopeForSection(section string) (contexts, signals []string, allContexts, allSignals bool, err error) {
+	switch section {
+	case "all":
+		return nil, nil, true, true, nil
+	case "resources":
+		return []string{"resource"}, nil, false, true, nil
+	case "spans":
+		return []string{"attribute"}, []string{"traces"}, false, false, nil
+	case "logs":
+		return []string{"attribute"}, []string{"logs"}, false, false, nil
+	case "metrics":
+		return []string{"attribute"}, []string{"metrics"}, false, false, nil
+	default:
+		return nil, nil, false, false, fmt.Errorf("unsupported schema section %q", section)
+	}
+}
+
+func buildFamilies(schemas []schemaFile, overlay overlayFile) ([]generatedFamily, error) {
+	edges, err := collectEdges(schemas)
+	if err != nil {
+		return nil, err
+	}
+	next := make(map[graphKey]string)
+	for _, item := range edges {
+		key := graphKey{kind: item.kind, name: item.old}
+		if existing, ok := next[key]; ok && existing == item.current {
+			// Repeated entries are common in chained schema histories. Treat an
+			// identical edge as a no-op so it cannot sever a later edge in the
+			// same chain (A -> B, B -> C, then a repeated A -> B).
+			continue
+		}
+		// Schema history occasionally repeats an old name with a newer direct
+		// destination or rolls a rename back. Edges are collected
+		// oldest-to-newest, so the latest published current name must be a root.
+		delete(next, graphKey{kind: item.kind, name: item.current})
+		next[key] = item.current
+	}
+
+	type familyState struct {
+		family      generatedFamily
+		distance    map[string]int
+		allContexts bool
+		allSignals  bool
+	}
+	states := map[graphKey]*familyState{}
+	for _, item := range edges {
+		root, distance, err := rootFor(next, item.kind, item.old)
+		if err != nil {
+			return nil, err
+		}
+		key := graphKey{kind: item.kind, name: root}
+		state := states[key]
+		if state == nil {
+			state = &familyState{
+				family:   generatedFamily{Current: root, Kind: item.kind},
+				distance: map[string]int{},
+			}
+			states[key] = state
+		}
+		if prior, ok := state.distance[item.old]; !ok || distance < prior {
+			state.distance[item.old] = distance
+		}
+		state.allContexts = state.allContexts || item.allContexts
+		state.allSignals = state.allSignals || item.allSignals
+		state.family.Contexts = appendUnique(state.family.Contexts, item.contexts...)
+		state.family.Signals = appendUnique(state.family.Signals, item.signals...)
+		state.family.ApplyToMetrics = appendUnique(state.family.ApplyToMetrics, item.applyToMetrics...)
+	}
+
+	for _, state := range states {
+		for old := range state.distance {
+			if old != state.family.Current {
+				state.family.Old = append(state.family.Old, old)
+			}
+		}
+		sort.Slice(state.family.Old, func(i, j int) bool {
+			left, right := state.family.Old[i], state.family.Old[j]
+			if state.distance[left] != state.distance[right] {
+				return state.distance[left] < state.distance[right]
+			}
+			return left < right
+		})
+		if state.allContexts {
+			state.family.Contexts = nil
+		} else {
+			sort.Strings(state.family.Contexts)
+		}
+		if state.allSignals {
+			state.family.Signals = nil
+		} else {
+			sort.Strings(state.family.Signals)
+		}
+		sort.Strings(state.family.ApplyToMetrics)
+	}
+
+	for _, current := range sortedMapKeys(overlay.Families) {
+		policy := overlay.Families[current]
+		kind, err := normalizedOverlayKind(current, policy)
+		if err != nil {
+			return nil, err
+		}
+		policy.Kind = kind
+		overlay.Families[current] = policy
+		key := graphKey{kind: kind, name: current}
+		state := states[key]
+		if state == nil {
+			if len(policy.Old) == 0 {
+				return nil, fmt.Errorf(
+					"overlay family %q with kind %q is absent from schemas and has no old members",
+					current,
+					kind,
+				)
+			}
+			state = &familyState{
+				family:   generatedFamily{Current: current, Kind: kind, Old: append([]string(nil), policy.Old...)},
+				distance: map[string]int{},
+			}
+			states[key] = state
+		}
+		applyOverlay(&state.family, policy)
+	}
+
+	var result []generatedFamily
+	for key, state := range states {
+		policy, hasPolicy := overlay.Families[key.name]
+		enabled := overlay.DefaultEnabled
+		if hasPolicy && policy.Kind != key.kind {
+			hasPolicy = false
+		}
+		if hasPolicy && policy.Enabled != nil {
+			enabled = *policy.Enabled
+		}
+		if !enabled {
+			continue
+		}
+		if len(state.family.Old) == 0 {
+			return nil, fmt.Errorf(
+				"enabled family %q with kind %q has no old members",
+				state.family.Current,
+				state.family.Kind,
+			)
+		}
+		sort.Strings(state.family.Contexts)
+		sort.Strings(state.family.Signals)
+		sort.Strings(state.family.ApplyToMetrics)
+		result = append(result, state.family)
+	}
+
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Current != result[j].Current {
+			return result[i].Current < result[j].Current
+		}
+		return result[i].Kind < result[j].Kind
+	})
+	return result, nil
+}
+
+func rootFor(next map[graphKey]string, kind, name string) (string, int, error) {
+	seen := map[string]bool{}
+	distance := 0
+	for {
+		if seen[name] {
+			return "", 0, fmt.Errorf("rename cycle for %s %q", kind, name)
+		}
+		seen[name] = true
+		current, ok := next[graphKey{kind: kind, name: name}]
+		if !ok {
+			return name, distance, nil
+		}
+		name = current
+		distance++
+	}
+}
+
+func normalizedOverlayKind(current string, policy overlayFamily) (string, error) {
+	kind := policy.Kind
+	if kind == "" {
+		kind = kindAttribute
+	}
+	if kind != kindAttribute && kind != kindMetric {
+		return "", fmt.Errorf("overlay family %q has unsupported kind %q", current, kind)
+	}
+	return kind, nil
+}
+
+func applyOverlay(family *generatedFamily, policy overlayFamily) {
+	if policy.Kind != "" {
+		family.Kind = policy.Kind
+	}
+	if policy.Old != nil {
+		family.Old = append([]string(nil), policy.Old...)
+	}
+	family.Old = appendUnique(family.Old, policy.AddOld...)
+	if len(policy.ExcludeOld) > 0 {
+		excluded := make(map[string]bool, len(policy.ExcludeOld))
+		for _, old := range policy.ExcludeOld {
+			excluded[old] = true
+		}
+		family.Old = deleteMatching(family.Old, excluded)
+	}
+	if policy.Contexts != nil {
+		family.Contexts = append([]string(nil), policy.Contexts...)
+	}
+	if policy.Signals != nil {
+		family.Signals = append([]string(nil), policy.Signals...)
+	}
+	family.Contexts = appendUnique(family.Contexts, policy.AddContexts...)
+	family.Signals = appendUnique(family.Signals, policy.AddSignals...)
+	if policy.ApplyToMetrics != nil {
+		family.ApplyToMetrics = append([]string(nil), policy.ApplyToMetrics...)
+	}
+	family.ApplyToMetrics = appendUnique(family.ApplyToMetrics, policy.AddApplyToMetrics...)
+	if policy.ValueMap != nil {
+		family.ValueMap = make(map[string]string, len(policy.ValueMap))
+		for old, current := range policy.ValueMap {
+			family.ValueMap[old] = current
+		}
+	}
+}
+
+func appendUnique(values []string, additions ...string) []string {
+	seen := make(map[string]bool, len(values)+len(additions))
+	for _, value := range values {
+		seen[value] = true
+	}
+	for _, value := range additions {
+		if value == "" || seen[value] {
+			continue
+		}
+		seen[value] = true
+		values = append(values, value)
+	}
+	return values
+}
+
+func deleteMatching(values []string, excluded map[string]bool) []string {
+	result := values[:0]
+	for _, value := range values {
+		if !excluded[value] {
+			result = append(result, value)
+		}
+	}
+	return result
+}
+
+func renderGo(families []generatedFamily) ([]byte, error) {
+	var out bytes.Buffer
+	out.WriteString("// Code generated by scripts/semconv. DO NOT EDIT.\n\n")
+	out.WriteString("package semconv\n\n")
+	needsTelemetryTypes := false
+	for _, family := range families {
+		if len(family.Contexts) > 0 || len(family.Signals) > 0 {
+			needsTelemetryTypes = true
+			break
+		}
+	}
+	if needsTelemetryTypes {
+		out.WriteString("import \"github.com/SigNoz/signoz/pkg/types/telemetrytypes\"\n\n")
+	}
+	out.WriteString("var families = []Family{\n")
+	for _, family := range families {
+		contexts, err := goFieldContextSlice(family.Contexts)
+		if err != nil {
+			return nil, fmt.Errorf("render family %q: %w", family.Current, err)
+		}
+		signals, err := goSignalSlice(family.Signals)
+		if err != nil {
+			return nil, fmt.Errorf("render family %q: %w", family.Current, err)
+		}
+		out.WriteString("\t{\n")
+		fmt.Fprintf(&out, "\t\tCurrent: %s,\n", strconv.Quote(family.Current))
+		fmt.Fprintf(&out, "\t\tOld: %s,\n", goStringSlice(family.Old))
+		if family.Kind == kindMetric {
+			out.WriteString("\t\tKind: KindMetric,\n")
+		} else {
+			out.WriteString("\t\tKind: KindAttribute,\n")
+		}
+		fmt.Fprintf(&out, "\t\tContexts: %s,\n", contexts)
+		fmt.Fprintf(&out, "\t\tSignals: %s,\n", signals)
+		fmt.Fprintf(&out, "\t\tApplyToMetrics: %s,\n", goStringSlice(family.ApplyToMetrics))
+		if len(family.ValueMap) > 0 {
+			out.WriteString("\t\tValueMap: map[string]string{\n")
+			keys := sortedMapKeys(family.ValueMap)
+			for _, key := range keys {
+				fmt.Fprintf(&out, "\t\t\t%s: %s,\n", strconv.Quote(key), strconv.Quote(family.ValueMap[key]))
+			}
+			out.WriteString("\t\t},\n")
+		}
+		out.WriteString("\t},\n")
+	}
+	out.WriteString("}\n")
+	return format.Source(out.Bytes())
+}
+
+func goStringSlice(values []string) string {
+	if len(values) == 0 {
+		return "nil"
+	}
+	quoted := make([]string, len(values))
+	for i, value := range values {
+		quoted[i] = strconv.Quote(value)
+	}
+	return "[]string{" + strings.Join(quoted, ", ") + "}"
+}
+
+func goFieldContextSlice(values []string) (string, error) {
+	if len(values) == 0 {
+		return "nil", nil
+	}
+	constants := make([]string, len(values))
+	for i, value := range values {
+		switch value {
+		case "metric":
+			constants[i] = "telemetrytypes.FieldContextMetric"
+		case "resource":
+			constants[i] = "telemetrytypes.FieldContextResource"
+		case "attribute":
+			constants[i] = "telemetrytypes.FieldContextAttribute"
+		default:
+			return "", fmt.Errorf("unsupported field context %q", value)
+		}
+	}
+	return "[]telemetrytypes.FieldContext{" + strings.Join(constants, ", ") + "}", nil
+}
+
+func goSignalSlice(values []string) (string, error) {
+	if len(values) == 0 {
+		return "nil", nil
+	}
+	constants := make([]string, len(values))
+	for i, value := range values {
+		switch value {
+		case "traces":
+			constants[i] = "telemetrytypes.SignalTraces"
+		case "logs":
+			constants[i] = "telemetrytypes.SignalLogs"
+		case "metrics":
+			constants[i] = "telemetrytypes.SignalMetrics"
+		default:
+			return "", fmt.Errorf("unsupported signal %q", value)
+		}
+	}
+	return "[]telemetrytypes.Signal{" + strings.Join(constants, ", ") + "}", nil
+}
+
+func renderTypeScript(families []generatedFamily) []byte {
+	var out bytes.Buffer
+	out.WriteString("// Code generated by scripts/semconv. DO NOT EDIT.\n\n")
+	out.WriteString("export type SemconvFamily = {\n")
+	out.WriteString("\treadonly current: string;\n\treadonly old: readonly string[];\n")
+	out.WriteString("\treadonly kind: 'attribute' | 'metric';\n")
+	out.WriteString("\treadonly contexts: readonly string[];\n\treadonly signals: readonly string[];\n")
+	out.WriteString("\treadonly applyToMetrics: readonly string[];\n")
+	out.WriteString("\treadonly valueMap: Readonly<Record<string, string>>;\n};\n\n")
+	out.WriteString("export const SEMCONV_FAMILIES: readonly SemconvFamily[] = [\n")
+	for _, family := range families {
+		out.WriteString("\t{\n")
+		fmt.Fprintf(&out, "\t\tcurrent: %s,\n", tsString(family.Current))
+		fmt.Fprintf(&out, "\t\told: %s,\n", tsStringSlice(family.Old))
+		fmt.Fprintf(&out, "\t\tkind: %s,\n", tsString(family.Kind))
+		fmt.Fprintf(&out, "\t\tcontexts: %s,\n", tsStringSlice(family.Contexts))
+		fmt.Fprintf(&out, "\t\tsignals: %s,\n", tsStringSlice(family.Signals))
+		fmt.Fprintf(&out, "\t\tapplyToMetrics: %s,\n", tsStringSlice(family.ApplyToMetrics))
+		out.WriteString("\t\tvalueMap: {")
+		keys := sortedMapKeys(family.ValueMap)
+		for i, key := range keys {
+			if i > 0 {
+				out.WriteString(", ")
+			}
+			fmt.Fprintf(&out, "%s: %s", tsString(key), tsString(family.ValueMap[key]))
+		}
+		out.WriteString("},\n\t},\n")
+	}
+	out.WriteString("] as const;\n")
+	return out.Bytes()
+}
+
+func tsString(value string) string {
+	quoted := strconv.Quote(value)
+	return "'" + strings.ReplaceAll(quoted[1:len(quoted)-1], "'", `\'`) + "'"
+}
+func tsStringSlice(values []string) string {
+	quoted := make([]string, len(values))
+	for i, value := range values {
+		quoted[i] = tsString(value)
+	}
+	return "[" + strings.Join(quoted, ", ") + "]"
+}
+
+func sortedMapKeys[T any](values map[string]T) []string {
+	keys := make([]string, 0, len(values))
+	for key := range values {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	return keys
+}
+
+func checkFile(path string, expected []byte) error {
+	actual, err := os.ReadFile(path)
+	if err != nil {
+		return fmt.Errorf("generated file %s is missing: run go run ./scripts/semconv", path)
+	}
+	if !bytes.Equal(actual, expected) {
+		return fmt.Errorf("generated file %s is stale: run go run ./scripts/semconv", path)
+	}
+	return nil
+}

scripts/semconv/generate_test.go

@@ -0,0 +1,366 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestSchemaDecoderRejectsUnsupportedSection(t *testing.T) {
+	var schema schemaFile
+	err := decodeKnownFields([]byte(`
+versions:
+  1.0.0:
+    span_events:
+      changes:
+        - rename_events:
+            event_map:
+              old: current
+`), &schema)
+
+	assert.ErrorContains(t, err, "field span_events not found", "unsupported schema sections must fail generation")
+}
+
+func TestBuildFamiliesRejectsMalformedSchemaVersion(t *testing.T) {
+	var schema schemaFile
+	require.NoError(t, decodeKnownFields([]byte(`
+versions:
+  latest:
+    spans:
+      changes: []
+`), &schema), "test schema must decode")
+
+	_, err := buildFamilies([]schemaFile{schema}, overlayFile{})
+	assert.ErrorContains(t, err, `schema version "latest"`, "malformed versions must not be silently reordered")
+}
+
+func TestBuildFamiliesResolvesRenameChain(t *testing.T) {
+	var schema schemaFile
+	require.NoError(t, decodeKnownFields([]byte(`
+versions:
+  4.0.0:
+    spans:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              a: b
+  3.0.0:
+    spans:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              b: c
+              x: c
+  2.0.0:
+    spans:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              a: b
+        - rename_attributes:
+            attribute_map:
+              a: b
+`), &schema), "test schema must decode")
+
+	enabled := true
+	families, err := buildFamilies([]schemaFile{schema}, overlayFile{Families: map[string]overlayFamily{
+		"c": {Enabled: &enabled},
+	}})
+	require.NoError(t, err)
+	assert.Equal(t, []generatedFamily{{
+		Current:  "c",
+		Old:      []string{"b", "x", "a"},
+		Kind:     kindAttribute,
+		Contexts: []string{"attribute"},
+		Signals:  []string{"traces"},
+	}}, families, "predecessors should be ordered by distance and then name")
+}
+
+func TestBuildFamiliesMapsSchemaSectionsToScopes(t *testing.T) {
+	var schema schemaFile
+	require.NoError(t, decodeKnownFields([]byte(`
+versions:
+  1.0.0:
+    resources:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              resource.old: resource.current
+    logs:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              log.old: log.current
+    metrics:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              state: cpu.mode
+            apply_to_metrics: [system.cpu.time]
+        - rename_metrics:
+            old.metric: current.metric
+`), &schema), "test schema must decode")
+
+	enabled := true
+	families, err := buildFamilies([]schemaFile{schema}, overlayFile{Families: map[string]overlayFamily{
+		"resource.current": {Enabled: &enabled},
+		"log.current":      {Enabled: &enabled},
+		"cpu.mode":         {Enabled: &enabled},
+		"current.metric":   {Enabled: &enabled, Kind: kindMetric},
+	}})
+	require.NoError(t, err)
+	assert.Equal(t, []generatedFamily{
+		{
+			Current: "cpu.mode", Old: []string{"state"}, Kind: kindAttribute,
+			Contexts: []string{"attribute"}, Signals: []string{"metrics"},
+			ApplyToMetrics: []string{"system.cpu.time"},
+		},
+		{
+			Current: "current.metric", Old: []string{"old.metric"}, Kind: kindMetric,
+			Contexts: []string{"metric"}, Signals: []string{"metrics"},
+		},
+		{
+			Current: "log.current", Old: []string{"log.old"}, Kind: kindAttribute,
+			Contexts: []string{"attribute"}, Signals: []string{"logs"},
+		},
+		{
+			Current: "resource.current", Old: []string{"resource.old"}, Kind: kindAttribute,
+			Contexts: []string{"resource"},
+		},
+	}, families, "schema sections should produce their documented signal and context scopes")
+}
+
+func TestOverlayAddsFamilyWithoutSchemaHistory(t *testing.T) {
+	enabled := true
+	families, err := buildFamilies(nil, overlayFile{Families: map[string]overlayFamily{
+		"added.current": {
+			Enabled:  &enabled,
+			Old:      []string{"added.old"},
+			Contexts: []string{"resource"},
+			Signals:  []string{"traces"},
+		},
+	}})
+
+	require.NoError(t, err)
+	assert.Equal(t, []generatedFamily{{
+		Current:  "added.current",
+		Old:      []string{"added.old"},
+		Kind:     kindAttribute,
+		Contexts: []string{"resource"},
+		Signals:  []string{"traces"},
+	}}, families, "an explicit overlay family should not require schema history")
+}
+
+func TestOverlayOverridesGeneratedFamily(t *testing.T) {
+	var schema schemaFile
+	require.NoError(t, decodeKnownFields([]byte(`
+versions:
+  1.0.0:
+    spans:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              old: current
+`), &schema), "test schema must decode")
+
+	enabled := true
+	families, err := buildFamilies([]schemaFile{schema}, overlayFile{Families: map[string]overlayFamily{
+		"current": {
+			Enabled:     &enabled,
+			AddOld:      []string{"older"},
+			ExcludeOld:  []string{"old"},
+			AddContexts: []string{"resource"},
+			AddSignals:  []string{"logs"},
+			ValueMap:    map[string]string{"legacy": "current"},
+		},
+	}})
+
+	require.NoError(t, err)
+	assert.Equal(t, []generatedFamily{{
+		Current:  "current",
+		Old:      []string{"older"},
+		Kind:     kindAttribute,
+		Contexts: []string{"attribute", "resource"},
+		Signals:  []string{"logs", "traces"},
+		ValueMap: map[string]string{"legacy": "current"},
+	}}, families, "overlay additions and exclusions should be applied to the generated family")
+}
+
+func TestOverlayDisablesFamilyWhenDefaultIsEnabled(t *testing.T) {
+	var schema schemaFile
+	require.NoError(t, decodeKnownFields([]byte(`
+versions:
+  1.0.0:
+    spans:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              old: current
+`), &schema), "test schema must decode")
+
+	disabled := false
+	families, err := buildFamilies([]schemaFile{schema}, overlayFile{
+		DefaultEnabled: true,
+		Families: map[string]overlayFamily{
+			"current": {Enabled: &disabled},
+		},
+	})
+
+	require.NoError(t, err)
+	assert.Empty(t, families, "an explicitly disabled family must override default_enabled")
+}
+
+func TestRenderGoIsDeterministic(t *testing.T) {
+	families := []generatedFamily{{
+		Current: "current", Old: []string{"old"}, Kind: kindAttribute,
+		ValueMap: map[string]string{"b": "2", "a": "1"},
+	}}
+
+	first, err := renderGo(families)
+	require.NoError(t, err)
+	second, err := renderGo(families)
+	require.NoError(t, err)
+	assert.Equal(t, first, second, "Go generation must not depend on map iteration order")
+}
+
+func TestRenderGoUsesCanonicalTelemetryTypes(t *testing.T) {
+	families := []generatedFamily{{
+		Current: "current", Old: []string{"old"}, Kind: kindAttribute,
+		Contexts: []string{"resource"}, Signals: []string{"traces"},
+	}}
+
+	output, err := renderGo(families)
+	require.NoError(t, err)
+	assert.Contains(t, string(output), "telemetrytypes.FieldContextResource", "generated contexts should use telemetrytypes")
+	assert.Contains(t, string(output), "telemetrytypes.SignalTraces", "generated signals should use telemetrytypes")
+}
+
+func TestRenderTypeScriptIsDeterministic(t *testing.T) {
+	families := []generatedFamily{{
+		Current: "current", Old: []string{"old"}, Kind: kindAttribute,
+		ValueMap: map[string]string{"b": "2", "a": "1"},
+	}}
+
+	assert.Equal(t, renderTypeScript(families), renderTypeScript(families), "TypeScript generation must not depend on map iteration order")
+}
+
+func TestBuildFamiliesHandlesRenameRollback(t *testing.T) {
+	var schema schemaFile
+	require.NoError(t, decodeKnownFields([]byte(`
+versions:
+  2.0.0:
+    metrics:
+      changes:
+        - rename_metrics:
+            temporary: original
+  1.0.0:
+    metrics:
+      changes:
+        - rename_metrics:
+            original: temporary
+`), &schema), "test schema must decode")
+
+	enabled := true
+	families, err := buildFamilies([]schemaFile{schema}, overlayFile{Families: map[string]overlayFamily{
+		"original": {Enabled: &enabled, Kind: kindMetric},
+	}})
+
+	require.NoError(t, err)
+	assert.Equal(t, []generatedFamily{{
+		Current:  "original",
+		Old:      []string{"temporary"},
+		Kind:     kindMetric,
+		Contexts: []string{"metric"},
+		Signals:  []string{"metrics"},
+	}}, families, "the latest rollback destination should remain the family root")
+}
+
+func TestBuildFamiliesRejectsSameVersionRenameChain(t *testing.T) {
+	var schema schemaFile
+	require.NoError(t, decodeKnownFields([]byte(`
+versions:
+  1.0.0:
+    spans:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              x: y
+              y: z
+`), &schema), "test schema must decode")
+
+	_, err := buildFamilies([]schemaFile{schema}, overlayFile{})
+	assert.ErrorContains(t, err, `same-version attribute rename chain through "y"`, "order-sensitive same-version chains must be rejected")
+}
+
+func TestBuildFamiliesRejectsOverlayFamilyWithoutHistory(t *testing.T) {
+	enabled := true
+	_, err := buildFamilies(nil, overlayFile{Families: map[string]overlayFamily{
+		"missing": {Enabled: &enabled},
+	}})
+
+	assert.ErrorContains(t, err, `overlay family "missing" with kind "attribute" is absent`, "an overlay cannot invent a family without old members")
+}
+
+func TestBuildFamiliesRejectsEnabledFamilyWithoutOldMembers(t *testing.T) {
+	var schema schemaFile
+	require.NoError(t, decodeKnownFields([]byte(`
+versions:
+  1.0.0:
+    spans:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              old: current
+`), &schema), "test schema must decode")
+
+	enabled := true
+	_, err := buildFamilies([]schemaFile{schema}, overlayFile{Families: map[string]overlayFamily{
+		"current": {Enabled: &enabled, ExcludeOld: []string{"old"}},
+	}})
+	assert.ErrorContains(t, err, `enabled family "current" with kind "attribute" has no old members`, "exclude_old cannot empty an enabled family")
+}
+
+func TestOverlayKindDefaultsToAttribute(t *testing.T) {
+	var schema schemaFile
+	require.NoError(t, decodeKnownFields([]byte(`
+versions:
+  1.0.0:
+    spans:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              attribute.old: shared.current
+    metrics:
+      changes:
+        - rename_metrics:
+            metric.old: shared.current
+`), &schema), "test schema must decode")
+
+	enabled := true
+	families, err := buildFamilies([]schemaFile{schema}, overlayFile{Families: map[string]overlayFamily{
+		"shared.current": {Enabled: &enabled},
+	}})
+
+	require.NoError(t, err)
+	assert.Equal(t, []generatedFamily{{
+		Current:  "shared.current",
+		Old:      []string{"attribute.old"},
+		Kind:     kindAttribute,
+		Contexts: []string{"attribute"},
+		Signals:  []string{"traces"},
+	}}, families, "a kind-less overlay policy should affect only the attribute family")
+}
+
+func TestCheckFileReportsStaleOutput(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "generated.go")
+	require.NoError(t, os.WriteFile(path, []byte("old"), 0o600), "test output must be writable")
+
+	assert.ErrorContains(t, checkFile(path, []byte("new")), "is stale", "check mode must reject stale generated output")
+}
+
+func TestTypeScriptStringEscapesControlCharacters(t *testing.T) {
+	assert.Equal(t, `'line\n\t\x01\'\\end'`, tsString("line\n\t\x01'\\end"), "generated TypeScript strings must remain valid literals")
+}

scripts/semconv/overlay.yaml

@@ -0,0 +1,11 @@
+# SigNoz semantic-convention rollout policy.
+#
+# Families are keyed by their current OpenTelemetry name. Schema-derived
+# families are disabled by default so rollout remains explicit and reversible.
+default_enabled: false
+
+families:
+  deployment.environment.name:
+    enabled: true
+  db.system.name:
+    enabled: true

scripts/semconv/schema-1.42.0.yaml

@@ -0,0 +1,760 @@
+
+
+file_format: 1.1.0
+schema_url: https://opentelemetry.io/schemas/1.42.0
+versions:
+  1.42.0:
+    metrics:
+      changes:
+        - rename_metrics:
+            v8js.memory.heap.limit: v8js.memory.heap.space.size
+  1.41.1:
+  1.41.0:
+    metrics:
+      changes:
+        - rename_metrics:
+            k8s.container.cpu.limit: k8s.container.cpu.limit.desired
+            k8s.container.cpu.limit_utilization: k8s.container.cpu.limit.utilization
+            k8s.container.cpu.request: k8s.container.cpu.request.desired
+            k8s.container.cpu.request_utilization: k8s.container.cpu.request.utilization
+            k8s.container.memory.limit: k8s.container.memory.limit.desired
+            k8s.container.memory.request: k8s.container.memory.request.desired
+  1.40.0:
+    all:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              feature_flag.evaluation.error.message: feature_flag.error.message
+    metrics:
+      changes:
+        - rename_metrics:
+            system.memory.shared: system.memory.linux.shared
+  1.39.0:
+    all:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              linux.memory.slab.state: system.memory.linux.slab.state
+              peer.service: service.peer.name
+              rpc.connect_rpc.error_code: rpc.response.status_code
+              rpc.connect_rpc.request.metadata: rpc.request.metadata
+              rpc.connect_rpc.response.metadata: rpc.response.metadata
+              rpc.grpc.request.metadata: rpc.request.metadata
+              rpc.grpc.response.metadata: rpc.response.metadata
+              rpc.jsonrpc.request_id: jsonrpc.request.id
+              rpc.jsonrpc.version: jsonrpc.protocol.version
+              rpc.system: rpc.system.name
+    metrics:
+      changes:
+        - rename_metrics:
+            process.open_file_descriptor.count: process.unix.file_descriptor.count
+            system.linux.memory.available: system.memory.linux.available
+            system.linux.memory.slab.usage: system.memory.linux.slab.usage
+  1.38.0:
+    all:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              process.context_switch_type: process.context_switch.type
+              process.paging.fault_type: system.paging.fault.type
+              system.cpu.logical_number: cpu.logical_number
+              system.paging.type: system.paging.fault.type
+              system.process.status: process.state
+              system.processes.status: process.state
+    metrics:
+      changes:
+        - rename_metrics:
+            k8s.cronjob.active_jobs: k8s.cronjob.job.active
+            k8s.daemonset.current_scheduled_nodes: k8s.daemonset.node.current_scheduled
+            k8s.daemonset.desired_scheduled_nodes: k8s.daemonset.node.desired_scheduled
+            k8s.daemonset.misscheduled_nodes: k8s.daemonset.node.misscheduled
+            k8s.daemonset.ready_nodes: k8s.daemonset.node.ready
+            k8s.deployment.available_pods: k8s.deployment.pod.available
+            k8s.deployment.desired_pods: k8s.deployment.pod.desired
+            k8s.hpa.current_pods: k8s.hpa.pod.current
+            k8s.hpa.desired_pods: k8s.hpa.pod.desired
+            k8s.hpa.max_pods: k8s.hpa.pod.max
+            k8s.hpa.min_pods: k8s.hpa.pod.min
+            k8s.job.active_pods: k8s.job.pod.active
+            k8s.job.desired_successful_pods: k8s.job.pod.desired_successful
+            k8s.job.failed_pods: k8s.job.pod.failed
+            k8s.job.max_parallel_pods: k8s.job.pod.max_parallel
+            k8s.job.successful_pods: k8s.job.pod.successful
+            k8s.node.allocatable.cpu: k8s.node.cpu.allocatable
+            k8s.node.allocatable.ephemeral_storage: k8s.node.ephemeral_storage.allocatable
+            k8s.node.allocatable.memory: k8s.node.memory.allocatable
+            k8s.node.allocatable.pods: k8s.node.pod.allocatable
+            k8s.replicaset.available_pods: k8s.replicaset.pod.available
+            k8s.replicaset.desired_pods: k8s.replicaset.pod.desired
+            k8s.replication_controller.available_pods: k8s.replicationcontroller.pod.available
+            k8s.replication_controller.desired_pods: k8s.replicationcontroller.pod.desired
+            k8s.replicationcontroller.available_pods: k8s.replicationcontroller.pod.available
+            k8s.replicationcontroller.desired_pods: k8s.replicationcontroller.pod.desired
+            k8s.statefulset.current_pods: k8s.statefulset.pod.current
+            k8s.statefulset.desired_pods: k8s.statefulset.pod.desired
+            k8s.statefulset.ready_pods: k8s.statefulset.pod.ready
+            k8s.statefulset.updated_pods: k8s.statefulset.pod.updated
+            v8js.heap.space.available_size: v8js.memory.heap.space.available_size
+            v8js.heap.space.physical_size: v8js.memory.heap.space.physical_size
+  1.37.0:
+    all:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              android.state: android.app.state
+              container.runtime: container.runtime.name
+              enduser.role: user.roles
+              gen_ai.openai.request.service_tier: openai.request.service_tier
+              gen_ai.openai.response.service_tier: openai.response.service_tier
+              gen_ai.openai.response.system_fingerprint: openai.response.system_fingerprint
+              gen_ai.system: gen_ai.provider.name
+              ios.state: ios.app.state
+  1.36.0:
+  1.35.0:
+    all:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1698
+        - rename_attributes:
+            attribute_map:
+              az.namespace: azure.resource_provider.namespace
+              az.service_request_id: azure.service.request.id
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/issues/1800
+        - rename_metrics:
+            system.network.connections: system.network.connection.count
+  1.34.0:
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/2295
+        - rename_metrics:
+            cpu.time: system.cpu.time
+            cpu.utilization: system.cpu.utilization
+            cpu.frequency: system.cpu.frequency
+  1.33.0:
+    all:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1982
+        - rename_attributes:
+            attribute_map:
+              feature_flag.provider_name: feature_flag.provider.name
+        # https://github.com/open-telemetry/semantic-conventions/pull/1994
+        - rename_attributes:
+            attribute_map:
+              feature_flag.evaluation.error.message: error.message
+  1.32.0:
+    all:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1989
+        - rename_attributes:
+            attribute_map:
+              feature_flag.evaluation.reason: feature_flag.result.reason
+              feature_flag.variant: feature_flag.result.variant
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/2042
+        - rename_metrics:
+            otel.sdk.span.live.count: otel.sdk.span.live
+            otel.sdk.span.ended.count: otel.sdk.span.ended
+            otel.sdk.processor.span.processed.count: otel.sdk.processor.span.processed
+            otel.sdk.exporter.span.inflight.count: otel.sdk.exporter.span.inflight
+            otel.sdk.exporter.span.exported.count: otel.sdk.exporter.span.exported
+  1.31.0:
+    all:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1880
+        - rename_attributes:
+            attribute_map:
+              android.state: android.app.state
+              io.state: ios.app.state
+    metrics:
+      changes:
+        - rename_metrics:
+            k8s.replication_controller.desired_pods: k8s.replicationcontroller.desired_pods
+            k8s.replication_controller.available_pods: k8s.replicationcontroller.available_pods
+        # https://github.com/open-telemetry/semantic-conventions/pull/1896
+        - rename_metrics:
+            system.cpu.time: cpu.time
+            system.cpu.utilization: cpu.utilization
+            system.cpu.frequency: cpu.frequency
+        # https://github.com/open-telemetry/semantic-conventions/pull/1896
+        - rename_attributes:
+            attribute_map:
+              system.cpu.logical_number: cpu.logical_number
+  1.30.0:
+    all:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1632
+        - rename_attributes:
+            attribute_map:
+              gen_ai.openai.request.seed: gen_ai.request.seed
+              system.network.state: network.connection.state
+        # https://github.com/open-telemetry/semantic-conventions/pull/1624
+        - rename_attributes:
+            attribute_map:
+              code.function: code.function.name
+              code.filepath: code.file.path
+              code.lineno: code.line.number
+              code.column: code.column.number
+        # https://github.com/open-telemetry/semantic-conventions/pull/1734
+        - rename_attributes:
+            attribute_map:
+              db.system: db.system.name
+              db.cassandra.coordinator.dc: cassandra.coordinator.dc
+              db.cassandra.coordinator.id: cassandra.coordinator.id
+              db.cassandra.consistency_level: cassandra.consistency.level
+              db.cassandra.idempotence: cassandra.query.idempotent
+              db.cassandra.page_size: cassandra.page.size
+              db.cassandra.speculative_execution_count: cassandra.speculative_execution.count
+              db.cosmosdb.client_id: azure.client.id
+              db.cosmosdb.connection_mode: azure.cosmosdb.connection.mode
+              db.cosmosdb.consistency_level: azure.cosmosdb.consistency.level
+              db.cosmosdb.request_charge: azure.cosmosdb.operation.request_charge
+              db.cosmosdb.request_content_length: azure.cosmosdb.request.body.size
+              db.cosmosdb.regions_contacted: azure.cosmosdb.operation.contacted_regions
+              db.cosmosdb.sub_status_code: azure.cosmosdb.response.sub_status_code
+              db.elasticsearch.node.name: elasticsearch.node.name
+              # db.elasticsearch.path_parts is a template attribute, schema transformation
+              # does not support it, adding as a comment for consistency
+              # db.elasticsearch.path_parts.<key> -> db.operation.parameter.<key>
+    metrics:
+      changes:
+        - rename_metrics:
+            db.client.cosmosdb.operation.request_charge: azure.cosmosdb.client.operation.request_charge
+            db.client.cosmosdb.active_instance.count: azure.cosmosdb.client.active_instance.count
+
+  1.29.0:
+    all:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1520
+        - rename_attributes:
+            attribute_map:
+              process.executable.build_id.profiling: process.executable.build_id.htlhash
+        # https://github.com/open-telemetry/semantic-conventions/pull/1383
+        - rename_attributes:
+            attribute_map:
+              vcs.repository.change.id: vcs.change.id
+              vcs.repository.change.title: vcs.change.title
+              vcs.repository.ref.name: vcs.ref.head.name
+              vcs.repository.ref.revision: vcs.ref.head.revision
+              vcs.repository.ref.type: vcs.ref.head.type
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1492
+        - rename_attributes:
+            attribute_map:
+              system.device: network.interface.name
+            apply_to_metrics:
+              - container.network.io
+              - system.network.dropped
+              - system.network.errors
+              - system.network.io
+              - system.network.connections
+  1.28.0:
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1422
+        - rename_metrics:
+            messaging.client.published.messages: messaging.client.sent.messages
+  1.27.0:
+    all:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1216
+        - rename_attributes:
+            attribute_map:
+              tls.client.server_name: server.address
+        # https://github.com/open-telemetry/semantic-conventions/pull/1075
+        - rename_attributes:
+            attribute_map:
+              deployment.environment: deployment.environment.name
+        # https://github.com/open-telemetry/semantic-conventions/pull/1245
+        - rename_attributes:
+            attribute_map:
+              messaging.kafka.message.offset: messaging.kafka.offset
+        # https://github.com/open-telemetry/semantic-conventions/pull/815
+        - rename_attributes:
+            attribute_map:
+              messaging.kafka.consumer.group: messaging.consumer.group.name
+              messaging.rocketmq.client_group: messaging.consumer.group.name
+              messaging.eventhubs.consumer.group: messaging.consumer.group.name
+              messaging.servicebus.destination.subscription_name: messaging.destination.subscription.name
+        # https://github.com/open-telemetry/semantic-conventions/pull/1200
+        - rename_attributes:
+            attribute_map:
+              gen_ai.usage.completion_tokens: gen_ai.usage.output_tokens
+              gen_ai.usage.prompt_tokens: gen_ai.usage.input_tokens
+    spans:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1002
+        - rename_attributes:
+            attribute_map:
+              db.elasticsearch.cluster.name: db.namespace
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/1125
+        - rename_attributes:
+            attribute_map:
+              db.client.connections.state: db.client.connection.state
+            apply_to_metrics:
+              - db.client.connection.count
+        - rename_attributes:
+            attribute_map:
+              db.client.connections.pool.name: db.client.connection.pool.name
+            apply_to_metrics:
+              - db.client.connection.count
+              - db.client.connection.idle.max
+              - db.client.connection.idle.min
+              - db.client.connection.max
+              - db.client.connection.pending_requests
+              - db.client.connection.timeouts
+              - db.client.connection.create_time
+              - db.client.connection.wait_time
+              - db.client.connection.use_time
+        # https://github.com/open-telemetry/semantic-conventions/pull/1006
+        - rename_metrics:
+            messaging.publish.messages: messaging.client.published.messages
+        # https://github.com/open-telemetry/semantic-conventions/pull/1026
+        - rename_attributes:
+            attribute_map:
+              system.cpu.state: cpu.mode
+              process.cpu.state: cpu.mode
+              container.cpu.state: cpu.mode
+            apply_to_metrics:
+              - system.cpu.time
+              - system.cpu.utilization
+              - process.cpu.time
+              - process.cpu.utilization
+              - container.cpu.time
+        # https://github.com/open-telemetry/semantic-conventions/pull/1265
+        - rename_metrics:
+            jvm.buffer.memory.usage: jvm.buffer.memory.used
+  1.26.0:
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/966
+        - rename_metrics:
+            db.client.connections.usage: db.client.connection.count
+            db.client.connections.idle.max: db.client.connection.idle.max
+            db.client.connections.idle.min: db.client.connection.idle.min
+            db.client.connections.max: db.client.connection.max
+            db.client.connections.pending_requests: db.client.connection.pending_requests
+            db.client.connections.timeouts: db.client.connection.timeouts
+        # https://github.com/open-telemetry/semantic-conventions/pull/948
+        - rename_attributes:
+            attribute_map:
+              messaging.client_id: messaging.client.id
+        # https://github.com/open-telemetry/semantic-conventions/pull/909
+        - rename_attributes:
+            attribute_map:
+              state: db.client.connections.state
+            apply_to_metrics:
+              - db.client.connections.usage
+        - rename_attributes:
+            attribute_map:
+              pool.name: db.client.connections.pool.name
+            apply_to_metrics:
+              - db.client.connections.usage
+              - db.client.connections.idle.max
+              - db.client.connections.idle.min
+              - db.client.connections.max
+              - db.client.connections.pending_requests
+              - db.client.connections.timeouts
+              - db.client.connections.create_time
+              - db.client.connections.wait_time
+              - db.client.connections.use_time
+    all:
+      changes:
+        # https://github:com/open-telemetry/semantic-conventions/pull/731/
+        - rename_attributes:
+            attribute_map:
+              enduser.id: user.id
+
+  1.25.0:
+    spans:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/911
+        - rename_attributes:
+            attribute_map:
+              db.name: db.namespace
+        # https://github.com/open-telemetry/semantic-conventions/pull/870
+        - rename_attributes:
+            attribute_map:
+              db.sql.table: db.collection.name
+              db.mongodb.collection: db.collection.name
+              db.cosmosdb.container: db.collection.name
+              db.cassandra.table: db.collection.name
+        # https://github.com/open-telemetry/semantic-conventions/pull/798
+        - rename_attributes:
+            attribute_map:
+              messaging.kafka.destination.partition: messaging.destination.partition.id
+        # https://github.com/open-telemetry/semantic-conventions/pull/875
+        - rename_attributes:
+            attribute_map:
+              db.operation: db.operation.name
+        # https://github.com/open-telemetry/semantic-conventions/pull/913
+        - rename_attributes:
+            attribute_map:
+              messaging.operation: messaging.operation.type
+        # https://github.com/open-telemetry/semantic-conventions/pull/866
+        - rename_attributes:
+            attribute_map:
+              db.statement: db.query.text
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/484
+        - rename_attributes:
+            attribute_map:
+              system.processes.status: system.process.status
+            apply_to_metrics:
+              - system.processes.count
+        - rename_metrics:
+            system.processes.count: system.process.count
+            system.processes.created: system.process.created
+        # https://github.com/open-telemetry/semantic-conventions/pull/625
+        - rename_attributes:
+            attribute_map:
+              container.labels: container.label
+              k8s.pod.labels: k8s.pod.label
+        # https://github.com/open-telemetry/semantic-conventions/pull/330
+        - rename_metrics:
+            process.threads: process.thread.count
+            process.open_file_descriptors: process.open_file_descriptor.count
+        - rename_attributes:
+            attribute_map:
+              state: process.cpu.state
+            apply_to_metrics:
+              - process.cpu.time
+              - process.cpu.utilization
+        - rename_attributes:
+            attribute_map:
+              direction: disk.io.direction
+            apply_to_metrics:
+              - process.disk.io
+        - rename_attributes:
+            attribute_map:
+              type: process.context_switch_type
+            apply_to_metrics:
+              - process.context_switches
+        - rename_attributes:
+            attribute_map:
+              direction: network.io.direction
+            apply_to_metrics:
+              - process.network.io
+        - rename_attributes:
+            attribute_map:
+              type: process.paging.fault_type
+            apply_to_metrics:
+              - process.paging.faults
+    all:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/854
+        - rename_attributes:
+            attribute_map:
+              message.type: rpc.message.type
+              message.id: rpc.message.id
+              message.compressed_size: rpc.message.compressed_size
+              message.uncompressed_size: rpc.message.uncompressed_size
+
+  1.24.0:
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/536
+        - rename_metrics:
+            jvm.memory.usage: jvm.memory.used
+            jvm.memory.usage_after_last_gc: jvm.memory.used_after_last_gc
+        # https://github.com/open-telemetry/semantic-conventions/pull/530
+        - rename_attributes:
+            attribute_map:
+              system.network.io.direction: network.io.direction
+              system.disk.io.direction: disk.io.direction
+  1.23.1:
+  1.23.0:
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/20
+        - rename_attributes:
+            attribute_map:
+              thread.daemon: jvm.thread.daemon
+            apply_to_metrics:
+              - jvm.thread.count
+  1.22.0:
+    spans:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/229
+        - rename_attributes:
+            attribute_map:
+              messaging.message.payload_size_bytes: messaging.message.body.size
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/374
+        - rename_attributes:
+            attribute_map:
+              http.resend_count: http.request.resend_count
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/224
+        - rename_metrics:
+            http.client.duration: http.client.request.duration
+            http.server.duration: http.server.request.duration
+        # https://github.com/open-telemetry/semantic-conventions/pull/241
+        - rename_metrics:
+            process.runtime.jvm.memory.usage: jvm.memory.usage
+            process.runtime.jvm.memory.committed: jvm.memory.committed
+            process.runtime.jvm.memory.limit: jvm.memory.limit
+            process.runtime.jvm.memory.usage_after_last_gc: jvm.memory.usage_after_last_gc
+            process.runtime.jvm.gc.duration: jvm.gc.duration
+            # also https://github.com/open-telemetry/semantic-conventions/pull/252
+            process.runtime.jvm.threads.count: jvm.thread.count
+            # also https://github.com/open-telemetry/semantic-conventions/pull/252
+            process.runtime.jvm.classes.loaded: jvm.class.loaded
+            # also https://github.com/open-telemetry/semantic-conventions/pull/252
+            process.runtime.jvm.classes.unloaded: jvm.class.unloaded
+            # also https://github.com/open-telemetry/semantic-conventions/pull/252
+            # and https://github.com/open-telemetry/semantic-conventions/pull/60
+            process.runtime.jvm.classes.current_loaded: jvm.class.count
+            process.runtime.jvm.cpu.time: jvm.cpu.time
+            process.runtime.jvm.cpu.recent_utilization: jvm.cpu.recent_utilization
+            process.runtime.jvm.memory.init: jvm.memory.init
+            process.runtime.jvm.system.cpu.utilization: jvm.system.cpu.utilization
+            process.runtime.jvm.system.cpu.load_1m: jvm.system.cpu.load_1m
+            # https://github.com/open-telemetry/semantic-conventions/pull/253
+            process.runtime.jvm.buffer.usage: jvm.buffer.memory.usage
+            # https://github.com/open-telemetry/semantic-conventions/pull/253
+            process.runtime.jvm.buffer.limit: jvm.buffer.memory.limit
+            process.runtime.jvm.buffer.count: jvm.buffer.count
+        # https://github.com/open-telemetry/semantic-conventions/pull/20
+        - rename_attributes:
+            attribute_map:
+              type: jvm.memory.type
+              pool: jvm.memory.pool.name
+            apply_to_metrics:
+              - jvm.memory.usage
+              - jvm.memory.committed
+              - jvm.memory.limit
+              - jvm.memory.usage_after_last_gc
+              - jvm.memory.init
+        - rename_attributes:
+            attribute_map:
+              name: jvm.gc.name
+              action: jvm.gc.action
+            apply_to_metrics:
+              - jvm.gc.duration
+        - rename_attributes:
+            attribute_map:
+              daemon: thread.daemon
+            apply_to_metrics:
+              - jvm.threads.count
+        - rename_attributes:
+            attribute_map:
+              pool: jvm.buffer.pool.name
+            apply_to_metrics:
+              - jvm.buffer.memory.usage
+              - jvm.buffer.memory.limit
+              - jvm.buffer.count
+        # https://github.com/open-telemetry/semantic-conventions/pull/89
+        - rename_attributes:
+            attribute_map:
+              state: system.cpu.state
+              cpu: system.cpu.logical_number
+            apply_to_metrics:
+              - system.cpu.time
+              - system.cpu.utilization
+        - rename_attributes:
+            attribute_map:
+              state: system.memory.state
+            apply_to_metrics:
+              - system.memory.usage
+              - system.memory.utilization
+        - rename_attributes:
+            attribute_map:
+              state: system.paging.state
+            apply_to_metrics:
+              - system.paging.usage
+              - system.paging.utilization
+        - rename_attributes:
+            attribute_map:
+              type: system.paging.type
+              direction: system.paging.direction
+            apply_to_metrics:
+              - system.paging.faults
+              - system.paging.operations
+        - rename_attributes:
+            attribute_map:
+              device: system.device
+              direction: system.disk.direction
+            apply_to_metrics:
+              - system.disk.io
+              - system.disk.operations
+              - system.disk.io_time
+              - system.disk.operation_time
+              - system.disk.merged
+        - rename_attributes:
+            attribute_map:
+              device: system.device
+              state: system.filesystem.state
+              type: system.filesystem.type
+              mode: system.filesystem.mode
+              mountpoint: system.filesystem.mountpoint
+            apply_to_metrics:
+              - system.filesystem.usage
+              - system.filesystem.utilization
+        - rename_attributes:
+            attribute_map:
+              device: system.device
+              direction: system.network.direction
+              protocol: network.protocol
+              state: system.network.state
+            apply_to_metrics:
+              - system.network.dropped
+              - system.network.packets
+              - system.network.errors
+              - system.network.io
+              - system.network.connections
+        - rename_attributes:
+            attribute_map:
+              status: system.processes.status
+            apply_to_metrics:
+              - system.processes.count
+        # https://github.com/open-telemetry/semantic-conventions/pull/247
+        - rename_metrics:
+            http.server.request.size: http.server.request.body.size
+            http.server.response.size: http.server.response.body.size
+    resources:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/178
+        - rename_attributes:
+            attribute_map:
+              telemetry.auto.version: telemetry.distro.version
+  1.21.0:
+    spans:
+      changes:
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/3336
+        - rename_attributes:
+            attribute_map:
+              messaging.kafka.client_id: messaging.client_id
+              messaging.rocketmq.client_id: messaging.client_id
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/3402
+        - rename_attributes:
+            attribute_map:
+              # net.peer.(name|port) attributes were usually populated on client side
+              # so they should be usually translated to server.(address|port)
+              # net.host.* attributes were only populated on server side
+              net.host.name: server.address
+              net.host.port: server.port
+              # was only populated on client side
+              net.sock.peer.name: server.socket.domain
+              # net.sock.peer.(addr|port) mapping is not possible
+              # since they applied to both client and server side
+              # were only populated on server side
+              net.sock.host.addr: server.socket.address
+              net.sock.host.port: server.socket.port
+              http.client_ip: client.address
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/3426
+        - rename_attributes:
+            attribute_map:
+              net.protocol.name: network.protocol.name
+              net.protocol.version: network.protocol.version
+              net.host.connection.type: network.connection.type
+              net.host.connection.subtype: network.connection.subtype
+              net.host.carrier.name: network.carrier.name
+              net.host.carrier.mcc: network.carrier.mcc
+              net.host.carrier.mnc: network.carrier.mnc
+              net.host.carrier.icc: network.carrier.icc
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/3355
+        - rename_attributes:
+            attribute_map:
+              http.method: http.request.method
+              http.status_code: http.response.status_code
+              http.scheme: url.scheme
+              http.url: url.full
+              http.request_content_length: http.request.body.size
+              http.response_content_length: http.response.body.size
+    metrics:
+      changes:
+        # https://github.com/open-telemetry/semantic-conventions/pull/53
+        - rename_metrics:
+            process.runtime.jvm.cpu.utilization: process.runtime.jvm.cpu.recent_utilization
+  1.20.0:
+    spans:
+      changes:
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/3272
+        - rename_attributes:
+            attribute_map:
+              net.app.protocol.name: net.protocol.name
+              net.app.protocol.version: net.protocol.version
+  1.19.0:
+    spans:
+      changes:
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/3209
+        - rename_attributes:
+            attribute_map:
+              faas.execution: faas.invocation_id
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/3188
+        - rename_attributes:
+            attribute_map:
+              faas.id: cloud.resource_id
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/3190
+        - rename_attributes:
+            attribute_map:
+              http.user_agent: user_agent.original
+    resources:
+      changes:
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/3190
+        - rename_attributes:
+            attribute_map:
+              browser.user_agent: user_agent.original
+  1.18.0:
+  1.17.0:
+    spans:
+      changes:
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/2957
+        - rename_attributes:
+            attribute_map:
+              messaging.consumer_id: messaging.consumer.id
+              messaging.protocol: net.app.protocol.name
+              messaging.protocol_version: net.app.protocol.version
+              messaging.destination: messaging.destination.name
+              messaging.temp_destination: messaging.destination.temporary
+              messaging.destination_kind: messaging.destination.kind
+              messaging.message_id: messaging.message.id
+              messaging.conversation_id: messaging.message.conversation_id
+              messaging.message_payload_size_bytes: messaging.message.payload_size_bytes
+              messaging.message_payload_compressed_size_bytes: messaging.message.payload_compressed_size_bytes
+              messaging.rabbitmq.routing_key: messaging.rabbitmq.destination.routing_key
+              messaging.kafka.message_key: messaging.kafka.message.key
+              messaging.kafka.partition: messaging.kafka.destination.partition
+              messaging.kafka.tombstone: messaging.kafka.message.tombstone
+              messaging.rocketmq.message_type: messaging.rocketmq.message.type
+              messaging.rocketmq.message_tag: messaging.rocketmq.message.tag
+              messaging.rocketmq.message_keys: messaging.rocketmq.message.keys
+              messaging.kafka.consumer_group: messaging.kafka.consumer.group
+  1.16.0:
+  1.15.0:
+    spans:
+      changes:
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/2743
+        - rename_attributes:
+            attribute_map:
+              http.retry_count: http.resend_count
+  1.14.0:
+  1.13.0:
+    spans:
+      changes:
+        # https://github.com/open-telemetry/opentelemetry-specification/pull/2614
+        - rename_attributes:
+            attribute_map:
+              net.peer.ip: net.sock.peer.addr
+              net.host.ip: net.sock.host.addr
+  1.12.0:
+  1.11.0:
+  1.10.0:
+  1.9.0:
+  1.8.0:
+    spans:
+      changes:
+        - rename_attributes:
+            attribute_map:
+              db.cassandra.keyspace: db.name
+              db.hbase.namespace: db.name
+  1.7.0:
+  1.6.1:
+  1.5.0:
+  1.4.0: