add enable_metrics and before_send_metric

Author: Litarnus

src/Metrics/Metrics.php

@@ -48,7 +48,7 @@ public function increment(
     /**
      * @param array<string, string> $tags
      *
-     * @deprecated Metrics are no longer supported. Metrics API is a no-op and will be removed in 5.x.
+     * @deprecated Use TraceMetrics::distribution() instead. Metrics API is a no-op and will be removed in 5.x.
      */
     public function distribution(
         string $key,

src/Metrics/MetricsAggregator.php

@@ -42,7 +42,7 @@ public function __construct()
     ];
 
     /**
-     * @param int|float|string                     $value
+     * @param int|float                            $value
      * @param array<string, int|float|string|bool> $attributes
      */
     public function add(
@@ -58,6 +58,10 @@ public function add(
         if ($client instanceof Client) {
             $options = $client->getOptions();
 
+            if ($options->getEnableMetrics() === false) {
+                return;
+            }
+
             $defaultAttributes = [
                 'sentry.sdk.name' => $client->getSdkIdentifier(),
                 'sentry.sdk.version' => $client->getSdkVersion(),
@@ -89,9 +93,17 @@ public function add(
 
         $metricTypeClass = self::METRIC_TYPES[$type];
         /** @var AbstractType $metric */
-        /** @phpstan-ignore-next-line SetType accepts int|float|string, others only int|float */
+        /** @phpstan-ignore-next-line */
         $metric = new $metricTypeClass($name, $value, $traceId, $spanId, $attributes, microtime(true), $unit);
 
+        if ($client !== null) {
+            $beforeSendMetric = $client->getOptions()->getBeforeSendMetricCallback();
+            $metric = $beforeSendMetric($metric);
+            if ($metric === null) {
+                return;
+            }
+        }
+
         $this->metrics->push($metric);
     }
 

src/Options.php

@@ -10,6 +10,7 @@
 use Sentry\Integration\ErrorListenerIntegration;
 use Sentry\Integration\IntegrationInterface;
 use Sentry\Logs\Log;
+use Sentry\Metrics\Types\AbstractType;
 use Sentry\Transport\TransportInterface;
 use Symfony\Component\OptionsResolver\Options as SymfonyOptions;
 use Symfony\Component\OptionsResolver\OptionsResolver;
@@ -177,6 +178,31 @@ public function getEnableLogs(): bool
         return $this->options['enable_logs'] ?? false;
     }
 
+    /**
+     * Sets if metrics should be enabled or not.
+     */
+    public function setEnableMetrics(bool $enableTracing): self
+    {
+        $options = array_merge($this->options, ['enable_metrics' => $enableTracing]);
+
+        $this->options = $this->resolver->resolve($options);
+
+        return $this;
+    }
+
+    /**
+     * Returns whether metrics are enabled or not.
+     */
+    public function getEnableMetrics(): bool
+    {
+        /**
+         * @var bool $enableMetrics
+         */
+        $enableMetrics = $this->options['enable_metrics'] ?? true;
+
+        return $enableMetrics;
+    }
+
     /**
      * Sets the sampling factor to apply to transactions. A value of 0 will deny
      * sending any transactions, and a value of 1 will send 100% of transactions.
@@ -676,6 +702,35 @@ public function getBeforeSendMetricsCallback(): callable
         return $this->options['before_send_metrics'];
     }
 
+    /**
+     * Gets a callback that will be invoked before a metric is added.
+     * Returning `null` means that the metric will be discarded.
+     */
+    public function getBeforeSendMetricCallback(): callable
+    {
+        /**
+         * @var callable $callback
+         */
+        $callback = $this->options['before_send_metric'];
+
+        return $callback;
+    }
+
+    /**
+     * Sets a new callback that is invoked before metrics are sent.
+     * Returning `null` means that the metric will be discarded.
+     *
+     * @return $this
+     */
+    public function setBeforeSendMetricCallback(callable $callback): self
+    {
+        $options = array_merge($this->options, ['before_send_metric' => $callback]);
+
+        $this->options = $this->resolver->resolve($options);
+
+        return $this;
+    }
+
     /**
      * Sets a callable to be called to decide whether metrics should
      * be send or not.
@@ -1220,6 +1275,7 @@ private function configureOptions(OptionsResolver $resolver): void
             'sample_rate' => 1,
             'enable_tracing' => null,
             'enable_logs' => false,
+            'enable_metrics' => true,
             'traces_sample_rate' => null,
             'traces_sampler' => null,
             'profiles_sample_rate' => null,
@@ -1256,10 +1312,14 @@ private function configureOptions(OptionsResolver $resolver): void
             },
             /**
              * @deprecated Metrics are no longer supported. Metrics API is a no-op and will be removed in 5.x.
+             * Use `before_send_metric` instead.
              */
             'before_send_metrics' => static function (Event $metrics): ?Event {
                 return null;
             },
+            'before_send_metric' => static function (AbstractType $metric): AbstractType {
+                return $metric;
+            },
             'trace_propagation_targets' => null,
             'strict_trace_propagation' => false,
             'tags' => [],
@@ -1290,6 +1350,7 @@ private function configureOptions(OptionsResolver $resolver): void
         $resolver->setAllowedTypes('sample_rate', ['int', 'float']);
         $resolver->setAllowedTypes('enable_tracing', ['null', 'bool']);
         $resolver->setAllowedTypes('enable_logs', 'bool');
+        $resolver->setAllowedTypes('enable_metrics', 'bool');
         $resolver->setAllowedTypes('traces_sample_rate', ['null', 'int', 'float']);
         $resolver->setAllowedTypes('traces_sampler', ['null', 'callable']);
         $resolver->setAllowedTypes('profiles_sample_rate', ['null', 'int', 'float']);
@@ -1309,6 +1370,7 @@ private function configureOptions(OptionsResolver $resolver): void
         $resolver->setAllowedTypes('before_send', ['callable']);
         $resolver->setAllowedTypes('before_send_transaction', ['callable']);
         $resolver->setAllowedTypes('before_send_log', 'callable');
+        $resolver->setAllowedTypes('before_send_metric', ['callable']);
         $resolver->setAllowedTypes('ignore_exceptions', 'string[]');
         $resolver->setAllowedTypes('ignore_transactions', 'string[]');
         $resolver->setAllowedTypes('trace_propagation_targets', ['null', 'string[]']);

tests/Metrics/TraceMetricsTest.php

@@ -7,6 +7,7 @@
 use PHPUnit\Framework\TestCase;
 use Sentry\Client;
 use Sentry\Metrics\MetricsAggregator;
+use Sentry\Metrics\Types\AbstractType;
 use Sentry\Metrics\Types\CounterType;
 use Sentry\Metrics\Types\DistributionType;
 use Sentry\Metrics\Types\GaugeType;
@@ -19,7 +20,7 @@ final class TraceMetricsTest extends TestCase
 {
     protected function setUp(): void
     {
-        HubAdapter::getInstance()->bindClient(new Client(new Options(), new StubTransport()));
+        HubAdapter::getInstance()->bindClient(new Client(new Options(), StubTransport::getInstance()));
         StubTransport::$events = [];
     }
 
@@ -82,4 +83,37 @@ public function testMetricsBufferFull(): void
         $metrics = $event->getMetrics();
         $this->assertCount(MetricsAggregator::METRICS_BUFFER_SIZE, $metrics);
     }
+
+    public function testEnableMetrics(): void
+    {
+        HubAdapter::getInstance()->bindClient(new Client(new Options([
+            'enable_metrics' => false,
+        ]), StubTransport::getInstance()));
+
+        trace_metrics()->count('test-count', 2, ['foo' => 'bar']);
+        trace_metrics()->flush();
+
+        $this->assertEmpty(StubTransport::$events);
+    }
+
+    public function testBeforeSendMetricAltersContent()
+    {
+        HubAdapter::getInstance()->bindClient(new Client(new Options([
+            'before_send_metric' => static function (AbstractType $metric) {
+                $metric->setValue(99999);
+
+                return $metric;
+            },
+        ]), StubTransport::getInstance()));
+
+        trace_metrics()->count('test-count', 2, ['foo' => 'bar']);
+        trace_metrics()->flush();
+
+        $this->assertCount(1, StubTransport::$events);
+        $event = StubTransport::$events[0];
+
+        $this->assertCount(1, $event->getMetrics());
+        $metric = $event->getMetrics()[0];
+        $this->assertEquals(99999, $metric->getValue());
+    }
 }

tests/StubTransport.php

@@ -19,6 +19,20 @@ class StubTransport implements TransportInterface
      */
     public static $events = [];
 
+    /**
+     * @var self
+     */
+    private static $instance;
+
+    public static function getInstance(): self
+    {
+        if (self::$instance === null) {
+            self::$instance = new self();
+        }
+
+        return self::$instance;
+    }
+
     public function send(Event $event): Result
     {
         self::$events[] = $event;