Download the PHP package mensbeam/logger without Composer

On this page you can find all versions of the php package mensbeam/logger. It is possible to download/install these versions without Composer. Possible dependencies are resolved automatically.

FAQ

After the download, you have to make one include require_once('vendor/autoload.php');. After that you have to import the classes with use statements.

Example:
If you use only one package a project is not needed. But if you use more then one package, without a project it is not possible to import the classes with use statements.

In general, it is recommended to use always a project to download your libraries. In an application normally there is more than one library needed.
Some PHP packages are not free to download and because of that hosted in private repositories. In this case some credentials are needed to access such packages. Please use the auth.json textarea to insert credentials, if a package is coming from a private repository. You can look here for more information.

  • Some hosting areas are not accessible by a terminal or SSH. Then it is not possible to use Composer.
  • To use Composer is sometimes complicated. Especially for beginners.
  • Composer needs much resources. Sometimes they are not available on a simple webspace.
  • If you are using private repositories you don't need to share your credentials. You can set up everything on our site and then you provide a simple download link to your team member.
  • Simplify your Composer build process. Use our own command line tool to download the vendor folder as binary. This makes your build process faster and you don't need to expose your credentials for private repositories.
Please rate this library. Is it a good library?

Example code of mensbeam/logger

Informations about the package logger

Logger

Logger is a simple yet configurable logger for PHP. It is an opinionated implementation of PSR-3 Logger Interface. It uses classes called handlers to handle messages to log. Currently there is only one handler: StreamHandler which allows for logging to files or to streams such as php://stdout or php://stderr. Handlers can be easily written and plugged into Logger.

Opinionated?

This library attempts what we're calling an "opinionated" implementation of PSR-3. This is because while it successfully implements Psr\Log\LoggerInterface Logger deviates from the true spirit of the specification in various ways:

  1. In section 1.1 PSR-3 states that when calling the log method with one of the log level constants (later shown to be in Psr\Log\LogLevel) it must have the same result as calling the level-specific methods. The log level constants in Psr\Log\LogLevel are strings, but the $level parameter of the log method in Psr\Log\LoggerInterface is typeless. The words of the specification suggest that the $level parameter should be a string, but the actual code implementors are to use doesn't specify a type. The same section also references RFC 5424 when mentioning the log level methods, but why use strings when there are standardized integers used to identify severity? Since the interface allows for any type for $level, Logger will prefer the actual RFC standard's integers but will accept and convert PSR-3's strings internally to the integers just so it can remain PSR-3 compatible.

  2. In section 1.2 of the specification it describes an optional feature, placeholders, and requires the implementor to write code to parse out and replace placeholders using a syntax and a method that's not present anywhere else in the entirety of PHP. Logger won't support this feature because a logging library's place is to log messages and not to interpolate template strings. A separate library or a built-in function such as sprintf should be used instead. Logger provides a way to transform messages that can be used to hook in a preferred interpolation method if desired, though.

  3. The specification in section 1.3 also specifies that if an Exception object is passed in the $context parameter it must be within an exception key. This makes sense, but curiously there's nary a mention of what to do with an Error object. They've existed since PHP 7 and can be thrown just like exceptions. Logger will accept any Throwable in the exception key, but at present does nothing with it. Theoretically future handlers could be written to take advantage of it for structured data.

  4. Also in the first item of section 1.3 it states categorically that implementors must not trigger a warning when errant data is in the $context array and treat it with "as much lenience as possible". It then states in the following item that if an exception is present in the context data it must be in the exception key and that implementors must verify the exception key. This is contradictory. You can't verify the exception key without triggering an error or exception when it's wrong. The user should be notified they've made a mistake; it's bad design otherwise. Our solution to this problem is to remove errant throwables from $context and also trigger warnings when they're encountered. However, Logger->$warnOnInvalidContextThrowables is provided to make it easy to suppress the warnings if necessary.

Requirements

Note

This library uses mensbeam/filesystem which provides polyfills for ext-ctype and ext-mbstring. If you have these extensions installed the polyfills won't be used. However, they are still installed. If you don't want the polyfills needlessly installed you can add this to your project's composer.json:

Installation

Usage

This library works without any configuration, but it might not be quite how you think it would work by default:

This will create a logger that outputs all debug, info, notice, and warning entries to STDOUT while any error, critical, alert, and emergency entries are output to STDERR. This seems like it would be a bizarre default since it causes duplicate output to the shell on errors. However, if you accompany it with an error handler like Catcher it suddenly makes sense:

Now, Logger will take care of the printing. But, Logger can do far more.

Documentation

MensBeam\Logger

Properties

warnOnInvalidContextThrowables: When set to true Logger will trigger warnings when invalid Throwables are in the $context array in the logging methods.

MensBeam\Logger::getChannel

Returns the channel name for the instance of Logger.

MensBeam\Logger::getHandlers

Returns an array of the handlers defined for use in the Logger instance.

MensBeam\Logger::popHandler

Pops the last handler off the stack and returns it

MensBeam\Logger::pushHandler

Pushes the specified handler(s) onto the stack

MensBeam\Logger::setChannel

Sets the channel to the specified string

MensBeam\Logger::setHandlers

Replaces the stack of handlers with those specified as parameters

MensBeam\Logger::shiftHandler

Shifts the first handler off the stack of handlers and returns it

MensBeam\Logger::unshiftHandler

Unshifts the specified handler(s) onto the beginning of the stack

MensBeam\Logger::emergency

Adds an emergency entry to the log

MensBeam\Logger::alert

Adds an alert entry to the log

MensBeam\Logger::critical

Adds a critical entry to the log

MensBeam\Logger::error

Adds an error entry to the log

MensBeam\Logger::warning

Adds a warning entry to the log

MensBeam\Logger::notice

Adds a notice entry to the log

MensBeam\Logger::info

Adds an info entry to the log

MensBeam\Logger::debug

Adds a debug entry to the log

MensBeam\Logger::log

Adds an entry to the log in the specified level

MensBeam\Logger\Level

This is an enum of the RFC 5424 integer values for each of the log levels; also provides methods for converting to and from PSR-3 string values.

MensBeam\Logger\Level::fromPSR3

Takes a provided PSR-3 string level and returns a Level enum.

MensBeam\Logger\Level::toPSR3

Returns a PSR-3 string level representation of the enum.

MensBeam\Logger\Handler

Handlers inherit from this abstract class. Since it is an abstract class meant for constructing handlers protected methods and properties will be documented here as well.

Properties (Protected)

levels: This is where the levels the handler is configured to support are stored

Options

Properties which begin with an underscore are all options. They can be set either through the constructor or via setHandler by name, removing the underscore (_) at the beginning. All handlers inherit these options. Options in inherited classes should also begin with an underscore (_).

bubbles: When set to true the stack loop will continue onto the next handler; if false it won't. Defaults to true
messageTransform: A callable to use to transform messages before outputting. Defaults to null
timeFormat: The PHP-standard date format which to use for times in output. Defaults to "M d H:i:s"

Message Transform

The messageTransform option allows for manipulation of log messages. It accepts any callable with the following structure:

One common use of this feature would be to do string interpolation which isn't handled by the library. By providing a message transform it's possible to use any preferred method of interpolation:

Of course this is a simplistic example. One would want to convert the $context array to numerical keys (or just use numerical keys) before usage in vsprintf, but as can be seen it's very possible.

MensBeam\Logger\Handler::getLevels

Returns the levels the handler is configured to support

MensBeam\Logger\Handler::getOption

Returns the value of the provided option name

MensBeam\Logger\Handler::setLevels

Sets the levels the handler will then support

MensBeam\Logger\Handler::setOption

Sets the provided option with the provided value

MensBeam\Logger\Handler::__invoke

Outputs/dispatches the log entry

MensBeam\Logger\Handler::invokeCallback (protected)

A callback method meant to be extended by inherited classes to output/dispatch the log entry

MensBeam\Logger\StreamHandler

Options

entryTransform: A callable where the log entry can be manipulated. Defaults to null

Entry Transform
Parameters
time
The timestamp the log entry was dispatched at; can be altered with the timeFormat option
level
The RFC 5424 level integer for the entry
levelName
The RFC 5424 level name for the entry
channel
The channel defined when creating the logger
message
The message string; can be manipulated with the messageTransform option
context
The context array used when dispatching the entry

Here is an example of how to use the entryTransform option to output entries to php://stdout as JSONLines/NDJSON/whatever (ugh):

MensBeam\Logger\StreamHandler::getStream

Returns the resource where the handler will output to

MensBeam\Logger\StreamHandler::getURI

Returns the URI where the handler will output to

MensBeam\Logger\StreamHandler::setStream

Sets where the handler will output to

All versions of logger with dependencies

PHP Build Version
Package Version
Requires php Version >=8.1
psr/log Version ^3.0
mensbeam/filesystem Version >=1.0
Composer command for our command line client (download client) This client runs in each environment. You don't need a specific PHP version etc. The first 20 API calls are free. Standard composer command

The package mensbeam/logger contains the following files

Loading the files please wait ....