critical example

&& !\in_array($last->getCode(), [
                        Enlight_Controller_Exception::ActionNotFound,
                        Enlight_Controller_Exception::Controller_Dispatcher_Controller_Not_Found,
                        Enlight_Controller_Exception::Controller_Dispatcher_Controller_No_Route,
                        Enlight_Controller_Exception::NO_ROUTE,
                    ], true)
                    && !\in_array(\get_class($last), $this->ignoredExceptionClasses, true) // Check for exceptions to be ignored                 ) {
                    if ($last instanceof CSRFTokenValidationException || $this->isBotSession($request)) {
                        $this->logger->warning($last->getMessage());
                    } else {
                        $this->logger->critical($last->getMessage());
                    }
                }
            }

            return;
        }

        if (!$response->isException()) {
            return;
        }

        

        $classes = [];

        foreach ($serialized as $className => $arguments) {
            $className = explode('|', $className);
            /** @var class-string<ConditionInterface|SortingInterface|FacetInterface> $className */
            $className = $className[0];

            try {
                $classes[] = $this->reflector->createInstanceFromNamedArguments($className, $arguments);
            } catch (Exception $e) {
                $this->logger->critical($errorSource . ': ' . $e->getMessage());
            }
        }

        return $classes;
    }
}

try {
        // All changes done to the views here can be trusted and this might be         // called during updates, when it is not safe to rely on configuration         // containing valid schema. Trust the data and disable schema validation         // and casting.         $view->trustData()->save();
      }
      catch (\Exception $e) {
        // In case the view could not be saved, log an error message that the         // view needs to be updated manually instead of failing the entire         // entity update process.         $this->logger->critical("The %view_id view could not be updated automatically while processing an entity schema update for the %entity_type_id entity type.", [
          '%view_id' => $view->id(),
          '%entity_type_id' => $entity_type->id(),
        ]);
      }
    }
    $this->viewsToSave = [];
  }

  /** * {@inheritdoc} */
  

private readonly bool $throwException,
        private readonly Client $client,
        private readonly ElasticsearchRegistry $registry,
        private readonly CriteriaParser $parser,
        private readonly LoggerInterface $logger,
        private readonly AbstractKeyValueStorage $keyValueStorage
    ) {
    }

    public function logAndThrowException(\Throwable $exception): bool
    {
        $this->logger->critical($exception->getMessage());

        if ($this->environment === 'test' || $this->throwException) {
            throw $exception;
        }

        return false;
    }

    /** * Created the index alias * * @deprecated tag:v6.6.0 - reason:new-optional-parameter - Parameter $languageId will be removed. */

        $handler = new TestHandler();
        $processor = new DebugProcessor();
        $logger = new Logger(__METHOD__, [$handler], [$processor]);

        $logger->debug('test message');
        $logger->info('test message');
        $logger->notice('test message');
        $logger->warning('test message');

        $logger->error('test message');
        $logger->critical('test message');
        $logger->alert('test message');
        $logger->emergency('test message');

        $this->assertSame(4, $logger->countErrors());
    }

    public function testGetLogsWithDebugProcessor2()
    {
        $handler = new TestHandler();
        $logger = new Logger('test', [$handler]);
        $logger->pushProcessor(new DebugProcessor());

        

    public function onConsoleError(ConsoleErrorEvent $event)
    {
        if (null === $this->logger) {
            return;
        }

        $error = $event->getError();

        if (!$inputString = $this->getInputString($event)) {
            $this->logger->critical('An error occurred while using the console. Message: "{message}"', ['exception' => $error, 'message' => $error->getMessage()]);

            return;
        }

        $this->logger->critical('Error thrown while running command "{command}". Message: "{message}"', ['exception' => $error, 'command' => $inputString, 'message' => $error->getMessage()]);
    }

    /** * @return void */
    public function onConsoleTerminate(ConsoleTerminateEvent $event)
    {

$this->logger?->warning('Error thrown while handling message {class}. Sending for retry #{retryCount} using {delay} ms delay. Error: "{error}"', $context + ['retryCount' => $retryCount, 'delay' => $delay, 'error' => $throwable->getMessage(), 'exception' => $throwable]);

            // add the delay and retry stamp info             $retryEnvelope = $this->withLimitedHistory($envelope, new DelayStamp($delay), new RedeliveryStamp($retryCount));

            // re-send the message for retry             $this->getSenderForTransport($event->getReceiverName())->send($retryEnvelope);

            $this->eventDispatcher?->dispatch(new WorkerMessageRetriedEvent($retryEnvelope, $event->getReceiverName()));
        } else {
            $this->logger?->critical('Error thrown while handling message {class}. Removing from transport after {retryCount} retries. Error: "{error}"', $context + ['retryCount' => $retryCount, 'error' => $throwable->getMessage(), 'exception' => $throwable]);
        }
    }

    /** * Adds stamps to the envelope by keeping only the First + Last N stamps. */
    private function withLimitedHistory(Envelope $envelope, StampInterface ...$stamps): Envelope
    {
        foreach ($stamps as $stamp) {
            $history = $envelope->all($stamp::class);
            if (\count($history) < $this->historySize) {
                

$this->logger->warning('Crazy context data', $context);

        $expected = ['[warning] Crazy context data'];
        $this->assertLogsMatch($expected, $this->getLogs());
    }

    public function testContextExceptionKeyCanBeExceptionOrOtherValues()
    {
        $logger = $this->logger;
        $logger->warning('Random message', ['exception' => 'oops']);
        $logger->critical('Uncaught Exception!', ['exception' => new \LogicException('Fail')]);

        $expected = [
            '[warning] Random message',
            '[critical] Uncaught Exception!',
        ];
        $this->assertLogsMatch($expected, $this->getLogs());
    }

    public function testFormatter()
    {
        $this->logger = new Logger(LogLevel::DEBUG, $this->tmpFile, fn ($level, $message, $context) => json_encode(['level' => $level, 'message' => $message, 'context' => $context]));

        

    public function onConsoleError(ConsoleErrorEvent $event)
    {
        if (null === $this->logger) {
            return;
        }

        $error = $event->getError();

        if (!$inputString = $this->getInputString($event)) {
            $this->logger->critical('An error occurred while using the console. Message: "{message}"', ['exception' => $error, 'message' => $error->getMessage()]);

            return;
        }

        $this->logger->critical('Error thrown while running command "{command}". Message: "{message}"', ['exception' => $error, 'command' => $inputString, 'message' => $error->getMessage()]);
    }

    /** * @return void */
    public function onConsoleTerminate(ConsoleTerminateEvent $event)
    {

$this->getLogger()->warning('Crazy context data', $context);

        $expected = ['warning Crazy context data'];
        $this->assertEquals($expected, $this->getLogs());
    }

    public function testContextExceptionKeyCanBeExceptionOrOtherValues()
    {
        $logger = $this->getLogger();
        $logger->warning('Random message', ['exception' => 'oops']);
        $logger->critical('Uncaught Exception!', ['exception' => new \LogicException('Fail')]);

        $expected = [
            'warning Random message',
            'critical Uncaught Exception!',
        ];
        $this->assertEquals($expected, $this->getLogs());
    }
}

class DummyTest
{