Logging är hjärtat av en produktionsapplikation. I de tidiga dagarna av ett projekt, en enkel svans är tillräckligt. men när din Symfony-applikation skalar för att hantera och och , "skrivning till en fil" blir ett ansvar snarare än en tillgång. dev.log payments asynchronous workers high-concurrency traffic den erbjuder sofistikerade verktyg för att omvandla loggar från enkla textflöden till strukturerade, åtgärdbara observationsdata. symfony/monolog-bundle Denna guide utforskar 10 avancerade loggning mönster som går utöver standard. Vi kommer att använda strikt skrivning, PHP attribut, och modern YAML konfiguration. Förutsättningar 
 
 
 
 
 
 Symfoni: 7,4 + För PHP: 8.3+ Symfoni / Monologbund Monolog och monolog symfoni/notifier (för att varna exempel) Scenario 1: Den ”svarta lådan” inspelare: FingersCrossed Handler Du vill ha detaljerade felsökningsloggar när ett fel inträffar för att förstå sekvensen av händelser som leder till det, men du har inte råd med disk I/O för att logga felsökningsmeddelanden för varje framgångsrik förfrågan i produktion. den buffertar alla loggar i minnet under begäran. Om begäran avslutas framgångsrikt tas buffern bort. Om ett fel (eller en viss tröskel) uppnås spolas hela buffern (inklusive tidigare debuggloggar) till persistenshanteraren. FingersCrossedHandler Konfiguration config/packages/prod/monolog.yaml är följande: monolog:
    handlers:
        main:
            type: fingers_crossed
            # The strategy: "error" means if an ERROR occurs, dump everything.
            action_level: error
            # Where to dump the logs if the threshold is met
            handler: nested
            # Optional: Keep a small buffer size to prevent memory leaks in long processes
            buffer_size: 50
        nested:
            type: stream
            path: "%kernel.logs_dir%/%kernel.environment%.log"
            level: debug
 Du får den rättsmedicinska detaljerna av debug-nivå loggning exakt när du behöver det - under en krasch - utan att fylla din skiva med buller under normala operationer. Scenario 2: Segregerade kanaler: ”Payment” loggen Din är en blandning av doktrinfrågor, routermatchning och kritisk affärslogik. Du behöver en dedikerad fil för finansiella transaktioner som kan granskas separat. app.log Skapa en monologskanal. Konfiguration config/packages/monolog.yaml är följande: monolog:
    channels: ['payment'] # Register the channel

    handlers:
        payment:
            type: stream
            path: "%kernel.logs_dir%/payment.log"
            level: info
            channels: ["payment"] # Only listen to this channel
        
        main:
            type: stream
            path: "%kernel.logs_dir%/%kernel.environment%.log"
            level: debug
            channels: ["!payment"] # Exclude payment logs from the main file
 genomförandet Injicera loggen specifikt för den här kanalen med hjälp av Target-attributet (tillgängligt sedan Symfony 5.3+). namespace App\Command;

use Psr\Log\LoggerInterface;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\DependencyInjection\Attribute\Target;

#[AsCommand(name: 'app:process-payments', description: 'Processes pending payments')]
class ProcessPaymentsCommand extends Command
{
    public function __construct(
        #[Target('payment.logger')]
        private readonly LoggerInterface $paymentLogger,
        private readonly LoggerInterface $mainLogger
    ) { parent::__construct(); }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $this->mainLogger->info('Cron job app:process-payments started.');

        $amounts = [10.50, 99.99, 45.00];
        foreach ($amounts as $amount) {
            $this->paymentLogger->info('Processing payment', ['amount' => $amount, 'status' => 'success']);
        }

        $this->mainLogger->info('Cron job finished.');
        return Command::SUCCESS;
    }
}
 Kör kommandot. du kommer att se Skapad i Innehåller endast dessa specifika poster. payment.log var/log/ Scenario 3: Kontextberikande: Attributet #[AsMonologProcessor] Loggar är värdelösa om du inte kan korrelera dem med en viss användare eller begäran ID. Du hittar dig själv manuellt lägga till [‘user_id’ => $user->getId()] till varje enskild logg uttalande. En global processor kan automatiskt injicera kontext i varje loggpost. genomförandet namespace App\Log;

use Monolog\Attribute\AsMonologProcessor;
use Monolog\LogRecord;

#[AsMonologProcessor]
class RequestContextProcessor
{
    public function __invoke(LogRecord $record): LogRecord
    {
        // Simulated context since CLI commands don't have HTTP Requests
        $extra = [
            'pid' => getmypid(),
            'user' => get_current_user(),
        ];

        return $record->with(extra: array_merge($record->extra, $extra));
    }
}
 i och Vi använder att returnera en modifierad kopia. Monolog 3 LogRecord is immutable with() Scenario 4: GDPR-överensstämmelse: Redigering av känsliga data En utvecklare loggar av misstag ett användarobjekt, dumpar PII (Personligt identifierbar information) eller kreditkortsnummer i loggarna, vilket bryter mot GDPR/PCI-DSS. En specialiserad processor kan skanna sammanhanget och maskera känsliga nycklar. genomförandet 
namespace App\Log;

use Monolog\Attribute\AsMonologProcessor;
use Monolog\LogRecord;

#[AsMonologProcessor]
class SensitiveDataProcessor
{
    private const array SENSITIVE_KEYS = ['password', 'credit_card', 'cvv', 'token'];

    public function __invoke(LogRecord $record): LogRecord
    {
        $context = $record->context;

        foreach ($context as $key => $value) {
            if (in_array($key, self::SENSITIVE_KEYS, true)) {
                $context[$key] = '***REDACTED***';
            }
        }

        return $record->with(context: $context);
    }
}
 För verifiering: $logger->info('User login', ['password' => 'secret123']);
// Output in log: "User login" {"password": "***REDACTED***"}
 Scenario 5: Strukturerad loggning: JSON för ELK/Datadog Parning av textloggar med flera rader (till exempel stackspår) i eller är smärtsamt. Regex parsers bryts lätt. Kibana Datadog Du kan utföra loggar som JSON-rader. Detta gör det möjligt för loggaggregatorer att nativt indexera fält som eller . context.order_id extra.req_id Konfiguration config/packages/monolog.yaml är följande: monolog:
    handlers:
        json_report:
            type: stream
            path: "%kernel.logs_dir%/app.json"
            level: info
            formatter: monolog.formatter.json
            channels: ["!payment", "!event"]
 Öppna Utgången ska se ut som: var/log/app.json {"message":"Order created","context":{"id":123},"level":200,"channel":"app","datetime":"..."}
 Scenario 6: Spamprevention: Deduplicationshanteraren Din databas går ner. Din ansökan får Din "Email on Error" -hanterare skickar dig Att få din . 5,000 requests 5,000 emails SMTP server blacklisted and flooding your inbox den kan aggregera identiska loggposter och skicka en enda sammanfattning. DeduplicationHandler Konfiguration config/packages/monolog.yaml är följande: monolog:
    handlers:
        deduplication:
            type: deduplication
            handler: nested_dedup
            buffer_size: 60
            time: 60
            level: error
            channels: ["!console"]
 Om DB kraschar får du lista alla förekomster, snarare än en e-post per begäran. one email every 60 seconds Scenario 7: Dynamiska loggnivåer (Runtime Debugging) Du kan inte reproducera det, och du kan inte byta hela produktionsservern till DEBUG-nivå på grund av prestandahoppet. Använd en ändra loggnivån dynamiskt baserat på en begäran header. ActivationStrategy genomförandet Skapa en custom strategi: 
namespace App\Command;

use Psr\Log\LoggerInterface;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

#[AsCommand(name: 'app:dynamic-debug', description: 'Tests dynamic log level activation')]
class DynamicDebugCommand extends Command
{
    public function __construct(private readonly LoggerInterface $logger) {
        parent::__construct();
    }

    protected function configure(): void
    {
        $this->addOption('force-debug', null, InputOption::VALUE_NONE, 'Force debug logging for this run');
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        if ($input->getOption('force-debug')) {
            $output->writeln('Debug mode forced via option. (Simulated, as Monolog ActivationStrategy relies on Http/Request state typically. But you can add processors/handlers dynamically in real apps based on this flag).');
        }

        $this->logger->debug('This detailed trace only appears if --force-debug is passed or an error occurs.');
        $this->logger->info('Standard processing information.');

        return Command::SUCCESS;
    }
}
 Scenario 8.Messenger Logging: Arbetarens sammanhang loggar från Du ser ”Hantera meddelande”, men du vet inte vilket meddelande-ID som orsakade felet eftersom arbetstagare körs som långvariga processer. messenger:consume Använd att injicera meddelande-ID i Monolog-kontexten specifikt för arbetsprocessen. Symfony’s EventListener genomförandet 
namespace App\EventListener;

use Psr\Log\LoggerInterface;
use Symfony\Component\EventDispatcher\Attribute\AsEventListener;
use Symfony\Component\Messenger\Event\WorkerMessageReceivedEvent;

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

    #[AsEventListener]
    public function onMessageHandling(WorkerMessageReceivedEvent $event): void
    {
        $this->logger->info('Worker started message', [
            'message_class' => $event->getEnvelope()->getMessage()::class,
        ]);
    }
}
 Scenario 9: Undanta 404s från felloggar Bots som skannar din webbplats för eller generera Dessa blockerar ditt felövervakningsverktyg (Sentry / Slack) med falska positiva. .env wp-login.php thousands of 404 NotFoundHttpException logs Använd kanalexklusionen eller en specifik konfiguration för att ignorera bounced loggar, eller bättre - konfigurera att ignoreras av huvudfelhanteraren. NotFoundHttpException Konfiguration config/packages/monolog.yaml är följande: monolog:
    handlers:
        fingers_crossed:
            type: fingers_crossed
            action_level: error
            handler: nested
            excluded_http_codes: [404, 405]
            buffer_size: 50
 Scenario 10: Anmälningsbron: ChatOps E-postmeddelanden är långsamma och ofta ignoreras.Du vill ha kritiska infrastrukturfel för att Kanalen omedelbart Slack Använd bryggt med . symfony/notifier Monolog Förutsättningar composer require symfony/notifier symfony/slack-notifier
 Konfiguration config/packages/monolog.yaml är följande: monolog:
    handlers:
        slack_alerts:
            type: service
            id: Symfony\Bridge\Monolog\Handler\NotifierHandler
            level: critical
 Konfigurera sedan notifier chatter i och din DSN i . config/packages/notifier.yaml .env framework:
    notifier:
        chatter_transports:
            slack: '%env(SLACK_DSN)%'
        texter_transports:
        channel_policy:
            urgent: ['chat/slack']
            high: ['chat/slack']
            medium: ['chat/slack']
            low: ['chat/slack']
        admin_recipients:
            - { email: admin@example.com }
 kartor logg nivåer till Notifier betydelse. En kritisk logg blir en . NotifierHandler High Priority Slack notification automatically Slutsats Loggning är inte en biprodukt av kod - det är en funktion i din infrastruktur. I en juniorutvecklares tankegång är loggning ett säkerhetsnät – något att bara kontrollera när saker går sönder. Men när du skalar till Senior- och Lead-roller måste ditt perspektiv förändras. Genom att flytta till Symfony 7.4 och utnyttja den fulla kraften i Monolog 3 övergår vi från "loggning" till "observabilitet". Förvandla dina loggar till en sökbar databas. Structured JSON Handlare löser ”signal-to-noise”-förhållandet, vilket sparar dig gigabyte lagringsutrymme samtidigt som du bevarar kritiskt sammanhang. FingersCrossed säkerställa att varje logginmatning bär DNA för begäran (användar-ID, begäran-ID) förvandla timmars debugging till minuter av verifiering. Processors Skyddar din inkorg och din hälsa. Deduplication Genomförandet av dessa mönster skiljer en bräcklig applikation från ett robust, företagsklass system.När din produktionsmiljö står inför en trafikspike eller ett tyst dataförstöringsproblem, kommer dessa konfigurationer att vara skillnaden mellan en stressig all-nighter och en snabb, exakt hotfix. Källkod: Du kan hitta hela genomförandet och följa projektets framsteg på GitHub: [ ] https://github.com/mattleads/MonologPatterns https://github.com/mattleads/MonologPatterns Låt oss ansluta! Om du hittade det här användbart eller har frågor om implementeringen, skulle jag gärna höra från dig. 
 
 
 
 
 Linkedin: [https://www.linkedin.com/in/matthew-mochalkin/] X (Twitter): [https://x.com/MattLeads] Hemsida för [https://t.me/MattLeads] GitHub: [https://github.com/mattleads] https://www.linkedin.com/in/matthew-mochalkin/ https://x.com/MattLeads https://t.me/MattLeads https://github.com/mattleads

Read My Stories

Det här ljudet är producerat på berättelsens originalspråk!

Symfony 7.4: 10 avancerade loggning mönster du borde veta om

About Author

KOMMENTARER

HÄNG TAGGAR

DENNA ARTIKEL PRESENTERAS I

Related Stories

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps