feat(sdk): implement exporter metrics

CHANGELOG.md

@@ -31,6 +31,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   ([#4970](https://github.com/open-telemetry/opentelemetry-python/pull/4970))
 - `opentelemetry-sdk`: upgrade vendored OTel configuration schema from v1.0.0-rc.3 to v1.0.0
   ([#4965](https://github.com/open-telemetry/opentelemetry-python/pull/4965))
+- `opentelemetry-sdk`: implement exporter metrics
+  ([#4976](https://github.com/open-telemetry/opentelemetry-python/pull/4976))
 - improve check-links ci job
   ([#4978](https://github.com/open-telemetry/opentelemetry-python/pull/4978))
 - Resolve some Pyright type errors in Span/ReadableSpan and utility stubs

exporter/opentelemetry-exporter-otlp-proto-common/src/opentelemetry/exporter/otlp/proto/common/_exporter_metrics.py

@@ -0,0 +1,133 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from collections import Counter
+from contextlib import contextmanager
+from dataclasses import dataclass
+from time import perf_counter
+from typing import TYPE_CHECKING, Iterator
+
+from opentelemetry.metrics import MeterProvider, get_meter_provider
+from opentelemetry.semconv._incubating.attributes.otel_attributes import (
+    OTEL_COMPONENT_NAME,
+    OTEL_COMPONENT_TYPE,
+    OtelComponentTypeValues,
+)
+from opentelemetry.semconv._incubating.metrics.otel_metrics import (
+    create_otel_sdk_exporter_log_exported,
+    create_otel_sdk_exporter_log_inflight,
+    create_otel_sdk_exporter_metric_data_point_exported,
+    create_otel_sdk_exporter_metric_data_point_inflight,
+    create_otel_sdk_exporter_operation_duration,
+    create_otel_sdk_exporter_span_exported,
+    create_otel_sdk_exporter_span_inflight,
+)
+from opentelemetry.semconv.attributes.error_attributes import ERROR_TYPE
+from opentelemetry.semconv.attributes.server_attributes import (
+    SERVER_ADDRESS,
+    SERVER_PORT,
+)
+
+if TYPE_CHECKING:
+    from typing import Literal
+    from urllib.parse import ParseResult as UrlParseResult
+
+    from opentelemetry.util.types import Attributes, AttributeValue
+
+_component_counter = Counter()
+
+
+@dataclass
+class ExportResult:
+    error: Exception | None = None
+    error_attrs: Attributes = None
+
+
+class ExporterMetrics:
+    def __init__(
+        self,
+        component_type: OtelComponentTypeValues | None,
+        signal: Literal["traces", "metrics", "logs"],
+        endpoint: UrlParseResult,
+        meter_provider: MeterProvider | None,
+    ) -> None:
+        if signal == "traces":
+            create_exported = create_otel_sdk_exporter_span_exported
+            create_inflight = create_otel_sdk_exporter_span_inflight
+        elif signal == "logs":
+            create_exported = create_otel_sdk_exporter_log_exported
+            create_inflight = create_otel_sdk_exporter_log_inflight
+        else:
+            create_exported = (
+                create_otel_sdk_exporter_metric_data_point_exported
+            )
+            create_inflight = (
+                create_otel_sdk_exporter_metric_data_point_inflight
+            )
+
+        port = endpoint.port
+        if port is None:
+            if endpoint.scheme == "https":
+                port = 443
+            elif endpoint.scheme == "http":
+                port = 80
+
+        component_type = (
+            component_type or OtelComponentTypeValues("unknown_otlp_exporter")
+        ).value
+        count = _component_counter[component_type]
+        _component_counter[component_type] = count + 1
+        self._standard_attrs: dict[str, AttributeValue] = {
+            OTEL_COMPONENT_TYPE: component_type,
+            OTEL_COMPONENT_NAME: f"{component_type}/{count}",
+        }
+        if endpoint.hostname:
+            self._standard_attrs[SERVER_ADDRESS] = endpoint.hostname
+        if port is not None:
+            self._standard_attrs[SERVER_PORT] = port
+
+        meter_provider = meter_provider or get_meter_provider()
+        meter = meter_provider.get_meter("opentelemetry-sdk")
+        self._inflight = create_inflight(meter)
+        self._exported = create_exported(meter)
+        self._duration = create_otel_sdk_exporter_operation_duration(meter)
+
+    @contextmanager
+    def export_operation(self, num_items: int) -> Iterator[ExportResult]:
+        start_time = perf_counter()
+        self._inflight.add(num_items, self._standard_attrs)
+
+        result = ExportResult()
+        try:
+            yield result
+        finally:
+            error = result.error
+            error_attrs = result.error_attrs
+
+            end_time = perf_counter()
+            self._inflight.add(-num_items, self._standard_attrs)
+            exported_attrs = (
+                {**self._standard_attrs, ERROR_TYPE: type(error).__qualname__}
+                if error
+                else self._standard_attrs
+            )
+            self._exported.add(num_items, exported_attrs)
+            duration_attrs = (
+                {**exported_attrs, **error_attrs}
+                if error_attrs
+                else exported_attrs
+            )
+            self._duration.record(end_time - start_time, duration_attrs)

exporter/opentelemetry-exporter-otlp-proto-grpc/src/opentelemetry/exporter/otlp/proto/grpc/_log_exporter/__init__.py

@@ -22,6 +22,7 @@
     _get_credentials,
     environ_to_compression,
 )
+from opentelemetry.metrics import MeterProvider
 from opentelemetry.proto.collector.logs.v1.logs_service_pb2 import (
     ExportLogsServiceRequest,
 )
@@ -44,6 +45,9 @@
     OTEL_EXPORTER_OTLP_LOGS_INSECURE,
     OTEL_EXPORTER_OTLP_LOGS_TIMEOUT,
 )
+from opentelemetry.semconv._incubating.attributes.otel_attributes import (
+    OtelComponentTypeValues,
+)
 
 
 class OTLPLogExporter(
@@ -66,6 +70,8 @@ def __init__(
         timeout: Optional[float] = None,
         compression: Optional[Compression] = None,
         channel_options: Optional[Tuple[Tuple[str, str]]] = None,
+        *,
+        meter_provider: Optional[MeterProvider] = None,
     ):
         insecure_logs = environ.get(OTEL_EXPORTER_OTLP_LOGS_INSECURE)
         if insecure is None and insecure_logs is not None:
@@ -105,13 +111,19 @@ def __init__(
             stub=LogsServiceStub,
             result=LogRecordExportResult,
             channel_options=channel_options,
+            component_type=OtelComponentTypeValues.OTLP_GRPC_LOG_EXPORTER,
+            signal="logs",
+            meter_provider=meter_provider,
         )
 
     def _translate_data(
         self, data: Sequence[ReadableLogRecord]
     ) -> ExportLogsServiceRequest:
         return encode_logs(data)
 
+    def _count_data(self, data: Sequence[ReadableLogRecord]):
+        return len(data)
+
     def export(  # type: ignore [reportIncompatibleMethodOverride]
         self,
         batch: Sequence[ReadableLogRecord],