Returns a singleton instance of the monolog stream handler.
@return \Monolog\Handler\StreamHandler
420728
private static function getStreamHandler()
    {
        if(!is_object(self::$stream))
        {
            self::$stream = new StreamHandler(self::$logFilePath, self::$minimumLevel);
        }
        return self::$stream;
    }
93697
public function stream()
    {
        $stream = fopen($this->file, 'r');

        $stream = $stream === false ? null : $stream;

        return new Stream($stream);
    }
11137
private static function getInstance()
    {
        if (self::$converter === null) {
            self::$converter = new AnsiToHtmlConverter(null, false);
        }

        return self::$converter;
    }
366309
public function getStream(): StreamInterface
        {
            if ($this->moved) {
                throw new \RuntimeException(sprintf('Uploaded file %1s has already been moved', $this->clientFilename));
            }
            return $this->file;
        }
266455
public function getLogger() {
		if ($this->_logger !== null) {
			return $this->_logger;
		}
		
		$factoryFirst = $this->isTryLoggersFactoryFirst();
		
		if ($factoryFirst) {
			try {
				$logger = $this->_createLogger();
			} catch (Exception $exception) {}
		}
		
		if (empty($logger)) {
			try {
				$logger = $this->_getLogger();
			} catch (Exception $exception) {}
		}
		
		if (! $factoryFirst && empty($logger)) {
			try {
				$logger = $this->_createLogger();
			} catch (Exception $exception) {}
		}
		
		if (empty($logger)) {
			throw new NoLogger('Unable to provide a logger', 0, $exception);
		}
		
		if (! $logger instanceof LoggerInterface) {
			throw new NoLogger('Logger must implement the "LoggerInterface"');
		}
				
		$this->_logger = $logger;
		return $logger;
	}
484699
public function getStreamWriter()
    {
        if ($this->streamWriter !== null) {
            return $this->streamWriter;
        }

        return $this->streamWriter = new StreamWriter($this);
    }
294269
public function getStream()
    {
        if ($this->moved === true) {
            throw new \RuntimeException('File has already been moved to disk.');
        }

        if ($this->stream instanceof StreamInterface) {
            return $this->stream;
        }

        return $this->stream = new Stream($this->stream);
    }
389505
public function getLogger(): LoggerInterface
    {
        if ($this->logger === null) {
            $this->setLogger(new NullLogger());
        }
        assert($this->logger instanceof LoggerInterface);
        return $this->logger;
    }
30709
protected function getCurrentInstance()
    {
        $instance = $this->getRequest()->getSession()->get('instance');
        
        if($instance) {
            // Update of instance to have last logs created
            $instance = $this->getManager()->find($instance->getId());
        }
        return $instance;
    }
756222
public function getStream()
    {
        if ($this->stream instanceof \Closure) {
            $this->stream = $this->stream->__invoke();
        }
        if (is_resource($this->stream)) {
            $meta = stream_get_meta_data($this->stream);
            if ($meta['seekable']) {
                rewind($this->stream);
            }
        }
        return $this->stream;
    }
265644
public function getBody(): StreamInterface
    {
        if ($this->body->eof()) {
            $this->body->rewind();
        }

        return $this->body;
    }
1155536
public function handler()
    {
        $handler = $this->pop();

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

        return $handler;
    }
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;
    }
998583
public static function create()
    {
        $dispatcher = new Dispatcher();
        foreach (static::$_stack as $middleware) {
            $dispatcher->addFilter($middleware);
        }

        return $dispatcher;
    }
913914
protected function getHandler()
    {
        $stack = HandlerStack::create();

        foreach ($this->middlewares as $middleware) {
            $stack->push($middleware);
        }

        if (isset(static::$defaults['handler']) && is_callable(static::$defaults['handler'])) {
            $stack->push(static::$defaults['handler'], self::USER_DEFINED_HANDLER);
        }

        return $stack;
    }
1006689
public function getLogger()
    {
        if ($this->logger === null) {
            if ($this->configuration->get('silent')) {
                $this->logger = new Logger\NullLogger();
            } else {
                $loggerClass = $this->configuration->get('logger') ?: '\\Pinocchio\\Logger\\StandardLogger';
                $loggerOpts  = $this->configuration->get('logger_opts') ?: array();

                $this->logger = new $loggerClass($loggerOpts);
            }
        }

        return $this->logger;
    }
101082
public function getLog()
    {
        if (null == $this->log) {
            $handler    = new StreamHandler($this->_getLogFileName(), Logger::INFO);
            $this->log  = new Logger('VagrantTransient');
            $this->log->pushHandler($handler);
        }
        return $this->log;
    }