botocore: metrics setup

Add lazy init of meters

Author: xrmx

instrumentation/opentelemetry-instrumentation-botocore/src/opentelemetry/instrumentation/botocore/__init__.py

@@ -104,6 +104,7 @@ def response_hook(span, service_name, operation_name, result):
     suppress_http_instrumentation,
     unwrap,
 )
+from opentelemetry.metrics import Instrument, Meter, get_meter
 from opentelemetry.propagators.aws.aws_xray_propagator import AwsXRayPropagator
 from opentelemetry.semconv.trace import SpanAttributes
 from opentelemetry.trace import get_tracer
@@ -134,6 +135,10 @@ def _instrument(self, **kwargs):
         self._tracers = {}
         # event_loggers are lazy initialized per-extension in _get_event_logger
         self._event_loggers = {}
+        # meters are lazy initialized per-extension in _get_meter
+        self._meters = {}
+        # metrics are lazy initial per-extension in _get_metrics
+        self._metrics: dict[str, dict[str, Instrument]] = {}
 
         self.request_hook = kwargs.get("request_hook")
         self.response_hook = kwargs.get("response_hook")
@@ -144,6 +149,7 @@ def _instrument(self, **kwargs):
 
         self.tracer_provider = kwargs.get("tracer_provider")
         self.event_logger_provider = kwargs.get("event_logger_provider")
+        self.meter_provider = kwargs.get("meter_provider")
 
         wrap_function_wrapper(
             "botocore.client",
@@ -201,6 +207,38 @@ def _get_event_logger(self, extension: _AwsSdkExtension):
 
         return self._event_loggers[instrumentation_name]
 
+    def _get_meter(self, extension: _AwsSdkExtension):
+        """This is a multiplexer in order to have an event logger per extension"""
+
+        instrumentation_name = self._get_instrumentation_name(extension)
+        meter = self._meters.get(instrumentation_name)
+        if meter:
+            return meter
+
+        schema_version = extension.meter_schema_version()
+        self._meters[instrumentation_name] = get_meter(
+            instrumentation_name,
+            "",
+            schema_url=f"https://opentelemetry.io/schemas/{schema_version}",
+            meter_provider=self.meter_provider,
+        )
+
+        return self._meters[instrumentation_name]
+
+    def _get_metrics(
+        self, extension: _AwsSdkExtension, meter: Meter
+    ) -> dict[str, Instrument]:
+        """This is a multiplexer for lazy initial metrics required by extensions"""
+        instrumentation_name = self._get_instrumentation_name(extension)
+        metrics = self._metrics.get(instrumentation_name)
+        if metrics is not None:
+            return metrics
+
+        self._metrics.setdefault(instrumentation_name, {})
+        metrics = self._metrics[instrumentation_name]
+        _safe_invoke(extension.setup_metrics, meter, metrics)
+        return metrics
+
     def _uninstrument(self, **kwargs):
         unwrap(BaseClient, "_make_api_call")
         unwrap(Endpoint, "prepare_request")
@@ -244,8 +282,11 @@ def _patched_api_call(self, original_func, instance, args, kwargs):
 
         tracer = self._get_tracer(extension)
         event_logger = self._get_event_logger(extension)
+        meter = self._get_meter(extension)
+        metrics = self._get_metrics(extension, meter)
         instrumentor_ctx = _BotocoreInstrumentorContext(
-            event_logger=event_logger
+            event_logger=event_logger,
+            metrics=metrics,
         )
         with tracer.start_as_current_span(
             call_context.span_name,

instrumentation/opentelemetry-instrumentation-botocore/src/opentelemetry/instrumentation/botocore/extensions/bedrock.py

@@ -39,10 +39,13 @@
     _BotoClientErrorT,
     _BotocoreInstrumentorContext,
 )
+from opentelemetry.metrics import Instrument, Meter
 from opentelemetry.semconv._incubating.attributes.error_attributes import (
     ERROR_TYPE,
 )
 from opentelemetry.semconv._incubating.attributes.gen_ai_attributes import (
+    GEN_AI_CLIENT_OPERATION_DURATION,
+    GEN_AI_CLIENT_TOKEN_USAGE,
     GEN_AI_OPERATION_NAME,
     GEN_AI_REQUEST_MAX_TOKENS,
     GEN_AI_REQUEST_MODEL,
@@ -61,6 +64,40 @@
 
 _logger = logging.getLogger(__name__)
 
+_GEN_AI_CLIENT_OPERATION_DURATION_BUCKETS = [
+    0.01,
+    0.02,
+    0.04,
+    0.08,
+    0.16,
+    0.32,
+    0.64,
+    1.28,
+    2.56,
+    5.12,
+    10.24,
+    20.48,
+    40.96,
+    81.92,
+]
+
+_GEN_AI_CLIENT_TOKEN_USAGE_BUCKETS = [
+    1,
+    4,
+    16,
+    64,
+    256,
+    1024,
+    4096,
+    16384,
+    65536,
+    262144,
+    1048576,
+    4194304,
+    16777216,
+    67108864,
+]
+
 _MODEL_ID_KEY: str = "modelId"
 
 
@@ -88,6 +125,20 @@ def should_end_span_on_exit(self):
             not in self._DONT_CLOSE_SPAN_ON_END_OPERATIONS
         )
 
+    def setup_metrics(self, meter: Meter, metrics: dict[str, Instrument]):
+        metrics[GEN_AI_CLIENT_OPERATION_DURATION] = meter.create_histogram(
+            name=GEN_AI_CLIENT_OPERATION_DURATION,
+            description="GenAI operation duration",
+            unit="s",
+            explicit_bucket_boundaries_advisory=_GEN_AI_CLIENT_OPERATION_DURATION_BUCKETS,
+        )
+        metrics[GEN_AI_CLIENT_TOKEN_USAGE] = meter.create_histogram(
+            name=GEN_AI_CLIENT_TOKEN_USAGE,
+            description="Measures number of input and output tokens used",
+            unit="{token}",
+            explicit_bucket_boundaries_advisory=_GEN_AI_CLIENT_TOKEN_USAGE_BUCKETS,
+        )
+
     def extract_attributes(self, attributes: _AttributeMapT):
         if self._call_context.operation not in self._HANDLED_OPERATIONS:
             return

instrumentation/opentelemetry-instrumentation-botocore/src/opentelemetry/instrumentation/botocore/extensions/types.py

@@ -16,6 +16,7 @@
 from typing import Any, Dict, Optional, Tuple
 
 from opentelemetry._events import EventLogger
+from opentelemetry.metrics import Instrument, Meter
 from opentelemetry.trace import SpanKind
 from opentelemetry.trace.span import Span
 from opentelemetry.util.types import AttributeValue
@@ -91,8 +92,11 @@ def _get_attr(obj, name: str, default=None):
 
 
 class _BotocoreInstrumentorContext:
-    def __init__(self, event_logger: EventLogger):
+    def __init__(
+        self, event_logger: EventLogger, metrics: dict[str, Instrument]
+    ):
         self.event_logger = event_logger
+        self.metrics = metrics
 
 
 class _AwsSdkExtension:
@@ -109,6 +113,11 @@ def event_logger_schema_version() -> str:
         """Returns the event logger OTel schema version the extension is following"""
         return "1.30.0"
 
+    @staticmethod
+    def meter_schema_version() -> str:
+        """Returns the meter OTel schema version the extension is following"""
+        return "1.30.0"
+
     def should_trace_service_call(self) -> bool:  # pylint:disable=no-self-use
         """Returns if the AWS SDK service call should be traced or not
 
@@ -125,6 +134,12 @@ def should_end_span_on_exit(self) -> bool:  # pylint:disable=no-self-use
         """
         return True
 
+    def setup_metrics(self, meter: Meter, metrics: dict[str, Instrument]):
+        """Callback which gets invoked to setup metrics.
+
+        Extensions might override this function to add to the metrics dictionary all the metrics
+        they want to receive later in _BotocoreInstrumentorContext."""
+
     def extract_attributes(self, attributes: _AttributeMapT):
         """Callback which gets invoked before the span is created.