/** * @param int $level * @throws CM_Exception_Invalid */ public function setMinLevel($level) { $level = (int) $level; if (CM_Log_Logger::hasLevel($level)) { $this->_minLevel = $level; } }
public function prepare(CM_Frontend_Environment $environment, CM_Frontend_ViewResponse $viewResponse) { $level = $this->_params->has('level') ? $this->_params->getInt('level') : null; if (null !== $level && !CM_Log_Logger::hasLevel($level)) { throw new CM_Exception_InvalidParam('Invalid `level` param'); } $levelList = $level ? [$level] : null; $type = $this->_params->has('type') ? $this->_params->getInt('type') : null; if (null !== $type && !CM_Paging_Log::isValidType($type)) { throw new CM_Exception_InvalidParam('Invalid `type` param'); } $aggregate = $this->_params->has('aggregate') ? $this->_params->getInt('aggregate') : null; $urlPage = $this->_params->has('urlPage') ? $this->_params->getString('urlPage') : null; $urlParams = $this->_params->has('urlParams') ? $this->_params->getArray('urlParams') : null; $aggregationPeriod = $aggregate; if (0 === $aggregationPeriod) { $deployStamp = CM_App::getInstance()->getDeployVersion(); $aggregationPeriod = time() - $deployStamp; } $logList = new CM_Paging_Log($levelList, $type, (bool) $aggregationPeriod, $aggregationPeriod); $logList->setPage($this->_params->getPage(), $this->_params->getInt('count', 50)); $viewResponse->setData(['level' => $level, 'type' => $type, 'logList' => $logList, 'aggregate' => $aggregate, 'aggregationPeriod' => $aggregationPeriod, 'aggregationPeriodList' => array(3600, 86400, 7 * 86400, 31 * 86400), 'urlPage' => $urlPage, 'urlParams' => $urlParams, 'levelMap' => array_flip(CM_Log_Logger::getLevels())]); $viewResponse->getJs()->setProperty('level', $level); $viewResponse->getJs()->setProperty('type', $type); }
/** * @param array $filterLevelList * @param int|boolean|null $filterType * @param boolean|null $aggregate * @param int|null $ageMax * @throws CM_Exception_Invalid */ public function __construct(array $filterLevelList = null, $filterType = null, $aggregate = null, $ageMax = null) { if (null !== $filterLevelList) { foreach ($filterLevelList as $level) { $level = (int) $level; if (!CM_Log_Logger::hasLevel($level)) { throw new CM_Exception_Invalid('Log level does not exist.', null, ['level' => $level]); } } } if (null !== $filterType && false !== $filterType && !self::isValidType((int) $filterType)) { throw new CM_Exception_Invalid('Type is not a children of CM_Paging_Log.'); } if (null !== $ageMax) { $ageMax = (int) $ageMax; } $this->_filterLevelList = $filterLevelList; $this->_filterType = $filterType; $this->_ageMax = $ageMax; $criteria = $this->_getCriteria(); if (true === $aggregate) { $aggregate = [['$match' => $criteria], ['$group' => ['_id' => ['level' => '$level', 'message' => '$message', 'exception_message' => '$context.exception.message', 'exception_class' => '$context.exception.class', 'exception_line' => '$context.exception.line', 'exception_file' => '$context.exception.file'], 'count' => ['$sum' => 1], 'createdAt' => ['$max' => '$createdAt'], 'exception' => ['$last' => '$context.exception']]], ['$sort' => ['count' => -1]], ['$project' => ['level' => '$_id.level', 'message' => '$_id.message', 'exception' => '$exception', 'count' => '$count', 'createdAt' => '$createdAt', '_id' => false]]]; $source = new CM_PagingSource_MongoDb(self::COLLECTION_NAME, null, null, $aggregate); } else { $sorting = empty($criteria) ? ['_id' => -1] : ['createdAt' => -1]; $source = new CM_PagingSource_MongoDb(self::COLLECTION_NAME, $criteria, null, null, $sorting); } parent::__construct($source); }
/** * @param CM_Log_Record $record * @return array */ protected function _formatRecord(CM_Log_Record $record) { $levelsMapping = array_flip(CM_Log_Logger::getLevels()); $context = $record->getContext(); $result = ['message' => (string) $record->getMessage(), 'level' => strtolower($levelsMapping[$record->getLevel()]), 'timestamp' => $record->getCreatedAt()->format('Y-m-d\\TH:i:s.uO')]; $result = array_merge($result, $this->_contextFormatter->formatContext($context)); return $result; }
/** * @param int $level * @param string $message * @param CM_Log_Context $context * @throws CM_Exception_Invalid */ public function __construct($level, $message, CM_Log_Context $context) { $level = (int) $level; $message = (string) $message; if (!CM_Log_Logger::hasLevel($level)) { throw new CM_Exception_Invalid('Log level does not exist.', null, ['level' => $level]); } $this->_level = $level; $this->_message = $message; $this->_context = $context; $this->_createdAt = CM_Util::createDateTimeWithMillis(); }
/** * @param Exception $exception * @param int|null $severity */ public function handleExceptionWithSeverity(Exception $exception, $severity) { $printException = true; if ($exception instanceof CM_Exception) { $printException = $severity >= $this->_getPrintSeverityMin(); } if ($printException) { $this->_printException($exception); } $logLevel = CM_Log_Logger::severityToLevel($severity); $this->getServiceManager()->getLogger()->addMessage('Application error', $logLevel, (new CM_Log_Context())->setException($exception)); }
/** * @param string $className * @return CM_Jobdistribution_Job_Abstract|null */ protected function _instantiateJob($className) { try { /** @var CM_Jobdistribution_Job_Abstract $job */ $job = new $className(); if ($job instanceof CM_Service_ManagerAwareInterface) { /** @var CM_Service_ManagerAwareInterface $job */ $job->setServiceManager($this->getServiceManager()); } return $job; } catch (Exception $e) { $logLevel = CM_Log_Logger::exceptionToLevel($e); $context = new CM_Log_Context(); $context->setException($e); $this->getServiceManager()->getLogger()->addMessage('Delayed queue error', $logLevel, $context); return null; } }
public function run() { $jobsRun = 0; while (true) { if ($jobsRun >= $this->_jobLimit) { return; } $workFailed = false; try { $jobsRun++; CM_Cache_Storage_Runtime::getInstance()->flush(); $workFailed = !$this->_getGearmanWorker()->work(); } catch (Exception $ex) { $this->getServiceManager()->getLogger()->addMessage('Worker failed', CM_Log_Logger::exceptionToLevel($ex), (new CM_Log_Context())->setException($ex)); } if ($workFailed) { throw new CM_Exception_Invalid('Worker failed'); } } }
/** * @param Exception $exception */ protected function _logException(Exception $exception) { $logLevel = CM_Log_Logger::exceptionToLevel($exception); $context = new CM_Log_Context(); $context->setException($exception); CM_Service_Manager::getInstance()->getLogger()->addMessage('KickBox client error', $logLevel, $context); }
/** * @param string|string[] $channels * @param Closure $callback * @return mixed return something else than null to exit the pubsub loop */ public function subscribe($channels, Closure $callback) { $redisClient = $this->_createPredisClient($this->_config['host'], $this->_config['port'], $this->_config['database'], 60, -1); $pubsub = $redisClient->pubSubLoop(['subscribe' => $channels]); $response = null; /** @var stdClass $message */ foreach ($pubsub as $message) { try { if ($message->kind == 'message') { $response = $callback($message->channel, $message->payload); } } catch (Exception $e) { $this->getServiceManager()->getLogger()->addMessage('Redis message callback failed', CM_Log_Logger::exceptionToLevel($e), (new CM_Log_Context())->setException($e)); } if (!is_null($response)) { break; } } return $response; }
/** * @param CM_Log_Record $record * @return array * @throws CM_Exception_Invalid */ protected function _getRecordInfo(CM_Log_Record $record) { $computerInfo = $record->getContext()->getComputerInfo(); return ['datetime' => $record->getCreatedAt()->format($this->_formatDate), 'levelname' => CM_Log_Logger::getLevelName($record->getLevel()), 'message' => $record->getMessage(), 'fqdn' => null === $computerInfo ? 'none' : $computerInfo->getFullyQualifiedDomainName(), 'phpVersion' => null === $computerInfo ? 'none' : $computerInfo->getPhpVersion()]; }
protected function _registerCallbacks() { $this->_registerClockworkCallbacks('1 second', ['CM_Jobdistribution_DelayedQueue::queueOutstanding' => function () { $delayedQueue = $this->getServiceManager()->getDelayedJobQueue(); $delayedQueue->queueOutstanding(); }]); $this->_registerClockworkCallbacks('1 minute', array('CM_Model_User::offlineOld' => function () { CM_Model_User::offlineOld(); }, 'CM_ModelAsset_User_Roles::deleteOld' => function () { CM_ModelAsset_User_Roles::deleteOld(); }, 'CM_Paging_Useragent_Abstract::deleteOlder' => function () { CM_Paging_Useragent_Abstract::deleteOlder(100 * 86400); }, 'CM_File_UserContent_Temp::deleteOlder' => function () { CM_File_UserContent_Temp::deleteOlder(86400); }, 'CM_SVM_Model::deleteOldTrainings' => function () { CM_SVM_Model::deleteOldTrainings(3000); }, 'CM_Paging_Ip_Blocked::deleteOlder' => function () { CM_Paging_Ip_Blocked::deleteOld(); }, 'CM_Captcha::deleteOlder' => function () { CM_Captcha::deleteOlder(3600); }, 'CM_Session::deleteExpired' => function () { CM_Session::deleteExpired(); }, 'CM_MessageStream_Service::synchronize' => function () { CM_Service_Manager::getInstance()->getStreamMessage()->synchronize(); })); if ($this->getServiceManager()->has('janus')) { $this->_registerClockworkCallbacks('1 minute', array('CM_Janus_Service::synchronize' => function () { $this->getServiceManager()->getJanus('janus')->synchronize(); }, 'CM_Janus_Service::checkStreams' => function () { $this->getServiceManager()->getJanus('janus')->checkStreams(); })); } $this->_registerClockworkCallbacks('15 minutes', array('CM_Action_Abstract::aggregate' => function () { CM_Action_Abstract::aggregate(); }, 'CM_Action_Abstract::deleteTransgressionsOlder' => function () { CM_Action_Abstract::deleteTransgressionsOlder(3 * 31 * 86400); }, 'CM_Paging_Log::cleanup' => function () { $allLevelsList = array_values(CM_Log_Logger::getLevels()); foreach (CM_Paging_Log::getClassChildren() as $pagingLogClass) { /** @type CM_Paging_Log $log */ $log = new $pagingLogClass($allLevelsList); $log->cleanUp(); } (new CM_Paging_Log($allLevelsList, false))->cleanUp(); //deletes all untyped records })); if ($this->getServiceManager()->has('maxmind')) { $this->_registerClockworkCallbacks('8 days', array('CMService_MaxMind::upgrade' => function () { try { /** @var CMService_MaxMind $maxMind */ $maxMind = $this->getServiceManager()->get('maxmind', 'CMService_MaxMind'); $maxMind->upgrade(); } catch (Exception $exception) { if (!is_a($exception, 'CM_Exception')) { $exception = new CM_Exception($exception->getMessage(), null, ['file' => $exception->getFile(), 'line' => $exception->getLine(), 'trace' => $exception->getTraceAsString()]); } $exception->setSeverity(CM_Exception::FATAL); throw $exception; } })); } }
/** * @param Closure $regularCode * @param Closure $errorCode * @return mixed * @throws CM_Exception */ protected function _runWithCatching(Closure $regularCode, Closure $errorCode) { try { return $regularCode(); } catch (CM_Exception $ex) { $config = self::_getConfig(); $exceptionsToCatch = $config->exceptionsToCatch; $catchPublicExceptions = !empty($config->catchPublicExceptions); $errorOptions = \Functional\first($exceptionsToCatch, function ($options, $exceptionClass) use($ex) { return is_a($ex, $exceptionClass); }); $catchException = null !== $errorOptions; if ($catchException && isset($errorOptions['log']) && true === $errorOptions['log']) { $logLevel = isset($errorOptions['level']) ? $errorOptions['level'] : null; if (null === $logLevel) { $logLevel = CM_Log_Logger::exceptionToLevel($ex); } $context = new CM_Log_Context(); $context->setUser($this->getViewer()); $context->setException($ex); $this->getServiceManager()->getLogger()->addMessage('Response processing error', $logLevel, $context); } if (!$catchException && ($catchPublicExceptions && $ex->isPublic())) { $errorOptions = []; $catchException = true; } if ($catchException) { return $errorCode($ex, $errorOptions); } throw $ex; } }
public function testStaticGetLevelNameException() { $exception = $this->catchException(function () { CM_Log_Logger::getLevelName(666); }); $this->assertInstanceOf('CM_Exception_Invalid', $exception); /** @var CM_Exception_Invalid $exception */ $this->assertSame('Level is not defined', $exception->getMessage()); $this->assertSame(['level' => 666, 'availableLevels' => '100, 200, 300, 400, 500'], $exception->getMetaInfo()); }
public function testStaticLogLevelMethods() { $this->assertSame('INFO', CM_Log_Logger::getLevelName(CM_Log_Logger::INFO)); $this->assertNotEmpty(CM_Log_Logger::getLevels()); $this->assertTrue(CM_Log_Logger::hasLevel(CM_Log_Logger::INFO)); $this->assertFalse(CM_Log_Logger::hasLevel(666)); }