PHP Logger::popHandler方法代码示例

 public function work()
 {
     $identity = $this->identify();
     $this->logger->notice(sprintf('%s waiting for work on queue(s) [%s]', $identity, join(', ', $this->queues)));
     for (;;) {
         $job = $this->metro->pop($this->queues, $this);
         if (null !== $job) {
             $jobHandler = $this->metro->createTaskLogHander($job->getId());
             $this->logger->pushHandler($jobHandler);
             $this->logger->pushProcessor(function ($record) use($job) {
                 $record['extra']['job_id'] = $job->getId();
                 return $record;
             });
             $this->workOn($job, $jobHandler);
             $this->logger->popHandler();
             $this->logger->popProcessor();
         }
         if ($this->interval <= 0) {
             return;
         }
         if (null === $job) {
             if ($this->drainMode) {
                 $this->logger->notice(sprintf('%s exiting because all queues are empty', $identity));
                 return;
             }
             usleep($this->interval * 1000.0);
         }
     }
 }

 /**
  * The three arguments below are provided by:
  * @dataProvider provideMappedSeverities
  *
  */
 public function testNotifyGetsPassedCorrectlyMappedSeverity($monologLevel, $expectedSeverity)
 {
     // Update the tested handler to always send messages rather than just errors.
     $this->monolog->popHandler($this->testedHandler);
     $this->testedHandler = new BugsnagHandler($this->mockBugsnag->reveal(), Logger::DEBUG);
     $this->monolog->pushHandler($this->testedHandler);
     $errorMessage = "Oh no!";
     $this->mockBugsnag->notifyError($expectedSeverity, Argument::any(), Argument::any(), $expectedSeverity)->shouldBeCalledTimes(1);
     $this->monolog->log($monologLevel, $errorMessage);
 }

 /**
  * @covers Monolog\Logger::pushHandler
  * @covers Monolog\Logger::popHandler
  * @expectedException LogicException
  */
 public function testPushPopHandler()
 {
     $logger = new Logger(__METHOD__);
     $handler1 = new TestHandler();
     $handler2 = new TestHandler();
     $logger->pushHandler($handler1);
     $logger->pushHandler($handler2);
     $this->assertEquals($handler2, $logger->popHandler());
     $this->assertEquals($handler1, $logger->popHandler());
     $logger->popHandler();
 }

 /**
  * Start the worker.
  */
 public function startWorker()
 {
     $this->pheanstalk->watch($this->queue);
     $this->pheanstalk->ignore('default');
     $buildStore = Factory::getStore('Build');
     while ($this->run) {
         // Get a job from the queue:
         $job = $this->pheanstalk->reserve();
         $this->checkJobLimit();
         // Get the job data and run the job:
         $jobData = json_decode($job->getData(), true);
         if (!$this->verifyJob($job, $jobData)) {
             continue;
         }
         $this->logger->addInfo('Received build #' . $jobData['build_id'] . ' from Beanstalkd');
         // If the job comes with config data, reset our config and database connections
         // and then make sure we kill the worker afterwards:
         if (!empty($jobData['config'])) {
             $this->logger->addDebug('Using job-specific config.');
             $currentConfig = Config::getInstance()->getArray();
             $config = new Config($jobData['config']);
             Database::reset($config);
         }
         try {
             $build = BuildFactory::getBuildById($jobData['build_id']);
         } catch (\Exception $ex) {
             $this->logger->addWarning('Build #' . $jobData['build_id'] . ' does not exist in the database.');
             $this->pheanstalk->delete($job);
         }
         try {
             // Logging relevant to this build should be stored
             // against the build itself.
             $buildDbLog = new BuildDBLogHandler($build, Logger::INFO);
             $this->logger->pushHandler($buildDbLog);
             $builder = new Builder($build, $this->logger);
             $builder->execute();
             // After execution we no longer want to record the information
             // back to this specific build so the handler should be removed.
             $this->logger->popHandler($buildDbLog);
         } catch (\PDOException $ex) {
             // If we've caught a PDO Exception, it is probably not the fault of the build, but of a failed
             // connection or similar. Release the job and kill the worker.
             $this->run = false;
             $this->pheanstalk->release($job);
         } catch (\Exception $ex) {
             $build->setStatus(Build::STATUS_FAILED);
             $build->setFinished(new \DateTime());
             $build->setLog($build->getLog() . PHP_EOL . PHP_EOL . $ex->getMessage());
             $buildStore->save($build);
             $build->sendStatusPostback();
         }
         // Reset the config back to how it was prior to running this job:
         if (!empty($currentConfig)) {
             $config = new Config($currentConfig);
             Database::reset($config);
         }
         // Delete the job when we're done:
         $this->pheanstalk->delete($job);
     }
 }

 public function onPost()
 {
     parent::onPost();
     $commandClass = $this->getParameter('command');
     $parameters = $this->getBody();
     $parameters = !empty($parameters) ? $parameters : array();
     if (!empty($commandClass)) {
         $stream = fopen('php://memory', 'r+');
         $this->logger->pushHandler(new StreamHandler($stream, Logger::DEBUG));
         $this->executor->run(new ParameterParser\Map($commandClass, $parameters));
         $output = stream_get_contents($stream, -1, 0);
         $this->logger->popHandler();
         $this->setBody(array('output' => $output));
     } else {
         throw new \Exception('Command not available');
     }
 }

 public function assertDefaultHandlers(Logger $logger)
 {
     $handlers = array();
     do {
         try {
             $handlers[] = $handler = $logger->popHandler();
         } catch (\Exception $e) {
         }
     } while (!isset($e));
     $this->assertSame(array(), $handlers, 'There are more handlers defined than should be');
 }

 /**
  * Pulls all pending builds from the database and runs them.
  */
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->output = $output;
     // For verbose mode we want to output all informational and above
     // messages to the symphony output interface.
     if ($input->hasOption('verbose') && $input->getOption('verbose')) {
         $this->logger->pushHandler(new OutputLogHandler($this->output, Logger::INFO));
     }
     $running = $this->validateRunningBuilds();
     $this->logger->pushProcessor(new LoggedBuildContextTidier());
     $this->logger->addInfo(Lang::get('finding_builds'));
     $store = Factory::getStore('Build');
     $result = $store->getByStatus(0, $this->maxBuilds);
     $this->logger->addInfo(Lang::get('found_n_builds', count($result['items'])));
     $builds = 0;
     while (count($result['items'])) {
         $build = array_shift($result['items']);
         $build = BuildFactory::getBuild($build);
         // Skip build (for now) if there's already a build running in that project:
         if (!$this->isFromDaemon && in_array($build->getProjectId(), $running)) {
             $this->logger->addInfo(Lang::get('skipping_build', $build->getId()));
             $result['items'][] = $build;
             // Re-run build validator:
             $running = $this->validateRunningBuilds();
             continue;
         }
         $builds++;
         try {
             // Logging relevant to this build should be stored
             // against the build itself.
             $buildDbLog = new BuildDBLogHandler($build, Logger::INFO);
             $this->logger->pushHandler($buildDbLog);
             $builder = new Builder($build, $this->logger);
             $builder->execute();
             // After execution we no longer want to record the information
             // back to this specific build so the handler should be removed.
             $this->logger->popHandler($buildDbLog);
         } catch (\Exception $ex) {
             $build->setStatus(Build::STATUS_FAILED);
             $build->setFinished(new \DateTime());
             $build->setLog($build->getLog() . PHP_EOL . PHP_EOL . $ex->getMessage());
             $store->save($build);
         }
     }
     $this->logger->addInfo(Lang::get('finished_processing_builds'));
     return $builds;
 }

 public function testPreAndPostCommandHandlersAreRun()
 {
     $preLogger = new Logger('sdfs', array(new TestHandler()));
     $this->dispatcher->addPreCommandHandler(function ($command) use($preLogger) {
         $preLogger->info('pre');
     });
     $postLogger = new Logger('fghhgf', array(new TestHandler()));
     $this->dispatcher->addPostCommandHandler(function ($command) use($postLogger) {
         $postLogger->info('post');
     });
     $command = $this->createCommand();
     $this->dispatcher->handleCommands(array($command));
     $records = $preLogger->popHandler()->getRecords();
     $this->assertEquals('pre', $records[0]['message']);
     $records = $postLogger->popHandler()->getRecords();
     $this->assertEquals('post', $records[0]['message']);
 }

 /**
  * Pulls all pending builds from the database and runs them.
  */
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->output = $output;
     // For verbose mode we want to output all informational and above
     // messages to the symphony output interface.
     if ($input->hasOption('verbose')) {
         $this->logger->pushHandler(new OutputLogHandler($this->output, Logger::INFO));
     }
     $this->logger->pushProcessor(new LoggedBuildContextTidier());
     $this->logger->addInfo("Finding builds to process");
     $store = Factory::getStore('Build');
     $result = $store->getByStatus(0, $this->maxBuilds);
     $this->logger->addInfo(sprintf("Found %d builds", count($result['items'])));
     $builds = 0;
     foreach ($result['items'] as $build) {
         $builds++;
         $build = BuildFactory::getBuild($build);
         try {
             // Logging relevant to this build should be stored
             // against the build itself.
             $buildDbLog = new BuildDBLogHandler($build, Logger::INFO);
             $this->logger->pushHandler($buildDbLog);
             $builder = new Builder($build, $this->logger);
             $builder->execute();
             // After execution we no longer want to record the information
             // back to this specific build so the handler should be removed.
             $this->logger->popHandler($buildDbLog);
         } catch (\Exception $ex) {
             $build->setStatus(Build::STATUS_FAILED);
             $build->setLog($build->getLog() . PHP_EOL . PHP_EOL . $ex->getMessage());
             $store->save($build);
         }
     }
     $this->logger->addInfo("Finished processing builds");
     return $builds;
 }

 /**
  * Pops a handler from the stack
  *
  * @return \Monolog\HandlerInterface 
  * @static 
  */
 public static function popHandler()
 {
     return \Monolog\Logger::popHandler();
 }

 /**
  * Pops a handler from the stack
  *
  * @return \Monolog\Handler\HandlerInterface
  */
 public function popHandler()
 {
     return $this->monolog->popHandler();
 }

 /**
  * @return HandlerInterface
  */
 public function popHandler()
 {
     return parent::popHandler();
 }

 /**
  * Pops a handler from the stack
  *
  * @return HandlerInterface
  */
 public function popHandler()
 {
     $handler = parent::popHandler();
     array_shift($this->filters);
     return $handler;
 }