Get the Monolog handler for the application.

@return \Monolog\Handler\AbstractHandler
774149
protected function getMonologHandler()
    {
        return (new StreamHandler($this->path('storage', 'logs/netforce.log'), Logger::DEBUG))->setFormatter(new LineFormatter(null, null, true, true));
    }
974244
public function createHandler($classOrName, $args = [])
    {
        $classes = [
            $classOrName,
            '\\Monolog\\Handler\\' . $classOrName
        ];

        foreach ($classes as $class)
        {
            if (class_exists($class))
            {
                $object = (new ReflectionClass($class))->newInstanceArgs($args);

                return new Handler($object);
            }
        }

        throw new InvalidArgumentException("Monolog handler [$classOrName] does not exist.");
    }
52295
public function getLogger($name)
    {
        $logger = new Logger($name);
        if ($this->handlers !== null) {
            foreach ($this->handlers as $handler) {
                $logger->pushHandler($handler);
            }
        }
        return $logger;
    }
385652
protected function client()
    {
        $handlerClass = $this->config('handlerClass');
        $level = $this->config('level');
        $stream = $this->config('stream');
        $log = new Logger($this->config('name'));
        $log->pushHandler(new $handlerClass($stream, $level));

        return $log;
    }
389505
public function getLogger(): LoggerInterface
    {
        if ($this->logger === null) {
            $this->setLogger(new NullLogger());
        }
        assert($this->logger instanceof LoggerInterface);
        return $this->logger;
    }
1197765
protected function getHandler()
    {
        $handler = resolve($this->type->handler);
        if (!$handler instanceof ContentTypeHandler) {
            throw new DomainException("Type: $this->type can't be handled");
        }
        return $handler;
    }
154201
private static function _getLoggerStderr() {
        if (!isset(self::$loggerStderr)) {        
            $CymapgtStderrLogger = new MonologLogger('cymapgt_stderr');
            $CymapgtStderrLogger->pushHandler(new ErrorLogHandler());
            self::$loggerStderr = $CymapgtStderrLogger;
        }
        return self::$loggerStderr;
    }
196208
public function getLogManager(): ?LogManager
    {
        if (!$this->hasLogManager()) {
            $this->setLogManager($this->getDefaultLogManager());
        }
        return $this->logManager;
    }
1131331
public static function getHandler($level = null)
    {
        if (empty($level)) {
            $level = static::DEFAULT_LEVEL;
        }

        if (empty(static::$handler)) {
            static::setHandler($level);
        }
        return static::$handler;
    }
121153
public function getClient() {
		if (!$this->client) {
			// Create custom handler stack with middlewares
			$stack = HandlerStack::create();

			$context = $this;
			$stack->push(Middleware::mapResponse(function (ResponseInterface $response) use ($context) {
   				// If a new version of this accessor is available, store its COID
				if ($response->hasHeader('C-Accessor-Latest-Version'))
      				$context->setLatestAccessorVersionCOID(
						new IRI($response->getHeaderLine('C-Accessor-Latest-Version')));
    			return $response;
			}));

			// Prepare client options
			$options = [
				'base_uri' => str_replace('{aauid}', AAUIDParser::getAAUID($this->getAAUID()), $this->agwBaseUrl),
				'headers' => [
					'Authorization' => 'Bearer '.$this->getAccessToken()
				],
				'handler' => $stack
			];
			if (isset($this->request) && $this->request->hasHeader('X-Forwarded-For')) {
				$options['headers']['X-Forwarded-For'] = $this->request->getHeaderLine('X-Forwarded-For');				
			}

			// Create client
			$this->client = new Client($options);
		}
		return $this->client;
	}
81837
public function logger()
    {
        if (is_null($this->logger)) {
            $this->logger = app(Logger::class);
        }

        return $this->logger;
    }
1153528
protected function createEmergencyLogger()
    {
        return new Logger(new Monolog('laravel', $this->prepareHandlers([new StreamHandler(
                $this->app->storagePath().'/logs/laravel.log', $this->level(['level' => 'debug'])
        )])), $this->app['events']);
    }
796664
protected function getFileHandler()
    {
        if ($this->fileHandler === null) {
            $fileHandler = @fopen($this->logFile, 'r');

            if ($fileHandler === false) {
                throw new ParserException('Can not open log file.');
            }

            $this->fileHandler = $fileHandler;
        }

        return $this->fileHandler;
    }
488925
public function handlers()
    {
        if ($this->_handlers === null) {
            $this->_handlers = Yii::$app->cache->lazy(function () {
                $models = PropertyHandlers::find()
                    ->orderBy(['sort_order' => SORT_ASC])
                    ->all();

                $handlers = [];
                foreach ($models as $model) {
                    $className = $model->class_name;
                    $handlers[$model->id] = new $className($model->default_config);
                }

                return $handlers;
            }, 'AllPropertyHandlers', 86400, PropertyHandlers::commonTag());
        }
        return $this->_handlers;
    }
1155536
public function handler()
    {
        $handler = $this->pop();

        if (null !== $handler) {
            $this->push($handler);
        }

        return $handler;
    }
779621
protected function getViewHandler()
    {
        if (!$this->viewhandler instanceof ViewHandlerInterface) {
            $this->viewhandler = $this->container->get('fos_rest.view_handler');
        }

        return $this->viewhandler;
    }
435289
public static function getLogger()
	{
		if(self::$logger === NULL)
		{
			self::$logger = new Logger('sonic');
			self::$logger->pushHandler(new StreamHandler(Configuration::getLogfile()));
		}
		
		return self::$logger;
	}