go.opentelemetry.io/otel/sdk/metric v1.37.0: WithTemporalitySelector

# OpenTelemetry Go Metric TemporalitySelector & WithTemporalitySelector Contract

## Search Known Solution Result
`search_known_solution` returned `NO_SAFE_MATCH` for `go.opentelemetry.io/otel/sdk/metric.WithTemporalitySelector` in `pkg:golang/go.opentelemetry.io/otel/sdk/metric@v1.37.0`.
While existing samples verify general `NewManualReader` collection or trace context lifecycles, none demonstrated how `WithTemporalitySelector` alters instrument temporality aggregation rules across successive reader collection cycles.

## Key Behaviors Proven
1. `sdkmetric.DefaultTemporalitySelector` assigns `metricdata.CumulativeTemporality` across all standard `InstrumentKind`s (Counter, UpDownCounter, Histogram, ObservableCounter, ObservableUpDownCounter, ObservableGauge).
2. `sdkmetric.WithTemporalitySelector` configures a `ManualReader` to query a custom `TemporalitySelector` function for each instrument.
3. For instruments mapped to `metricdata.DeltaTemporality` (such as `InstrumentKindCounter`), the generated `metricdata.Sum[int64]` explicitly records `Temporality == metricdata.DeltaTemporality`. Successive collections report the incremental delta since the previous collection rather than the cumulative total.
4. Instruments not mapped to Delta (such as `InstrumentKindUpDownCounter`) retain `CumulativeTemporality`, reporting cumulative sums across consecutive collection intervals.
5. A `ManualReader` initialized without `WithTemporalitySelector` defaults to cumulative temporality across all instruments, accumulating measurements across consecutive collections.

## What a Model Would Have Written Instead
A model might assume that `TemporalitySelector` is configured at the provider or exporter level rather than as an option to `NewManualReader`, or assume that `DeltaTemporality` resets the internal counter in a way that affects other readers or alters the instrument's monotonic property.

## How the Wrong Version Fails
Code assuming default reader temporality reports delta metrics will misinterpret cumulative metrics as deltas, causing downstream telemetry pipelines to vastly over-count metrics across collection cycles. Conversely, passing unconfigured readers when delta metrics are expected leads to invalid metrics processing downstream.

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify go.opentelemetry.io/otel/sdk/metric.WithTemporalitySelector in pkg:golang/go.opentelemetry.io/otel/sdk/metric@v1.37.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/go.opentelemetry.io/otel/sdk/metric@v1.37.0
Demonstrate these symbols/APIs:
  - go.opentelemetry.io/otel/sdk/metric.WithTemporalitySelector

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:5f4e987ca379f51b3a48bf962a0592a103ee4f6453c1e11abfef62f69988b79b","contract":["DefaultTemporalitySelector assigns CumulativeTemporality to all instrument kinds","WithTemporalitySelector configures a ManualReader to use custom temporality per instrument kind","Counter configured with WithTemporalitySelector has DeltaTemporality and reports incremental deltas per collection","Instrument kinds not mapped to Delta retain CumulativeTemporality and report running totals","ManualReader without WithTemporalitySelector defaults to CumulativeTemporality for all instruments"],"goal":"verify go.opentelemetry.io/otel/sdk/metric.WithTemporalitySelector in pkg:golang/go.opentelemetry.io/otel/sdk/metric@v1.37.0","kind":"HOW","packages":["pkg:golang/go.opentelemetry.io/otel/sdk/metric@v1.37.0"],"schemaVersion":1,"symbols":["go.opentelemetry.io/otel/sdk/metric.WithTemporalitySelector"]},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/go.opentelemetry.io/otel/sdk/metric@v1.37.0"],"schemaVersion":1,"subject":"pkg:golang/go.opentelemetry.io/otel/sdk/metric@v1.37.0","symbols":["go.opentelemetry.io/otel/sdk/metric.WithTemporalitySelector"],"verifierAdapter":"golang@1"}

module sample

go 1.26.6

require (
	go.opentelemetry.io/otel v1.37.0
	go.opentelemetry.io/otel/metric v1.37.0
	go.opentelemetry.io/otel/sdk/metric v1.37.0
)

require (
	github.com/go-logr/logr v1.4.3 // indirect
	github.com/go-logr/stdr v1.2.2 // indirect
	github.com/google/uuid v1.6.0 // indirect
	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
	go.opentelemetry.io/otel/trace v1.37.0 // indirect
	golang.org/x/sys v0.33.0 // indirect
)

github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
go.opentelemetry.io/otel/sdk/metric v1.37.0 h1:90lI228XrB9jCMuSdA0673aubgRobVZFhbjxHHspCPc=
go.opentelemetry.io/otel/sdk/metric v1.37.0/go.mod h1:cNen4ZWfiD37l5NhS+Keb5RXVWZWpRE+9WyVCpbo5ps=
go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

package sample

import (
	sdkmetric "go.opentelemetry.io/otel/sdk/metric"
	"go.opentelemetry.io/otel/sdk/metric/metricdata"
)

// NewDeltaManualReader creates a ManualReader configured with WithTemporalitySelector
// that selects DeltaTemporality for the specified instrument kind, and CumulativeTemporality otherwise.
func NewDeltaManualReader(deltaKind sdkmetric.InstrumentKind) *sdkmetric.ManualReader {
	selector := func(kind sdkmetric.InstrumentKind) metricdata.Temporality {
		if kind == deltaKind {
			return metricdata.DeltaTemporality
		}
		return metricdata.CumulativeTemporality
	}
	return sdkmetric.NewManualReader(sdkmetric.WithTemporalitySelector(selector))
}

// NewDefaultManualReader creates a ManualReader without WithTemporalitySelector,
// which defaults to DefaultTemporalitySelector (CumulativeTemporality for all kinds).
func NewDefaultManualReader() *sdkmetric.ManualReader {
	return sdkmetric.NewManualReader()
}

// NewProviderWithReader configures a MeterProvider registered with the given reader.
func NewProviderWithReader(r sdkmetric.Reader) *sdkmetric.MeterProvider {
	return sdkmetric.NewMeterProvider(
		sdkmetric.WithReader(r),
	)
}

{
  "schemaVersion": 1,
  "goal": "verify go.opentelemetry.io/otel/sdk/metric.WithTemporalitySelector in pkg:golang/go.opentelemetry.io/otel/sdk/metric@v1.37.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/go.opentelemetry.io/otel/sdk/metric@v1.37.0"
  ],
  "symbols": [
    "go.opentelemetry.io/otel/sdk/metric.WithTemporalitySelector"
  ]
}

package main

import (
	"context"
	"fmt"
	"os"

	"go.opentelemetry.io/otel/attribute"
	otelmetric "go.opentelemetry.io/otel/metric"
	sdkmetric "go.opentelemetry.io/otel/sdk/metric"
	"go.opentelemetry.io/otel/sdk/metric/metricdata"
	"sample"
)

func main() {
	ctx := context.Background()

	// Assertion 1: DefaultTemporalitySelector assigns CumulativeTemporality to all instrument kinds
	kinds := []sdkmetric.InstrumentKind{
		sdkmetric.InstrumentKindCounter,
		sdkmetric.InstrumentKindUpDownCounter,
		sdkmetric.InstrumentKindHistogram,
		sdkmetric.InstrumentKindObservableCounter,
		sdkmetric.InstrumentKindObservableUpDownCounter,
		sdkmetric.InstrumentKindObservableGauge,
	}
	for _, k := range kinds {
		if t := sdkmetric.DefaultTemporalitySelector(k); t != metricdata.CumulativeTemporality {
			fmt.Fprintf(os.Stderr, "FAIL: DefaultTemporalitySelector(%v) = %v, expected CumulativeTemporality\n", k, t)
			os.Exit(1)
		}
	}

	// Assertion 2: WithTemporalitySelector configures a ManualReader to use custom temporality per instrument kind
	customSelector := func(kind sdkmetric.InstrumentKind) metricdata.Temporality {
		if kind == sdkmetric.InstrumentKindCounter {
			return metricdata.DeltaTemporality
		}
		return metricdata.CumulativeTemporality
	}
	deltaReader := sdkmetric.NewManualReader(sdkmetric.WithTemporalitySelector(customSelector))
	if deltaReader == nil {
		fmt.Fprintf(os.Stderr, "FAIL: NewManualReader with WithTemporalitySelector returned nil\n")
		os.Exit(1)
	}

	deltaProvider := sample.NewProviderWithReader(deltaReader)
	deltaMeter := deltaProvider.Meter("delta-test")

	deltaCounter, err := deltaMeter.Int64Counter("items_delta")
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: Int64Counter failed: %v\n", err)
		os.Exit(1)
	}

	upDownCounter, err := deltaMeter.Int64UpDownCounter("items_updown")
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: Int64UpDownCounter failed: %v\n", err)
		os.Exit(1)
	}

	// Record initial values: 10 to counter, 10 to upDownCounter
	deltaCounter.Add(ctx, 10, otelmetric.WithAttributes(attribute.String("env", "test")))
	upDownCounter.Add(ctx, 10, otelmetric.WithAttributes(attribute.String("env", "test")))

	var rm1 metricdata.ResourceMetrics
	if err := deltaReader.Collect(ctx, &rm1); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: first deltaReader.Collect failed: %v\n", err)
		os.Exit(1)
	}

	// Verify temporality and values from first collection
	var foundCounter, foundUpDown bool
	for _, sm := range rm1.ScopeMetrics {
		for _, m := range sm.Metrics {
			switch m.Name {
			case "items_delta":
				foundCounter = true
				sum, ok := m.Data.(metricdata.Sum[int64])
				if !ok {
					fmt.Fprintf(os.Stderr, "FAIL: items_delta data is not metricdata.Sum[int64]\n")
					os.Exit(1)
				}
				// Assertion 3: Counter configured with WithTemporalitySelector has DeltaTemporality
				if sum.Temporality != metricdata.DeltaTemporality {
					fmt.Fprintf(os.Stderr, "FAIL: items_delta temporality = %v, expected DeltaTemporality\n", sum.Temporality)
					os.Exit(1)
				}
				if len(sum.DataPoints) != 1 || sum.DataPoints[0].Value != 10 {
					fmt.Fprintf(os.Stderr, "FAIL: items_delta first collection expected 10, got %v\n", sum.DataPoints)
					os.Exit(1)
				}
			case "items_updown":
				foundUpDown = true
				sum, ok := m.Data.(metricdata.Sum[int64])
				if !ok {
					fmt.Fprintf(os.Stderr, "FAIL: items_updown data is not metricdata.Sum[int64]\n")
					os.Exit(1)
				}
				// Assertion 4: UpDownCounter configured to Cumulative has CumulativeTemporality
				if sum.Temporality != metricdata.CumulativeTemporality {
					fmt.Fprintf(os.Stderr, "FAIL: items_updown temporality = %v, expected CumulativeTemporality\n", sum.Temporality)
					os.Exit(1)
				}
				if len(sum.DataPoints) != 1 || sum.DataPoints[0].Value != 10 {
					fmt.Fprintf(os.Stderr, "FAIL: items_updown first collection expected 10, got %v\n", sum.DataPoints)
					os.Exit(1)
				}
			}
		}
	}
	if !foundCounter || !foundUpDown {
		fmt.Fprintf(os.Stderr, "FAIL: missing metric in first collection: counter=%v, updown=%v\n", foundCounter, foundUpDown)
		os.Exit(1)
	}

	// Record second batch of measurements: +5 to counter, +5 to upDownCounter
	deltaCounter.Add(ctx, 5, otelmetric.WithAttributes(attribute.String("env", "test")))
	upDownCounter.Add(ctx, 5, otelmetric.WithAttributes(attribute.String("env", "test")))

	var rm2 metricdata.ResourceMetrics
	if err := deltaReader.Collect(ctx, &rm2); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: second deltaReader.Collect failed: %v\n", err)
		os.Exit(1)
	}

	// Assertion 5: Under DeltaTemporality, second collection reports 5 (delta), whereas Cumulative reports 15 (cumulative sum)
	for _, sm := range rm2.ScopeMetrics {
		for _, m := range sm.Metrics {
			switch m.Name {
			case "items_delta":
				sum := m.Data.(metricdata.Sum[int64])
				if len(sum.DataPoints) != 1 || sum.DataPoints[0].Value != 5 {
					fmt.Fprintf(os.Stderr, "FAIL: items_delta second collection expected delta value 5, got %v\n", sum.DataPoints)
					os.Exit(1)
				}
			case "items_updown":
				sum := m.Data.(metricdata.Sum[int64])
				if len(sum.DataPoints) != 1 || sum.DataPoints[0].Value != 15 {
					fmt.Fprintf(os.Stderr, "FAIL: items_updown second collection expected cumulative value 15, got %v\n", sum.DataPoints)
					os.Exit(1)
				}
			}
		}
	}

	// Assertion 6: ManualReader without WithTemporalitySelector preserves CumulativeTemporality for Counter (values 10 then 15)
	defaultReader := sample.NewDefaultManualReader()
	defaultProvider := sample.NewProviderWithReader(defaultReader)
	defaultMeter := defaultProvider.Meter("default-test")
	defaultCounter, err := defaultMeter.Int64Counter("items_default")
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: default Int64Counter failed: %v\n", err)
		os.Exit(1)
	}

	defaultCounter.Add(ctx, 10, otelmetric.WithAttributes(attribute.String("env", "test")))
	var defRm1 metricdata.ResourceMetrics
	if err := defaultReader.Collect(ctx, &defRm1); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: defaultReader.Collect failed: %v\n", err)
		os.Exit(1)
	}
	defSum1 := defRm1.ScopeMetrics[0].Metrics[0].Data.(metricdata.Sum[int64])
	if defSum1.Temporality != metricdata.CumulativeTemporality || defSum1.DataPoints[0].Value != 10 {
		fmt.Fprintf(os.Stderr, "FAIL: default counter first collect expected Cumulative and 10, got %v and %v\n", defSum1.Temporality, defSum1.DataPoints[0].Value)
		os.Exit(1)
	}

	defaultCounter.Add(ctx, 5, otelmetric.WithAttributes(attribute.String("env", "test")))
	var defRm2 metricdata.ResourceMetrics
	if err := defaultReader.Collect(ctx, &defRm2); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: defaultReader.Collect 2 failed: %v\n", err)
		os.Exit(1)
	}
	defSum2 := defRm2.ScopeMetrics[0].Metrics[0].Data.(metricdata.Sum[int64])
	if defSum2.Temporality != metricdata.CumulativeTemporality || defSum2.DataPoints[0].Value != 15 {
		fmt.Fprintf(os.Stderr, "FAIL: default counter second collect expected Cumulative and 15, got %v and %v\n", defSum2.Temporality, defSum2.DataPoints[0].Value)
		os.Exit(1)
	}

	// Cleanup providers
	if err := deltaProvider.Shutdown(ctx); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: deltaProvider.Shutdown failed: %v\n", err)
		os.Exit(1)
	}
	if err := defaultProvider.Shutdown(ctx); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: defaultProvider.Shutdown failed: %v\n", err)
		os.Exit(1)
	}

	fmt.Println("PASS: go.opentelemetry.io/otel/sdk/metric.WithTemporalitySelector contract verified")
}