Remote Logger Bundle Laravel Package

Getting Started

Minimal Setup

1. Install the Package

   composer require avtonom/remote-logger-bundle ~1.1
   

   Replace ~1.1 with the latest version from GitHub Releases.

2. Register the Bundle Add to config/bundles.php (Symfony 4+):

   Avtonom\RemoteLoggerBundle\AvtonomRemoteLoggerBundle::class => ['all' => true],
   

   For Symfony 3.x, add to app/AppKernel.php:

   new Avtonom\RemoteLoggerBundle\AvtonomRemoteLoggerBundle(),
   

3. Configure Parameters Define required parameters in .env or config/packages/parameters.yaml:

   parameters:
       avtonom_remote_logger.token: "your_api_token_here"
       avtonom_remote_logger.remote_host: "logs.yourdomain.com"
       avtonom_remote_logger.use_ssl: true
   

4. Enable Monolog Handler Add to config/packages/monolog.yaml:

   monolog:
       handlers:
           avtonom_remote_logger:
               type: service
               id: avtonom_remote_logger.monolog.handler
               channels: ["!event"]
               level: debug
   

5. First Use Case Log a test message in a controller:

   use Psr\Log\LoggerInterface;
   
   class TestController extends AbstractController
   {
       public function test(LoggerInterface $logger)
       {
           $logger->debug('Test log message for remote storage');
           return new Response('Logged!');
       }
   }
   

Implementation Patterns

Core Workflow

1. Log Integration Inject LoggerInterface into services/controllers and use standard Monolog methods (debug, error, etc.).

   $logger->info('User action', ['user_id' => 123]);
   

2. Environment-Specific Config Use monolog.yaml to toggle buffering in dev:

   # config/packages/monolog.yaml (dev)
   monolog:
       handlers:
           avtonom_remote_logger_buffered:
               type: buffer
               handler: avtonom_remote_logger
               buffer_size: 10  # Max 10 logs before flush
               level: debug
   

3. Contextual Logging Leverage parameters for metadata:

   parameters:
       avtonom_remote_logger.service: "mobile_app_v1"
       avtonom_remote_logger.appname: "cron_job"
   

   This auto-tags logs for filtering on the remote server.

4. Error Handling Catch Monolog\Handler\HandlerInterface exceptions and retry:

   try {
       $logger->error('Critical failure', ['trace' => $e->getTraceAsString()]);
   } catch (\Exception $e) {
       // Fallback to file/logger
   }
   

Advanced Patterns

• Dynamic Token Rotation Override the service to fetch tokens from a secure source:

  services:
      avtonom_remote_logger.monolog.handler:
          arguments:
              $token: '@security.token_fetcher'
  

• Log Level Filtering Use level to exclude verbose logs in production:

  # prod monolog.yaml
  avtonom_remote_logger:
      level: warning
  

• Custom Metadata Extend the handler to add request IDs:

  $logger->withContext(['request_id' => $request->get('X-Request-ID')])->debug('...');
  

Gotchas and Tips

Pitfalls

1. Buffering Quirks

   • Issue: Logs may vanish if writing_timeout (default: 10s) expires before flush.
   • Fix: Increase buffer_size or reduce writing_timeout for critical apps.

     buffer_size: 5
     writing_timeout: 5
     

2. SSL Misconfigurations

   • Issue: use_ssl: true may fail silently if the remote host lacks a valid certificate.
   • Fix: Test with use_ssl: false first, then debug SSL errors.

3. Token Exposure

   • Risk: Hardcoded tokens in parameters.yaml are visible in var/cache.
   • Fix: Use environment variables or Symfony’s ParameterBag with encryption.

4. Symfony Version Mismatch

   • Issue: The bundle targets Symfony 2.3–3.x. For Symfony 5/6, expect compatibility gaps.
   • Workaround: Fork and update composer.json dependencies.

Debugging Tips

• Check Remote Server Verify the remote endpoint accepts logs via curl:

  curl -X POST https://logs.yourdomain.com/api \
       -H "X-Auth-Token: your_token" \
       -d '{"message":"test","level":1}'
  

• Log Local Fallback Add a fallback handler to monolog.yaml:

  handlers:
      main:
          type: stream
          path: "%kernel.logs_dir%/%kernel.environment%.log"
          level: debug
      avtonom_remote_logger: ...
  

• Buffer Overflow Monitor buffer_size vs. log volume. Use monolog.logger.avtonom_remote_logger.buffer events to log overflows.

Extension Points

1. Custom Handler Extend Avtonom\RemoteLoggerBundle\Handler\RemoteLoggerHandler to add:

   • Pre-log processing (e.g., PII redaction).
   • Post-log actions (e.g., triggering alerts).

2. Async Logging Use Symfony’s Messenger component to queue logs:

   services:
       avtonom_remote_logger.monolog.handler:
           arguments:
               $dispatcher: '@messenger.default_bus'
   

3. Log Retention Implement a LogCleaner command to purge old logs from the remote server via the same API.

Configuration Quirks

• Default Values Unset parameters use defaults (e.g., level: 100 = DEBUG). Explicitly set critical values like token and remote_host.

• Channel Whitelisting The channels: ~ config includes all channels except those explicitly excluded (e.g., ["!event"]). Use channels: ["debug", "info"] for strict filtering.

• Environment Variables Prefer .env for sensitive data:

  parameters:
      avtonom_remote_logger.token: "%env(AVTONOM_LOGGER_TOKEN)%"