{% import 'helpers.j2' as h -%} {% import 'instrument.j2' as i -%} // Code generated from semantic convention specification. DO NOT EDIT. // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 {% set pkg = ctx.root_namespace | camel_case | lower ~ "conv" -%} // Package {{ pkg }} provides types and functionality for OpenTelemetry semantic // conventions in the "{{ ctx.root_namespace }}" namespace. package {{ pkg }} import ( "context" "sync" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/metric" "go.opentelemetry.io/otel/metric/noop" ) var ( addOptPool = &sync.Pool{New: func() any { return &[]metric.AddOption{} }} recOptPool = &sync.Pool{New: func() any { return &[]metric.RecordOption{} }} ) {%- for attr in ctx.metrics | map(attribute="attributes") | flatten | selectattr("type", "mapping") | unique(attribute="name") | sort(attribute="name") %} {%- set name = h.to_go_name(attr.name, ctx.root_namespace) %} {{ [ name ~ "Attr is an attribute conforming to the " ~ attr.name ~ " semantic conventions. " ~ h.it_reps(attr.brief) ] | comment }} type {{ name }}Attr {{ h.member_type(attr.type.members[0]) }} var ( {%- for m in attr.type.members %} {%- set m_name = name ~ h.to_go_name(m.id, ctx.root_namespace) -%} {% if attr.type.members[0].value is string -%} {%- set m_value = '"' + m.value + '"' -%} {%- else -%} {%- set m_value = m.value -%} {%- endif -%} {%- if m.brief is defined %} {%- set m_brief = m.brief -%} {%- else %} {%- set m_brief = "standardized value " + m_value + ' of ' + name + 'Attr.' -%} {%- endif %} {{ h.prefix_brief(m_brief, m_name ~ " is ") | comment(format="go_1tab") }} {{ m_name }} {{ name }}Attr = {{ m_value }} {%- endfor %} ) {%- endfor %} {%- for metric in ctx.metrics %} {%- set metric_name = h.to_go_name(metric.metric_name, ctx.root_namespace) %} {%- set metric_inst = metric.metric_name | map_text("instrument", i.instrument_default(metric)) %} {{ h.metric_typedoc(metric, ctx.root_namespace) | comment | trim }} type {{ metric_name }} struct { metric.{{ metric_inst }} } var new{{ metric_name }}Opts = []metric.{{ metric_inst }}Option{ metric.WithDescription("{{ i.desc(metric) }}"), metric.WithUnit("{{metric.unit}}"), } {{ ["New" ~ metric_name ~ " returns a new " ~ metric_name ~ " instrument."] | comment }} func New{{ metric_name }}( m metric.Meter, opt ...metric.{{ metric_inst}}Option, ) ({{ metric_name }}, error) { // Check if the meter is nil. if m == nil { return {{metric_name}}{noop.{{ metric_inst }}{}}, nil } if len(opt) == 0 { opt = new{{ metric_name }}Opts } else { opt = append(opt, new{{ metric_name }}Opts...) } i, err := m.{{ metric_inst }}( "{{metric.metric_name}}", opt..., ) if err != nil { return {{metric_name}}{noop.{{ metric_inst }}{}}, err } return {{ metric_name }}{i}, nil } // Inst returns the underlying metric instrument. func (m {{ metric_name }}) Inst() metric.{{ metric_inst }} { return m.{{ metric_inst }} } // Name returns the semantic convention name of the instrument. func ({{ metric_name }}) Name() string { return "{{ metric.metric_name }}" } // Unit returns the semantic convention unit of the instrument func ({{ metric_name }}) Unit() string { return "{{ metric.unit }}" } {%- if metric.brief %} // Description returns the semantic convention description of the instrument func ({{ metric_name }}) Description() string { return "{{ i.desc(metric) }}" } {%- endif %} {%- if "Observable" is in metric_inst %} {%- 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) %} {{ [ "Attr" ~ name ~ " returns an optional attribute for the \"" ~ attr.name ~ "\" semantic convention. " ~ h.it_reps(attr.brief) ] | comment }} {%- if attr.type is mapping %} func ({{ metric_name}}) Attr{{name}}(val {{ name }}Attr) attribute.KeyValue { return attribute.{{ h.attr_type(attr) | map_text("attribute_type_method")}}("{{ attr.name }}", {{ h.member_type(attr.type.members[0]) }}(val)) } {%- else %} func ({{ metric_name}}) Attr{{name}}(val {{ attr.type | map_text("attribute_type_value")}}) attribute.KeyValue { return attribute.{{ h.attr_type(attr) | map_text("attribute_type_method")}}("{{ attr.name }}", val) } {%- endif %} {%- endfor %} {%- endfor %}