chore(perf): improve performance of creating telemetry metrics

.gitignore

@@ -18,6 +18,7 @@ ddtrace/internal/datadog/profiling/crashtracker/crashtracker_exe*
 ddtrace/internal/_encoding.c
 ddtrace/internal/_rand.c
 ddtrace/internal/_tagset.c
+ddtrace/internal/telemetry/metrics_namespaces.c
 pygoat/*
 *.so
 *.dylib

benchmarks/telemetry_add_metric/config.yaml

@@ -1,33 +1,67 @@
-# The scenario expects specific names:
-#   - create-1-<type>-metric: {}
-#   - create-100-<type>-metrics: {}
-#   - increment-1-<type>-metric-100-times: {}
-#   - increment-100-<type>-metrics-100-times: {}
-#
-# The create/increment-<num> is assumed to be a static name, it is not parsed.
-# The "100-times" is assumed as a static name, it is not parsed.
-
-
 # Count metrics
-create-1-count-metric: {}
-create-100-count-metrics: {}
-increment-1-count-metric-100-times: {}
-increment-100-count-metrics-100-times: {}
+1-count-metric-1-times: &count
+  metric_type: count
+  num_metrics: 1
+  per_metric: 1
+1-count-metrics-100-times:
+  <<: *count
+  num_metrics: 1
+  per_metric: 100
+100-count-metrics-100-times:
+  <<: *count
+  num_metrics: 100
+  per_metric: 100
 
 # Gauge metrics
-create-1-gauge-metric: {}
-create-100-gauge-metrics: {}
-increment-1-gauge-metric-100-times: {}
-increment-100-gauge-metrics-100-times: {}
+1-gauge-metric-1-times: &gauge
+  metric_type: gauge
+  num_metrics: 1
+  per_metric: 1
+1-gauge-metrics-100-times:
+  <<: *gauge
+  num_metrics: 1
+  per_metric: 100
+100-gauge-metrics-100-times:
+  <<: *gauge
+  num_metrics: 100
+  per_metric: 10
 
 # Distribution metrics
-create-1-distribution-metric: {}
-create-100-distribution-metrics: {}
-increment-1-distribution-metric-100-times: {}
-increment-100-distribution-metrics-100-times: {}
+1-distribution-metric-1-times: &distribution
+  metric_type: distribution
+  num_metrics: 1
+  per_metric: 1
+1-distribution-metrics-100-times:
+  <<: *distribution
+  num_metrics: 1
+  per_metric: 100
+100-distribution-metrics-100-times:
+  <<: *distribution
+  num_metrics: 100
+  per_metric: 10
 
 # Rate metrics
-create-1-rate-metric: {}
-create-100-rate-metrics: {}
-increment-1-rate-metric-100-times: {}
-increment-100-rate-metrics-100-times: {}
+1-rate-metric-1-times: &rate
+  metric_type: rate
+  num_metrics: 1
+  per_metric: 1
+1-rate-metrics-100-times:
+  <<: *rate
+  num_metrics: 1
+  per_metric: 100
+100-rate-metrics-100-times:
+  <<: *rate
+  num_metrics: 100
+  per_metric: 10
+
+# Flush
+flush-1-metric: &flush
+  metric_type: count  # unused
+  per_metric: 1
+  num_metrics: 1
+flush-100-metrics:
+  <<: *flush
+  num_metrics: 100
+flush-1000-metrics:
+  <<: *flush
+  num_metrics: 1000

benchmarks/telemetry_add_metric/scenario.py

@@ -1,13 +1,25 @@
+import time
+
 from bm import Scenario
 
 from ddtrace.internal.telemetry.constants import TELEMETRY_NAMESPACE
-from ddtrace.internal.telemetry.metrics import CountMetric
-from ddtrace.internal.telemetry.metrics import DistributionMetric
-from ddtrace.internal.telemetry.metrics import GaugeMetric
-from ddtrace.internal.telemetry.metrics import RateMetric
 from ddtrace.internal.telemetry.metrics_namespaces import MetricNamespace
 
 
+try:
+    from ddtrace.internal.telemetry.metrics_namespaces import MetricType
+
+    CountMetric = MetricType.COUNT
+    DistributionMetric = MetricType.DISTRIBUTION
+    GaugeMetric = MetricType.GAUGE
+    RateMetric = MetricType.RATE
+except ImportError:
+    from ddtrace.internal.telemetry.metrics import CountMetric
+    from ddtrace.internal.telemetry.metrics import DistributionMetric
+    from ddtrace.internal.telemetry.metrics import GaugeMetric
+    from ddtrace.internal.telemetry.metrics import RateMetric
+
+
 def add_count_metric(namespace: MetricNamespace, name: str):
     namespace.add_metric(
         CountMetric,
@@ -53,52 +65,67 @@ class TelemetryAddMetric(Scenario):
     This scenario checks to see if there's an impact on sending metrics via instrumentation telemetry
     """
 
-    def run(self):
+    metric_type: str
+    num_metrics: int
+    per_metric: int
+
+    # Override `_pyperf` instead of `run` so we get better control over
+    # how we run/time the scenario. This way we can ignore the creation time
+    # of the MetricNamespace or other parts and only time the actual flush or
+    # metrics adding
+    def _pyperf(self, loops: int) -> float:
+        if self.name.startswith("flush-"):
+            return self.run_flush(loops)
+        return self.run_add_metric(loops)
+
+    def run_add_metric(self, loops: int) -> float:
         add_metric = None
-        if "count-metric" in self.name:
+        if self.metric_type == "count":
             add_metric = add_count_metric
-        elif "gauge-metric" in self.name:
+        elif self.metric_type == "gauge":
             add_metric = add_gauge_metric
-        elif "distribution-metric" in self.name:
+        elif self.metric_type == "distribution":
             add_metric = add_distribution_metric
-        elif "rate-metric" in self.name:
+        elif self.metric_type == "rate":
             add_metric = add_rate_metric
         else:
-            raise ValueError(f"Unknown scenario: {self.name}")
-
-        if "create-1-" in self.name:
-
-            def _(loops: int):
-                for _ in range(loops):
-                    metricnamespace = MetricNamespace()
-                    add_metric(metricnamespace, "metric")
-
-        elif "create-100-" in self.name:
-
-            def _(loops: int):
-                for _ in range(loops):
-                    metricnamespace = MetricNamespace()
-                    for i in range(100):
-                        add_metric(metricnamespace, str(i))
-
-        elif "increment-1-" in self.name:
-
-            def _(loops: int):
-                for _ in range(loops):
-                    metricnamespace = MetricNamespace()
-                    for _ in range(100):
-                        add_metric(metricnamespace, "metric")
-
-        elif "increment-100-" in self.name:
-
-            def _(loops: int):
-                for _ in range(loops):
-                    metricnamespace = MetricNamespace()
-                    for i in range(100):
-                        for _ in range(100):
-                            add_metric(metricnamespace, str(i))
-
-        else:
-            raise ValueError(f"Unknown scenario: {self.name}")
-
-        yield _
+            raise ValueError(f"Scenario {self.name} has an unknown metric type: {self.metric_type}")
+
+        total = 0
+        metric_names = [str(i) for i in range(self.num_metrics)]
+        for _ in range(loops):
+            metricnamespace = MetricNamespace()
+            st = time.perf_counter()
+            for m in metric_names:
+                for _ in range(self.per_metric):
+                    add_metric(metricnamespace, m)
+
+            total += time.perf_counter() - st
+        return total
+
+    def run_flush(self, loops: int) -> float:
+        # Pool of metrics to use for adding
+        metrics = (
+            [(f"count-{i}", add_count_metric) for i in range(250)]
+            + [(f"gauge-{i}", add_gauge_metric) for i in range(250)]
+            + [(f"distribution-{i}", add_distribution_metric) for i in range(250)]
+            + [(f"rate-{i}", add_rate_metric) for i in range(250)]
+        )
+        start = 0
+        end = len(metrics)
+        step = end // self.num_metrics
+        total = 0.0
+
+        # Pre-fill the dummy namespace with metrics
+        dummy_namespace = MetricNamespace()
+        for i in range(start, end, step):
+            metrics[i][1](dummy_namespace, metrics[i][0])
+
+        for _ in range(loops):
+            metricnamespace = MetricNamespace()
+            # Copy the dummy metrics to the new namespace, this saves time on adding metrics
+            metricnamespace._metrics_data = dummy_namespace._metrics_data.copy()
+            st = time.perf_counter()
+            metricnamespace.flush()
+            total += time.perf_counter() - st
+        return total