Merge branch 'master' into continuous-profiling

Author: cleptric

CHANGELOG.md

@@ -1,5 +1,33 @@
 # CHANGELOG
 
+## 4.13.0
+
+The Sentry SDK team is happy to announce the immediate availability of Sentry PHP SDK v4.13.0.
+
+### Features
+
+- Add regex support for `ignore_exceptions` and `ignore_transactions` [(#1850)](https://github.com/getsentry/sentry-php/pull/1850)
+
+  You can now use regular expressions to ignore exceptions and transactions:
+
+  ```php
+  Sentry\init([
+      'ignore_exceptions' => [
+          '/.*ArgumentException$/',
+      ],
+      'ignore_transactions' => [
+          '/^GET \/api\/users\/\d+$/',
+      ],
+  ]);
+  ```
+
+- Add support for variadic parameters and null values [(#1849)](https://github.com/getsentry/sentry-php/pull/1849)
+
+### Bug Fixes
+
+- Fix `Options::setEnableLogs` [(#1852)](https://github.com/getsentry/sentry-php/pull/1852)
+- Fix `vsprintf` not handling errors [(#1855)](https://github.com/getsentry/sentry-php/pull/1855)
+
 ## 4.12.0
 
 The Sentry SDK team is happy to announce the immediate availability of Sentry PHP SDK v4.12.0.
@@ -86,7 +114,7 @@ The Sentry SDK team is happy to announce the immediate availability of Sentry PH
 
 ### Features
 
-- Allow retrieving a single piece of data from the span by it’s key [(#1767)](https://github.com/getsentry/sentry-php/pull/1767)
+- Allow retrieving a single piece of data from the span by it's key [(#1767)](https://github.com/getsentry/sentry-php/pull/1767)
 
   ```php
   \Sentry\SentrySdk::getCurrentHub()->getSpan()?->setData([

src/Client.php

@@ -32,7 +32,13 @@ class Client implements ClientInterface
     /**
      * The version of the SDK.
      */
-    public const SDK_VERSION = '4.12.0';
+    public const SDK_VERSION = '4.13.0';
+
+    /**
+     * Regex pattern to detect if a string is a regex pattern (starts and ends with / optionally followed by flags).
+     * Supported flags: i (case-insensitive), m (multiline), s (dotall), u (unicode).
+     */
+    private const REGEX_PATTERN_DETECTION = '/^\/.*\/[imsu]*$/';
 
     /**
      * @var Options The client options
@@ -149,7 +155,7 @@ public function captureMessage(string $message, ?Severity $level = null, ?Scope
     public function captureException(\Throwable $exception, ?Scope $scope = null, ?EventHint $hint = null): ?EventId
     {
         $className = \get_class($exception);
-        if ($this->isIgnoredException($className)) {
+        if ($this->shouldIgnoreException($className)) {
             $this->logger->info(
                 'The exception will be discarded because it matches an entry in "ignore_exceptions".',
                 ['className' => $className]
@@ -359,11 +365,64 @@ private function prepareEvent(Event $event, ?EventHint $hint = null, ?Scope $sco
         return $event;
     }
 
-    private function isIgnoredException(string $className): bool
+    /**
+     * Checks if an exception should be ignored based on configured patterns.
+     * Supports both class hierarchy matching and regex patterns.
+     * Patterns starting and ending with '/' are treated as regex patterns.
+     */
+    private function shouldIgnoreException(string $className): bool
+    {
+        foreach ($this->options->getIgnoreExceptions() as $pattern) {
+            // Check for regex pattern (starts with / and ends with / optionally followed by flags)
+            if (preg_match(self::REGEX_PATTERN_DETECTION, $pattern)) {
+                try {
+                    if (preg_match($pattern, $className)) {
+                        return true;
+                    }
+                } catch (\Throwable $e) {
+                    // Invalid regex pattern, log and skip
+                    $this->logger->warning(
+                        \sprintf('Invalid regex pattern in ignore_exceptions: "%s". Error: %s', $pattern, $e->getMessage())
+                    );
+                    continue;
+                }
+            } else {
+                // Class hierarchy check
+                if (is_a($className, $pattern, true)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Checks if a transaction should be ignored based on configured patterns.
+     * Supports both exact string matching and regex patterns.
+     * Patterns starting and ending with '/' are treated as regex patterns.
+     */
+    private function shouldIgnoreTransaction(string $transactionName): bool
     {
-        foreach ($this->options->getIgnoreExceptions() as $ignoredException) {
-            if (is_a($className, $ignoredException, true)) {
-                return true;
+        foreach ($this->options->getIgnoreTransactions() as $pattern) {
+            // Check for regex pattern (starts with / and ends with / optionally followed by flags)
+            if (preg_match(self::REGEX_PATTERN_DETECTION, $pattern)) {
+                try {
+                    if (preg_match($pattern, $transactionName)) {
+                        return true;
+                    }
+                } catch (\Throwable $e) {
+                    // Invalid regex pattern, log and skip
+                    $this->logger->warning(
+                        \sprintf('Invalid regex pattern in ignore_transactions: "%s". Error: %s', $pattern, $e->getMessage())
+                    );
+                    continue;
+                }
+            } else {
+                // Exact string match
+                if ($transactionName === $pattern) {
+                    return true;
+                }
             }
         }
 
@@ -380,7 +439,7 @@ private function applyIgnoreOptions(Event $event, string $eventDescription): ?Ev
             }
 
             foreach ($exceptions as $exception) {
-                if ($this->isIgnoredException($exception->getType())) {
+                if ($this->shouldIgnoreException($exception->getType())) {
                     $this->logger->info(
                         \sprintf('The %s will be discarded because it matches an entry in "ignore_exceptions".', $eventDescription),
                         ['event' => $event]
@@ -398,7 +457,7 @@ private function applyIgnoreOptions(Event $event, string $eventDescription): ?Ev
                 return $event;
             }
 
-            if (\in_array($transactionName, $this->options->getIgnoreTransactions(), true)) {
+            if ($this->shouldIgnoreTransaction($transactionName)) {
                 $this->logger->info(
                     \sprintf('The %s will be discarded because it matches a entry in "ignore_transactions".', $eventDescription),
                     ['event' => $event]

src/FrameBuilder.php

@@ -219,7 +219,18 @@ private function getFunctionArgumentValues(\ReflectionFunctionAbstract $reflecti
         foreach ($reflectionFunction->getParameters() as $reflectionParameter) {
             $parameterPosition = $reflectionParameter->getPosition();
 
-            if (!isset($backtraceFrameArgs[$parameterPosition])) {
+            if ($reflectionParameter->isVariadic()) {
+                // For variadic parameters, collect all remaining arguments into an array
+                $variadicArgs = [];
+                for ($i = $parameterPosition; $i < \count($backtraceFrameArgs); ++$i) {
+                    $variadicArgs[] = $backtraceFrameArgs[$i];
+                }
+                $argumentValues[$reflectionParameter->getName()] = $variadicArgs;
+                // Variadic parameter is always the last one, so we can break
+                break;
+            }
+
+            if (!\array_key_exists($parameterPosition, $backtraceFrameArgs)) {
                 continue;
             }
 

src/HttpClient/Request.php

@@ -4,9 +4,6 @@
 
 namespace Sentry\HttpClient;
 
-/**
- * @internal
- */
 final class Request
 {
     /**

src/HttpClient/Response.php

@@ -4,9 +4,6 @@
 
 namespace Sentry\HttpClient;
 
-/**
- * @internal
- */
 final class Response
 {
     /**

src/Logs/LogsAggregator.php

@@ -12,6 +12,7 @@
 use Sentry\State\HubInterface;
 use Sentry\State\Scope;
 use Sentry\Util\Arr;
+use Sentry\Util\Str;
 
 /**
  * @internal
@@ -57,7 +58,21 @@ public function add(
             return;
         }
 
-        $log = (new Log($timestamp, $this->getTraceId($hub), $level, vsprintf($message, $values)))
+        $formattedMessage = Str::vsprintfOrNull($message, $values);
+
+        if ($formattedMessage === null) {
+            // If formatting fails we don't format the message and log the error
+            if ($sdkLogger !== null) {
+                $sdkLogger->warning('Failed to format log message with values.', [
+                    'message' => $message,
+                    'values' => $values,
+                ]);
+            }
+
+            $formattedMessage = $message;
+        }
+
+        $log = (new Log($timestamp, $this->getTraceId($hub), $level, $formattedMessage))
             ->setAttribute('sentry.release', $options->getRelease())
             ->setAttribute('sentry.environment', $options->getEnvironment() ?? Event::DEFAULT_ENVIRONMENT)
             ->setAttribute('sentry.server.address', $options->getServerName())
@@ -124,6 +139,14 @@ public function flush(): ?EventId
         return $hub->captureEvent($event);
     }
 
+    /**
+     * @return Log[]
+     */
+    public function all(): array
+    {
+        return $this->logs;
+    }
+
     private function getTraceId(HubInterface $hub): string
     {
         $span = $hub->getSpan();

src/Serializer/EnvelopItems/EventItem.php

@@ -9,6 +9,7 @@
 use Sentry\Serializer\Traits\BreadcrumbSeralizerTrait;
 use Sentry\Serializer\Traits\StacktraceFrameSeralizerTrait;
 use Sentry\Util\JSON;
+use Sentry\Util\Str;
 
 /**
  * @internal
@@ -124,7 +125,7 @@ public static function toEnvelopeItem(Event $event): string
                 $payload['message'] = [
                     'message' => $event->getMessage(),
                     'params' => $event->getMessageParams(),
-                    'formatted' => $event->getMessageFormatted() ?? vsprintf($event->getMessage(), $event->getMessageParams()),
+                    'formatted' => $event->getMessageFormatted() ?? Str::vsprintfOrNull($event->getMessage(), $event->getMessageParams()) ?? $event->getMessage(),
                 ];
             }
         }

src/Util/Str.php

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Sentry\Util;
+
+/**
+ * This class provides some utility methods to work with strings.
+ *
+ * @internal
+ */
+class Str
+{
+    /**
+     * Safe way of running `vsprintf` without throwing exceptions or errors.
+     *
+     * If the string could not be formatted, it returns `null`.
+     *
+     * @see https://www.php.net/manual/en/function.vsprintf.php
+     *
+     * @param array<bool|float|int|string|null> $values
+     */
+    public static function vsprintfOrNull(string $message, array $values): ?string
+    {
+        if (empty($values)) {
+            return $message;
+        }
+
+        foreach ($values as $value) {
+            // If the value is not a scalar or null, we cannot safely format it
+            if (!\is_scalar($value) && $value !== null) {
+                return null;
+            }
+        }
+
+        try {
+            $result = @vsprintf($message, $values);
+
+            // @phpstan-ignore-next-line on PHP 7 `vsprintf` does not throw an exception but can return `false`
+            return $result === false ? null : $result;
+        } catch (\Error $e) { // This is technically a `ValueError` in PHP 8.0+ but this works in PHP 7 as well
+            return null;
+        }
+    }
+}

src/functions.php

@@ -58,7 +58,6 @@
  *     send_attempts?: int,
  *     send_default_pii?: bool,
  *     server_name?: string,
- *     server_name?: string,
  *     spotlight?: bool,
  *     spotlight_url?: string,
  *     strict_trace_propagation?: bool,