feat(trace): implement span start/end metrics

CHANGELOG.md

@@ -30,6 +30,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   ([#4806](https://github.com/open-telemetry/opentelemetry-python/pull/4806))
 - Prevent possible endless recursion from happening in `SimpleLogRecordProcessor.on_emit`,
   ([#4799](https://github.com/open-telemetry/opentelemetry-python/pull/4799)) and ([#4867](https://github.com/open-telemetry/opentelemetry-python/pull/4867)).
+- Implement span start/end metrics
+  ([#4880](https://github.com/open-telemetry/opentelemetry-python/pull/4880))
 - Add environment variable carriers to API
   ([#4609](https://github.com/open-telemetry/opentelemetry-python/pull/4609))
 - Add experimental composable rule based sampler

opentelemetry-sdk/src/opentelemetry/sdk/trace/__init__.py

@@ -47,6 +47,7 @@
 from typing_extensions import deprecated
 
 from opentelemetry import context as context_api
+from opentelemetry import metrics as metrics_api
 from opentelemetry import trace as trace_api
 from opentelemetry.attributes import BoundedAttributes
 from opentelemetry.sdk import util
@@ -80,6 +81,8 @@
 from opentelemetry.util import types
 from opentelemetry.util._decorator import _agnosticcontextmanager
 
+from ._tracer_metrics import TracerMetrics
+
 logger = logging.getLogger(__name__)
 
 _DEFAULT_OTEL_ATTRIBUTE_COUNT_LIMIT = 128
@@ -814,6 +817,7 @@ def __init__(
         set_status_on_exception: bool = True,
         limits=_UnsetLimits,
         instrumentation_scope: Optional[InstrumentationScope] = None,
+        record_end_metrics: Optional[Callable[[], None]] = None,
     ) -> None:
         if resource is None:
             resource = Resource.create({})
@@ -851,6 +855,8 @@ def __init__(
 
         self._links = self._new_links(links)
 
+        self._record_end_metrics = record_end_metrics
+
     def __repr__(self):
         return f'{type(self).__name__}(name="{self._name}", context={self._context})'
 
@@ -980,6 +986,8 @@ def end(self, end_time: Optional[int] = None) -> None:
 
             self._end_time = end_time if end_time is not None else time_ns()
 
+        if self._record_end_metrics:
+            self._record_end_metrics()
         # pylint: disable=protected-access
         self._span_processor._on_ending(self)
         self._span_processor.on_end(self._readable_span())
@@ -1106,6 +1114,7 @@ def __init__(
         instrumentation_info: InstrumentationInfo,
         span_limits: SpanLimits,
         instrumentation_scope: InstrumentationScope,
+        meter_provider: Optional[metrics_api.MeterProvider] = None,
         *,
         _tracer_provider: Optional["TracerProvider"] = None,
     ) -> None:
@@ -1118,6 +1127,9 @@ def __init__(
         self._instrumentation_scope = instrumentation_scope
         self._tracer_provider = _tracer_provider
 
+        meter_provider = meter_provider or metrics_api.get_meter_provider()
+        self._tracer_metrics = TracerMetrics(meter_provider)
+
     def _is_enabled(self) -> bool:
         """If the tracer is not enabled, start_span will create a NonRecordingSpan"""
 
@@ -1214,6 +1226,10 @@ def start_span(  # pylint: disable=too-many-locals
             trace_state=sampling_result.trace_state,
         )
 
+        record_end_metrics = self._tracer_metrics.start_span(
+            parent_span_context, sampling_result.decision
+        )
+
         # Only record if is_recording() is true
         if sampling_result.decision.is_recording():
             # pylint:disable=protected-access
@@ -1232,6 +1248,7 @@ def start_span(  # pylint: disable=too-many-locals
                 set_status_on_exception=set_status_on_exception,
                 limits=self._span_limits,
                 instrumentation_scope=self._instrumentation_scope,
+                record_end_metrics=record_end_metrics,
             )
             span.start(start_time=start_time, parent_context=context)
         else:
@@ -1313,6 +1330,7 @@ def __init__(
         ] = None,
         id_generator: Optional[IdGenerator] = None,
         span_limits: Optional[SpanLimits] = None,
+        meter_provider: Optional[metrics_api.MeterProvider] = None,
         *,
         _tracer_configurator: Optional[_TracerConfiguratorT] = None,
     ) -> None:
@@ -1334,6 +1352,7 @@ def __init__(
         disabled = environ.get(OTEL_SDK_DISABLED, "")
         self._disabled = disabled.lower().strip() == "true"
         self._atexit_handler = None
+        self._meter_provider = meter_provider
 
         if shutdown_on_exit:
             self._atexit_handler = atexit.register(self.shutdown)
@@ -1406,6 +1425,7 @@ def get_tracer(
                 schema_url,
                 attributes,
             ),
+            self._meter_provider,
             _tracer_provider=self,
         )
 

opentelemetry-sdk/src/opentelemetry/sdk/trace/_tracer_metrics.py

@@ -0,0 +1,85 @@
+# 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.abc import Callable
+
+from opentelemetry import metrics as metrics_api
+from opentelemetry.sdk.trace.sampling import Decision
+from opentelemetry.semconv._incubating.attributes.otel_attributes import (
+    OTEL_SPAN_PARENT_ORIGIN,
+    OTEL_SPAN_SAMPLING_RESULT,
+    OtelSpanSamplingResultValues,
+)
+from opentelemetry.semconv._incubating.metrics.otel_metrics import (
+    create_otel_sdk_span_live,
+    create_otel_sdk_span_started,
+)
+from opentelemetry.trace.span import SpanContext
+
+
+class TracerMetrics:
+    def __init__(self, meter_provider: metrics_api.MeterProvider) -> None:
+        meter = meter_provider.get_meter("opentelemetry-sdk")
+
+        self._started_spans = create_otel_sdk_span_started(meter)
+        self._live_spans = create_otel_sdk_span_live(meter)
+
+    def start_span(
+        self,
+        parent_span_context: SpanContext | None,
+        sampling_decision: Decision,
+    ) -> Callable[[], None]:
+        sampling_result_value = sampling_result(sampling_decision)
+        self._started_spans.add(
+            1,
+            {
+                OTEL_SPAN_PARENT_ORIGIN: parent_origin(parent_span_context),
+                OTEL_SPAN_SAMPLING_RESULT: sampling_result_value,
+            },
+        )
+
+        if not sampling_decision.is_recording():
+            return noop
+
+        live_span_attrs = {
+            OTEL_SPAN_SAMPLING_RESULT: sampling_result_value,
+        }
+        self._live_spans.add(1, live_span_attrs)
+
+        def end_span() -> None:
+            self._live_spans.add(-1, live_span_attrs)
+
+        return end_span
+
+
+def noop() -> None:
+    pass
+
+
+def parent_origin(span_ctx: SpanContext | None) -> str:
+    if span_ctx is None:
+        return "none"
+    if span_ctx.is_remote:
+        return "remote"
+    return "local"
+
+
+def sampling_result(decision: Decision) -> str:
+    if decision == Decision.RECORD_AND_SAMPLE:
+        return OtelSpanSamplingResultValues.RECORD_AND_SAMPLE.value
+    if decision == Decision.RECORD_ONLY:
+        return OtelSpanSamplingResultValues.RECORD_ONLY.value
+    return OtelSpanSamplingResultValues.DROP.value