From 0b47699705ec9db104f1903d86562635e6a87e87 Mon Sep 17 00:00:00 2001 From: Tyler Yahn Date: Tue, 26 Aug 2025 09:20:45 -0700 Subject: [PATCH] Add `AddSet` and `RecordSet` methods to semconv generated packages (#7223) The current design of the packages is for ergonomics, and it works well at this. However, it is not the most performant. When a user passes a slice of attributes it will use [`metric.WithAttributes`](https://github.com/open-telemetry/opentelemetry-go/blob/cf787f3e3ad0093985b0834eaf63ceb679705545/metric/instrument.go#L372-L376): ```go func WithAttributes(attributes ...attribute.KeyValue) MeasurementOption { cp := make([]attribute.KeyValue, len(attributes)) copy(cp, attributes) return attrOpt{set: attribute.NewSet(cp...)} } ``` This will copy the passed attributes and then pass that copy to `attribute.NewSet` which adds its own allocation. If a user is performance conscious and already have a set, allow them to pass it directly and reduce the required allocations for the measurement call. ## Alternatives Considered ### Why not allow users to just use `Inst()` method? With the current design a user can still just call: ```go counter.Inst().Add(ctx, val, metric.WithAttributeSet(set)) ``` However, the option slice (in this case `[]metric.AddOption`) is allocated on the call. Meaning a user will also need to recreate the pooling that our semconv generated packages already handle. Providing the `*Set` methods is convenient, but it also helps the application performance as one larger pool will be less strain on the GC than many smaller ones. ### Why not just call `WithAttributeSet` in the existing methods? Instead of appending a `WithAttributes` option internal to all the measurement methods, we could also just create a `Set` and pass that with `WithAttributeSet`. This will avoid the additional slice copy that `WithAttributes` does on top of calling `attribute.NewSet`. However, this copy that `WithAttributes` does is important as calling `attribute.NewSet` will sort the original slice. Bypassing that will mean all the passed attribute slices will be modified when used. This is not great as it is likely going to be unexpected behavior by the user, and is the reason we copy the slice in `WithAttributes` in the first place. ### Why not just copy user attributes to an amortized slice pool to create a new `attribute.Set`? The additional creation of an `[]attribute.KeyValue` that user attributes are copied to in order to prevent modification can be amortized with a pool. For example, #7249. There shouldn't be any difference than between calling a `*Set` method introduced here vs the non-`Set` method. This is true, and motivates this type of change. However, also providing these additional methods allows the user additional performance gains if the set is used for more than one measurement. For example: ```go set := attributes.NewSet(attrs) counter1.AddSet(ctx, 1, set) counter2.AddSet(ctx, 2, set) // No additional set is created here. ``` Without these methods: ```go counter1.Add(ctx, 1, attrs...) // A set is created for attrs counter2.Add(ctx, 2, attrs...) // Another set is created for attrs ``` Each `attribute.Set` created will require an allocation (i.e. the internal `any` field needs to be allocated to the heap). Meaning without these methods a user will still not be able to write the most performant code. The attribute pool approach has merit, and should be pursued. However, it does not invalidate the value of these changes. --- semconv/templates/registry/go/instrument.j2 | 52 +- semconv/templates/registry/go/metric.go.j2 | 4 + semconv/v1.36.0/azureconv/metric.go | 37 +- semconv/v1.36.0/cicdconv/metric.go | 102 +- semconv/v1.36.0/containerconv/metric.go | 128 +- semconv/v1.36.0/dbconv/metric.go | 206 ++- semconv/v1.36.0/dnsconv/metric.go | 18 +- semconv/v1.36.0/faasconv/metric.go | 166 +- semconv/v1.36.0/genaiconv/metric.go | 90 +- semconv/v1.36.0/goconv/metric.go | 21 +- semconv/v1.36.0/httpconv/metric.go | 211 ++- semconv/v1.36.0/hwconv/metric.go | 168 +- semconv/v1.36.0/k8sconv/metric.go | 1798 ++++++++++++++++++- semconv/v1.36.0/messagingconv/metric.go | 90 +- semconv/v1.36.0/otelconv/metric.go | 309 +++- semconv/v1.36.0/processconv/metric.go | 192 +- semconv/v1.36.0/rpcconv/metric.go | 214 ++- semconv/v1.36.0/signalrconv/metric.go | 43 +- semconv/v1.36.0/systemconv/metric.go | 613 ++++++- semconv/v1.36.0/vcsconv/metric.go | 195 +- 20 files changed, 4443 insertions(+), 214 deletions(-) diff --git a/semconv/templates/registry/go/instrument.j2 b/semconv/templates/registry/go/instrument.j2 index 3df51a907..25700b640 100644 --- a/semconv/templates/registry/go/instrument.j2 +++ b/semconv/templates/registry/go/instrument.j2 @@ -137,7 +137,7 @@ func (m {{ name }}) Add( {%- macro add_method(metric, inst, pkg="") -%} -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. {%- if metric.attributes is not none and metric.attributes | length > 0 %} {{ params_docs(metric.attributes, pkg=pkg) }} {%- if metric.note is defined %} @@ -168,6 +168,30 @@ func (m {{ h.to_go_name(metric.metric_name, pkg) }}) Add(ctx context.Context, in {%- endif -%} {%- endmacro -%} +{%- macro add_set_method(metric, inst, pkg="") -%} + +// AddSet adds incr to the existing count for set. +{%- if metric.note is defined %} +// +{{ metric.note | comment }} +{%- endif %} +func (m {{ h.to_go_name(metric.metric_name, pkg) }}) AddSet(ctx context.Context, incr {{ value_type(metric) | lower }}, set attribute.Set) { + if set.Len() == 0 { + m.{{ inst }}.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.{{ inst }}.Add(ctx, incr, *o...) +} +{%- endmacro -%} + {%- macro record_method_with_optional(metric, inst, pkg="") -%} {%- set name = h.to_go_name(metric.metric_name, pkg) -%} {%- set req_attr = metric.attributes | required | attribute_sort -%} @@ -198,7 +222,7 @@ func (m {{ name }}) Record( {%- macro record_method(metric, inst, pkg="") -%} -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. {%- if metric.attributes is not none and metric.attributes | length > 0 %} {{ params_docs(metric.attributes, pkg=pkg) }} {%- if metric.note is defined %} @@ -230,6 +254,30 @@ func (m {{ name }}) Record(ctx context.Context, val {{ value_type(metric) | lowe {%- endif -%} {%- endmacro -%} +{%- macro record_set_method(metric, inst, pkg="") -%} +{%- set name = h.to_go_name(metric.metric_name, pkg) -%} + +// RecordSet records val to the current distribution for set. +{%- if metric.note is defined %} +// +{{ metric.note | comment }} +{%- endif %} +func (m {{ name }}) RecordSet(ctx context.Context, val {{ value_type(metric) | lower }}, set attribute.Set) { + if set.Len() == 0 { + m.{{ inst }}.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.{{ inst }}.Record(ctx, val, *o...) +} +{%- endmacro -%} + {%- macro desc(metric) -%} {{metric.brief | replace('\n', ' ') | trim}} {%- endmacro -%} diff --git a/semconv/templates/registry/go/metric.go.j2 b/semconv/templates/registry/go/metric.go.j2 index 98f8792f6..f516d120b 100644 --- a/semconv/templates/registry/go/metric.go.j2 +++ b/semconv/templates/registry/go/metric.go.j2 @@ -106,9 +106,13 @@ func ({{ metric_name }}) Description() string { {%- elif metric.instrument == "counter" or metric.instrument == "updowncounter" %} {{ i.add_method(metric, metric_inst, ctx.root_namespace) }} + +{{ i.add_set_method(metric, metric_inst, ctx.root_namespace) }} {%- elif metric.instrument == "histogram" or metric.instrument == "gauge" %} {{ i.record_method(metric, metric_inst, ctx.root_namespace) }} + +{{ i.record_set_method(metric, metric_inst, ctx.root_namespace) }} {%- endif %} {%- for attr in metric.attributes | not_required | attribute_sort %} {%- set name = h.to_go_name(attr.name, ctx.root_namespace) %} diff --git a/semconv/v1.36.0/azureconv/metric.go b/semconv/v1.36.0/azureconv/metric.go index 8d94f54c9..9d08c2ca7 100644 --- a/semconv/v1.36.0/azureconv/metric.go +++ b/semconv/v1.36.0/azureconv/metric.go @@ -108,7 +108,7 @@ func (CosmosDBClientActiveInstanceCount) Description() string { return "Number of active client instances" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m CosmosDBClientActiveInstanceCount) Add( @@ -137,6 +137,23 @@ func (m CosmosDBClientActiveInstanceCount) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m CosmosDBClientActiveInstanceCount) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrServerPort returns an optional attribute for the "server.port" semantic // convention. It represents the server port number. func (CosmosDBClientActiveInstanceCount) AttrServerPort(val int) attribute.KeyValue { @@ -203,7 +220,7 @@ func (CosmosDBClientOperationRequestCharge) Description() string { return "[Request units](https://learn.microsoft.com/azure/cosmos-db/request-units) consumed by the operation" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The dbOperationName is the the name of the operation or command being // executed. @@ -239,6 +256,22 @@ func (m CosmosDBClientOperationRequestCharge) Record( m.Int64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m CosmosDBClientOperationRequestCharge) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Histogram.Record(ctx, val, *o...) +} + // AttrCosmosDBConsistencyLevel returns an optional attribute for the // "azure.cosmosdb.consistency.level" semantic convention. It represents the // account or request [consistency level]. diff --git a/semconv/v1.36.0/cicdconv/metric.go b/semconv/v1.36.0/cicdconv/metric.go index 367574d41..2e156d394 100644 --- a/semconv/v1.36.0/cicdconv/metric.go +++ b/semconv/v1.36.0/cicdconv/metric.go @@ -140,7 +140,7 @@ func (PipelineRunActive) Description() string { return "The number of pipeline runs currently active in the system by state." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The pipelineName is the the human readable name of the pipeline within a CI/CD // system. @@ -179,6 +179,23 @@ func (m PipelineRunActive) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m PipelineRunActive) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // PipelineRunDuration is an instrument used to record metric values conforming // to the "cicd.pipeline.run.duration" semantic conventions. It represents the // duration of a pipeline run grouped by pipeline, state and result. @@ -229,7 +246,7 @@ func (PipelineRunDuration) Description() string { return "Duration of a pipeline run grouped by pipeline, state and result." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The pipelineName is the the human readable name of the pipeline within a CI/CD // system. @@ -270,6 +287,22 @@ func (m PipelineRunDuration) Record( m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m PipelineRunDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // AttrPipelineResult returns an optional attribute for the // "cicd.pipeline.result" semantic convention. It represents the result of a // pipeline run. @@ -334,7 +367,7 @@ func (PipelineRunErrors) Description() string { return "The number of errors encountered in pipeline runs (eg. compile, test failures)." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The pipelineName is the the human readable name of the pipeline within a CI/CD // system. @@ -377,6 +410,28 @@ func (m PipelineRunErrors) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// There might be errors in a pipeline run that are non fatal (eg. they are +// suppressed) or in a parallel stage multiple stages could have a fatal error. +// This means that this error count might not be the same as the count of metric +// `cicd.pipeline.run.duration` with run result `failure`. +func (m PipelineRunErrors) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // SystemErrors is an instrument used to record metric values conforming to the // "cicd.system.errors" semantic conventions. It represents the number of errors // in a component of the CICD system (eg. controller, scheduler, agent). @@ -427,7 +482,7 @@ func (SystemErrors) Description() string { return "The number of errors in a component of the CICD system (eg. controller, scheduler, agent)." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The systemComponent is the the name of a component of the CICD system. // @@ -467,6 +522,26 @@ func (m SystemErrors) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// Errors in pipeline run execution are explicitly excluded. Ie a test failure is +// not counted in this metric. +func (m SystemErrors) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // WorkerCount is an instrument used to record metric values conforming to the // "cicd.worker.count" semantic conventions. It represents the number of workers // on the CICD system by state. @@ -517,7 +592,7 @@ func (WorkerCount) Description() string { return "The number of workers on the CICD system by state." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The workerState is the the state of a CICD worker / agent. func (m WorkerCount) Add( @@ -547,5 +622,22 @@ func (m WorkerCount) Add( ), ) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + +// AddSet adds incr to the existing count for set. +func (m WorkerCount) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) m.Int64UpDownCounter.Add(ctx, incr, *o...) } \ No newline at end of file diff --git a/semconv/v1.36.0/containerconv/metric.go b/semconv/v1.36.0/containerconv/metric.go index 01097c9a9..8bcacf5f4 100644 --- a/semconv/v1.36.0/containerconv/metric.go +++ b/semconv/v1.36.0/containerconv/metric.go @@ -121,7 +121,7 @@ func (CPUTime) Description() string { return "Total CPU time consumed" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -152,6 +152,25 @@ func (m CPUTime) Add( m.Float64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// Total CPU time consumed by the specific container on all available CPU cores +func (m CPUTime) AddSet(ctx context.Context, incr float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Counter.Add(ctx, incr, *o...) +} + // AttrCPUMode returns an optional attribute for the "cpu.mode" semantic // convention. It represents the CPU mode for this data point. A container's CPU // metric SHOULD be characterized *either* by data points with no `mode` labels, @@ -210,7 +229,7 @@ func (CPUUsage) Description() string { return "Container's CPU usage, measured in cpus. Range from 0 to the number of allocatable CPUs" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // All additional attrs passed are included in the recorded value. // @@ -242,6 +261,25 @@ func (m CPUUsage) Record( m.Int64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// CPU usage of the specific container on all available CPU cores, averaged over +// the sample window +func (m CPUUsage) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Gauge.Record(ctx, val, *o...) +} + // AttrCPUMode returns an optional attribute for the "cpu.mode" semantic // convention. It represents the CPU mode for this data point. A container's CPU // metric SHOULD be characterized *either* by data points with no `mode` labels, @@ -300,7 +338,7 @@ func (DiskIO) Description() string { return "Disk bytes for the container." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -332,6 +370,26 @@ func (m DiskIO) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// The total number of bytes read/written successfully (aggregated from all +// disks). +func (m DiskIO) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrDiskIODirection returns an optional attribute for the "disk.io.direction" // semantic convention. It represents the disk IO operation direction. func (DiskIO) AttrDiskIODirection(val DiskIODirectionAttr) attribute.KeyValue { @@ -394,7 +452,7 @@ func (MemoryUsage) Description() string { return "Memory usage of the container." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // Memory usage of the container. func (m MemoryUsage) Add(ctx context.Context, incr int64, attrs ...attribute.KeyValue) { @@ -413,6 +471,25 @@ func (m MemoryUsage) Add(ctx context.Context, incr int64, attrs ...attribute.Key m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// Memory usage of the container. +func (m MemoryUsage) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // NetworkIO is an instrument used to record metric values conforming to the // "container.network.io" semantic conventions. It represents the network bytes // for the container. @@ -463,7 +540,7 @@ func (NetworkIO) Description() string { return "Network bytes for the container." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -494,6 +571,25 @@ func (m NetworkIO) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// The number of bytes sent/received on all network interfaces by the container. +func (m NetworkIO) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrNetworkInterfaceName returns an optional attribute for the // "network.interface.name" semantic convention. It represents the network // interface name. @@ -558,7 +654,7 @@ func (Uptime) Description() string { return "The time the container has been running" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // Instrumentations SHOULD use a gauge with type `double` and measure uptime in // seconds as a floating point number with the highest precision available. @@ -577,4 +673,24 @@ func (m Uptime) Record(ctx context.Context, val float64, attrs ...attribute.KeyV *o = append(*o, metric.WithAttributes(attrs...)) m.Float64Gauge.Record(ctx, val, *o...) +} + +// RecordSet records val to the current distribution for set. +// +// Instrumentations SHOULD use a gauge with type `double` and measure uptime in +// seconds as a floating point number with the highest precision available. +// The actual accuracy would depend on the instrumentation and operating system. +func (m Uptime) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Gauge.Record(ctx, val, *o...) } \ No newline at end of file diff --git a/semconv/v1.36.0/dbconv/metric.go b/semconv/v1.36.0/dbconv/metric.go index 685407ef1..1db72b593 100644 --- a/semconv/v1.36.0/dbconv/metric.go +++ b/semconv/v1.36.0/dbconv/metric.go @@ -267,7 +267,7 @@ func (ClientConnectionCount) Description() string { return "The number of connections that are currently in state described by the `state` attribute" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The clientConnectionPoolName is the the name of the connection pool; unique // within the instrumented application. In case the connection pool @@ -310,6 +310,23 @@ func (m ClientConnectionCount) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m ClientConnectionCount) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ClientConnectionCreateTime is an instrument used to record metric values // conforming to the "db.client.connection.create_time" semantic conventions. It // represents the time it took to create a new connection. @@ -361,7 +378,7 @@ func (ClientConnectionCreateTime) Description() string { return "The time it took to create a new connection" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The clientConnectionPoolName is the the name of the connection pool; unique // within the instrumented application. In case the connection pool @@ -400,6 +417,22 @@ func (m ClientConnectionCreateTime) Record( m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m ClientConnectionCreateTime) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // ClientConnectionIdleMax is an instrument used to record metric values // conforming to the "db.client.connection.idle.max" semantic conventions. It // represents the maximum number of idle open connections allowed. @@ -450,7 +483,7 @@ func (ClientConnectionIdleMax) Description() string { return "The maximum number of idle open connections allowed" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The clientConnectionPoolName is the the name of the connection pool; unique // within the instrumented application. In case the connection pool @@ -489,6 +522,23 @@ func (m ClientConnectionIdleMax) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m ClientConnectionIdleMax) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ClientConnectionIdleMin is an instrument used to record metric values // conforming to the "db.client.connection.idle.min" semantic conventions. It // represents the minimum number of idle open connections allowed. @@ -539,7 +589,7 @@ func (ClientConnectionIdleMin) Description() string { return "The minimum number of idle open connections allowed" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The clientConnectionPoolName is the the name of the connection pool; unique // within the instrumented application. In case the connection pool @@ -578,6 +628,23 @@ func (m ClientConnectionIdleMin) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m ClientConnectionIdleMin) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ClientConnectionMax is an instrument used to record metric values conforming // to the "db.client.connection.max" semantic conventions. It represents the // maximum number of open connections allowed. @@ -628,7 +695,7 @@ func (ClientConnectionMax) Description() string { return "The maximum number of open connections allowed" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The clientConnectionPoolName is the the name of the connection pool; unique // within the instrumented application. In case the connection pool @@ -667,6 +734,23 @@ func (m ClientConnectionMax) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m ClientConnectionMax) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ClientConnectionPendingRequests is an instrument used to record metric values // conforming to the "db.client.connection.pending_requests" semantic // conventions. It represents the number of current pending requests for an open @@ -719,7 +803,7 @@ func (ClientConnectionPendingRequests) Description() string { return "The number of current pending requests for an open connection" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The clientConnectionPoolName is the the name of the connection pool; unique // within the instrumented application. In case the connection pool @@ -758,6 +842,23 @@ func (m ClientConnectionPendingRequests) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m ClientConnectionPendingRequests) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ClientConnectionTimeouts is an instrument used to record metric values // conforming to the "db.client.connection.timeouts" semantic conventions. It // represents the number of connection timeouts that have occurred trying to @@ -809,7 +910,7 @@ func (ClientConnectionTimeouts) Description() string { return "The number of connection timeouts that have occurred trying to obtain a connection from the pool" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The clientConnectionPoolName is the the name of the connection pool; unique // within the instrumented application. In case the connection pool @@ -848,6 +949,23 @@ func (m ClientConnectionTimeouts) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m ClientConnectionTimeouts) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // ClientConnectionUseTime is an instrument used to record metric values // conforming to the "db.client.connection.use_time" semantic conventions. It // represents the time between borrowing a connection and returning it to the @@ -899,7 +1017,7 @@ func (ClientConnectionUseTime) Description() string { return "The time between borrowing a connection and returning it to the pool" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The clientConnectionPoolName is the the name of the connection pool; unique // within the instrumented application. In case the connection pool @@ -938,6 +1056,22 @@ func (m ClientConnectionUseTime) Record( m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m ClientConnectionUseTime) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // ClientConnectionWaitTime is an instrument used to record metric values // conforming to the "db.client.connection.wait_time" semantic conventions. It // represents the time it took to obtain an open connection from the pool. @@ -988,7 +1122,7 @@ func (ClientConnectionWaitTime) Description() string { return "The time it took to obtain an open connection from the pool" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The clientConnectionPoolName is the the name of the connection pool; unique // within the instrumented application. In case the connection pool @@ -1027,6 +1161,22 @@ func (m ClientConnectionWaitTime) Record( m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m ClientConnectionWaitTime) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // ClientOperationDuration is an instrument used to record metric values // conforming to the "db.client.operation.duration" semantic conventions. It // represents the duration of database client operations. @@ -1077,7 +1227,7 @@ func (ClientOperationDuration) Description() string { return "Duration of database client operations." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The systemName is the the database management system (DBMS) product as // identified by the client instrumentation. @@ -1115,6 +1265,24 @@ func (m ClientOperationDuration) Record( m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// Batch operations SHOULD be recorded as a single operation. +func (m ClientOperationDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // AttrCollectionName returns an optional attribute for the "db.collection.name" // semantic convention. It represents the name of a collection (table, container) // within the database. @@ -1247,7 +1415,7 @@ func (ClientResponseReturnedRows) Description() string { return "The actual number of records returned by the database operation." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The systemName is the the database management system (DBMS) product as // identified by the client instrumentation. @@ -1283,6 +1451,22 @@ func (m ClientResponseReturnedRows) Record( m.Int64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m ClientResponseReturnedRows) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Histogram.Record(ctx, val, *o...) +} + // AttrCollectionName returns an optional attribute for the "db.collection.name" // semantic convention. It represents the name of a collection (table, container) // within the database. diff --git a/semconv/v1.36.0/dnsconv/metric.go b/semconv/v1.36.0/dnsconv/metric.go index cce82621a..b5348a23f 100644 --- a/semconv/v1.36.0/dnsconv/metric.go +++ b/semconv/v1.36.0/dnsconv/metric.go @@ -81,7 +81,7 @@ func (LookupDuration) Description() string { return "Measures the time taken to perform a DNS lookup." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The questionName is the the name being queried. // @@ -116,6 +116,22 @@ func (m LookupDuration) Record( m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m LookupDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents the describes the error the DNS lookup failed with. func (LookupDuration) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue { diff --git a/semconv/v1.36.0/faasconv/metric.go b/semconv/v1.36.0/faasconv/metric.go index 2fa23f94b..c952a507e 100644 --- a/semconv/v1.36.0/faasconv/metric.go +++ b/semconv/v1.36.0/faasconv/metric.go @@ -91,7 +91,7 @@ func (Coldstarts) Description() string { return "Number of invocation cold starts" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m Coldstarts) Add( @@ -120,6 +120,23 @@ func (m Coldstarts) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m Coldstarts) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrTrigger returns an optional attribute for the "faas.trigger" semantic // convention. It represents the type of the trigger which caused this function // invocation. @@ -177,7 +194,7 @@ func (CPUUsage) Description() string { return "Distribution of CPU usage per invocation" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // All additional attrs passed are included in the recorded value. func (m CPUUsage) Record( @@ -206,6 +223,22 @@ func (m CPUUsage) Record( m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m CPUUsage) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // AttrTrigger returns an optional attribute for the "faas.trigger" semantic // convention. It represents the type of the trigger which caused this function // invocation. @@ -263,7 +296,7 @@ func (Errors) Description() string { return "Number of invocation errors" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m Errors) Add( @@ -292,6 +325,23 @@ func (m Errors) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m Errors) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrTrigger returns an optional attribute for the "faas.trigger" semantic // convention. It represents the type of the trigger which caused this function // invocation. @@ -349,7 +399,7 @@ func (InitDuration) Description() string { return "Measures the duration of the function's initialization, such as a cold start" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // All additional attrs passed are included in the recorded value. func (m InitDuration) Record( @@ -378,6 +428,22 @@ func (m InitDuration) Record( m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m InitDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // AttrTrigger returns an optional attribute for the "faas.trigger" semantic // convention. It represents the type of the trigger which caused this function // invocation. @@ -435,7 +501,7 @@ func (Invocations) Description() string { return "Number of successful invocations" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m Invocations) Add( @@ -464,6 +530,23 @@ func (m Invocations) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m Invocations) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrTrigger returns an optional attribute for the "faas.trigger" semantic // convention. It represents the type of the trigger which caused this function // invocation. @@ -521,7 +604,7 @@ func (InvokeDuration) Description() string { return "Measures the duration of the function's logic execution" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // All additional attrs passed are included in the recorded value. func (m InvokeDuration) Record( @@ -550,6 +633,22 @@ func (m InvokeDuration) Record( m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m InvokeDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // AttrTrigger returns an optional attribute for the "faas.trigger" semantic // convention. It represents the type of the trigger which caused this function // invocation. @@ -607,7 +706,7 @@ func (MemUsage) Description() string { return "Distribution of max memory usage per invocation" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // All additional attrs passed are included in the recorded value. func (m MemUsage) Record( @@ -636,6 +735,22 @@ func (m MemUsage) Record( m.Int64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m MemUsage) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Histogram.Record(ctx, val, *o...) +} + // AttrTrigger returns an optional attribute for the "faas.trigger" semantic // convention. It represents the type of the trigger which caused this function // invocation. @@ -693,7 +808,7 @@ func (NetIO) Description() string { return "Distribution of net I/O usage per invocation" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // All additional attrs passed are included in the recorded value. func (m NetIO) Record( @@ -722,6 +837,22 @@ func (m NetIO) Record( m.Int64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m NetIO) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Histogram.Record(ctx, val, *o...) +} + // AttrTrigger returns an optional attribute for the "faas.trigger" semantic // convention. It represents the type of the trigger which caused this function // invocation. @@ -779,7 +910,7 @@ func (Timeouts) Description() string { return "Number of invocation timeouts" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m Timeouts) Add( @@ -808,6 +939,23 @@ func (m Timeouts) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m Timeouts) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrTrigger returns an optional attribute for the "faas.trigger" semantic // convention. It represents the type of the trigger which caused this function // invocation. diff --git a/semconv/v1.36.0/genaiconv/metric.go b/semconv/v1.36.0/genaiconv/metric.go index 37cc807ef..7b049c1ca 100644 --- a/semconv/v1.36.0/genaiconv/metric.go +++ b/semconv/v1.36.0/genaiconv/metric.go @@ -164,7 +164,7 @@ func (ClientOperationDuration) Description() string { return "GenAI operation duration" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The operationName is the the name of the operation being performed. // @@ -204,6 +204,22 @@ func (m ClientOperationDuration) Record( m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m ClientOperationDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents the describes a class of error the operation ended // with. @@ -287,7 +303,7 @@ func (ClientTokenUsage) Description() string { return "Measures number of input and output tokens used" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The operationName is the the name of the operation being performed. // @@ -331,6 +347,22 @@ func (m ClientTokenUsage) Record( m.Int64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m ClientTokenUsage) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Histogram.Record(ctx, val, *o...) +} + // AttrRequestModel returns an optional attribute for the "gen_ai.request.model" // semantic convention. It represents the name of the GenAI model a request is // being made to. @@ -408,7 +440,7 @@ func (ServerRequestDuration) Description() string { return "Generative AI server request duration such as time-to-last byte or last output token" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The operationName is the the name of the operation being performed. // @@ -448,6 +480,22 @@ func (m ServerRequestDuration) Record( m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m ServerRequestDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents the describes a class of error the operation ended // with. @@ -532,7 +580,7 @@ func (ServerTimePerOutputToken) Description() string { return "Time per output token generated after the first token for successful responses" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The operationName is the the name of the operation being performed. // @@ -572,6 +620,22 @@ func (m ServerTimePerOutputToken) Record( m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m ServerTimePerOutputToken) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // AttrRequestModel returns an optional attribute for the "gen_ai.request.model" // semantic convention. It represents the name of the GenAI model a request is // being made to. @@ -648,7 +712,7 @@ func (ServerTimeToFirstToken) Description() string { return "Time to generate first token for successful responses" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The operationName is the the name of the operation being performed. // @@ -688,6 +752,22 @@ func (m ServerTimeToFirstToken) Record( m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m ServerTimeToFirstToken) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // AttrRequestModel returns an optional attribute for the "gen_ai.request.model" // semantic convention. It represents the name of the GenAI model a request is // being made to. diff --git a/semconv/v1.36.0/goconv/metric.go b/semconv/v1.36.0/goconv/metric.go index f2e906471..fe9e2933e 100644 --- a/semconv/v1.36.0/goconv/metric.go +++ b/semconv/v1.36.0/goconv/metric.go @@ -491,7 +491,7 @@ func (ScheduleDuration) Description() string { return "The time goroutines have spent in the scheduler in a runnable state before actually running." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // Computed from `/sched/latencies:seconds`. Bucket boundaries are provided by // the runtime, and are subject to change. @@ -509,4 +509,23 @@ func (m ScheduleDuration) Record(ctx context.Context, val float64, attrs ...attr *o = append(*o, metric.WithAttributes(attrs...)) m.Float64Histogram.Record(ctx, val, *o...) +} + +// RecordSet records val to the current distribution for set. +// +// Computed from `/sched/latencies:seconds`. Bucket boundaries are provided by +// the runtime, and are subject to change. +func (m ScheduleDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) } \ No newline at end of file diff --git a/semconv/v1.36.0/httpconv/metric.go b/semconv/v1.36.0/httpconv/metric.go index 214ba9386..552763e31 100644 --- a/semconv/v1.36.0/httpconv/metric.go +++ b/semconv/v1.36.0/httpconv/metric.go @@ -134,7 +134,7 @@ func (ClientActiveRequests) Description() string { return "Number of active HTTP requests." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The serverAddress is the server domain name if available without reverse DNS // lookup; otherwise, IP address or Unix domain socket name. @@ -177,6 +177,23 @@ func (m ClientActiveRequests) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m ClientActiveRequests) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrURLTemplate returns an optional attribute for the "url.template" semantic // convention. It represents the low-cardinality template of an // [absolute path reference]. @@ -252,7 +269,7 @@ func (ClientConnectionDuration) Description() string { return "The duration of the successfully established outbound HTTP connections." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The serverAddress is the server domain name if available without reverse DNS // lookup; otherwise, IP address or Unix domain socket name. @@ -295,6 +312,22 @@ func (m ClientConnectionDuration) Record( m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m ClientConnectionDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // AttrNetworkPeerAddress returns an optional attribute for the // "network.peer.address" semantic convention. It represents the peer address of // the network connection - IP address or Unix domain socket name. @@ -369,7 +402,7 @@ func (ClientOpenConnections) Description() string { return "Number of outbound HTTP connections that are currently active or idle on the client." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The connectionState is the state of the HTTP connection in the HTTP connection // pool. @@ -417,6 +450,23 @@ func (m ClientOpenConnections) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m ClientOpenConnections) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrNetworkPeerAddress returns an optional attribute for the // "network.peer.address" semantic convention. It represents the peer address of // the network connection - IP address or Unix domain socket name. @@ -490,7 +540,7 @@ func (ClientRequestBodySize) Description() string { return "Size of HTTP client request bodies." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The requestMethod is the HTTP request method. // @@ -545,6 +595,29 @@ func (m ClientRequestBodySize) Record( m.Int64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// The size of the request payload body in bytes. This is the number of bytes +// transferred excluding headers and is often, but not always, present as the +// [Content-Length] header. For requests using transport encoding, this should be +// the compressed size. +// +// [Content-Length]: https://www.rfc-editor.org/rfc/rfc9110.html#field.content-length +func (m ClientRequestBodySize) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Histogram.Record(ctx, val, *o...) +} + // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents the describes a class of error the operation ended // with. @@ -645,7 +718,7 @@ func (ClientRequestDuration) Description() string { return "Duration of HTTP client requests." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The requestMethod is the HTTP request method. // @@ -693,6 +766,22 @@ func (m ClientRequestDuration) Record( m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m ClientRequestDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents the describes a class of error the operation ended // with. @@ -793,7 +882,7 @@ func (ClientResponseBodySize) Description() string { return "Size of HTTP client response bodies." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The requestMethod is the HTTP request method. // @@ -848,6 +937,29 @@ func (m ClientResponseBodySize) Record( m.Int64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// The size of the response payload body in bytes. This is the number of bytes +// transferred excluding headers and is often, but not always, present as the +// [Content-Length] header. For requests using transport encoding, this should be +// the compressed size. +// +// [Content-Length]: https://www.rfc-editor.org/rfc/rfc9110.html#field.content-length +func (m ClientResponseBodySize) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Histogram.Record(ctx, val, *o...) +} + // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents the describes a class of error the operation ended // with. @@ -948,7 +1060,7 @@ func (ServerActiveRequests) Description() string { return "Number of active HTTP server requests." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The requestMethod is the HTTP request method. // @@ -989,6 +1101,23 @@ func (m ServerActiveRequests) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m ServerActiveRequests) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrServerAddress returns an optional attribute for the "server.address" // semantic convention. It represents the name of the local HTTP server that // received the request. @@ -1053,7 +1182,7 @@ func (ServerRequestBodySize) Description() string { return "Size of HTTP server request bodies." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The requestMethod is the HTTP request method. // @@ -1101,6 +1230,29 @@ func (m ServerRequestBodySize) Record( m.Int64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// The size of the request payload body in bytes. This is the number of bytes +// transferred excluding headers and is often, but not always, present as the +// [Content-Length] header. For requests using transport encoding, this should be +// the compressed size. +// +// [Content-Length]: https://www.rfc-editor.org/rfc/rfc9110.html#field.content-length +func (m ServerRequestBodySize) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Histogram.Record(ctx, val, *o...) +} + // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents the describes a class of error the operation ended // with. @@ -1211,7 +1363,7 @@ func (ServerRequestDuration) Description() string { return "Duration of HTTP server requests." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The requestMethod is the HTTP request method. // @@ -1252,6 +1404,22 @@ func (m ServerRequestDuration) Record( m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m ServerRequestDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents the describes a class of error the operation ended // with. @@ -1362,7 +1530,7 @@ func (ServerResponseBodySize) Description() string { return "Size of HTTP server response bodies." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The requestMethod is the HTTP request method. // @@ -1410,6 +1578,29 @@ func (m ServerResponseBodySize) Record( m.Int64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// The size of the response payload body in bytes. This is the number of bytes +// transferred excluding headers and is often, but not always, present as the +// [Content-Length] header. For requests using transport encoding, this should be +// the compressed size. +// +// [Content-Length]: https://www.rfc-editor.org/rfc/rfc9110.html#field.content-length +func (m ServerResponseBodySize) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Histogram.Record(ctx, val, *o...) +} + // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents the describes a class of error the operation ended // with. diff --git a/semconv/v1.36.0/hwconv/metric.go b/semconv/v1.36.0/hwconv/metric.go index 4a2a7d461..2e8ca7f80 100644 --- a/semconv/v1.36.0/hwconv/metric.go +++ b/semconv/v1.36.0/hwconv/metric.go @@ -129,7 +129,7 @@ func (Energy) Description() string { return "Energy consumed by the component" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host @@ -169,6 +169,23 @@ func (m Energy) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m Energy) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (Energy) AttrName(val string) attribute.KeyValue { @@ -232,7 +249,7 @@ func (Errors) Description() string { return "Number of errors encountered by the component" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host @@ -272,6 +289,23 @@ func (m Errors) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m Errors) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents the type of error encountered by the component. func (Errors) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue { @@ -341,7 +375,7 @@ func (HostAmbientTemperature) Description() string { return "Ambient (external) temperature of the physical host" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host @@ -377,6 +411,22 @@ func (m HostAmbientTemperature) Record( m.Int64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m HostAmbientTemperature) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Gauge.Record(ctx, val, *o...) +} + // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (HostAmbientTemperature) AttrName(val string) attribute.KeyValue { @@ -440,7 +490,7 @@ func (HostEnergy) Description() string { return "Total energy consumed by the entire physical host, in joules" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host @@ -481,6 +531,28 @@ func (m HostEnergy) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// The overall energy usage of a host MUST be reported using the specific +// `hw.host.energy` and `hw.host.power` metrics **only**, instead of the generic +// `hw.energy` and `hw.power` described in the previous section, to prevent +// summing up overlapping values. +func (m HostEnergy) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (HostEnergy) AttrName(val string) attribute.KeyValue { @@ -545,7 +617,7 @@ func (HostHeatingMargin) Description() string { return "By how many degrees Celsius the temperature of the physical host can be increased, before reaching a warning threshold on one of the internal sensors" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host @@ -581,6 +653,22 @@ func (m HostHeatingMargin) Record( m.Int64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m HostHeatingMargin) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Gauge.Record(ctx, val, *o...) +} + // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (HostHeatingMargin) AttrName(val string) attribute.KeyValue { @@ -644,7 +732,7 @@ func (HostPower) Description() string { return "Instantaneous power consumed by the entire physical host in Watts (`hw.host.energy` is preferred)" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host @@ -685,6 +773,27 @@ func (m HostPower) Record( m.Int64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// The overall energy usage of a host MUST be reported using the specific +// `hw.host.energy` and `hw.host.power` metrics **only**, instead of the generic +// `hw.energy` and `hw.power` described in the previous section, to prevent +// summing up overlapping values. +func (m HostPower) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Gauge.Record(ctx, val, *o...) +} + // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (HostPower) AttrName(val string) attribute.KeyValue { @@ -748,7 +857,7 @@ func (Power) Description() string { return "Instantaneous power consumed by the component" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host @@ -790,6 +899,24 @@ func (m Power) Record( m.Int64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// It is recommended to report `hw.energy` instead of `hw.power` when possible. +func (m Power) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Gauge.Record(ctx, val, *o...) +} + // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (Power) AttrName(val string) attribute.KeyValue { @@ -853,7 +980,7 @@ func (Status) Description() string { return "Operational status: `1` (true) or `0` (false) for each of the possible states" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host @@ -905,6 +1032,31 @@ func (m Status) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// `hw.status` is currently specified as an *UpDownCounter* but would ideally be +// represented using a [*StateSet* as defined in OpenMetrics]. This semantic +// convention will be updated once *StateSet* is specified in OpenTelemetry. This +// planned change is not expected to have any consequence on the way users query +// their timeseries backend to retrieve the values of `hw.status` over time. +// +// [ [*StateSet* as defined in OpenMetrics]: https://github.com/prometheus/OpenMetrics/blob/v1.0.0/specification/OpenMetrics.md#stateset +func (m Status) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (Status) AttrName(val string) attribute.KeyValue { diff --git a/semconv/v1.36.0/k8sconv/metric.go b/semconv/v1.36.0/k8sconv/metric.go index 3e84cd08d..5f6328b9b 100644 --- a/semconv/v1.36.0/k8sconv/metric.go +++ b/semconv/v1.36.0/k8sconv/metric.go @@ -191,7 +191,7 @@ func (ContainerCPULimit) Description() string { return "Maximum CPU resource limit set for the container" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // See // https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core @@ -212,6 +212,27 @@ func (m ContainerCPULimit) Add(ctx context.Context, incr int64, attrs ...attribu m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// See +// https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core +// for details. +func (m ContainerCPULimit) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ContainerCPURequest is an instrument used to record metric values conforming // to the "k8s.container.cpu.request" semantic conventions. It represents the CPU // resource requested for the container. @@ -262,7 +283,7 @@ func (ContainerCPURequest) Description() string { return "CPU resource requested for the container" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // See // https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core @@ -283,6 +304,27 @@ func (m ContainerCPURequest) Add(ctx context.Context, incr int64, attrs ...attri m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// See +// https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core +// for details. +func (m ContainerCPURequest) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ContainerEphemeralStorageLimit is an instrument used to record metric values // conforming to the "k8s.container.ephemeral_storage.limit" semantic // conventions. It represents the maximum ephemeral storage resource limit set @@ -335,7 +377,7 @@ func (ContainerEphemeralStorageLimit) Description() string { return "Maximum ephemeral storage resource limit set for the container" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // See // https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core @@ -356,6 +398,27 @@ func (m ContainerEphemeralStorageLimit) Add(ctx context.Context, incr int64, att m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// See +// https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core +// for details. +func (m ContainerEphemeralStorageLimit) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ContainerEphemeralStorageRequest is an instrument used to record metric values // conforming to the "k8s.container.ephemeral_storage.request" semantic // conventions. It represents the ephemeral storage resource requested for the @@ -408,7 +471,7 @@ func (ContainerEphemeralStorageRequest) Description() string { return "Ephemeral storage resource requested for the container" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // See // https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core @@ -429,6 +492,27 @@ func (m ContainerEphemeralStorageRequest) Add(ctx context.Context, incr int64, a m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// See +// https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core +// for details. +func (m ContainerEphemeralStorageRequest) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ContainerMemoryLimit is an instrument used to record metric values conforming // to the "k8s.container.memory.limit" semantic conventions. It represents the // maximum memory resource limit set for the container. @@ -479,7 +563,7 @@ func (ContainerMemoryLimit) Description() string { return "Maximum memory resource limit set for the container" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // See // https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core @@ -500,6 +584,27 @@ func (m ContainerMemoryLimit) Add(ctx context.Context, incr int64, attrs ...attr m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// See +// https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core +// for details. +func (m ContainerMemoryLimit) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ContainerMemoryRequest is an instrument used to record metric values // conforming to the "k8s.container.memory.request" semantic conventions. It // represents the memory resource requested for the container. @@ -550,7 +655,7 @@ func (ContainerMemoryRequest) Description() string { return "Memory resource requested for the container" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // See // https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core @@ -571,6 +676,27 @@ func (m ContainerMemoryRequest) Add(ctx context.Context, incr int64, attrs ...at m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// See +// https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core +// for details. +func (m ContainerMemoryRequest) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ContainerReady is an instrument used to record metric values conforming to the // "k8s.container.ready" semantic conventions. It represents the indicates // whether the container is currently marked as ready to accept traffic, based on @@ -622,7 +748,7 @@ func (ContainerReady) Description() string { return "Indicates whether the container is currently marked as ready to accept traffic, based on its readiness probe (1 = ready, 0 = not ready)" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric SHOULD reflect the value of the `ready` field in the // [K8s ContainerStatus]. @@ -644,6 +770,28 @@ func (m ContainerReady) Add(ctx context.Context, incr int64, attrs ...attribute. m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric SHOULD reflect the value of the `ready` field in the +// [K8s ContainerStatus]. +// +// [K8s ContainerStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#containerstatus-v1-core +func (m ContainerReady) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ContainerRestartCount is an instrument used to record metric values conforming // to the "k8s.container.restart.count" semantic conventions. It represents the // describes how many times the container has restarted (since the last counter @@ -695,7 +843,7 @@ func (ContainerRestartCount) Description() string { return "Describes how many times the container has restarted (since the last counter reset)" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This value is pulled directly from the K8s API and the value can go // indefinitely high and be reset to 0 @@ -722,6 +870,33 @@ func (m ContainerRestartCount) Add(ctx context.Context, incr int64, attrs ...att m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This value is pulled directly from the K8s API and the value can go +// indefinitely high and be reset to 0 +// at any time depending on how your kubelet is configured to prune dead +// containers. +// It is best to not depend too much on the exact value but rather look at it as +// either == 0, in which case you can conclude there were no restarts in the +// recent past, or > 0, in which case +// you can conclude there were restarts in the recent past, and not try and +// analyze the value beyond that. +func (m ContainerRestartCount) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ContainerStatusReason is an instrument used to record metric values conforming // to the "k8s.container.status.reason" semantic conventions. It represents the // describes the number of K8s containers that are currently in a state for a @@ -773,7 +948,7 @@ func (ContainerStatusReason) Description() string { return "Describes the number of K8s containers that are currently in a state for a given reason" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The containerStatusReason is the the reason for the container state. // Corresponds to the `reason` field of the: [K8s ContainerStateWaiting] or @@ -815,6 +990,27 @@ func (m ContainerStatusReason) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// All possible container state reasons will be reported at each time interval to +// avoid missing metrics. +// Only the value corresponding to the current state reason will be non-zero. +func (m ContainerStatusReason) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ContainerStatusState is an instrument used to record metric values conforming // to the "k8s.container.status.state" semantic conventions. It represents the // describes the number of K8s containers that are currently in a given state. @@ -865,7 +1061,7 @@ func (ContainerStatusState) Description() string { return "Describes the number of K8s containers that are currently in a given state" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The containerStatusState is the the state of the container. // [K8s ContainerState] @@ -905,6 +1101,27 @@ func (m ContainerStatusState) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// All possible container states will be reported at each time interval to avoid +// missing metrics. +// Only the value corresponding to the current state will be non-zero. +func (m ContainerStatusState) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ContainerStorageLimit is an instrument used to record metric values conforming // to the "k8s.container.storage.limit" semantic conventions. It represents the // maximum storage resource limit set for the container. @@ -955,7 +1172,7 @@ func (ContainerStorageLimit) Description() string { return "Maximum storage resource limit set for the container" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // See // https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core @@ -976,6 +1193,27 @@ func (m ContainerStorageLimit) Add(ctx context.Context, incr int64, attrs ...att m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// See +// https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core +// for details. +func (m ContainerStorageLimit) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ContainerStorageRequest is an instrument used to record metric values // conforming to the "k8s.container.storage.request" semantic conventions. It // represents the storage resource requested for the container. @@ -1026,7 +1264,7 @@ func (ContainerStorageRequest) Description() string { return "Storage resource requested for the container" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // See // https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core @@ -1047,6 +1285,27 @@ func (m ContainerStorageRequest) Add(ctx context.Context, incr int64, attrs ...a m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// See +// https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core +// for details. +func (m ContainerStorageRequest) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // CronJobActiveJobs is an instrument used to record metric values conforming to // the "k8s.cronjob.active_jobs" semantic conventions. It represents the number // of actively running jobs for a cronjob. @@ -1097,7 +1356,7 @@ func (CronJobActiveJobs) Description() string { return "The number of actively running jobs for a cronjob" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `active` field of the // [K8s CronJobStatus]. @@ -1119,6 +1378,28 @@ func (m CronJobActiveJobs) Add(ctx context.Context, incr int64, attrs ...attribu m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `active` field of the +// [K8s CronJobStatus]. +// +// [K8s CronJobStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#cronjobstatus-v1-batch +func (m CronJobActiveJobs) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // DaemonSetCurrentScheduledNodes is an instrument used to record metric values // conforming to the "k8s.daemonset.current_scheduled_nodes" semantic // conventions. It represents the number of nodes that are running at least 1 @@ -1171,7 +1452,7 @@ func (DaemonSetCurrentScheduledNodes) Description() string { return "Number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `currentNumberScheduled` field of the // [K8s DaemonSetStatus]. @@ -1193,6 +1474,28 @@ func (m DaemonSetCurrentScheduledNodes) Add(ctx context.Context, incr int64, att m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `currentNumberScheduled` field of the +// [K8s DaemonSetStatus]. +// +// [K8s DaemonSetStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#daemonsetstatus-v1-apps +func (m DaemonSetCurrentScheduledNodes) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // DaemonSetDesiredScheduledNodes is an instrument used to record metric values // conforming to the "k8s.daemonset.desired_scheduled_nodes" semantic // conventions. It represents the number of nodes that should be running the @@ -1245,7 +1548,7 @@ func (DaemonSetDesiredScheduledNodes) Description() string { return "Number of nodes that should be running the daemon pod (including nodes currently running the daemon pod)" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `desiredNumberScheduled` field of the // [K8s DaemonSetStatus]. @@ -1267,6 +1570,28 @@ func (m DaemonSetDesiredScheduledNodes) Add(ctx context.Context, incr int64, att m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `desiredNumberScheduled` field of the +// [K8s DaemonSetStatus]. +// +// [K8s DaemonSetStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#daemonsetstatus-v1-apps +func (m DaemonSetDesiredScheduledNodes) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // DaemonSetMisscheduledNodes is an instrument used to record metric values // conforming to the "k8s.daemonset.misscheduled_nodes" semantic conventions. It // represents the number of nodes that are running the daemon pod, but are not @@ -1319,7 +1644,7 @@ func (DaemonSetMisscheduledNodes) Description() string { return "Number of nodes that are running the daemon pod, but are not supposed to run the daemon pod" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `numberMisscheduled` field of the // [K8s DaemonSetStatus]. @@ -1341,6 +1666,28 @@ func (m DaemonSetMisscheduledNodes) Add(ctx context.Context, incr int64, attrs . m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `numberMisscheduled` field of the +// [K8s DaemonSetStatus]. +// +// [K8s DaemonSetStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#daemonsetstatus-v1-apps +func (m DaemonSetMisscheduledNodes) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // DaemonSetReadyNodes is an instrument used to record metric values conforming // to the "k8s.daemonset.ready_nodes" semantic conventions. It represents the // number of nodes that should be running the daemon pod and have one or more of @@ -1392,7 +1739,7 @@ func (DaemonSetReadyNodes) Description() string { return "Number of nodes that should be running the daemon pod and have one or more of the daemon pod running and ready" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `numberReady` field of the // [K8s DaemonSetStatus]. @@ -1414,6 +1761,28 @@ func (m DaemonSetReadyNodes) Add(ctx context.Context, incr int64, attrs ...attri m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `numberReady` field of the +// [K8s DaemonSetStatus]. +// +// [K8s DaemonSetStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#daemonsetstatus-v1-apps +func (m DaemonSetReadyNodes) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // DeploymentAvailablePods is an instrument used to record metric values // conforming to the "k8s.deployment.available_pods" semantic conventions. It // represents the total number of available replica pods (ready for at least @@ -1465,7 +1834,7 @@ func (DeploymentAvailablePods) Description() string { return "Total number of available replica pods (ready for at least minReadySeconds) targeted by this deployment" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `availableReplicas` field of the // [K8s DeploymentStatus]. @@ -1487,6 +1856,28 @@ func (m DeploymentAvailablePods) Add(ctx context.Context, incr int64, attrs ...a m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `availableReplicas` field of the +// [K8s DeploymentStatus]. +// +// [K8s DeploymentStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#deploymentstatus-v1-apps +func (m DeploymentAvailablePods) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // DeploymentDesiredPods is an instrument used to record metric values conforming // to the "k8s.deployment.desired_pods" semantic conventions. It represents the // number of desired replica pods in this deployment. @@ -1537,7 +1928,7 @@ func (DeploymentDesiredPods) Description() string { return "Number of desired replica pods in this deployment" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `replicas` field of the // [K8s DeploymentSpec]. @@ -1559,6 +1950,28 @@ func (m DeploymentDesiredPods) Add(ctx context.Context, incr int64, attrs ...att m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `replicas` field of the +// [K8s DeploymentSpec]. +// +// [K8s DeploymentSpec]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#deploymentspec-v1-apps +func (m DeploymentDesiredPods) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // HPACurrentPods is an instrument used to record metric values conforming to the // "k8s.hpa.current_pods" semantic conventions. It represents the current number // of replica pods managed by this horizontal pod autoscaler, as last seen by the @@ -1610,7 +2023,7 @@ func (HPACurrentPods) Description() string { return "Current number of replica pods managed by this horizontal pod autoscaler, as last seen by the autoscaler" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `currentReplicas` field of the // [K8s HorizontalPodAutoscalerStatus] @@ -1632,6 +2045,28 @@ func (m HPACurrentPods) Add(ctx context.Context, incr int64, attrs ...attribute. m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `currentReplicas` field of the +// [K8s HorizontalPodAutoscalerStatus] +// +// [K8s HorizontalPodAutoscalerStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#horizontalpodautoscalerstatus-v2-autoscaling +func (m HPACurrentPods) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // HPADesiredPods is an instrument used to record metric values conforming to the // "k8s.hpa.desired_pods" semantic conventions. It represents the desired number // of replica pods managed by this horizontal pod autoscaler, as last calculated @@ -1683,7 +2118,7 @@ func (HPADesiredPods) Description() string { return "Desired number of replica pods managed by this horizontal pod autoscaler, as last calculated by the autoscaler" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `desiredReplicas` field of the // [K8s HorizontalPodAutoscalerStatus] @@ -1705,6 +2140,28 @@ func (m HPADesiredPods) Add(ctx context.Context, incr int64, attrs ...attribute. m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `desiredReplicas` field of the +// [K8s HorizontalPodAutoscalerStatus] +// +// [K8s HorizontalPodAutoscalerStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#horizontalpodautoscalerstatus-v2-autoscaling +func (m HPADesiredPods) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // HPAMaxPods is an instrument used to record metric values conforming to the // "k8s.hpa.max_pods" semantic conventions. It represents the upper limit for the // number of replica pods to which the autoscaler can scale up. @@ -1755,7 +2212,7 @@ func (HPAMaxPods) Description() string { return "The upper limit for the number of replica pods to which the autoscaler can scale up" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `maxReplicas` field of the // [K8s HorizontalPodAutoscalerSpec] @@ -1777,6 +2234,28 @@ func (m HPAMaxPods) Add(ctx context.Context, incr int64, attrs ...attribute.KeyV m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `maxReplicas` field of the +// [K8s HorizontalPodAutoscalerSpec] +// +// [K8s HorizontalPodAutoscalerSpec]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#horizontalpodautoscalerspec-v2-autoscaling +func (m HPAMaxPods) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // HPAMetricTargetCPUAverageUtilization is an instrument used to record metric // values conforming to the "k8s.hpa.metric.target.cpu.average_utilization" // semantic conventions. It represents the target average utilization, in @@ -1829,7 +2308,7 @@ func (HPAMetricTargetCPUAverageUtilization) Description() string { return "Target average utilization, in percentage, for CPU resource in HPA config." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // All additional attrs passed are included in the recorded value. // @@ -1867,6 +2346,31 @@ func (m HPAMetricTargetCPUAverageUtilization) Record( m.Int64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// This metric aligns with the `averageUtilization` field of the +// [K8s HPA MetricTarget]. +// If the type of the metric is [`ContainerResource`], +// the `k8s.container.name` attribute MUST be set to identify the specific +// container within the pod to which the metric applies. +// +// [K8s HPA MetricTarget]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#metrictarget-v2-autoscaling +// [`ContainerResource`]: https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/#support-for-metrics-apis +func (m HPAMetricTargetCPUAverageUtilization) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Gauge.Record(ctx, val, *o...) +} + // AttrContainerName returns an optional attribute for the "k8s.container.name" // semantic convention. It represents the name of the Container from Pod // specification, must be unique within a Pod. Container runtime usually uses @@ -1934,7 +2438,7 @@ func (HPAMetricTargetCPUAverageValue) Description() string { return "Target average value for CPU resource in HPA config." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // All additional attrs passed are included in the recorded value. // @@ -1972,6 +2476,31 @@ func (m HPAMetricTargetCPUAverageValue) Record( m.Int64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// This metric aligns with the `averageValue` field of the +// [K8s HPA MetricTarget]. +// If the type of the metric is [`ContainerResource`], +// the `k8s.container.name` attribute MUST be set to identify the specific +// container within the pod to which the metric applies. +// +// [K8s HPA MetricTarget]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#metrictarget-v2-autoscaling +// [`ContainerResource`]: https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/#support-for-metrics-apis +func (m HPAMetricTargetCPUAverageValue) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Gauge.Record(ctx, val, *o...) +} + // AttrContainerName returns an optional attribute for the "k8s.container.name" // semantic convention. It represents the name of the Container from Pod // specification, must be unique within a Pod. Container runtime usually uses @@ -2037,7 +2566,7 @@ func (HPAMetricTargetCPUValue) Description() string { return "Target value for CPU resource in HPA config." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // All additional attrs passed are included in the recorded value. // @@ -2075,6 +2604,31 @@ func (m HPAMetricTargetCPUValue) Record( m.Int64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// This metric aligns with the `value` field of the +// [K8s HPA MetricTarget]. +// If the type of the metric is [`ContainerResource`], +// the `k8s.container.name` attribute MUST be set to identify the specific +// container within the pod to which the metric applies. +// +// [K8s HPA MetricTarget]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#metrictarget-v2-autoscaling +// [`ContainerResource`]: https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/#support-for-metrics-apis +func (m HPAMetricTargetCPUValue) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Gauge.Record(ctx, val, *o...) +} + // AttrContainerName returns an optional attribute for the "k8s.container.name" // semantic convention. It represents the name of the Container from Pod // specification, must be unique within a Pod. Container runtime usually uses @@ -2140,7 +2694,7 @@ func (HPAMinPods) Description() string { return "The lower limit for the number of replica pods to which the autoscaler can scale down" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `minReplicas` field of the // [K8s HorizontalPodAutoscalerSpec] @@ -2162,6 +2716,28 @@ func (m HPAMinPods) Add(ctx context.Context, incr int64, attrs ...attribute.KeyV m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `minReplicas` field of the +// [K8s HorizontalPodAutoscalerSpec] +// +// [K8s HorizontalPodAutoscalerSpec]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#horizontalpodautoscalerspec-v2-autoscaling +func (m HPAMinPods) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // JobActivePods is an instrument used to record metric values conforming to the // "k8s.job.active_pods" semantic conventions. It represents the number of // pending and actively running pods for a job. @@ -2212,7 +2788,7 @@ func (JobActivePods) Description() string { return "The number of pending and actively running pods for a job" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `active` field of the // [K8s JobStatus]. @@ -2234,6 +2810,28 @@ func (m JobActivePods) Add(ctx context.Context, incr int64, attrs ...attribute.K m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `active` field of the +// [K8s JobStatus]. +// +// [K8s JobStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobstatus-v1-batch +func (m JobActivePods) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // JobDesiredSuccessfulPods is an instrument used to record metric values // conforming to the "k8s.job.desired_successful_pods" semantic conventions. It // represents the desired number of successfully finished pods the job should be @@ -2285,7 +2883,7 @@ func (JobDesiredSuccessfulPods) Description() string { return "The desired number of successfully finished pods the job should be run with" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `completions` field of the // [K8s JobSpec].. @@ -2307,6 +2905,28 @@ func (m JobDesiredSuccessfulPods) Add(ctx context.Context, incr int64, attrs ... m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `completions` field of the +// [K8s JobSpec].. +// +// [K8s JobSpec]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobspec-v1-batch +func (m JobDesiredSuccessfulPods) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // JobFailedPods is an instrument used to record metric values conforming to the // "k8s.job.failed_pods" semantic conventions. It represents the number of pods // which reached phase Failed for a job. @@ -2357,7 +2977,7 @@ func (JobFailedPods) Description() string { return "The number of pods which reached phase Failed for a job" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `failed` field of the // [K8s JobStatus]. @@ -2379,6 +2999,28 @@ func (m JobFailedPods) Add(ctx context.Context, incr int64, attrs ...attribute.K m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `failed` field of the +// [K8s JobStatus]. +// +// [K8s JobStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobstatus-v1-batch +func (m JobFailedPods) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // JobMaxParallelPods is an instrument used to record metric values conforming to // the "k8s.job.max_parallel_pods" semantic conventions. It represents the max // desired number of pods the job should run at any given time. @@ -2429,7 +3071,7 @@ func (JobMaxParallelPods) Description() string { return "The max desired number of pods the job should run at any given time" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `parallelism` field of the // [K8s JobSpec]. @@ -2451,6 +3093,28 @@ func (m JobMaxParallelPods) Add(ctx context.Context, incr int64, attrs ...attrib m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `parallelism` field of the +// [K8s JobSpec]. +// +// [K8s JobSpec]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobspec-v1-batch +func (m JobMaxParallelPods) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // JobSuccessfulPods is an instrument used to record metric values conforming to // the "k8s.job.successful_pods" semantic conventions. It represents the number // of pods which reached phase Succeeded for a job. @@ -2501,7 +3165,7 @@ func (JobSuccessfulPods) Description() string { return "The number of pods which reached phase Succeeded for a job" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `succeeded` field of the // [K8s JobStatus]. @@ -2523,6 +3187,28 @@ func (m JobSuccessfulPods) Add(ctx context.Context, incr int64, attrs ...attribu m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `succeeded` field of the +// [K8s JobStatus]. +// +// [K8s JobStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobstatus-v1-batch +func (m JobSuccessfulPods) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // NamespacePhase is an instrument used to record metric values conforming to the // "k8s.namespace.phase" semantic conventions. It represents the describes number // of K8s namespaces that are currently in a given phase. @@ -2573,7 +3259,7 @@ func (NamespacePhase) Description() string { return "Describes number of K8s namespaces that are currently in a given phase." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The namespacePhase is the the phase of the K8s namespace. func (m NamespacePhase) Add( @@ -2606,6 +3292,23 @@ func (m NamespacePhase) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m NamespacePhase) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // NodeAllocatableCPU is an instrument used to record metric values conforming to // the "k8s.node.allocatable.cpu" semantic conventions. It represents the amount // of cpu allocatable on the node. @@ -2656,7 +3359,7 @@ func (NodeAllocatableCPU) Description() string { return "Amount of cpu allocatable on the node" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. func (m NodeAllocatableCPU) Add(ctx context.Context, incr int64, attrs ...attribute.KeyValue) { if len(attrs) == 0 { m.Int64UpDownCounter.Add(ctx, incr) @@ -2673,6 +3376,23 @@ func (m NodeAllocatableCPU) Add(ctx context.Context, incr int64, attrs ...attrib m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m NodeAllocatableCPU) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // NodeAllocatableEphemeralStorage is an instrument used to record metric values // conforming to the "k8s.node.allocatable.ephemeral_storage" semantic // conventions. It represents the amount of ephemeral-storage allocatable on the @@ -2725,7 +3445,7 @@ func (NodeAllocatableEphemeralStorage) Description() string { return "Amount of ephemeral-storage allocatable on the node" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. func (m NodeAllocatableEphemeralStorage) Add(ctx context.Context, incr int64, attrs ...attribute.KeyValue) { if len(attrs) == 0 { m.Int64UpDownCounter.Add(ctx, incr) @@ -2742,6 +3462,23 @@ func (m NodeAllocatableEphemeralStorage) Add(ctx context.Context, incr int64, at m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m NodeAllocatableEphemeralStorage) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // NodeAllocatableMemory is an instrument used to record metric values conforming // to the "k8s.node.allocatable.memory" semantic conventions. It represents the // amount of memory allocatable on the node. @@ -2792,7 +3529,7 @@ func (NodeAllocatableMemory) Description() string { return "Amount of memory allocatable on the node" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. func (m NodeAllocatableMemory) Add(ctx context.Context, incr int64, attrs ...attribute.KeyValue) { if len(attrs) == 0 { m.Int64UpDownCounter.Add(ctx, incr) @@ -2809,6 +3546,23 @@ func (m NodeAllocatableMemory) Add(ctx context.Context, incr int64, attrs ...att m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m NodeAllocatableMemory) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // NodeAllocatablePods is an instrument used to record metric values conforming // to the "k8s.node.allocatable.pods" semantic conventions. It represents the // amount of pods allocatable on the node. @@ -2859,7 +3613,7 @@ func (NodeAllocatablePods) Description() string { return "Amount of pods allocatable on the node" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. func (m NodeAllocatablePods) Add(ctx context.Context, incr int64, attrs ...attribute.KeyValue) { if len(attrs) == 0 { m.Int64UpDownCounter.Add(ctx, incr) @@ -2876,6 +3630,23 @@ func (m NodeAllocatablePods) Add(ctx context.Context, incr int64, attrs ...attri m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m NodeAllocatablePods) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // NodeConditionStatus is an instrument used to record metric values conforming // to the "k8s.node.condition.status" semantic conventions. It represents the // describes the condition of a particular Node. @@ -2926,7 +3697,7 @@ func (NodeConditionStatus) Description() string { return "Describes the condition of a particular Node." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The nodeConditionStatus is the the status of the condition, one of True, // False, Unknown. @@ -2968,6 +3739,27 @@ func (m NodeConditionStatus) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// All possible node condition pairs (type and status) will be reported at each +// time interval to avoid missing metrics. Condition pairs corresponding to the +// current conditions' statuses will be non-zero. +func (m NodeConditionStatus) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // NodeCPUTime is an instrument used to record metric values conforming to the // "k8s.node.cpu.time" semantic conventions. It represents the total CPU time // consumed. @@ -3018,7 +3810,7 @@ func (NodeCPUTime) Description() string { return "Total CPU time consumed" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // Total CPU time consumed by the specific Node on all available CPU cores func (m NodeCPUTime) Add(ctx context.Context, incr float64, attrs ...attribute.KeyValue) { @@ -3037,6 +3829,25 @@ func (m NodeCPUTime) Add(ctx context.Context, incr float64, attrs ...attribute.K m.Float64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// Total CPU time consumed by the specific Node on all available CPU cores +func (m NodeCPUTime) AddSet(ctx context.Context, incr float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Counter.Add(ctx, incr, *o...) +} + // NodeCPUUsage is an instrument used to record metric values conforming to the // "k8s.node.cpu.usage" semantic conventions. It represents the node's CPU usage, // measured in cpus. Range from 0 to the number of allocatable CPUs. @@ -3087,7 +3898,7 @@ func (NodeCPUUsage) Description() string { return "Node's CPU usage, measured in cpus. Range from 0 to the number of allocatable CPUs" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // CPU usage of the specific Node on all available CPU cores, averaged over the // sample window @@ -3107,6 +3918,25 @@ func (m NodeCPUUsage) Record(ctx context.Context, val int64, attrs ...attribute. m.Int64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// CPU usage of the specific Node on all available CPU cores, averaged over the +// sample window +func (m NodeCPUUsage) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Gauge.Record(ctx, val, *o...) +} + // NodeMemoryUsage is an instrument used to record metric values conforming to // the "k8s.node.memory.usage" semantic conventions. It represents the memory // usage of the Node. @@ -3157,7 +3987,7 @@ func (NodeMemoryUsage) Description() string { return "Memory usage of the Node" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // Total memory usage of the Node func (m NodeMemoryUsage) Record(ctx context.Context, val int64, attrs ...attribute.KeyValue) { @@ -3176,6 +4006,24 @@ func (m NodeMemoryUsage) Record(ctx context.Context, val int64, attrs ...attribu m.Int64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// Total memory usage of the Node +func (m NodeMemoryUsage) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Gauge.Record(ctx, val, *o...) +} + // NodeNetworkErrors is an instrument used to record metric values conforming to // the "k8s.node.network.errors" semantic conventions. It represents the node // network errors. @@ -3226,7 +4074,7 @@ func (NodeNetworkErrors) Description() string { return "Node network errors" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m NodeNetworkErrors) Add( @@ -3255,6 +4103,23 @@ func (m NodeNetworkErrors) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m NodeNetworkErrors) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrNetworkInterfaceName returns an optional attribute for the // "network.interface.name" semantic convention. It represents the network // interface name. @@ -3319,7 +4184,7 @@ func (NodeNetworkIO) Description() string { return "Network bytes for the Node" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m NodeNetworkIO) Add( @@ -3348,6 +4213,23 @@ func (m NodeNetworkIO) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m NodeNetworkIO) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrNetworkInterfaceName returns an optional attribute for the // "network.interface.name" semantic convention. It represents the network // interface name. @@ -3412,7 +4294,7 @@ func (NodeUptime) Description() string { return "The time the Node has been running" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // Instrumentations SHOULD use a gauge with type `double` and measure uptime in // seconds as a floating point number with the highest precision available. @@ -3433,6 +4315,26 @@ func (m NodeUptime) Record(ctx context.Context, val float64, attrs ...attribute. m.Float64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// Instrumentations SHOULD use a gauge with type `double` and measure uptime in +// seconds as a floating point number with the highest precision available. +// The actual accuracy would depend on the instrumentation and operating system. +func (m NodeUptime) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Gauge.Record(ctx, val, *o...) +} + // PodCPUTime is an instrument used to record metric values conforming to the // "k8s.pod.cpu.time" semantic conventions. It represents the total CPU time // consumed. @@ -3483,7 +4385,7 @@ func (PodCPUTime) Description() string { return "Total CPU time consumed" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // Total CPU time consumed by the specific Pod on all available CPU cores func (m PodCPUTime) Add(ctx context.Context, incr float64, attrs ...attribute.KeyValue) { @@ -3502,6 +4404,25 @@ func (m PodCPUTime) Add(ctx context.Context, incr float64, attrs ...attribute.Ke m.Float64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// Total CPU time consumed by the specific Pod on all available CPU cores +func (m PodCPUTime) AddSet(ctx context.Context, incr float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Counter.Add(ctx, incr, *o...) +} + // PodCPUUsage is an instrument used to record metric values conforming to the // "k8s.pod.cpu.usage" semantic conventions. It represents the pod's CPU usage, // measured in cpus. Range from 0 to the number of allocatable CPUs. @@ -3552,7 +4473,7 @@ func (PodCPUUsage) Description() string { return "Pod's CPU usage, measured in cpus. Range from 0 to the number of allocatable CPUs" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // CPU usage of the specific Pod on all available CPU cores, averaged over the // sample window @@ -3572,6 +4493,25 @@ func (m PodCPUUsage) Record(ctx context.Context, val int64, attrs ...attribute.K m.Int64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// CPU usage of the specific Pod on all available CPU cores, averaged over the +// sample window +func (m PodCPUUsage) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Gauge.Record(ctx, val, *o...) +} + // PodMemoryUsage is an instrument used to record metric values conforming to the // "k8s.pod.memory.usage" semantic conventions. It represents the memory usage of // the Pod. @@ -3622,7 +4562,7 @@ func (PodMemoryUsage) Description() string { return "Memory usage of the Pod" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // Total memory usage of the Pod func (m PodMemoryUsage) Record(ctx context.Context, val int64, attrs ...attribute.KeyValue) { @@ -3641,6 +4581,24 @@ func (m PodMemoryUsage) Record(ctx context.Context, val int64, attrs ...attribut m.Int64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// Total memory usage of the Pod +func (m PodMemoryUsage) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Gauge.Record(ctx, val, *o...) +} + // PodNetworkErrors is an instrument used to record metric values conforming to // the "k8s.pod.network.errors" semantic conventions. It represents the pod // network errors. @@ -3691,7 +4649,7 @@ func (PodNetworkErrors) Description() string { return "Pod network errors" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m PodNetworkErrors) Add( @@ -3720,6 +4678,23 @@ func (m PodNetworkErrors) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m PodNetworkErrors) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrNetworkInterfaceName returns an optional attribute for the // "network.interface.name" semantic convention. It represents the network // interface name. @@ -3784,7 +4759,7 @@ func (PodNetworkIO) Description() string { return "Network bytes for the Pod" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m PodNetworkIO) Add( @@ -3813,6 +4788,23 @@ func (m PodNetworkIO) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m PodNetworkIO) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrNetworkInterfaceName returns an optional attribute for the // "network.interface.name" semantic convention. It represents the network // interface name. @@ -3877,7 +4869,7 @@ func (PodUptime) Description() string { return "The time the Pod has been running" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // Instrumentations SHOULD use a gauge with type `double` and measure uptime in // seconds as a floating point number with the highest precision available. @@ -3898,6 +4890,26 @@ func (m PodUptime) Record(ctx context.Context, val float64, attrs ...attribute.K m.Float64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// Instrumentations SHOULD use a gauge with type `double` and measure uptime in +// seconds as a floating point number with the highest precision available. +// The actual accuracy would depend on the instrumentation and operating system. +func (m PodUptime) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Gauge.Record(ctx, val, *o...) +} + // ReplicaSetAvailablePods is an instrument used to record metric values // conforming to the "k8s.replicaset.available_pods" semantic conventions. It // represents the total number of available replica pods (ready for at least @@ -3949,7 +4961,7 @@ func (ReplicaSetAvailablePods) Description() string { return "Total number of available replica pods (ready for at least minReadySeconds) targeted by this replicaset" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `availableReplicas` field of the // [K8s ReplicaSetStatus]. @@ -3971,6 +4983,28 @@ func (m ReplicaSetAvailablePods) Add(ctx context.Context, incr int64, attrs ...a m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `availableReplicas` field of the +// [K8s ReplicaSetStatus]. +// +// [K8s ReplicaSetStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicasetstatus-v1-apps +func (m ReplicaSetAvailablePods) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ReplicaSetDesiredPods is an instrument used to record metric values conforming // to the "k8s.replicaset.desired_pods" semantic conventions. It represents the // number of desired replica pods in this replicaset. @@ -4021,7 +5055,7 @@ func (ReplicaSetDesiredPods) Description() string { return "Number of desired replica pods in this replicaset" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `replicas` field of the // [K8s ReplicaSetSpec]. @@ -4043,6 +5077,28 @@ func (m ReplicaSetDesiredPods) Add(ctx context.Context, incr int64, attrs ...att m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `replicas` field of the +// [K8s ReplicaSetSpec]. +// +// [K8s ReplicaSetSpec]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicasetspec-v1-apps +func (m ReplicaSetDesiredPods) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ReplicationControllerAvailablePods is an instrument used to record metric // values conforming to the "k8s.replicationcontroller.available_pods" semantic // conventions. It represents the total number of available replica pods (ready @@ -4095,7 +5151,7 @@ func (ReplicationControllerAvailablePods) Description() string { return "Total number of available replica pods (ready for at least minReadySeconds) targeted by this replication controller" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `availableReplicas` field of the // [K8s ReplicationControllerStatus] @@ -4117,6 +5173,28 @@ func (m ReplicationControllerAvailablePods) Add(ctx context.Context, incr int64, m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `availableReplicas` field of the +// [K8s ReplicationControllerStatus] +// +// [K8s ReplicationControllerStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicationcontrollerstatus-v1-core +func (m ReplicationControllerAvailablePods) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ReplicationControllerDesiredPods is an instrument used to record metric values // conforming to the "k8s.replicationcontroller.desired_pods" semantic // conventions. It represents the number of desired replica pods in this @@ -4169,7 +5247,7 @@ func (ReplicationControllerDesiredPods) Description() string { return "Number of desired replica pods in this replication controller" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `replicas` field of the // [K8s ReplicationControllerSpec] @@ -4191,6 +5269,28 @@ func (m ReplicationControllerDesiredPods) Add(ctx context.Context, incr int64, a m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `replicas` field of the +// [K8s ReplicationControllerSpec] +// +// [K8s ReplicationControllerSpec]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicationcontrollerspec-v1-core +func (m ReplicationControllerDesiredPods) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ResourceQuotaCPULimitHard is an instrument used to record metric values // conforming to the "k8s.resourcequota.cpu.limit.hard" semantic conventions. It // represents the CPU limits in a specific namespace. @@ -4244,7 +5344,7 @@ func (ResourceQuotaCPULimitHard) Description() string { return "The CPU limits in a specific namespace. The value represents the configured quota limit of the resource in the namespace." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric is retrieved from the `hard` field of the // [K8s ResourceQuotaStatus]. @@ -4266,6 +5366,28 @@ func (m ResourceQuotaCPULimitHard) Add(ctx context.Context, incr int64, attrs .. m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric is retrieved from the `hard` field of the +// [K8s ResourceQuotaStatus]. +// +// [K8s ResourceQuotaStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core +func (m ResourceQuotaCPULimitHard) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ResourceQuotaCPULimitUsed is an instrument used to record metric values // conforming to the "k8s.resourcequota.cpu.limit.used" semantic conventions. It // represents the CPU limits in a specific namespace. @@ -4319,7 +5441,7 @@ func (ResourceQuotaCPULimitUsed) Description() string { return "The CPU limits in a specific namespace. The value represents the current observed total usage of the resource in the namespace." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric is retrieved from the `used` field of the // [K8s ResourceQuotaStatus]. @@ -4341,6 +5463,28 @@ func (m ResourceQuotaCPULimitUsed) Add(ctx context.Context, incr int64, attrs .. m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric is retrieved from the `used` field of the +// [K8s ResourceQuotaStatus]. +// +// [K8s ResourceQuotaStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core +func (m ResourceQuotaCPULimitUsed) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ResourceQuotaCPURequestHard is an instrument used to record metric values // conforming to the "k8s.resourcequota.cpu.request.hard" semantic conventions. // It represents the CPU requests in a specific namespace. @@ -4394,7 +5538,7 @@ func (ResourceQuotaCPURequestHard) Description() string { return "The CPU requests in a specific namespace. The value represents the configured quota limit of the resource in the namespace." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric is retrieved from the `hard` field of the // [K8s ResourceQuotaStatus]. @@ -4416,6 +5560,28 @@ func (m ResourceQuotaCPURequestHard) Add(ctx context.Context, incr int64, attrs m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric is retrieved from the `hard` field of the +// [K8s ResourceQuotaStatus]. +// +// [K8s ResourceQuotaStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core +func (m ResourceQuotaCPURequestHard) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ResourceQuotaCPURequestUsed is an instrument used to record metric values // conforming to the "k8s.resourcequota.cpu.request.used" semantic conventions. // It represents the CPU requests in a specific namespace. @@ -4469,7 +5635,7 @@ func (ResourceQuotaCPURequestUsed) Description() string { return "The CPU requests in a specific namespace. The value represents the current observed total usage of the resource in the namespace." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric is retrieved from the `used` field of the // [K8s ResourceQuotaStatus]. @@ -4491,6 +5657,28 @@ func (m ResourceQuotaCPURequestUsed) Add(ctx context.Context, incr int64, attrs m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric is retrieved from the `used` field of the +// [K8s ResourceQuotaStatus]. +// +// [K8s ResourceQuotaStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core +func (m ResourceQuotaCPURequestUsed) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ResourceQuotaEphemeralStorageLimitHard is an instrument used to record metric // values conforming to the "k8s.resourcequota.ephemeral_storage.limit.hard" // semantic conventions. It represents the sum of local ephemeral storage limits @@ -4545,7 +5733,7 @@ func (ResourceQuotaEphemeralStorageLimitHard) Description() string { return "The sum of local ephemeral storage limits in the namespace. The value represents the configured quota limit of the resource in the namespace." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric is retrieved from the `hard` field of the // [K8s ResourceQuotaStatus]. @@ -4567,6 +5755,28 @@ func (m ResourceQuotaEphemeralStorageLimitHard) Add(ctx context.Context, incr in m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric is retrieved from the `hard` field of the +// [K8s ResourceQuotaStatus]. +// +// [K8s ResourceQuotaStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core +func (m ResourceQuotaEphemeralStorageLimitHard) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ResourceQuotaEphemeralStorageLimitUsed is an instrument used to record metric // values conforming to the "k8s.resourcequota.ephemeral_storage.limit.used" // semantic conventions. It represents the sum of local ephemeral storage limits @@ -4621,7 +5831,7 @@ func (ResourceQuotaEphemeralStorageLimitUsed) Description() string { return "The sum of local ephemeral storage limits in the namespace. The value represents the current observed total usage of the resource in the namespace." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric is retrieved from the `used` field of the // [K8s ResourceQuotaStatus]. @@ -4643,6 +5853,28 @@ func (m ResourceQuotaEphemeralStorageLimitUsed) Add(ctx context.Context, incr in m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric is retrieved from the `used` field of the +// [K8s ResourceQuotaStatus]. +// +// [K8s ResourceQuotaStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core +func (m ResourceQuotaEphemeralStorageLimitUsed) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ResourceQuotaEphemeralStorageRequestHard is an instrument used to record // metric values conforming to the // "k8s.resourcequota.ephemeral_storage.request.hard" semantic conventions. It @@ -4697,7 +5929,7 @@ func (ResourceQuotaEphemeralStorageRequestHard) Description() string { return "The sum of local ephemeral storage requests in the namespace. The value represents the configured quota limit of the resource in the namespace." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric is retrieved from the `hard` field of the // [K8s ResourceQuotaStatus]. @@ -4719,6 +5951,28 @@ func (m ResourceQuotaEphemeralStorageRequestHard) Add(ctx context.Context, incr m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric is retrieved from the `hard` field of the +// [K8s ResourceQuotaStatus]. +// +// [K8s ResourceQuotaStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core +func (m ResourceQuotaEphemeralStorageRequestHard) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ResourceQuotaEphemeralStorageRequestUsed is an instrument used to record // metric values conforming to the // "k8s.resourcequota.ephemeral_storage.request.used" semantic conventions. It @@ -4773,7 +6027,7 @@ func (ResourceQuotaEphemeralStorageRequestUsed) Description() string { return "The sum of local ephemeral storage requests in the namespace. The value represents the current observed total usage of the resource in the namespace." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric is retrieved from the `used` field of the // [K8s ResourceQuotaStatus]. @@ -4795,6 +6049,28 @@ func (m ResourceQuotaEphemeralStorageRequestUsed) Add(ctx context.Context, incr m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric is retrieved from the `used` field of the +// [K8s ResourceQuotaStatus]. +// +// [K8s ResourceQuotaStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core +func (m ResourceQuotaEphemeralStorageRequestUsed) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ResourceQuotaHugepageCountRequestHard is an instrument used to record metric // values conforming to the "k8s.resourcequota.hugepage_count.request.hard" // semantic conventions. It represents the huge page requests in a specific @@ -4849,7 +6125,7 @@ func (ResourceQuotaHugepageCountRequestHard) Description() string { return "The huge page requests in a specific namespace. The value represents the configured quota limit of the resource in the namespace." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The hugepageSize is the the size (identifier) of the K8s huge page. // @@ -4887,6 +6163,28 @@ func (m ResourceQuotaHugepageCountRequestHard) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric is retrieved from the `hard` field of the +// [K8s ResourceQuotaStatus]. +// +// [K8s ResourceQuotaStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core +func (m ResourceQuotaHugepageCountRequestHard) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ResourceQuotaHugepageCountRequestUsed is an instrument used to record metric // values conforming to the "k8s.resourcequota.hugepage_count.request.used" // semantic conventions. It represents the huge page requests in a specific @@ -4941,7 +6239,7 @@ func (ResourceQuotaHugepageCountRequestUsed) Description() string { return "The huge page requests in a specific namespace. The value represents the current observed total usage of the resource in the namespace." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The hugepageSize is the the size (identifier) of the K8s huge page. // @@ -4979,6 +6277,28 @@ func (m ResourceQuotaHugepageCountRequestUsed) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric is retrieved from the `used` field of the +// [K8s ResourceQuotaStatus]. +// +// [K8s ResourceQuotaStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core +func (m ResourceQuotaHugepageCountRequestUsed) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ResourceQuotaMemoryLimitHard is an instrument used to record metric values // conforming to the "k8s.resourcequota.memory.limit.hard" semantic conventions. // It represents the memory limits in a specific namespace. @@ -5032,7 +6352,7 @@ func (ResourceQuotaMemoryLimitHard) Description() string { return "The memory limits in a specific namespace. The value represents the configured quota limit of the resource in the namespace." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric is retrieved from the `hard` field of the // [K8s ResourceQuotaStatus]. @@ -5054,6 +6374,28 @@ func (m ResourceQuotaMemoryLimitHard) Add(ctx context.Context, incr int64, attrs m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric is retrieved from the `hard` field of the +// [K8s ResourceQuotaStatus]. +// +// [K8s ResourceQuotaStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core +func (m ResourceQuotaMemoryLimitHard) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ResourceQuotaMemoryLimitUsed is an instrument used to record metric values // conforming to the "k8s.resourcequota.memory.limit.used" semantic conventions. // It represents the memory limits in a specific namespace. @@ -5107,7 +6449,7 @@ func (ResourceQuotaMemoryLimitUsed) Description() string { return "The memory limits in a specific namespace. The value represents the current observed total usage of the resource in the namespace." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric is retrieved from the `used` field of the // [K8s ResourceQuotaStatus]. @@ -5129,6 +6471,28 @@ func (m ResourceQuotaMemoryLimitUsed) Add(ctx context.Context, incr int64, attrs m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric is retrieved from the `used` field of the +// [K8s ResourceQuotaStatus]. +// +// [K8s ResourceQuotaStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core +func (m ResourceQuotaMemoryLimitUsed) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ResourceQuotaMemoryRequestHard is an instrument used to record metric values // conforming to the "k8s.resourcequota.memory.request.hard" semantic // conventions. It represents the memory requests in a specific namespace. @@ -5182,7 +6546,7 @@ func (ResourceQuotaMemoryRequestHard) Description() string { return "The memory requests in a specific namespace. The value represents the configured quota limit of the resource in the namespace." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric is retrieved from the `hard` field of the // [K8s ResourceQuotaStatus]. @@ -5204,6 +6568,28 @@ func (m ResourceQuotaMemoryRequestHard) Add(ctx context.Context, incr int64, att m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric is retrieved from the `hard` field of the +// [K8s ResourceQuotaStatus]. +// +// [K8s ResourceQuotaStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core +func (m ResourceQuotaMemoryRequestHard) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ResourceQuotaMemoryRequestUsed is an instrument used to record metric values // conforming to the "k8s.resourcequota.memory.request.used" semantic // conventions. It represents the memory requests in a specific namespace. @@ -5257,7 +6643,7 @@ func (ResourceQuotaMemoryRequestUsed) Description() string { return "The memory requests in a specific namespace. The value represents the current observed total usage of the resource in the namespace." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric is retrieved from the `used` field of the // [K8s ResourceQuotaStatus]. @@ -5279,6 +6665,28 @@ func (m ResourceQuotaMemoryRequestUsed) Add(ctx context.Context, incr int64, att m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric is retrieved from the `used` field of the +// [K8s ResourceQuotaStatus]. +// +// [K8s ResourceQuotaStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core +func (m ResourceQuotaMemoryRequestUsed) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ResourceQuotaObjectCountHard is an instrument used to record metric values // conforming to the "k8s.resourcequota.object_count.hard" semantic conventions. // It represents the object count limits in a specific namespace. @@ -5332,7 +6740,7 @@ func (ResourceQuotaObjectCountHard) Description() string { return "The object count limits in a specific namespace. The value represents the configured quota limit of the resource in the namespace." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The resourcequotaResourceName is the the name of the K8s resource a resource // quota defines. @@ -5371,6 +6779,28 @@ func (m ResourceQuotaObjectCountHard) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric is retrieved from the `hard` field of the +// [K8s ResourceQuotaStatus]. +// +// [K8s ResourceQuotaStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core +func (m ResourceQuotaObjectCountHard) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ResourceQuotaObjectCountUsed is an instrument used to record metric values // conforming to the "k8s.resourcequota.object_count.used" semantic conventions. // It represents the object count limits in a specific namespace. @@ -5424,7 +6854,7 @@ func (ResourceQuotaObjectCountUsed) Description() string { return "The object count limits in a specific namespace. The value represents the current observed total usage of the resource in the namespace." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The resourcequotaResourceName is the the name of the K8s resource a resource // quota defines. @@ -5463,6 +6893,28 @@ func (m ResourceQuotaObjectCountUsed) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric is retrieved from the `used` field of the +// [K8s ResourceQuotaStatus]. +// +// [K8s ResourceQuotaStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core +func (m ResourceQuotaObjectCountUsed) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // ResourceQuotaPersistentvolumeclaimCountHard is an instrument used to record // metric values conforming to the // "k8s.resourcequota.persistentvolumeclaim_count.hard" semantic conventions. It @@ -5518,7 +6970,7 @@ func (ResourceQuotaPersistentvolumeclaimCountHard) Description() string { return "The total number of PersistentVolumeClaims that can exist in the namespace. The value represents the configured quota limit of the resource in the namespace." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -5556,6 +7008,32 @@ func (m ResourceQuotaPersistentvolumeclaimCountHard) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric is retrieved from the `hard` field of the +// [K8s ResourceQuotaStatus]. +// +// The `k8s.storageclass.name` should be required when a resource quota is +// defined for a specific +// storage class. +// +// [K8s ResourceQuotaStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core +func (m ResourceQuotaPersistentvolumeclaimCountHard) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrStorageclassName returns an optional attribute for the // "k8s.storageclass.name" semantic convention. It represents the name of K8s // [StorageClass] object. @@ -5620,7 +7098,7 @@ func (ResourceQuotaPersistentvolumeclaimCountUsed) Description() string { return "The total number of PersistentVolumeClaims that can exist in the namespace. The value represents the current observed total usage of the resource in the namespace." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -5658,6 +7136,32 @@ func (m ResourceQuotaPersistentvolumeclaimCountUsed) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric is retrieved from the `used` field of the +// [K8s ResourceQuotaStatus]. +// +// The `k8s.storageclass.name` should be required when a resource quota is +// defined for a specific +// storage class. +// +// [K8s ResourceQuotaStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core +func (m ResourceQuotaPersistentvolumeclaimCountUsed) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrStorageclassName returns an optional attribute for the // "k8s.storageclass.name" semantic convention. It represents the name of K8s // [StorageClass] object. @@ -5720,7 +7224,7 @@ func (ResourceQuotaStorageRequestHard) Description() string { return "The storage requests in a specific namespace. The value represents the configured quota limit of the resource in the namespace." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -5758,6 +7262,32 @@ func (m ResourceQuotaStorageRequestHard) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric is retrieved from the `hard` field of the +// [K8s ResourceQuotaStatus]. +// +// The `k8s.storageclass.name` should be required when a resource quota is +// defined for a specific +// storage class. +// +// [K8s ResourceQuotaStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core +func (m ResourceQuotaStorageRequestHard) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrStorageclassName returns an optional attribute for the // "k8s.storageclass.name" semantic convention. It represents the name of K8s // [StorageClass] object. @@ -5820,7 +7350,7 @@ func (ResourceQuotaStorageRequestUsed) Description() string { return "The storage requests in a specific namespace. The value represents the current observed total usage of the resource in the namespace." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -5858,6 +7388,32 @@ func (m ResourceQuotaStorageRequestUsed) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric is retrieved from the `used` field of the +// [K8s ResourceQuotaStatus]. +// +// The `k8s.storageclass.name` should be required when a resource quota is +// defined for a specific +// storage class. +// +// [K8s ResourceQuotaStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core +func (m ResourceQuotaStorageRequestUsed) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrStorageclassName returns an optional attribute for the // "k8s.storageclass.name" semantic convention. It represents the name of K8s // [StorageClass] object. @@ -5918,7 +7474,7 @@ func (StatefulSetCurrentPods) Description() string { return "The number of replica pods created by the statefulset controller from the statefulset version indicated by currentRevision" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `currentReplicas` field of the // [K8s StatefulSetStatus]. @@ -5940,6 +7496,28 @@ func (m StatefulSetCurrentPods) Add(ctx context.Context, incr int64, attrs ...at m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `currentReplicas` field of the +// [K8s StatefulSetStatus]. +// +// [K8s StatefulSetStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#statefulsetstatus-v1-apps +func (m StatefulSetCurrentPods) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // StatefulSetDesiredPods is an instrument used to record metric values // conforming to the "k8s.statefulset.desired_pods" semantic conventions. It // represents the number of desired replica pods in this statefulset. @@ -5990,7 +7568,7 @@ func (StatefulSetDesiredPods) Description() string { return "Number of desired replica pods in this statefulset" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `replicas` field of the // [K8s StatefulSetSpec]. @@ -6012,6 +7590,28 @@ func (m StatefulSetDesiredPods) Add(ctx context.Context, incr int64, attrs ...at m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `replicas` field of the +// [K8s StatefulSetSpec]. +// +// [K8s StatefulSetSpec]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#statefulsetspec-v1-apps +func (m StatefulSetDesiredPods) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // StatefulSetReadyPods is an instrument used to record metric values conforming // to the "k8s.statefulset.ready_pods" semantic conventions. It represents the // number of replica pods created for this statefulset with a Ready Condition. @@ -6062,7 +7662,7 @@ func (StatefulSetReadyPods) Description() string { return "The number of replica pods created for this statefulset with a Ready Condition" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `readyReplicas` field of the // [K8s StatefulSetStatus]. @@ -6084,6 +7684,28 @@ func (m StatefulSetReadyPods) Add(ctx context.Context, incr int64, attrs ...attr m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `readyReplicas` field of the +// [K8s StatefulSetStatus]. +// +// [K8s StatefulSetStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#statefulsetstatus-v1-apps +func (m StatefulSetReadyPods) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // StatefulSetUpdatedPods is an instrument used to record metric values // conforming to the "k8s.statefulset.updated_pods" semantic conventions. It // represents the number of replica pods created by the statefulset controller @@ -6135,7 +7757,7 @@ func (StatefulSetUpdatedPods) Description() string { return "Number of replica pods created by the statefulset controller from the statefulset version indicated by updateRevision" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This metric aligns with the `updatedReplicas` field of the // [K8s StatefulSetStatus]. @@ -6155,4 +7777,26 @@ func (m StatefulSetUpdatedPods) Add(ctx context.Context, incr int64, attrs ...at *o = append(*o, metric.WithAttributes(attrs...)) m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + +// AddSet adds incr to the existing count for set. +// +// This metric aligns with the `updatedReplicas` field of the +// [K8s StatefulSetStatus]. +// +// [K8s StatefulSetStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#statefulsetstatus-v1-apps +func (m StatefulSetUpdatedPods) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) } \ No newline at end of file diff --git a/semconv/v1.36.0/messagingconv/metric.go b/semconv/v1.36.0/messagingconv/metric.go index 131827839..5f1837fe6 100644 --- a/semconv/v1.36.0/messagingconv/metric.go +++ b/semconv/v1.36.0/messagingconv/metric.go @@ -136,7 +136,7 @@ func (ClientConsumedMessages) Description() string { return "Number of messages that were delivered to the application." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The operationName is the the system-specific name of the messaging operation. // @@ -183,6 +183,30 @@ func (m ClientConsumedMessages) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// Records the number of messages pulled from the broker or number of messages +// dispatched to the application in push-based scenarios. +// The metric SHOULD be reported once per message delivery. For example, if +// receiving and processing operations are both instrumented for a single message +// delivery, this counter is incremented when the message is received and not +// reported when it is processed. +func (m ClientConsumedMessages) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents the describes a class of error the operation ended // with. @@ -290,7 +314,7 @@ func (ClientOperationDuration) Description() string { return "Duration of messaging operation initiated by a producer or consumer client." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The operationName is the the system-specific name of the messaging operation. // @@ -333,6 +357,25 @@ func (m ClientOperationDuration) Record( m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// This metric SHOULD NOT be used to report processing duration - processing +// duration is reported in `messaging.process.duration` metric. +func (m ClientOperationDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents the describes a class of error the operation ended // with. @@ -446,7 +489,7 @@ func (ClientSentMessages) Description() string { return "Number of messages producer attempted to send to the broker." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The operationName is the the system-specific name of the messaging operation. // @@ -489,6 +532,26 @@ func (m ClientSentMessages) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This metric MUST NOT count messages that were created but haven't yet been +// sent. +func (m ClientSentMessages) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents the describes a class of error the operation ended // with. @@ -581,7 +644,7 @@ func (ProcessDuration) Description() string { return "Duration of processing operation." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The operationName is the the system-specific name of the messaging operation. // @@ -624,6 +687,25 @@ func (m ProcessDuration) Record( m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// This metric MUST be reported for operations with `messaging.operation.type` +// that matches `process`. +func (m ProcessDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents the describes a class of error the operation ended // with. diff --git a/semconv/v1.36.0/otelconv/metric.go b/semconv/v1.36.0/otelconv/metric.go index 803b725ef..f5dd8fe80 100644 --- a/semconv/v1.36.0/otelconv/metric.go +++ b/semconv/v1.36.0/otelconv/metric.go @@ -215,7 +215,7 @@ func (SDKExporterLogExported) Description() string { return "The number of log records for which the export has finished, either successful or failed" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -252,6 +252,31 @@ func (m SDKExporterLogExported) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// For successful exports, `error.type` MUST NOT be set. For failed exports, +// `error.type` MUST contain the failure cause. +// For exporters with partial success semantics (e.g. OTLP with +// `rejected_log_records`), rejected log records MUST count as failed and only +// non-rejected log records count as success. +// If no rejection reason is available, `rejected` SHOULD be used as value for +// `error.type`. +func (m SDKExporterLogExported) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents the describes a class of error the operation ended // with. @@ -337,7 +362,7 @@ func (SDKExporterLogInflight) Description() string { return "The number of log records which were passed to the exporter, but that have not been exported yet (neither successful, nor failed)" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -369,6 +394,26 @@ func (m SDKExporterLogInflight) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// For successful exports, `error.type` MUST NOT be set. For failed exports, +// `error.type` MUST contain the failure cause. +func (m SDKExporterLogInflight) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrComponentName returns an optional attribute for the "otel.component.name" // semantic convention. It represents a name uniquely identifying the instance of // the OpenTelemetry component within its containing SDK instance. @@ -448,7 +493,7 @@ func (SDKExporterMetricDataPointExported) Description() string { return "The number of metric data points for which the export has finished, either successful or failed" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -485,6 +530,31 @@ func (m SDKExporterMetricDataPointExported) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// For successful exports, `error.type` MUST NOT be set. For failed exports, +// `error.type` MUST contain the failure cause. +// For exporters with partial success semantics (e.g. OTLP with +// `rejected_data_points`), rejected data points MUST count as failed and only +// non-rejected data points count as success. +// If no rejection reason is available, `rejected` SHOULD be used as value for +// `error.type`. +func (m SDKExporterMetricDataPointExported) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents the describes a class of error the operation ended // with. @@ -572,7 +642,7 @@ func (SDKExporterMetricDataPointInflight) Description() string { return "The number of metric data points which were passed to the exporter, but that have not been exported yet (neither successful, nor failed)" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -604,6 +674,26 @@ func (m SDKExporterMetricDataPointInflight) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// For successful exports, `error.type` MUST NOT be set. For failed exports, +// `error.type` MUST contain the failure cause. +func (m SDKExporterMetricDataPointInflight) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrComponentName returns an optional attribute for the "otel.component.name" // semantic convention. It represents a name uniquely identifying the instance of // the OpenTelemetry component within its containing SDK instance. @@ -682,7 +772,7 @@ func (SDKExporterOperationDuration) Description() string { return "The duration of exporting a batch of telemetry records." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // All additional attrs passed are included in the recorded value. // @@ -721,6 +811,32 @@ func (m SDKExporterOperationDuration) Record( m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// This metric defines successful operations using the full success definitions +// for [http] +// and [grpc]. Anything else is defined as an unsuccessful operation. For +// successful +// operations, `error.type` MUST NOT be set. For unsuccessful export operations, +// `error.type` MUST contain a relevant failure cause. +// +// [http]: https://github.com/open-telemetry/opentelemetry-proto/blob/v1.5.0/docs/specification.md#full-success-1 +// [grpc]: https://github.com/open-telemetry/opentelemetry-proto/blob/v1.5.0/docs/specification.md#full-success +func (m SDKExporterOperationDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents the describes a class of error the operation ended // with. @@ -820,7 +936,7 @@ func (SDKExporterSpanExported) Description() string { return "The number of spans for which the export has finished, either successful or failed" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -857,6 +973,31 @@ func (m SDKExporterSpanExported) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// For successful exports, `error.type` MUST NOT be set. For failed exports, +// `error.type` MUST contain the failure cause. +// For exporters with partial success semantics (e.g. OTLP with `rejected_spans` +// ), rejected spans MUST count as failed and only non-rejected spans count as +// success. +// If no rejection reason is available, `rejected` SHOULD be used as value for +// `error.type`. +func (m SDKExporterSpanExported) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents the describes a class of error the operation ended // with. @@ -942,7 +1083,7 @@ func (SDKExporterSpanInflight) Description() string { return "The number of spans which were passed to the exporter, but that have not been exported yet (neither successful, nor failed)" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -974,6 +1115,26 @@ func (m SDKExporterSpanInflight) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// For successful exports, `error.type` MUST NOT be set. For failed exports, +// `error.type` MUST contain the failure cause. +func (m SDKExporterSpanInflight) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrComponentName returns an optional attribute for the "otel.component.name" // semantic convention. It represents a name uniquely identifying the instance of // the OpenTelemetry component within its containing SDK instance. @@ -1051,7 +1212,7 @@ func (SDKLogCreated) Description() string { return "The number of logs submitted to enabled SDK Loggers" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. func (m SDKLogCreated) Add(ctx context.Context, incr int64, attrs ...attribute.KeyValue) { if len(attrs) == 0 { m.Int64Counter.Add(ctx, incr) @@ -1068,6 +1229,23 @@ func (m SDKLogCreated) Add(ctx context.Context, incr int64, attrs ...attribute.K m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m SDKLogCreated) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // SDKMetricReaderCollectionDuration is an instrument used to record metric // values conforming to the "otel.sdk.metric_reader.collection.duration" semantic // conventions. It represents the duration of the collect operation of the metric @@ -1120,7 +1298,7 @@ func (SDKMetricReaderCollectionDuration) Description() string { return "The duration of the collect operation of the metric reader." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // All additional attrs passed are included in the recorded value. // @@ -1155,6 +1333,28 @@ func (m SDKMetricReaderCollectionDuration) Record( m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// For successful collections, `error.type` MUST NOT be set. For failed +// collections, `error.type` SHOULD contain the failure cause. +// It can happen that metrics collection is successful for some MetricProducers, +// while others fail. In that case `error.type` SHOULD be set to any of the +// failure causes. +func (m SDKMetricReaderCollectionDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents the describes a class of error the operation ended // with. @@ -1227,7 +1427,7 @@ func (SDKProcessorLogProcessed) Description() string { return "The number of log records for which the processing has finished, either successful or failed" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -1262,6 +1462,29 @@ func (m SDKProcessorLogProcessed) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// For successful processing, `error.type` MUST NOT be set. For failed +// processing, `error.type` MUST contain the failure cause. +// For the SDK Simple and Batching Log Record Processor a log record is +// considered to be processed already when it has been submitted to the exporter, +// not when the corresponding export call has finished. +func (m SDKProcessorLogProcessed) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents a low-cardinality description of the failure reason. // SDK Batching Log Record Processors MUST use `queue_full` for log records @@ -1467,7 +1690,7 @@ func (SDKProcessorSpanProcessed) Description() string { return "The number of spans for which the processing has finished, either successful or failed" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -1502,6 +1725,29 @@ func (m SDKProcessorSpanProcessed) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// For successful processing, `error.type` MUST NOT be set. For failed +// processing, `error.type` MUST contain the failure cause. +// For the SDK Simple and Batching Span Processor a span is considered to be +// processed already when it has been submitted to the exporter, not when the +// corresponding export call has finished. +func (m SDKProcessorSpanProcessed) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents a low-cardinality description of the failure reason. // SDK Batching Span Processors MUST use `queue_full` for spans dropped due to a @@ -1707,7 +1953,7 @@ func (SDKSpanLive) Description() string { return "The number of created spans with `recording=true` for which the end operation has not been called yet" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m SDKSpanLive) Add( @@ -1736,6 +1982,23 @@ func (m SDKSpanLive) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m SDKSpanLive) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrSpanSamplingResult returns an optional attribute for the // "otel.span.sampling_result" semantic convention. It represents the result // value of the sampler for this span. @@ -1793,7 +2056,7 @@ func (SDKSpanStarted) Description() string { return "The number of created spans" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -1825,6 +2088,26 @@ func (m SDKSpanStarted) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// Implementations MUST record this metric for all spans, even for non-recording +// ones. +func (m SDKSpanStarted) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrSpanParentOrigin returns an optional attribute for the // "otel.span.parent.origin" semantic convention. It represents the determines // whether the span has a parent span, and if so, [whether it is a remote parent] diff --git a/semconv/v1.36.0/processconv/metric.go b/semconv/v1.36.0/processconv/metric.go index 673904290..608c62126 100644 --- a/semconv/v1.36.0/processconv/metric.go +++ b/semconv/v1.36.0/processconv/metric.go @@ -150,7 +150,7 @@ func (ContextSwitches) Description() string { return "Number of times the process has been context switched." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m ContextSwitches) Add( @@ -179,6 +179,23 @@ func (m ContextSwitches) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m ContextSwitches) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrContextSwitchType returns an optional attribute for the // "process.context_switch_type" semantic convention. It represents the specifies // whether the context switches for this data point were voluntary or @@ -295,7 +312,7 @@ func (CPUUtilization) Description() string { return "Difference in process.cpu.time since the last measurement, divided by the elapsed time and number of CPUs available to the process." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // All additional attrs passed are included in the recorded value. func (m CPUUtilization) Record( @@ -324,6 +341,22 @@ func (m CPUUtilization) Record( m.Int64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m CPUUtilization) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Gauge.Record(ctx, val, *o...) +} + // AttrCPUMode returns an optional attribute for the "cpu.mode" semantic // convention. It represents a process SHOULD be characterized *either* by data // points with no `mode` labels, *or only* data points with `mode` labels. @@ -381,7 +414,7 @@ func (DiskIO) Description() string { return "Disk bytes transferred." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m DiskIO) Add( @@ -410,6 +443,23 @@ func (m DiskIO) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m DiskIO) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrDiskIODirection returns an optional attribute for the "disk.io.direction" // semantic convention. It represents the disk IO operation direction. func (DiskIO) AttrDiskIODirection(val DiskIODirectionAttr) attribute.KeyValue { @@ -466,7 +516,7 @@ func (MemoryUsage) Description() string { return "The amount of physical memory in use." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. func (m MemoryUsage) Add(ctx context.Context, incr int64, attrs ...attribute.KeyValue) { if len(attrs) == 0 { m.Int64UpDownCounter.Add(ctx, incr) @@ -483,6 +533,23 @@ func (m MemoryUsage) Add(ctx context.Context, incr int64, attrs ...attribute.Key m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m MemoryUsage) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // MemoryVirtual is an instrument used to record metric values conforming to the // "process.memory.virtual" semantic conventions. It represents the amount of // committed virtual memory. @@ -533,7 +600,7 @@ func (MemoryVirtual) Description() string { return "The amount of committed virtual memory." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. func (m MemoryVirtual) Add(ctx context.Context, incr int64, attrs ...attribute.KeyValue) { if len(attrs) == 0 { m.Int64UpDownCounter.Add(ctx, incr) @@ -550,6 +617,23 @@ func (m MemoryVirtual) Add(ctx context.Context, incr int64, attrs ...attribute.K m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m MemoryVirtual) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // NetworkIO is an instrument used to record metric values conforming to the // "process.network.io" semantic conventions. It represents the network bytes // transferred. @@ -600,7 +684,7 @@ func (NetworkIO) Description() string { return "Network bytes transferred." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m NetworkIO) Add( @@ -629,6 +713,23 @@ func (m NetworkIO) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m NetworkIO) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrNetworkIODirection returns an optional attribute for the // "network.io.direction" semantic convention. It represents the network IO // operation direction. @@ -686,7 +787,7 @@ func (OpenFileDescriptorCount) Description() string { return "Number of file descriptors in use by the process." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. func (m OpenFileDescriptorCount) Add(ctx context.Context, incr int64, attrs ...attribute.KeyValue) { if len(attrs) == 0 { m.Int64UpDownCounter.Add(ctx, incr) @@ -703,6 +804,23 @@ func (m OpenFileDescriptorCount) Add(ctx context.Context, incr int64, attrs ...a m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m OpenFileDescriptorCount) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // PagingFaults is an instrument used to record metric values conforming to the // "process.paging.faults" semantic conventions. It represents the number of page // faults the process has made. @@ -753,7 +871,7 @@ func (PagingFaults) Description() string { return "Number of page faults the process has made." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m PagingFaults) Add( @@ -782,6 +900,23 @@ func (m PagingFaults) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m PagingFaults) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrPagingFaultType returns an optional attribute for the // "process.paging.fault_type" semantic convention. It represents the type of // page fault for this data point. Type `major` is for major/hard page faults, @@ -840,7 +975,7 @@ func (ThreadCount) Description() string { return "Process threads count." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. func (m ThreadCount) Add(ctx context.Context, incr int64, attrs ...attribute.KeyValue) { if len(attrs) == 0 { m.Int64UpDownCounter.Add(ctx, incr) @@ -857,6 +992,23 @@ func (m ThreadCount) Add(ctx context.Context, incr int64, attrs ...attribute.Key m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m ThreadCount) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // Uptime is an instrument used to record metric values conforming to the // "process.uptime" semantic conventions. It represents the time the process has // been running. @@ -907,7 +1059,7 @@ func (Uptime) Description() string { return "The time the process has been running." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // Instrumentations SHOULD use a gauge with type `double` and measure uptime in // seconds as a floating point number with the highest precision available. @@ -926,4 +1078,24 @@ func (m Uptime) Record(ctx context.Context, val float64, attrs ...attribute.KeyV *o = append(*o, metric.WithAttributes(attrs...)) m.Float64Gauge.Record(ctx, val, *o...) +} + +// RecordSet records val to the current distribution for set. +// +// Instrumentations SHOULD use a gauge with type `double` and measure uptime in +// seconds as a floating point number with the highest precision available. +// The actual accuracy would depend on the instrumentation and operating system. +func (m Uptime) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Gauge.Record(ctx, val, *o...) } \ No newline at end of file diff --git a/semconv/v1.36.0/rpcconv/metric.go b/semconv/v1.36.0/rpcconv/metric.go index d81499e5c..146b7eda6 100644 --- a/semconv/v1.36.0/rpcconv/metric.go +++ b/semconv/v1.36.0/rpcconv/metric.go @@ -71,7 +71,7 @@ func (ClientDuration) Description() string { return "Measures the duration of outbound RPC." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // While streaming RPCs may record this metric as start-of-batch // to end-of-batch, it's hard to interpret in practice. @@ -93,6 +93,27 @@ func (m ClientDuration) Record(ctx context.Context, val float64, attrs ...attrib m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// While streaming RPCs may record this metric as start-of-batch +// to end-of-batch, it's hard to interpret in practice. +// +// **Streaming**: N/A. +func (m ClientDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // ClientRequestSize is an instrument used to record metric values conforming to // the "rpc.client.request.size" semantic conventions. It represents the measures // the size of RPC request messages (uncompressed). @@ -143,7 +164,7 @@ func (ClientRequestSize) Description() string { return "Measures the size of RPC request messages (uncompressed)." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // **Streaming**: Recorded per message in a streaming batch func (m ClientRequestSize) Record(ctx context.Context, val int64, attrs ...attribute.KeyValue) { @@ -162,6 +183,24 @@ func (m ClientRequestSize) Record(ctx context.Context, val int64, attrs ...attri m.Int64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// **Streaming**: Recorded per message in a streaming batch +func (m ClientRequestSize) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Histogram.Record(ctx, val, *o...) +} + // ClientRequestsPerRPC is an instrument used to record metric values conforming // to the "rpc.client.requests_per_rpc" semantic conventions. It represents the // measures the number of messages received per RPC. @@ -212,7 +251,7 @@ func (ClientRequestsPerRPC) Description() string { return "Measures the number of messages received per RPC." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // Should be 1 for all non-streaming RPCs. // @@ -233,6 +272,26 @@ func (m ClientRequestsPerRPC) Record(ctx context.Context, val int64, attrs ...at m.Int64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// Should be 1 for all non-streaming RPCs. +// +// **Streaming**: This metric is required for server and client streaming RPCs +func (m ClientRequestsPerRPC) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Histogram.Record(ctx, val, *o...) +} + // ClientResponseSize is an instrument used to record metric values conforming to // the "rpc.client.response.size" semantic conventions. It represents the // measures the size of RPC response messages (uncompressed). @@ -283,7 +342,7 @@ func (ClientResponseSize) Description() string { return "Measures the size of RPC response messages (uncompressed)." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // **Streaming**: Recorded per response in a streaming batch func (m ClientResponseSize) Record(ctx context.Context, val int64, attrs ...attribute.KeyValue) { @@ -302,6 +361,24 @@ func (m ClientResponseSize) Record(ctx context.Context, val int64, attrs ...attr m.Int64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// **Streaming**: Recorded per response in a streaming batch +func (m ClientResponseSize) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Histogram.Record(ctx, val, *o...) +} + // ClientResponsesPerRPC is an instrument used to record metric values conforming // to the "rpc.client.responses_per_rpc" semantic conventions. It represents the // measures the number of messages sent per RPC. @@ -352,7 +429,7 @@ func (ClientResponsesPerRPC) Description() string { return "Measures the number of messages sent per RPC." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // Should be 1 for all non-streaming RPCs. // @@ -373,6 +450,26 @@ func (m ClientResponsesPerRPC) Record(ctx context.Context, val int64, attrs ...a m.Int64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// Should be 1 for all non-streaming RPCs. +// +// **Streaming**: This metric is required for server and client streaming RPCs +func (m ClientResponsesPerRPC) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Histogram.Record(ctx, val, *o...) +} + // ServerDuration is an instrument used to record metric values conforming to the // "rpc.server.duration" semantic conventions. It represents the measures the // duration of inbound RPC. @@ -423,7 +520,7 @@ func (ServerDuration) Description() string { return "Measures the duration of inbound RPC." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // While streaming RPCs may record this metric as start-of-batch // to end-of-batch, it's hard to interpret in practice. @@ -445,6 +542,27 @@ func (m ServerDuration) Record(ctx context.Context, val float64, attrs ...attrib m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// While streaming RPCs may record this metric as start-of-batch +// to end-of-batch, it's hard to interpret in practice. +// +// **Streaming**: N/A. +func (m ServerDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // ServerRequestSize is an instrument used to record metric values conforming to // the "rpc.server.request.size" semantic conventions. It represents the measures // the size of RPC request messages (uncompressed). @@ -495,7 +613,7 @@ func (ServerRequestSize) Description() string { return "Measures the size of RPC request messages (uncompressed)." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // **Streaming**: Recorded per message in a streaming batch func (m ServerRequestSize) Record(ctx context.Context, val int64, attrs ...attribute.KeyValue) { @@ -514,6 +632,24 @@ func (m ServerRequestSize) Record(ctx context.Context, val int64, attrs ...attri m.Int64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// **Streaming**: Recorded per message in a streaming batch +func (m ServerRequestSize) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Histogram.Record(ctx, val, *o...) +} + // ServerRequestsPerRPC is an instrument used to record metric values conforming // to the "rpc.server.requests_per_rpc" semantic conventions. It represents the // measures the number of messages received per RPC. @@ -564,7 +700,7 @@ func (ServerRequestsPerRPC) Description() string { return "Measures the number of messages received per RPC." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // Should be 1 for all non-streaming RPCs. // @@ -585,6 +721,26 @@ func (m ServerRequestsPerRPC) Record(ctx context.Context, val int64, attrs ...at m.Int64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// Should be 1 for all non-streaming RPCs. +// +// **Streaming** : This metric is required for server and client streaming RPCs +func (m ServerRequestsPerRPC) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Histogram.Record(ctx, val, *o...) +} + // ServerResponseSize is an instrument used to record metric values conforming to // the "rpc.server.response.size" semantic conventions. It represents the // measures the size of RPC response messages (uncompressed). @@ -635,7 +791,7 @@ func (ServerResponseSize) Description() string { return "Measures the size of RPC response messages (uncompressed)." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // **Streaming**: Recorded per response in a streaming batch func (m ServerResponseSize) Record(ctx context.Context, val int64, attrs ...attribute.KeyValue) { @@ -654,6 +810,24 @@ func (m ServerResponseSize) Record(ctx context.Context, val int64, attrs ...attr m.Int64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// **Streaming**: Recorded per response in a streaming batch +func (m ServerResponseSize) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Histogram.Record(ctx, val, *o...) +} + // ServerResponsesPerRPC is an instrument used to record metric values conforming // to the "rpc.server.responses_per_rpc" semantic conventions. It represents the // measures the number of messages sent per RPC. @@ -704,7 +878,7 @@ func (ServerResponsesPerRPC) Description() string { return "Measures the number of messages sent per RPC." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // Should be 1 for all non-streaming RPCs. // @@ -723,4 +897,24 @@ func (m ServerResponsesPerRPC) Record(ctx context.Context, val int64, attrs ...a *o = append(*o, metric.WithAttributes(attrs...)) m.Int64Histogram.Record(ctx, val, *o...) +} + +// RecordSet records val to the current distribution for set. +// +// Should be 1 for all non-streaming RPCs. +// +// **Streaming**: This metric is required for server and client streaming RPCs +func (m ServerResponsesPerRPC) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Histogram.Record(ctx, val, *o...) } \ No newline at end of file diff --git a/semconv/v1.36.0/signalrconv/metric.go b/semconv/v1.36.0/signalrconv/metric.go index 21dd89c19..57fb95286 100644 --- a/semconv/v1.36.0/signalrconv/metric.go +++ b/semconv/v1.36.0/signalrconv/metric.go @@ -101,7 +101,7 @@ func (ServerActiveConnections) Description() string { return "Number of connections that are currently active on the server." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -133,6 +133,26 @@ func (m ServerActiveConnections) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// Meter name: `Microsoft.AspNetCore.Http.Connections`; Added in: ASP.NET Core +// 8.0 +func (m ServerActiveConnections) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrConnectionStatus returns an optional attribute for the // "signalr.connection.status" semantic convention. It represents the signalR // HTTP connection closure status. @@ -198,7 +218,7 @@ func (ServerConnectionDuration) Description() string { return "The duration of connections on the server." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // All additional attrs passed are included in the recorded value. // @@ -230,6 +250,25 @@ func (m ServerConnectionDuration) Record( m.Float64Histogram.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// Meter name: `Microsoft.AspNetCore.Http.Connections`; Added in: ASP.NET Core +// 8.0 +func (m ServerConnectionDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Histogram.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Histogram.Record(ctx, val, *o...) +} + // AttrConnectionStatus returns an optional attribute for the // "signalr.connection.status" semantic convention. It represents the signalR // HTTP connection closure status. diff --git a/semconv/v1.36.0/systemconv/metric.go b/semconv/v1.36.0/systemconv/metric.go index 4bdb21643..30dd2d24b 100644 --- a/semconv/v1.36.0/systemconv/metric.go +++ b/semconv/v1.36.0/systemconv/metric.go @@ -299,7 +299,7 @@ func (CPUFrequency) Description() string { return "Operating frequency of the logical CPU in Hertz." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // All additional attrs passed are included in the recorded value. func (m CPUFrequency) Record( @@ -328,6 +328,22 @@ func (m CPUFrequency) Record( m.Int64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m CPUFrequency) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Gauge.Record(ctx, val, *o...) +} + // AttrCPULogicalNumber returns an optional attribute for the // "cpu.logical_number" semantic convention. It represents the logical CPU number // [0..n-1]. @@ -386,7 +402,7 @@ func (CPULogicalCount) Description() string { return "Reports the number of logical (virtual) processor cores created by the operating system to manage multitasking" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // Calculated by multiplying the number of sockets by the number of cores per // socket, and then by the number of threads per core @@ -406,6 +422,26 @@ func (m CPULogicalCount) Add(ctx context.Context, incr int64, attrs ...attribute m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// Calculated by multiplying the number of sockets by the number of cores per +// socket, and then by the number of threads per core +func (m CPULogicalCount) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // CPUPhysicalCount is an instrument used to record metric values conforming to // the "system.cpu.physical.count" semantic conventions. It represents the // reports the number of actual physical processor cores on the hardware. @@ -456,7 +492,7 @@ func (CPUPhysicalCount) Description() string { return "Reports the number of actual physical processor cores on the hardware" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // Calculated by multiplying the number of sockets by the number of cores per // socket @@ -476,6 +512,26 @@ func (m CPUPhysicalCount) Add(ctx context.Context, incr int64, attrs ...attribut m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// Calculated by multiplying the number of sockets by the number of cores per +// socket +func (m CPUPhysicalCount) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // CPUTime is an instrument used to record metric values conforming to the // "system.cpu.time" semantic conventions. It represents the seconds each logical // CPU spent on each mode. @@ -590,7 +646,7 @@ func (CPUUtilization) Description() string { return "For each logical CPU, the utilization is calculated as the change in cumulative CPU time (cpu.time) over a measurement interval, divided by the elapsed time." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // All additional attrs passed are included in the recorded value. func (m CPUUtilization) Record( @@ -619,6 +675,22 @@ func (m CPUUtilization) Record( m.Int64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m CPUUtilization) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Gauge.Record(ctx, val, *o...) +} + // AttrCPULogicalNumber returns an optional attribute for the // "cpu.logical_number" semantic convention. It represents the logical CPU number // [0..n-1]. @@ -676,7 +748,7 @@ func (DiskIO) Unit() string { return "By" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m DiskIO) Add( @@ -705,6 +777,23 @@ func (m DiskIO) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m DiskIO) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrDiskIODirection returns an optional attribute for the "disk.io.direction" // semantic convention. It represents the disk IO operation direction. func (DiskIO) AttrDiskIODirection(val DiskIODirectionAttr) attribute.KeyValue { @@ -767,7 +856,7 @@ func (DiskIOTime) Description() string { return "Time disk spent activated" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -808,6 +897,35 @@ func (m DiskIOTime) Add( m.Float64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// The real elapsed time ("wall clock") used in the I/O path (time from +// operations running in parallel are not counted). Measured as: +// +// - Linux: Field 13 from [procfs-diskstats] +// - Windows: The complement of +// ["Disk% Idle Time"] +// performance counter: `uptime * (100 - "Disk\% Idle Time") / 100` +// +// +// [procfs-diskstats]: https://www.kernel.org/doc/Documentation/ABI/testing/procfs-diskstats +// ["Disk% Idle Time"]: https://learn.microsoft.com/archive/blogs/askcore/windows-performance-monitor-disk-counters-explained#windows-performance-monitor-disk-counters-explained +func (m DiskIOTime) AddSet(ctx context.Context, incr float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Counter.Add(ctx, incr, *o...) +} + // AttrDevice returns an optional attribute for the "system.device" semantic // convention. It represents the device identifier. func (DiskIOTime) AttrDevice(val string) attribute.KeyValue { @@ -864,7 +982,7 @@ func (DiskLimit) Description() string { return "The total storage capacity of the disk" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m DiskLimit) Add( @@ -893,6 +1011,23 @@ func (m DiskLimit) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m DiskLimit) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrDevice returns an optional attribute for the "system.device" semantic // convention. It represents the device identifier. func (DiskLimit) AttrDevice(val string) attribute.KeyValue { @@ -943,7 +1078,7 @@ func (DiskMerged) Unit() string { return "{operation}" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m DiskMerged) Add( @@ -972,6 +1107,23 @@ func (m DiskMerged) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m DiskMerged) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrDiskIODirection returns an optional attribute for the "disk.io.direction" // semantic convention. It represents the disk IO operation direction. func (DiskMerged) AttrDiskIODirection(val DiskIODirectionAttr) attribute.KeyValue { @@ -1034,7 +1186,7 @@ func (DiskOperationTime) Description() string { return "Sum of the time each operation took to complete" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -1073,6 +1225,33 @@ func (m DiskOperationTime) Add( m.Float64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// Because it is the sum of time each request took, parallel-issued requests each +// contribute to make the count grow. Measured as: +// +// - Linux: Fields 7 & 11 from [procfs-diskstats] +// - Windows: "Avg. Disk sec/Read" perf counter multiplied by "Disk Reads/sec" +// perf counter (similar for Writes) +// +// +// [procfs-diskstats]: https://www.kernel.org/doc/Documentation/ABI/testing/procfs-diskstats +func (m DiskOperationTime) AddSet(ctx context.Context, incr float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Counter.Add(ctx, incr, *o...) +} + // AttrDiskIODirection returns an optional attribute for the "disk.io.direction" // semantic convention. It represents the disk IO operation direction. func (DiskOperationTime) AttrDiskIODirection(val DiskIODirectionAttr) attribute.KeyValue { @@ -1129,7 +1308,7 @@ func (DiskOperations) Unit() string { return "{operation}" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m DiskOperations) Add( @@ -1158,6 +1337,23 @@ func (m DiskOperations) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m DiskOperations) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrDiskIODirection returns an optional attribute for the "disk.io.direction" // semantic convention. It represents the disk IO operation direction. func (DiskOperations) AttrDiskIODirection(val DiskIODirectionAttr) attribute.KeyValue { @@ -1220,7 +1416,7 @@ func (FilesystemLimit) Description() string { return "The total storage capacity of the filesystem" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m FilesystemLimit) Add( @@ -1249,6 +1445,23 @@ func (m FilesystemLimit) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m FilesystemLimit) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrDevice returns an optional attribute for the "system.device" semantic // convention. It represents the identifier for the device where the filesystem // resides. @@ -1327,7 +1540,7 @@ func (FilesystemUsage) Description() string { return "Reports a filesystem's space usage across different states." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -1361,6 +1574,28 @@ func (m FilesystemUsage) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// The sum of all `system.filesystem.usage` values over the different +// `system.filesystem.state` attributes +// SHOULD equal the total storage capacity of the filesystem, that is +// `system.filesystem.limit`. +func (m FilesystemUsage) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrDevice returns an optional attribute for the "system.device" semantic // convention. It represents the identifier for the device where the filesystem // resides. @@ -1440,7 +1675,7 @@ func (FilesystemUtilization) Unit() string { return "1" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // All additional attrs passed are included in the recorded value. func (m FilesystemUtilization) Record( @@ -1469,6 +1704,22 @@ func (m FilesystemUtilization) Record( m.Int64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m FilesystemUtilization) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Gauge.Record(ctx, val, *o...) +} + // AttrDevice returns an optional attribute for the "system.device" semantic // convention. It represents the identifier for the device where the filesystem // resides. @@ -1555,7 +1806,7 @@ func (LinuxMemoryAvailable) Description() string { return "An estimate of how much memory is available for starting new applications, without causing swapping" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // This is an alternative to `system.memory.usage` metric with `state=free`. // Linux starting from 3.14 exports "available" memory. It takes "free" memory as @@ -1582,6 +1833,33 @@ func (m LinuxMemoryAvailable) Add(ctx context.Context, incr int64, attrs ...attr m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// This is an alternative to `system.memory.usage` metric with `state=free`. +// Linux starting from 3.14 exports "available" memory. It takes "free" memory as +// a baseline, and then factors in kernel-specific values. +// This is supposed to be more accurate than just "free" memory. +// For reference, see the calculations [here]. +// See also `MemAvailable` in [/proc/meminfo]. +// +// [here]: https://superuser.com/a/980821 +// [/proc/meminfo]: https://man7.org/linux/man-pages/man5/proc.5.html +func (m LinuxMemoryAvailable) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // LinuxMemorySlabUsage is an instrument used to record metric values conforming // to the "system.linux.memory.slab.usage" semantic conventions. It represents // the reports the memory used by the Linux kernel for managing caches of @@ -1633,7 +1911,7 @@ func (LinuxMemorySlabUsage) Description() string { return "Reports the memory used by the Linux kernel for managing caches of frequently used objects." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -1671,6 +1949,32 @@ func (m LinuxMemorySlabUsage) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// The sum over the `reclaimable` and `unreclaimable` state values in +// `linux.memory.slab.usage` SHOULD be equal to the total slab memory available +// on the system. +// Note that the total slab memory is not constant and may vary over time. +// See also the [Slab allocator] and `Slab` in [/proc/meminfo]. +// +// [Slab allocator]: https://blogs.oracle.com/linux/post/understanding-linux-kernel-memory-statistics +// [/proc/meminfo]: https://man7.org/linux/man-pages/man5/proc.5.html +func (m LinuxMemorySlabUsage) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrLinuxMemorySlabState returns an optional attribute for the // "linux.memory.slab.state" semantic convention. It represents the Linux Slab // memory state. @@ -1728,7 +2032,7 @@ func (MemoryLimit) Description() string { return "Total memory available in the system." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // Its value SHOULD equal the sum of `system.memory.state` over all states. func (m MemoryLimit) Add(ctx context.Context, incr int64, attrs ...attribute.KeyValue) { @@ -1747,6 +2051,25 @@ func (m MemoryLimit) Add(ctx context.Context, incr int64, attrs ...attribute.Key m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// Its value SHOULD equal the sum of `system.memory.state` over all states. +func (m MemoryLimit) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // MemoryShared is an instrument used to record metric values conforming to the // "system.memory.shared" semantic conventions. It represents the shared memory // used (mostly by tmpfs). @@ -1797,7 +2120,7 @@ func (MemoryShared) Description() string { return "Shared memory used (mostly by tmpfs)." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // Equivalent of `shared` from [`free` command] or // `Shmem` from [`/proc/meminfo`]" @@ -1820,6 +2143,29 @@ func (m MemoryShared) Add(ctx context.Context, incr int64, attrs ...attribute.Ke m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// Equivalent of `shared` from [`free` command] or +// `Shmem` from [`/proc/meminfo`]" +// +// [`free` command]: https://man7.org/linux/man-pages/man1/free.1.html +// [`/proc/meminfo`]: https://man7.org/linux/man-pages/man5/proc.5.html +func (m MemoryShared) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // MemoryUsage is an instrument used to record metric values conforming to the // "system.memory.usage" semantic conventions. It represents the reports memory // in use by state. @@ -1970,7 +2316,7 @@ func (NetworkConnectionCount) Unit() string { return "{connection}" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m NetworkConnectionCount) Add( @@ -1999,6 +2345,23 @@ func (m NetworkConnectionCount) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m NetworkConnectionCount) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrNetworkConnectionState returns an optional attribute for the // "network.connection.state" semantic convention. It represents the state of // network connection. @@ -2073,7 +2436,7 @@ func (NetworkDropped) Description() string { return "Count of packets that are dropped or discarded even though there was no error" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -2113,6 +2476,34 @@ func (m NetworkDropped) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// Measured as: +// +// - Linux: the `drop` column in `/proc/dev/net` ([source]) +// - Windows: [`InDiscards`/`OutDiscards`] +// from [`GetIfEntry2`] +// +// +// [source]: https://web.archive.org/web/20180321091318/http://www.onlamp.com/pub/a/linux/2000/11/16/LinuxAdmin.html +// [`InDiscards`/`OutDiscards`]: https://docs.microsoft.com/windows/win32/api/netioapi/ns-netioapi-mib_if_row2 +// [`GetIfEntry2`]: https://docs.microsoft.com/windows/win32/api/netioapi/nf-netioapi-getifentry2 +func (m NetworkDropped) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrNetworkInterfaceName returns an optional attribute for the // "network.interface.name" semantic convention. It represents the network // interface name. @@ -2177,7 +2568,7 @@ func (NetworkErrors) Description() string { return "Count of network errors detected" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. // @@ -2217,6 +2608,34 @@ func (m NetworkErrors) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +// +// Measured as: +// +// - Linux: the `errs` column in `/proc/dev/net` ([source]). +// - Windows: [`InErrors`/`OutErrors`] +// from [`GetIfEntry2`]. +// +// +// [source]: https://web.archive.org/web/20180321091318/http://www.onlamp.com/pub/a/linux/2000/11/16/LinuxAdmin.html +// [`InErrors`/`OutErrors`]: https://docs.microsoft.com/windows/win32/api/netioapi/ns-netioapi-mib_if_row2 +// [`GetIfEntry2`]: https://docs.microsoft.com/windows/win32/api/netioapi/nf-netioapi-getifentry2 +func (m NetworkErrors) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrNetworkInterfaceName returns an optional attribute for the // "network.interface.name" semantic convention. It represents the network // interface name. @@ -2333,7 +2752,7 @@ func (NetworkPackets) Unit() string { return "{packet}" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m NetworkPackets) Add( @@ -2362,6 +2781,23 @@ func (m NetworkPackets) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m NetworkPackets) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrNetworkIODirection returns an optional attribute for the // "network.io.direction" semantic convention. It represents the network IO // operation direction. @@ -2419,7 +2855,7 @@ func (PagingFaults) Unit() string { return "{fault}" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m PagingFaults) Add( @@ -2448,6 +2884,23 @@ func (m PagingFaults) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m PagingFaults) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrPagingType returns an optional attribute for the "system.paging.type" // semantic convention. It represents the memory paging type. func (PagingFaults) AttrPagingType(val PagingTypeAttr) attribute.KeyValue { @@ -2498,7 +2951,7 @@ func (PagingOperations) Unit() string { return "{operation}" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m PagingOperations) Add( @@ -2527,6 +2980,23 @@ func (m PagingOperations) Add( m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m PagingOperations) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // AttrPagingDirection returns an optional attribute for the // "system.paging.direction" semantic convention. It represents the paging access // direction. @@ -2590,7 +3060,7 @@ func (PagingUsage) Description() string { return "Unix swap or windows pagefile usage" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m PagingUsage) Add( @@ -2619,6 +3089,23 @@ func (m PagingUsage) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m PagingUsage) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrDevice returns an optional attribute for the "system.device" semantic // convention. It represents the unique identifier for the device responsible for // managing paging operations. @@ -2676,7 +3163,7 @@ func (PagingUtilization) Unit() string { return "1" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // All additional attrs passed are included in the recorded value. func (m PagingUtilization) Record( @@ -2705,6 +3192,22 @@ func (m PagingUtilization) Record( m.Int64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m PagingUtilization) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Gauge.Record(ctx, val, *o...) +} + // AttrDevice returns an optional attribute for the "system.device" semantic // convention. It represents the unique identifier for the device responsible for // managing paging operations. @@ -2768,7 +3271,7 @@ func (ProcessCount) Description() string { return "Total number of processes in each state" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m ProcessCount) Add( @@ -2797,6 +3300,23 @@ func (m ProcessCount) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m ProcessCount) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrProcessStatus returns an optional attribute for the // "system.process.status" semantic convention. It represents the process state, // e.g., [Linux Process State Codes]. @@ -2856,7 +3376,7 @@ func (ProcessCreated) Description() string { return "Total number of processes created over uptime of the host" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. func (m ProcessCreated) Add(ctx context.Context, incr int64, attrs ...attribute.KeyValue) { if len(attrs) == 0 { m.Int64Counter.Add(ctx, incr) @@ -2873,6 +3393,23 @@ func (m ProcessCreated) Add(ctx context.Context, incr int64, attrs ...attribute. m.Int64Counter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m ProcessCreated) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Counter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Counter.Add(ctx, incr, *o...) +} + // Uptime is an instrument used to record metric values conforming to the // "system.uptime" semantic conventions. It represents the time the system has // been running. @@ -2923,7 +3460,7 @@ func (Uptime) Description() string { return "The time the system has been running" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // Instrumentations SHOULD use a gauge with type `double` and measure uptime in // seconds as a floating point number with the highest precision available. @@ -2942,4 +3479,24 @@ func (m Uptime) Record(ctx context.Context, val float64, attrs ...attribute.KeyV *o = append(*o, metric.WithAttributes(attrs...)) m.Float64Gauge.Record(ctx, val, *o...) +} + +// RecordSet records val to the current distribution for set. +// +// Instrumentations SHOULD use a gauge with type `double` and measure uptime in +// seconds as a floating point number with the highest precision available. +// The actual accuracy would depend on the instrumentation and operating system. +func (m Uptime) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Gauge.Record(ctx, val, *o...) } \ No newline at end of file diff --git a/semconv/v1.36.0/vcsconv/metric.go b/semconv/v1.36.0/vcsconv/metric.go index cb586286f..5f1974cd3 100644 --- a/semconv/v1.36.0/vcsconv/metric.go +++ b/semconv/v1.36.0/vcsconv/metric.go @@ -196,7 +196,7 @@ func (ChangeCount) Description() string { return "The number of changes (pull requests/merge requests/changelists) in a repository, categorized by their state (e.g. open or merged)" } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The changeState is the the state of the change (pull request/merge // request/changelist). @@ -240,6 +240,23 @@ func (m ChangeCount) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m ChangeCount) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrOwnerName returns an optional attribute for the "vcs.owner.name" semantic // convention. It represents the group owner within the version control system. func (ChangeCount) AttrOwnerName(val string) attribute.KeyValue { @@ -311,7 +328,7 @@ func (ChangeDuration) Description() string { return "The time duration a change (pull request/merge request/changelist) has been in a given state." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The changeState is the the state of the change (pull request/merge // request/changelist). @@ -361,6 +378,22 @@ func (m ChangeDuration) Record( m.Float64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m ChangeDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Gauge.Record(ctx, val, *o...) +} + // AttrOwnerName returns an optional attribute for the "vcs.owner.name" semantic // convention. It represents the group owner within the version control system. func (ChangeDuration) AttrOwnerName(val string) attribute.KeyValue { @@ -433,7 +466,7 @@ func (ChangeTimeToApproval) Description() string { return "The amount of time since its creation it took a change (pull request/merge request/changelist) to get the first approval." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The refHeadName is the the name of the [reference] such as **branch** or // **tag** in the repository. @@ -478,6 +511,22 @@ func (m ChangeTimeToApproval) Record( m.Float64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m ChangeTimeToApproval) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Gauge.Record(ctx, val, *o...) +} + // AttrOwnerName returns an optional attribute for the "vcs.owner.name" semantic // convention. It represents the group owner within the version control system. func (ChangeTimeToApproval) AttrOwnerName(val string) attribute.KeyValue { @@ -579,7 +628,7 @@ func (ChangeTimeToMerge) Description() string { return "The amount of time since its creation it took a change (pull request/merge request/changelist) to get merged into the target(base) ref." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The refHeadName is the the name of the [reference] such as **branch** or // **tag** in the repository. @@ -624,6 +673,22 @@ func (m ChangeTimeToMerge) Record( m.Float64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m ChangeTimeToMerge) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Gauge.Record(ctx, val, *o...) +} + // AttrOwnerName returns an optional attribute for the "vcs.owner.name" semantic // convention. It represents the group owner within the version control system. func (ChangeTimeToMerge) AttrOwnerName(val string) attribute.KeyValue { @@ -724,7 +789,7 @@ func (ContributorCount) Description() string { return "The number of unique contributors to a repository" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The repositoryUrlFull is the the [canonical URL] of the repository providing // the complete HTTP(S) address in order to locate and identify the repository @@ -763,6 +828,22 @@ func (m ContributorCount) Record( m.Int64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m ContributorCount) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Gauge.Record(ctx, val, *o...) +} + // AttrOwnerName returns an optional attribute for the "vcs.owner.name" semantic // convention. It represents the group owner within the version control system. func (ContributorCount) AttrOwnerName(val string) attribute.KeyValue { @@ -834,7 +915,7 @@ func (RefCount) Description() string { return "The number of refs of type branch or tag in a repository." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // The refType is the the type of the [reference] in the repository. // @@ -878,6 +959,23 @@ func (m RefCount) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m RefCount) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrOwnerName returns an optional attribute for the "vcs.owner.name" semantic // convention. It represents the group owner within the version control system. func (RefCount) AttrOwnerName(val string) attribute.KeyValue { @@ -950,7 +1048,7 @@ func (RefLinesDelta) Description() string { return "The number of lines added/removed in a ref (branch) relative to the ref from the `vcs.ref.base.name` attribute." } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The lineChangeType is the the type of line change being measured on a branch // or change. @@ -1023,6 +1121,29 @@ func (m RefLinesDelta) Record( m.Int64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// This metric should be reported for each `vcs.line_change.type` value. For +// example if a ref added 3 lines and removed 2 lines, +// instrumentation SHOULD report two measurements: 3 and 2 (both positive +// numbers). +// If number of lines added/removed should be calculated from the start of time, +// then `vcs.ref.base.name` SHOULD be set to an empty string. +func (m RefLinesDelta) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Gauge.Record(ctx, val, *o...) +} + // AttrChangeID returns an optional attribute for the "vcs.change.id" semantic // convention. It represents the ID of the change (pull request/merge // request/changelist) if applicable. This is usually a unique (within @@ -1103,7 +1224,7 @@ func (RefRevisionsDelta) Description() string { return "The number of revisions (commits) a ref (branch) is ahead/behind the branch from the `vcs.ref.base.name` attribute" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The refBaseName is the the name of the [reference] such as **branch** or // **tag** in the repository. @@ -1173,6 +1294,27 @@ func (m RefRevisionsDelta) Record( m.Int64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +// +// This metric should be reported for each `vcs.revision_delta.direction` value. +// For example if branch `a` is 3 commits behind and 2 commits ahead of `trunk`, +// instrumentation SHOULD report two measurements: 3 and 2 (both positive +// numbers) and `vcs.ref.base.name` is set to `trunk`. +func (m RefRevisionsDelta) RecordSet(ctx context.Context, val int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64Gauge.Record(ctx, val, *o...) +} + // AttrChangeID returns an optional attribute for the "vcs.change.id" semantic // convention. It represents the ID of the change (pull request/merge // request/changelist) if applicable. This is usually a unique (within @@ -1253,7 +1395,7 @@ func (RefTime) Description() string { return "Time a ref (branch) created from the default branch (trunk) has existed. The `ref.type` attribute will always be `branch`" } -// Record records val to the current distribution. +// Record records val to the current distribution for attrs. // // The refHeadName is the the name of the [reference] such as **branch** or // **tag** in the repository. @@ -1303,6 +1445,22 @@ func (m RefTime) Record( m.Float64Gauge.Record(ctx, val, *o...) } +// RecordSet records val to the current distribution for set. +func (m RefTime) RecordSet(ctx context.Context, val float64, set attribute.Set) { + if set.Len() == 0 { + m.Float64Gauge.Record(ctx, val) + } + + o := recOptPool.Get().(*[]metric.RecordOption) + defer func() { + *o = (*o)[:0] + recOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Float64Gauge.Record(ctx, val, *o...) +} + // AttrOwnerName returns an optional attribute for the "vcs.owner.name" semantic // convention. It represents the group owner within the version control system. func (RefTime) AttrOwnerName(val string) attribute.KeyValue { @@ -1374,7 +1532,7 @@ func (RepositoryCount) Description() string { return "The number of repositories in an organization." } -// Add adds incr to the existing count. +// Add adds incr to the existing count for attrs. // // All additional attrs passed are included in the recorded value. func (m RepositoryCount) Add( @@ -1403,6 +1561,23 @@ func (m RepositoryCount) Add( m.Int64UpDownCounter.Add(ctx, incr, *o...) } +// AddSet adds incr to the existing count for set. +func (m RepositoryCount) AddSet(ctx context.Context, incr int64, set attribute.Set) { + if set.Len() == 0 { + m.Int64UpDownCounter.Add(ctx, incr) + return + } + + o := addOptPool.Get().(*[]metric.AddOption) + defer func() { + *o = (*o)[:0] + addOptPool.Put(o) + }() + + *o = append(*o, metric.WithAttributeSet(set)) + m.Int64UpDownCounter.Add(ctx, incr, *o...) +} + // AttrOwnerName returns an optional attribute for the "vcs.owner.name" semantic // convention. It represents the group owner within the version control system. func (RepositoryCount) AttrOwnerName(val string) attribute.KeyValue {