Get the Monolog handler for the application.

@return \Monolog\Handler\AbstractHandler
190926
protected function getMonologHandler()
  {
    $name = Str::slug($this->getNamespaceName());
    return (new StreamHandler($this->storagePath("logs/{$name}.log"), Logger::DEBUG))
      ->setFormatter(new LineFormatter(null, null, true, true));
  }
557762
public function getLogger()
    {
        if (!$this->logger) {
            $this->logger = $this->getClient()->getLogger();
        }
        return $this->logger;
    }
91832
protected static function createDefaultLogger()
    {
        $handler = new StreamHandler(sys_get_temp_dir().'/logs/yansongda.pay.log');
        $handler->setFormatter(new LineFormatter("%datetime% > %level_name% > %message% %context% %extra%\n\n"));

        $logger = new Logger('yansongda.pay');
        $logger->pushHandler($handler);

        return $logger;
    }
518524
public function create($handlerType, $level)
    {
        if (false === array_key_exists('handler', $this->_config)) {
            throw new MonologCreator\Exception(
                'no handler configuration found'
            );
        }

        if (false === array_key_exists($handlerType, $this->_config['handler'])) {
            throw new MonologCreator\Exception(
                'no handler configuration found for handlerType: '
                . $handlerType
            );
        }

        $handler       = null;
        $handlerConfig = $this->_config['handler'][$handlerType];

        // evaluate handler
        if ('stream' === $handlerType) {
            $handler = $this->_createStreamhandler($handlerConfig, $level);
        } elseif ('udp' === $handlerType) {
            $handler = $this->_createUdphandler($handlerConfig, $level);
        } elseif ('redis' === $handlerType) {
            $handler = $this->_createRedisHandler($handlerConfig, $level);
        } else {
            throw new MonologCreator\Exception(
                'handler type: ' . $handlerType . ' is not supported'
            );
        }

        // set formatter
        if (true === array_key_exists('formatter', $handlerConfig)) {
            $handler->setFormatter(
                $this->_formatterFactory->create($handlerConfig['formatter'])
            );
        }

        return $handler;
    }
1036659
public function getHandle()
    {
        if(!$handle = $this->getProperty($this->getIdentityKey())) {
            $handle = parent::getHandle();
        }

        return $handle;
    }
435289
public static function getLogger()
	{
		if(self::$logger === NULL)
		{
			self::$logger = new Logger('sonic');
			self::$logger->pushHandler(new StreamHandler(Configuration::getLogfile()));
		}
		
		return self::$logger;
	}
1047702
public static function getBackend()
    {
        if(!is_object(self::$backend))
        {
            self::$backend = new \Monolog\Logger(self::$name);
            self::$backend->pushHandler(self::getStreamHandler());
            self::setLogFormat(self::$logFormat);
        }
        return self::$backend;
    }
196208
public function getLogManager(): ?LogManager
    {
        if (!$this->hasLogManager()) {
            $this->setLogManager($this->getDefaultLogManager());
        }
        return $this->logManager;
    }
378156
protected function getHandler()
    {
        if ($this->builder) {
            return $this->builder;
        }

        if ($this->query) {
            return $this->query;
        }

        throw new InvalidArgumentException('Missing query builder');
    }
670051
public function getHandler() {
        $rs = $this->runQuery(
            "SELECT handler FROM " . self::$jobsTable . " WHERE id = ?",
            array($this->job_id)
        );
        foreach ($rs as $r) return unserialize($r["handler"]);
        return false;
    }
1342749
public function getHandlers()
    {
        $handlers = [];
        foreach ($this->handlers as $key => $handler) {
            $handlers[$key] = $handler->getCallable();
        }

        return $handlers;
    }
358394
protected function createEmergencyLogger()
    {
        return new Logger(
            new Monolog(
                'zilf', $this->prepareHandlers(
                    [new StreamHandler(
                        Zilf::$app->runtimePath() . '/logs/zilf.log', $this->level(['level' => 'debug'])
                    )]
                )
            )
        );
    }
420728
private static function getStreamHandler()
    {
        if(!is_object(self::$stream))
        {
            self::$stream = new StreamHandler(self::$logFilePath, self::$minimumLevel);
        }
        return self::$stream;
    }
414741
public function createLogger()
    {
        $log = new Writer(new Monolog($this->channel()));

        $this->configureHandler($log);

        return $log;
    }
389505
public function getLogger(): LoggerInterface
    {
        if ($this->logger === null) {
            $this->setLogger(new NullLogger());
        }
        assert($this->logger instanceof LoggerInterface);
        return $this->logger;
    }
564773
protected function getHandler()
    {
        $handler = $this->getConfig('unauthorizedHandler');
        if (!is_array($handler)) {
            $handler = [
                'className' => $handler,
            ];
        }
        if (!isset($handler['className'])) {
            throw new RuntimeException('Missing `className` key from handler config.');
        }

        return HandlerFactory::create($handler['className']);
    }
281754
public function getHandle()
    {
        if(!$handle = $this->getProperty($this->getIdentityColumn())) {
            $handle = parent::getHandle();
        }

        return $handle;
    }