Enable logging in console mode.

@return DebugListener
423166
public function enable(): self
    {
        if (!empty($this->logs)) {
            $this->logs->addListener($this);
        }

        return $this;
    }
627337
public function enable()
    {
        $this->assertIsDebugMode();

	    $extId = $this->getRequestParameter('id');
        $this->getExtensionManager()->setEnabled($extId, true);
	    MenuService::flushCache();
        $this->returnJson(array(
	        'success' => true,
	        'message' => __('Enabled %s', $this->getRequestParameter('id'))
	    ));
	}
49167
protected function disableLogging()
    {
        $config = $this->entityManager->getConnection()->getConfiguration();
        $this->originalLogger = $config->getSQLLogger();
        $config->setSQLLogger(null);
    }
1322568
private function enableDebuggerWith($enableMode)
    {
        if ($this->isLoggerEnabled() == true) {
            Debugger::enable($enableMode, $this->getLogPath());
        } else {
            Debugger::enable($enableMode);
        }

        return $this;
    }
446079
public function getPsrLog(): ?LoggerInterface
    {
        if (!$this->hasPsrLog()) {
            $this->setPsrLog($this->getDefaultPsrLog());
        }
        return $this->psrLog;
    }
715597
public static function enable(): void
    {
        self::$debugbar = new StandardDebugBar();
        self::$debugbar->addCollector(new ViewCollector());

        self::$renderer = self::$debugbar->getJavascriptRenderer('./vendor/maximebf/debugbar/src/DebugBar/Resources/');
    }
1354740
function ConsoleLogger() {

    this.error = function () {
        if (loggingLevel(ERROR)) {
            console.error.apply(this, arguments);
        }
    };

    this.warn = function () {
        if (loggingLevel(WARN)) {
            console.warn.apply(this, arguments);
        }
    };

    this.info = function () {
        if (loggingLevel(INFO)) {
            console.info.apply(this, arguments);
        }
    };

    this.log = function () {
        if (loggingLevel(INFO)) {
            console.log.apply(this, arguments);
        }
    };

    this.debug = function () {
        if (loggingLevel(DEBUG)) {
            console.log.apply(this, arguments);
        }
    };

    this.setLevelToInfo = function () {
        setLevel(INFO);
    };

    this.setLevelToDebug = function() {
        setLevel(DEBUG);
    };

    this.setLevelToWarning = function() {
        setLevel(WARN);
    };

    this.setLevelToError = function() {
        setLevel(ERROR);
    };
}
83563
private static function logger()
    {
        $settings = [
            'name' => config('app.name'),
            'level' => Logger::DEBUG,
            'path' => storage_path("logs/" . (PHP_SAPI === "cli" ? "cli.log" : "app.log"))
        ];

        $logger = new Logger($settings['name']);
        $handler = new StreamHandler($settings['path']);

        $lineFormatter = new LineFormatter;
        $lineFormatter->includeStacktraces();

        $handler->setFormatter($lineFormatter);

        return $logger->pushHandler($handler, $settings['level']);
    }
118702
public function getLogger()
    {
        if (!$this->logger) {
            if (!defined('STDERR')) {
                // See testGetLoggerRunFromStdin
                // @codeCoverageIgnoreStart
                define('STDERR', fopen('php://stderr', 'w'));
            }
            // @codeCoverageIgnoreEnd
            $handler = new StreamHandler(STDERR, Logger::DEBUG);
            $handler->setFormatter(new LineFormatter("%datetime% %level_name% %message% %context%\n"));
            $this->logger = new Logger(get_class($this));
            $this->logger->pushHandler($handler);
        }
        return $this->logger;
    }
824028
protected function createLogger()
    {
        if ($this->logger === null) {
            $consoleHandler = new ConsoleHandler($this->createOutput());
            $this->logger = new Logger('TYPO3 Surf', [$consoleHandler]);
        }

        return $this->logger;
    }
1198936
public function tinker()
    {
        \Psy\Shell::debug([
            'browser' => $this,
            'driver' => $this->driver,
            'resolver' => $this->resolver,
            'page' => $this->page,
        ], $this);

        return $this;
    }
436014
function ( enabled, debug ) {
		this.logging.enabled = enabled === true;
		this.logging.debug = debug === true;
		this.loaderWorker.setLogging( this.logging.enabled, this.logging.debug );
	}
1258191
protected function getLogger()
    {
        if (!isset($this->logger)) {
            // When no logger is injected, create a new one
            // that doesn't do anything
            $this->logger = new Logger('api-client');
            $this->logger->setHandlers([
                new NullHandler(),
            ]);
        }

        return $this->logger;
    }
163381
public static function isEnabled()
    {
        if (is_null(self::$isEnabled)) {
            self::$isEnabled = (bool) Config::getInstance()->Development['enabled'];
        }

        return self::$isEnabled;
    }
297919
public static function shutdown()
    {
        // And finally stop the Logging
        self::stopLevel();

        if (self::$debug === true || self::$print_to_screen) {
            self::log('Parsing debug log');
            self::logToScreen();
        }

        if (self::$log_to_file == true)
        {
            self::logToFile();
        }
    }
1052260
public function debugLog($log)
    {
        if (defined('DEBUG_MODE') and DEBUG_MODE == 1) {
            $log = 'DEBUG >>> ' . $log;
            echo $log . PHP_EOL . PHP_EOL;
        }

        return $this;
    }
1084943
protected function registerAccessLog()
    {
        $this->laravel->singleton(OutputStyle::class, function () {
            return new OutputStyle($this->input, $this->output);
        });

        $this->laravel->singleton(AccessOutput::class, function () {
            return new AccessOutput(new ConsoleOutput);
        });

        $this->laravel->singleton(AccessLog::class, function (Container $container) {
            return new AccessLog($container->make(AccessOutput::class));
        });
    }