Symfony Sentry Monolog Adapter

https://github.com/macpaw/sentry-monolog-adapter
Admin
A Symfony bundle designed to enhance and provide granular control over logging to Sentry, especially...
Tokens:6,537
Snippets:57
Trust Score:9.8
License:MIT
Update:4 months ago
Show doc for...
Tokens:
Raw
### Complete Sentry Monolog Adapter Configuration Example

Source: https://context7.com/macpaw/sentry-monolog-adapter/llms.txt

This YAML configuration file shows a comprehensive setup for the Sentry Monolog Adapter. It enables the messenger logging middleware and defines various logging strategies, alongside configuring Monolog handlers and processors.

```yaml
# config/packages/sentry_monolog_adapter.yaml
sentry_monolog_adapter:
    messenger_logging_middleware:
        enabled: true
        logging_strategies:
            # Log only after 3 retry attempts
            - id: sentry_monolog_adapter.log_after_position_strategy
              options:
                  position: 3
            # Always log messages that have been sent to failure transport
            - id: sentry_monolog_adapter.log_all_failed_strategy
            # Log every 5th retry attempt (arithmetic progression)
            - id: sentry_monolog_adapter.arithmetic_progression_strategy
              options:
                  step: 5
    monolog_handler_decorator:
        enabled: true
        processors:
            - sentry_monolog_adapter.exception_processor
```

--------------------------------

### Install Sentry Monolog Adapter using Composer

Source: https://github.com/macpaw/sentry-monolog-adapter/blob/develop/README.md

Installs the latest stable version of the Sentry Monolog Adapter bundle using Composer. This command requires Composer to be installed globally.

```bash
$ composer require macpaw/sentry-monolog-adapter
```

--------------------------------

### LogAfterPositionStrategy YAML Usage Example

Source: https://context7.com/macpaw/sentry-monolog-adapter/llms.txt

This YAML configuration demonstrates how to use the `LogAfterPositionStrategy`. It specifies that messages should only be logged after they have been retried 5 times, using the `options.position` key.

```yaml
# Log only after message has been retried 5 times
sentry_monolog_adapter:
    messenger_logging_middleware:
        logging_strategies:
            - id: sentry_monolog_adapter.log_after_position_strategy
              options:
                  position: 5
```

--------------------------------

### Log All Attempts Logging Strategy Configuration (YAML)

Source: https://context7.com/macpaw/sentry-monolog-adapter/llms.txt

Configuration example for the Log All Attempts Logging Strategy. This YAML registers the strategy, ensuring all message failures are logged by the middleware.

```yaml
# Log all message failures regardless of retry count
sentry_monolog_adapter:
    messenger_logging_middleware:
        logging_strategies:
            - id: sentry_monolog_adapter.log_all_strategy

```

--------------------------------

### Arithmetic Progression Logging Strategy Configuration (YAML)

Source: https://context7.com/macpaw/sentry-monolog-adapter/llms.txt

Configuration example for the Arithmetic Progression Logging Strategy. This YAML snippet shows how to register and configure the strategy, specifying a step of 3 to log every third retry attempt.

```yaml
# Log every 3rd retry attempt (attempts 0, 3, 6, 9, etc.)
sentry_monolog_adapter:
    messenger_logging_middleware:
        logging_strategies:
            - id: sentry_monolog_adapter.arithmetic_progression_strategy
              options:
                  step: 3

```

--------------------------------

### Custom Exponential Logging Strategy (PHP)

Source: https://context7.com/macpaw/sentry-monolog-adapter/llms.txt

An example of a custom logging strategy that logs messages only on specific retry counts (e.g., 1st, 5th, 10th). It checks the RedeliveryStamp for the retry count and compares it against a predefined array.

```php
<?php

namespace App\Messenger\LoggingStrategy;

use SentryMonologAdapter\Messenger\LoggingStrategy\LoggingStrategyInterface;
use Symfony\Component\Messenger\Envelope;
use Symfony\Component\Messenger\Stamp\RedeliveryStamp;

// Custom strategy: log only on specific retry counts (e.g., 1st, 5th, 10th attempt)
class ExponentialLoggingStrategy implements LoggingStrategyInterface
{
    private array $logOnRetries = [1, 5, 10, 20, 50];

    public function willLog(Envelope $envelope): bool
    {
        $redeliveryStamp = $envelope->last(RedeliveryStamp::class);
        $retryCount = $redeliveryStamp instanceof RedeliveryStamp
            ? $redeliveryStamp->getRetryCount()
            : 0;

        return in_array($retryCount, $this->logOnRetries, true);
    }
}

```

--------------------------------

### Enable Sentry Monolog Adapter Bundle in AppKernel.php

Source: https://github.com/macpaw/sentry-monolog-adapter/blob/develop/README.md

Enables the Sentry Monolog Adapter bundle by adding it to the `registerBundles` method in the `app/AppKernel.php` file. This makes the bundle's services available to the application.

```php
<?php
// app/AppKernel.php

// ...
class AppKernel extends Kernel
{
    public function registerBundles()
    {
        $bundles = array(
            // ...
            SentryMonologAdapter\SentryMonologAdapterBundle::class => ['all' => true],
        );

        // ...
    }

    // ...
}

```

--------------------------------

### Custom Logging Strategy Configuration (YAML)

Source: https://context7.com/macpaw/sentry-monolog-adapter/llms.txt

Configuration for a custom logging strategy. This YAML demonstrates how to register a custom strategy (ExponentialLoggingStrategy) as a service and then use it within the messenger_logging_middleware configuration.

```yaml
# Register custom strategy
services:
    App\Messenger\LoggingStrategy\ExponentialLoggingStrategy:
        tags: ['sentry_monolog_adapter.logging_strategy']

# Use in configuration
sentry_monolog_adapter:
    messenger_logging_middleware:
        logging_strategies:
            - id: App\Messenger\LoggingStrategy\ExponentialLoggingStrategy

```

--------------------------------

### Configure Sentry Monolog Adapter Messenger Logging Strategies

Source: https://github.com/macpaw/sentry-monolog-adapter/blob/develop/README.md

Configures the Messenger logging strategies for the Sentry Monolog Adapter in `config/packages/sentry_monolog_adapter.yaml`. This allows customization of when and how messages are logged.

```yaml
sentry_monolog_adapter:
    messenger_logging_middleware:
        logging_strategies: // array of logging strategies
            - id: sentry_monolog_adapter.log_after_position_strategy
              options:
                  position: 3
            - id: sentry_monolog_adapter.log_all_failed_strategy


```

--------------------------------

### Register and Configure Custom Sentry Monolog Processor (YAML)

Source: https://context7.com/macpaw/sentry-monolog-adapter/llms.txt

This YAML configuration demonstrates how to register the custom UserContextProcessor as a service and then include it in the Sentry Monolog adapter's handler configuration. This ensures that the processor is active for Sentry logging.

```yaml
# Register custom processor
services:
    App\Processor\UserContextProcessor:
        public: true

# Add to configuration
sentry_monolog_adapter:
    monolog_handler_decorator:
        processors:
            - sentry_monolog_adapter.exception_processor
            - App\Processor\UserContextProcessor

```

--------------------------------

### Configure Monolog Handler for Sentry

Source: https://github.com/macpaw/sentry-monolog-adapter/blob/develop/README.md

Configures Monolog to use the Sentry Monolog Adapter's handler in `config/packages/monolog.yaml`. This directs Monolog output to the Sentry handler for error reporting.

```yaml
monolog:
    handlers:
        # ... other handlers
        sentry:
            type: service
            id: sentry_monolog_adapter.monolog_handler_decorator

```

--------------------------------

### Configure Sentry Monolog Adapter Exception Processors

Source: https://github.com/macpaw/sentry-monolog-adapter/blob/develop/README.md

Configures additional processors for the Sentry Monolog Adapter in `config/packages/sentry_monolog_adapter.yaml`. This allows custom preprocessors to add parameters to Sentry events.

```yaml
sentry_monolog_adapter:
    monolog_handler_decorator:
        processors:
            - sentry_monolog_adapter.exception_processor

```

--------------------------------

### Enable Sentry Monolog Adapter Bundle in Symfony

Source: https://context7.com/macpaw/sentry-monolog-adapter/llms.txt

This PHP code snippet demonstrates how to enable the SentryMonologAdapterBundle within your Symfony application's configuration. It should be added to the `config/bundles.php` file.

```php
<?php
// config/bundles.php

return [
    // ... other bundles
    SentryMonologAdapter\SentryMonologAdapterBundle::class => ['all' => true],
];
```

--------------------------------

### Combine Multiple Logging Strategies for Messenger (YAML)

Source: https://context7.com/macpaw/sentry-monolog-adapter/llms.txt

This YAML configuration showcases how to combine multiple logging strategies for Symfony Messenger, including logging the first few attempts, throttling subsequent attempts, and always logging if a message fails. This intelligent logging prevents excessive log entries during retries.

```yaml
# Intelligent logging: log first few attempts, then throttle
sentry_monolog_adapter:
    messenger_logging_middleware:
        logging_strategies:
            # Log first 3 attempts
            - id: sentry_monolog_adapter.log_before_position_strategy
              options:
                  position: 3
            # Then log every 5th attempt
            - id: sentry_monolog_adapter.arithmetic_progression_strategy
              options:
                  step: 5
            # Always log if message is sent to failure transport
            - id: sentry_monolog_adapter.log_all_failed_strategy

```

--------------------------------

### Configure Messenger Middleware for Sentry Monolog Adapter

Source: https://github.com/macpaw/sentry-monolog-adapter/blob/develop/README.md

Adds the Sentry Monolog Adapter's messenger logging middleware to the Messenger configuration in `config/packages/messenger.yaml`. This enables the adapter to process messages within the Messenger component.

```yaml
framework:
    messenger:
        routing:
            # ...
        middleware:
            - sentry_monolog_adapter.messenger_logging_middleware
            # ...

```

--------------------------------

### LogAllFailedStrategy YAML Usage

Source: https://context7.com/macpaw/sentry-monolog-adapter/llms.txt

This YAML snippet shows how to configure the `LogAllFailedStrategy` within the `sentry_monolog_adapter` configuration. It enables the strategy by its defined ID.

```yaml
# Usage in configuration
sentry_monolog_adapter:
    messenger_logging_middleware:
        logging_strategies:
            - id: sentry_monolog_adapter.log_all_failed_strategy
```

--------------------------------

### LogAfterPositionStrategy PHP Implementation

Source: https://context7.com/macpaw/sentry-monolog-adapter/llms.txt

This PHP class extends `RetryCountDependentStrategy` and implements a logging strategy that logs messages only after they have been retried a specific number of times. The `position` option determines the minimum retry count.

```php
<?php

namespace SentryMonologAdapter\Messenger\LoggingStrategy;

use Symfony\Component\Messenger\Envelope;

class LogAfterPositionStrategy extends RetryCountDependentStrategy
{
    private int $position;

    public function __construct(int $position)
    {
        $this->position = $position;
    }

    public function willLog(Envelope $envelope): bool
    {
        return $this->getRetryCount($envelope) >= $this->position;
    }
}
```

--------------------------------

### Log All Attempts Logging Strategy (PHP)

Source: https://context7.com/macpaw/sentry-monolog-adapter/llms.txt

A simple logging strategy that logs every message attempt, regardless of the retry count. This is achieved by always returning true from the willLog method, ensuring all failures are logged.

```php
<?php

namespace SentryMonologAdapter\Messenger\LoggingStrategy;

use Symfony\Component\Messenger\Envelope;

class LogAllStrategy implements LoggingStrategyInterface
{
    public function willLog(Envelope $envelope): bool
    {
        return true;
    }
}

```

--------------------------------

### Messenger Middleware Configuration for Sentry Logging

Source: https://context7.com/macpaw/sentry-monolog-adapter/llms.txt

This YAML configuration integrates the Sentry Monolog Adapter's messenger logging middleware into the Symfony Messenger system. It ensures that the middleware is active and placed appropriately within the middleware chain, especially after retry strategies.

```yaml
# config/packages/messenger.yaml
framework:
    messenger:
        default_bus: messenger.bus.default
        buses:
            messenger.bus.default:
                middleware:
                    - validation
                    - doctrine_transaction
                    # Add after retry middleware to track retry counts
                    - sentry_monolog_adapter.messenger_logging_middleware
        transports:
            async:
                dsn: '%env(MESSENGER_TRANSPORT_DSN)%' # Ensure this environment variable is set
                retry_strategy:
                    max_retries: 10
                    delay: 1000
                    multiplier: 2
```

--------------------------------

### Monolog Handler Configuration for Sentry

Source: https://context7.com/macpaw/sentry-monolog-adapter/llms.txt

This YAML configuration snippet sets up the Monolog handler to use the Sentry Monolog Adapter's decorator service. It specifies the service ID and the minimum logging level for messages to be processed.

```yaml
# config/packages/monolog.yaml
monolog:
    handlers:
        sentry:
            type: service
            id: sentry_monolog_adapter.monolog_handler_decorator
            level: error
```

--------------------------------

### Messenger Logging Middleware Core Logic (PHP)

Source: https://context7.com/macpaw/sentry-monolog-adapter/llms.txt

The core middleware for logging in Symfony Messenger. It catches exceptions, checks configured logging strategies, logs errors using PSR-3 logger and Sentry Hub, and flushes the Sentry client. Dependencies include PSR-3 Logger and Sentry Hub.

```php
<?php

namespace SentryMonologAdapter\Messenger\Middleware;

use Psr\Log\LoggerInterface;
use Sentry\State\HubInterface;
use SentryMonologAdapter\Messenger\LoggingStrategy\LoggingStrategyInterface;
use Symfony\Component\Messenger\Envelope;
use Symfony\Component\Messenger\Exception\HandlerFailedException;
use Symfony\Component\Messenger\Middleware\MiddlewareInterface;
use Symfony\Component\Messenger\Middleware\StackInterface;

class MessengerLoggingMiddleware implements MiddlewareInterface
{
    private HubInterface $hub;
    private LoggerInterface $logger;
    private array $loggingStrategies = [];

    public function __construct(HubInterface $hub, LoggerInterface $logger)
    {
        $this->hub = $hub;
        $this->logger = $logger;
    }

    public function addLoggingStrategy(LoggingStrategyInterface $loggingStrategy): void
    {
        $this->loggingStrategies[] = $loggingStrategy;
    }

    public function handle(Envelope $envelope, StackInterface $stack): Envelope
    {
        try {
            return $stack->next()->handle($envelope, $stack);
        } catch (\Throwable $exception) {
            $this->logToSentry($exception);
            throw $exception;
        }
    }

    private function logToSentry(\Throwable $exception): void
    {
        if (!($exception instanceof HandlerFailedException)) {
            return;
        }

        foreach ($this->loggingStrategies as $loggingStrategy) {
            if ($loggingStrategy->willLog($exception->getEnvelope())) {
                $this->logger->error(get_class($exception), [
                    'exception' => $exception,
                ]);

                $client = $this->hub->getClient();
                if ($client instanceof \Sentry\ClientInterface) {
                    $client->flush();
                }
                return;
            }
        }
    }
}

```

--------------------------------

### LogAllFailedStrategy PHP Implementation

Source: https://context7.com/macpaw/sentry-monolog-adapter/llms.txt

This PHP class implements the `LoggingStrategyInterface` to log only messages that have been sent to a failure transport. It checks for the presence of the `SentToFailureTransportStamp` on the message envelope.

```php
<?php

namespace SentryMonologAdapter\Messenger\LoggingStrategy;

use Symfony\Component\Messenger\Envelope;
use Symfony\Component\Messenger\Stamp\SentToFailureTransportStamp;

class LogAllFailedStrategy implements LoggingStrategyInterface
{
    public function willLog(Envelope $envelope): bool
    {
        return $envelope->last(SentToFailureTransportStamp::class) instanceof SentToFailureTransportStamp;
    }
}
```

--------------------------------

### Arithmetic Progression Logging Strategy (PHP)

Source: https://context7.com/macpaw/sentry-monolog-adapter/llms.txt

Implements a logging strategy that logs messages at regular retry intervals. It uses a step value to determine when to log, ensuring logs occur at intervals like every 3rd attempt. This strategy extends RetryCountDependentStrategy.

```php
<?php

namespace SentryMonologAdapter\Messenger\LoggingStrategy;

use Symfony\Component\Messenger\Envelope;

class ArithmeticProgressionStrategy extends RetryCountDependentStrategy
{
    private int $step;

    public function __construct(int $step)
    {
        $this->step = $step;
    }

    public function willLog(Envelope $envelope): bool
    {
        return $this->getRetryCount($envelope) % $this->step === 0;
    }
}

```

--------------------------------

### ExceptionProcessor - Automatic Exception Context Extraction in PHP

Source: https://context7.com/macpaw/sentry-monolog-adapter/llms.txt

The ExceptionProcessor is a Monolog processor that automatically extracts message and parameter data from Throwable objects present in the log record's context. If an exception has a getParameters() method, its return value is merged into the 'extra' context of the log record. This requires Monolog and standard PHP Throwable interface.

```php
<?php

namespace SentryMonologAdapter\Processor;

class ExceptionProcessor
{
    public function __invoke(array $record): array
    {
        if (
            array_key_exists('context', $record) === false
            || array_key_exists('exception', $record['context']) === false
            || !($record['context']['exception'] instanceof \Throwable)
        ) {
            return $record;
        }

        $exception = $record['context']['exception'];
        $record['message'] = $exception->getMessage();

        // If exception has getParameters() method, add as extra data
        if (method_exists($exception, 'getParameters')) {
            if (!array_key_exists('extra', $record['context'])) {
                $record['context']['extra'] = [];
            }

            $record['context']['extra'] = array_merge(
                $record['context']['extra'],
                $exception->getParameters()
            );
        }

        return $record;
    }
}

```

```php
<?php

// Custom exception with parameters
namespace App\Exception;

class PaymentException extends \RuntimeException
{
    private array $parameters;

    public function __construct(string $message, array $parameters = [])
    {
        parent::__construct($message);
        $this->parameters = $parameters;
    }

    public function getParameters(): array
    {
        return $this->parameters;
    }
}

// Usage
namespace App\Service;

use App\Exception\PaymentException;
use Psr\Log\LoggerInterface;

class OrderService
{
    public function __construct(private LoggerInterface $logger)
    {
    }

    public function createOrder(array $orderData): void
    {
        try {
            throw new PaymentException('Insufficient funds', [
                'user_id' => $orderData['user_id'],
                'required_amount' => 100.00,
                'available_balance' => 50.00,
                'currency' => 'USD',
            ]);
        } catch (PaymentException $e) {
            // ExceptionProcessor will automatically extract parameters
            // and add them to Sentry as extra data
            $this->logger->error('Order creation failed', [
                'exception' => $e,
            ]);

            throw $e;
        }
    }
}

```

--------------------------------

### Implement User Context Processor for Sentry Logs (PHP)

Source: https://context7.com/macpaw/sentry-monolog-adapter/llms.txt

This PHP code defines a custom Monolog processor that adds user context information (user ID) to Sentry logs. It allows dynamically setting the current user ID, which is then injected into the 'extra' and 'tags' fields of the log record.

```php
<?php

namespace App\Processor;

class UserContextProcessor
{
    private ?string $currentUserId = null;

    public function setCurrentUser(?string $userId): void
    {
        $this->currentUserId = $userId;
    }

    public function __invoke(array $record): array
    {
        if ($this->currentUserId !== null) {
            if (!isset($record['context']['extra'])) {
                $record['context']['extra'] = [];
            }

            $record['context']['extra']['user_id'] = $this->currentUserId;
            $record['context']['tags']['user'] = $this->currentUserId;
        }

        return $record;
    }
}

```

--------------------------------

### Implement Message-Specific Logging Strategy (PHP)

Source: https://context7.com/macpaw/sentry-monolog-adapter/llms.txt

This PHP code defines a custom logging strategy for Symfony Messenger that determines whether to log a message based on its type and retry count. It prioritizes logging critical messages and applies a retry threshold for others, reducing log volume.

```php
<?php

namespace App\Messenger\LoggingStrategy;

use App\Message\CriticalMessage;
use SentryMonologAdapter\Messenger\LoggingStrategy\LoggingStrategyInterface;
use Symfony\Component\Messenger\Envelope;

class MessageTypeStrategy implements LoggingStrategyInterface
{
    public function willLog(Envelope $envelope): bool
    {
        $message = $envelope->getMessage();

        // Always log critical messages, throttle others
        if ($message instanceof CriticalMessage) {
            return true;
        }

        // For other messages, only log after 5 retries
        $redeliveryStamp = $envelope->last(\Symfony\Component\Messenger\Stamp\RedeliveryStamp::class);
        $retryCount = $redeliveryStamp instanceof \Symfony\Component\Messenger\Stamp\RedeliveryStamp
            ? $redeliveryStamp->getRetryCount()
            : 0;

        return $retryCount >= 5;
    }
}

```

--------------------------------

### MonologHandlerDecorator - Enrich Logs with Context in PHP

Source: https://context7.com/macpaw/sentry-monolog-adapter/llms.txt

The MonologHandlerDecorator wraps a Sentry Monolog handler to enrich Sentry events with custom 'extra' data and 'tags' found in the Monolog log record's context. It uses the Sentry Hub to set these on the current scope before the Sentry handler processes the record. This requires the Monolog and Sentry SDKs.

```php
<?php

namespace SentryMonologAdapter\Monolog\Handler;

use Monolog\Handler\AbstractProcessingHandler;
use Monolog\LogRecord;
use Sentry\Monolog\Handler;
use Sentry\State\HubInterface;
use Sentry\State\Scope;

class MonologHandlerDecorator extends AbstractProcessingHandler
{
    private Handler $sentryHandler;
    private HubInterface $hub;

    public function __construct(HubInterface $hub, Handler $sentryHandler)
    {
        $this->sentryHandler = $sentryHandler;
        $this->hub = $hub;
        parent::__construct();
    }

    protected function write(LogRecord $record): void
    {
        $this->hub->withScope(function (Scope $scope) use ($record): void {
            $context = $record->context;

            // Add extra data to Sentry scope
            if (isset($context['extra']) && \is_array($context['extra'])) {
                foreach ($context['extra'] as $key => $value) {
                    $scope->setExtra((string) $key, $value);
                }
            }

            // Add tags to Sentry scope
            if (isset($context['tags']) && \is_array($context['tags'])) {
                foreach ($context['tags'] as $key => $value) {
                    $scope->setTag($key, $value);
                }
            }

            $this->sentryHandler->handle($record);
        });
    }
}

```

```php
<?php

// Example usage in application code
namespace App\Service;

use Psr\Log\LoggerInterface;

class PaymentService
{
    public function __construct(private LoggerInterface $logger)
    {
    }

    public function processPayment(string $orderId, float $amount): void
    {
        try {
            // Payment processing logic
            throw new \RuntimeException('Payment gateway timeout');
        } catch (\Exception $e) {
            // This will be enriched with extra data and tags in Sentry
            $this->logger->error('Payment processing failed', [
                'exception' => $e,
                'extra' => [
                    'order_id' => $orderId,
                    'amount' => $amount,
                    'gateway' => 'stripe',
                    'attempt_time' => time(),
                ],
                'tags' => [
                    'payment_method' => 'credit_card',
                    'environment' => 'production',
                    'service' => 'payment',
                ],
            ]);

            throw $e;
        }
    }
}

```
Tokens:
Raw