---
title: "Phalcon Logger"
version: "5.4"
---

> Documentation Index
> Fetch the complete documentation index at: https://docs.phalcon.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Phalcon Logger

:::info[NOTE]
All classes are prefixed with `Phalcon`
:::

## Logger\AbstractLogger ![Abstract](/assets/images/abstract-green.svg) 

[Source on GitHub](https://github.com/phalcon/cphalcon/blob/5.0.x/phalcon/Logger/AbstractLogger.zep)

-   __Namespace__

    - `Phalcon\Logger`

-   __Uses__

    - `DateTimeImmutable`
    - `DateTimeZone`
    - `Exception`
    - `Phalcon\Logger\Adapter\AdapterInterface`
    - `Phalcon\Logger\Exception`

-   __Extends__

-   __Implements__

Abstract Logger Class

Abstract logger class, providing common functionality. A formatter interface
is available as well as an adapter one. Adapters can be created easily using
the built in AdapterFactory. A LoggerFactory is also available that allows
developers to create new instances of the Logger or load them from config
files (see Phalcon\Config\Config object).

@property AdapterInterface[] $adapters
@property array              $excluded
@property int                $logLevel
@property string             $name
@property string             $timezone

### Constants
```php
const ALERT = 2;
const CRITICAL = 1;
const CUSTOM = 8;
const DEBUG = 7;
const EMERGENCY = 0;
const ERROR = 3;
const INFO = 6;
const NOTICE = 5;
const WARNING = 4;
```

### Properties
```php
/**
 * The adapter stack
 *
 * @var AdapterInterface[]
 */
protected $adapters;

/**
 * The excluded adapters for this log process
 *
 * @var array
 */
protected $excluded;

/**
 * Minimum log level for the logger
 *
 * @var int
 */
protected $logLevel = 8;

/**
 * @var string
 */
protected $name = ;

/**
 * @var DateTimeZone
 */
protected $timezone;

```

### Methods

```php
public function __construct( string $name, array $adapters = [], DateTimeZone $timezone = null );
```
Constructor.

```php
public function addAdapter( string $name, AdapterInterface $adapter ): AbstractLogger;
```
Add an adapter to the stack. For processing we use FIFO

```php
public function excludeAdapters( array $adapters = [] ): AbstractLogger;
```
Exclude certain adapters.

```php
public function getAdapter( string $name ): AdapterInterface;
```
Returns an adapter from the stack

```php
public function getAdapters(): array;
```
Returns the adapter stack array

```php
public function getLogLevel(): int;
```
Returns the log level

```php
public function getName(): string;
```
Returns the name of the logger

```php
public function removeAdapter( string $name ): AbstractLogger;
```
Removes an adapter from the stack

```php
public function setAdapters( array $adapters ): AbstractLogger;
```
Sets the adapters stack overriding what is already there

```php
public function setLogLevel( int $level ): AbstractLogger;
```
Sets the adapters stack overriding what is already there

```php
protected function addMessage( int $level, string $message, array $context = [] ): bool;
```
Adds a message to each handler for processing

```php
protected function getLevelNumber( mixed $level ): int;
```
Converts the level from string/word to an integer

```php
protected function getLevels(): array;
```
Returns an array of log levels with integer to string conversion

## Logger\Adapter\AbstractAdapter ![Abstract](/assets/images/abstract-green.svg) 

[Source on GitHub](https://github.com/phalcon/cphalcon/blob/5.0.x/phalcon/Logger/Adapter/AbstractAdapter.zep)

-   __Namespace__

    - `Phalcon\Logger\Adapter`

-   __Uses__

    - `Phalcon\Logger\Exception`
    - `Phalcon\Logger\Formatter\FormatterInterface`
    - `Phalcon\Logger\Formatter\Line`
    - `Phalcon\Logger\Item`

-   __Extends__

-   __Implements__

    - `AdapterInterface`

Class AbstractAdapter

@property string             $defaultFormatter
@property FormatterInterface $formatter
@property bool               $inTransaction
@property array              $queue

### Properties
```php
/**
 * Name of the default formatter class
 *
 * @var string
 */
protected $defaultFormatter = Phalcon\\Logger\Formatter\\Line;

/**
 * Formatter
 *
 * @var FormatterInterface|null
 */
protected $formatter;

/**
 * Tells if there is an active transaction or not
 *
 * @var bool
 */
protected $inTransaction = false;

/**
 * Array with messages queued in the transaction
 *
 * @var array
 */
protected $queue;

```

### Methods

```php
public function __destruct();
```
Destructor cleanup

@throws Exception

```php
public function __serialize(): array;
```
Prevent serialization

```php
public function __unserialize( array $data ): void;
```
Prevent unserialization

```php
public function add( Item $item ): AdapterInterface;
```
Adds a message to the queue

```php
public function begin(): AdapterInterface;
```
Starts a transaction

```php
public function commit(): AdapterInterface;
```
Commits the internal transaction

```php
public function getFormatter(): FormatterInterface;
```

```php
public function inTransaction(): bool;
```
Returns the whether the logger is currently in an active transaction or
not

```php
abstract public function process( Item $item ): void;
```
Processes the message in the adapter

```php
public function rollback(): AdapterInterface;
```
Rollbacks the internal transaction

```php
public function setFormatter( FormatterInterface $formatter ): AdapterInterface;
```
Sets the message formatter

```php
protected function getFormattedItem( Item $item ): string;
```
Returns the formatted item

## Logger\Adapter\AdapterInterface ![Interface](/assets/images/interface-blue.svg) 

[Source on GitHub](https://github.com/phalcon/cphalcon/blob/5.0.x/phalcon/Logger/Adapter/AdapterInterface.zep)

-   __Namespace__

    - `Phalcon\Logger\Adapter`

-   __Uses__

    - `Phalcon\Logger\Formatter\FormatterInterface`
    - `Phalcon\Logger\Item`

-   __Extends__

-   __Implements__

Phalcon\Logger\AdapterInterface

Interface for Phalcon\Logger adapters

### Methods

```php
public function add( Item $item ): AdapterInterface;
```
Adds a message in the queue

```php
public function begin(): AdapterInterface;
```
Starts a transaction

```php
public function close(): bool;
```
Closes the logger

```php
public function commit(): AdapterInterface;
```
Commits the internal transaction

```php
public function getFormatter(): FormatterInterface;
```
Returns the internal formatter

```php
public function inTransaction(): bool;
```
Returns the whether the logger is currently in an active transaction or
not

```php
public function process( Item $item ): void;
```
Processes the message in the adapter

```php
public function rollback(): AdapterInterface;
```
Rollbacks the internal transaction

```php
public function setFormatter( FormatterInterface $formatter ): AdapterInterface;
```
Sets the message formatter

## Logger\Adapter\Noop 

[Source on GitHub](https://github.com/phalcon/cphalcon/blob/5.0.x/phalcon/Logger/Adapter/Noop.zep)

-   __Namespace__

    - `Phalcon\Logger\Adapter`

-   __Uses__

    - `Phalcon\Logger\Item`

-   __Extends__

    `AbstractAdapter`

-   __Implements__

Class Noop

@package Phalcon\Logger\Adapter

### Methods

```php
public function close(): bool;
```
Closes the stream

```php
public function process( Item $item ): void;
```
Processes the message i.e. writes it to the file

## Logger\Adapter\Stream 

[Source on GitHub](https://github.com/phalcon/cphalcon/blob/5.0.x/phalcon/Logger/Adapter/Stream.zep)

-   __Namespace__

    - `Phalcon\Logger\Adapter`

-   __Uses__

    - `LogicException`
    - `Phalcon\Logger\Exception`
    - `Phalcon\Logger\Item`

-   __Extends__

    `AbstractAdapter`

-   __Implements__

Phalcon\Logger\Adapter\Stream

Adapter to store logs in plain text files

```php
$logger = new \Phalcon\Logger\Adapter\Stream('app/logs/test.log');

$logger->log('This is a message');
$logger->log(\Phalcon\Logger::ERROR, 'This is an error');
$logger->error('This is another error');

$logger->close();
```

@property string        $mode
@property string        $name
@property array         $options

### Properties
```php
/**
 * The file open mode. Defaults to 'ab'
 *
 * @var string
 */
protected $mode = ab;

/**
 * Stream name
 *
 * @var string
 */
protected $name;

/**
 * Path options
 *
 * @var array
 */
protected $options;

```

### Methods

```php
public function __construct( string $name, array $options = [] );
```
Stream constructor.

```php
public function close(): bool;
```
Closes the stream

```php
public function getName(): string;
```
Stream name

```php
public function process( Item $item ): void;
```
Processes the message i.e. writes it to the file

```php
protected function phpFopen( string $filename, string $mode );
```
@todo to be removed when we get traits

## Logger\Adapter\Syslog 

[Source on GitHub](https://github.com/phalcon/cphalcon/blob/5.0.x/phalcon/Logger/Adapter/Syslog.zep)

-   __Namespace__

    - `Phalcon\Logger\Adapter`

-   __Uses__

    - `LogicException`
    - `Phalcon\Logger\Item`
    - `Phalcon\Logger\Logger`

-   __Extends__

    `AbstractAdapter`

-   __Implements__

Class Syslog

@property string $defaultFormatter
@property int    $facility
@property string $name
@property bool   $opened
@property int    $option

### Properties
```php
/**
 * @var int
 */
protected $facility = ;

/**
 * @var string
 */
protected $name = ;

/**
 * @var bool
 */
protected $opened = false;

/**
 * @var int
 */
protected $option = ;

```

### Methods

```php
public function __construct( string $name, array $options = [] );
```
Syslog constructor.

```php
public function close(): bool;
```
 Closes the logger

```php
public function process( Item $item ): void;
```
Processes the message i.e. writes it to the syslog

```php
protected function openlog( string $ident, int $option, int $facility ): bool;
```
Open connection to system logger

@link https://php.net/manual/en/function.openlog.php

## Logger\AdapterFactory 

[Source on GitHub](https://github.com/phalcon/cphalcon/blob/5.0.x/phalcon/Logger/AdapterFactory.zep)

-   __Namespace__

    - `Phalcon\Logger`

-   __Uses__

    - `Phalcon\Factory\AbstractFactory`
    - `Phalcon\Logger\Adapter\AdapterInterface`
    - `Phalcon\Logger\Exception`

-   __Extends__

    `AbstractFactory`

-   __Implements__

Factory used to create adapters used for Logging

### Methods

```php
public function __construct( array $services = [] );
```
AdapterFactory constructor.

```php
public function newInstance( string $name, string $fileName, array $options = [] ): AdapterInterface;
```
Create a new instance of the adapter

```php
protected function getExceptionClass(): string;
```

```php
protected function getServices(): array;
```
Returns the available adapters

## Logger\Enum 

[Source on GitHub](https://github.com/phalcon/cphalcon/blob/5.0.x/phalcon/Logger/Enum.zep)

-   __Namespace__

    - `Phalcon\Logger`

-   __Uses__

-   __Extends__

-   __Implements__

Log Level Enum constants

### Constants
```php
const ALERT = 2;
const CRITICAL = 1;
const CUSTOM = 8;
const DEBUG = 7;
const EMERGENCY = 0;
const ERROR = 3;
const INFO = 6;
const NOTICE = 5;
const WARNING = 4;
```

## Logger\Exception 

[Source on GitHub](https://github.com/phalcon/cphalcon/blob/5.0.x/phalcon/Logger/Exception.zep)

-   __Namespace__

    - `Phalcon\Logger`

-   __Uses__

-   __Extends__

    `\Exception`

-   __Implements__

Phalcon\Logger\Exception

Exceptions thrown in Phalcon\Logger will use this class

## Logger\Formatter\AbstractFormatter ![Abstract](/assets/images/abstract-green.svg) 

[Source on GitHub](https://github.com/phalcon/cphalcon/blob/5.0.x/phalcon/Logger/Formatter/AbstractFormatter.zep)

-   __Namespace__

    - `Phalcon\Logger\Formatter`

-   __Uses__

    - `DateTimeImmutable`
    - `Phalcon\Logger\Item`
    - `Phalcon\Support\Helper\Str\AbstractStr`

-   __Extends__

    `AbstractStr`

-   __Implements__

    - `FormatterInterface`

Class AbstractFormatter

### Properties
```php
/**
 * Default date format
 *
 * @var string
 */
protected $dateFormat = c;

/**
 * @var string
 */
protected $interpolatorLeft = %;

/**
 * @var string
 */
protected $interpolatorRight = %;

```

### Methods

```php
public function getDateFormat(): string;
```

```php
public function setDateFormat( string $format ): void;
```

```php
protected function getFormattedDate( Item $item ): string;
```
Returns the date formatted for the logger.

```php
protected function getInterpolatedMessage( Item $item, string $message ): string;
```

## Logger\Formatter\FormatterInterface ![Interface](/assets/images/interface-blue.svg) 

[Source on GitHub](https://github.com/phalcon/cphalcon/blob/5.0.x/phalcon/Logger/Formatter/FormatterInterface.zep)

-   __Namespace__

    - `Phalcon\Logger\Formatter`

-   __Uses__

    - `Phalcon\Logger\Item`

-   __Extends__

-   __Implements__

Phalcon\Logger\FormatterInterface

This interface must be implemented by formatters in Phalcon\Logger

### Methods

```php
public function format( Item $item ): string;
```
Applies a format to an item

## Logger\Formatter\Json 

[Source on GitHub](https://github.com/phalcon/cphalcon/blob/5.0.x/phalcon/Logger/Formatter/Json.zep)

-   __Namespace__

    - `Phalcon\Logger\Formatter`

-   __Uses__

    - `JsonException`
    - `Phalcon\Logger\Item`

-   __Extends__

    `AbstractFormatter`

-   __Implements__

Formats messages using JSON encoding

### Methods

```php
public function __construct( string $dateFormat = string, string $interpolatorLeft = string, string $interpolatorRight = string );
```
Json constructor.

```php
public function format( Item $item ): string;
```
Applies a format to a message before sent it to the internal log

## Logger\Formatter\Line 

[Source on GitHub](https://github.com/phalcon/cphalcon/blob/5.0.x/phalcon/Logger/Formatter/Line.zep)

-   __Namespace__

    - `Phalcon\Logger\Formatter`

-   __Uses__

    - `Exception`
    - `Phalcon\Logger\Item`

-   __Extends__

    `AbstractFormatter`

-   __Implements__

Class Line

### Properties
```php
/**
 * Format applied to each message
 *
 * @var string
 */
protected $format;

```

### Methods

```php
public function __construct( string $format = string, string $dateFormat = string, string $interpolatorLeft = string, string $interpolatorRight = string );
```
Line constructor.

```php
public function format( Item $item ): string;
```
Applies a format to a message before sent it to the internal log

```php
public function getFormat(): string;
```
Return the format applied to each message

```php
public function setFormat( string $format ): Line;
```
Set the format applied to each message

## Logger\Item 

[Source on GitHub](https://github.com/phalcon/cphalcon/blob/5.0.x/phalcon/Logger/Item.zep)

-   __Namespace__

    - `Phalcon\Logger`

-   __Uses__

    - `DateTimeImmutable`

-   __Extends__

-   __Implements__

Phalcon\Logger\Item

Represents each item in a logging transaction

@property array             $context
@property string            $message
@property int               $level
@property string            $levelName
@property DateTimeImmutable $datetime

### Properties
```php
/**
 * @var array
 */
protected $context;

/**
 * @var DateTimeImmutable
 */
protected $dateTime;

/**
 * @var string
 */
protected $message;

/**
 * @var int
 */
protected $level;

/**
 * @var string
 */
protected $levelName;

```

### Methods

```php
public function __construct( string $message, string $levelName, int $level, DateTimeImmutable $dateTime, array $context = [] );
```
Item constructor.

```php
public function getContext(): array;
```

```php
public function getDateTime(): DateTimeImmutable;
```

```php
public function getLevel(): int;
```

```php
public function getLevelName(): string;
```

```php
public function getMessage(): string;
```

## Logger\Logger 

[Source on GitHub](https://github.com/phalcon/cphalcon/blob/5.0.x/phalcon/Logger/Logger.zep)

-   __Namespace__

    - `Phalcon\Logger`

-   __Uses__

    - `Exception`
    - `Phalcon\Logger\Exception`

-   __Extends__

    `AbstractLogger`

-   __Implements__

    - `LoggerInterface`

Phalcon Logger.

A logger, with various adapters and formatters. A formatter
interface is available as well as an adapter one. Adapters can be created
easily using the built-in AdapterFactory. A LoggerFactory is also available
that allows developers to create new instances of the Logger or load them
from config files (see Phalcon\Config\Config object).

### Methods

```php
public function alert( string $message, array $context = [] ): void;
```
Action must be taken immediately.

Example: Entire website down, database unavailable, etc. This should
trigger the SMS alerts and wake you up.

```php
public function critical( string $message, array $context = [] ): void;
```
Critical conditions.

Example: Application component unavailable, unexpected exception.

```php
public function debug( string $message, array $context = [] ): void;
```
Detailed debug information.

```php
public function emergency( string $message, array $context = [] ): void;
```
System is unusable.

```php
public function error( string $message, array $context = [] ): void;
```
Runtime errors that do not require immediate action but should typically
be logged and monitored.

```php
public function info( string $message, array $context = [] ): void;
```
Interesting events.

Example: User logs in, SQL logs.

```php
public function log( mixed $level, string $message, array $context = [] ): void;
```
Logs with an arbitrary level.

```php
public function notice( string $message, array $context = [] ): void;
```
Normal but significant events.

```php
public function warning( string $message, array $context = [] ): void;
```
Exceptional occurrences that are not errors.

Example: Use of deprecated APIs, poor use of an API, undesirable things
that are not necessarily wrong.

## Logger\LoggerFactory 

[Source on GitHub](https://github.com/phalcon/cphalcon/blob/5.0.x/phalcon/Logger/LoggerFactory.zep)

-   __Namespace__

    - `Phalcon\Logger`

-   __Uses__

    - `DateTimeZone`
    - `Phalcon\Config\ConfigInterface`
    - `Phalcon\Factory\AbstractConfigFactory`

-   __Extends__

    `AbstractConfigFactory`

-   __Implements__

Factory creating logger objects

### Properties
```php
/**
 * @var AdapterFactory
 */
private $adapterFactory;

```

### Methods

```php
public function __construct( AdapterFactory $factory );
```

```php
public function load( mixed $config ): Logger;
```
Factory to create an instance from a Config object

```php
public function newInstance( string $name, array $adapters = [], DateTimeZone $timezone = null ): Logger;
```
Returns a Logger object

```php
protected function getArrVal( array $collection, mixed $index, mixed $defaultValue = null ): mixed;
```
@todo Remove this when we get traits

```php
protected function getExceptionClass(): string;
```

## Logger\LoggerInterface ![Interface](/assets/images/interface-blue.svg) 

[Source on GitHub](https://github.com/phalcon/cphalcon/blob/5.0.x/phalcon/Logger/LoggerInterface.zep)

-   __Namespace__

    - `Phalcon\Logger`

-   __Uses__

    - `Phalcon\Logger\Adapter\AdapterInterface`

-   __Extends__

-   __Implements__

Interface for Phalcon based logger objects.

### Methods

```php
public function alert( string $message, array $context = [] ): void;
```
Action must be taken immediately.

Example: Entire website down, database unavailable, etc. This should
trigger the SMS alerts and wake you up.

```php
public function critical( string $message, array $context = [] ): void;
```
Critical conditions.

Example: Application component unavailable, unexpected exception.

```php
public function debug( string $message, array $context = [] ): void;
```
Detailed debug information.

```php
public function emergency( string $message, array $context = [] ): void;
```
System is unusable.

```php
public function error( string $message, array $context = [] ): void;
```
Runtime errors that do not require immediate action but should typically
be logged and monitored.

```php
public function getAdapter( string $name ): AdapterInterface;
```
Returns an adapter from the stack

```php
public function getAdapters(): array;
```
Returns the adapter stack array

```php
public function getLogLevel(): int;
```
Returns the log level

```php
public function getName(): string;
```
Returns the name of the logger

```php
public function info( string $message, array $context = [] ): void;
```
Interesting events.

Example: User logs in, SQL logs.

```php
public function log( mixed $level, string $message, array $context = [] ): void;
```
Logs with an arbitrary level.

```php
public function notice( string $message, array $context = [] ): void;
```
Normal but significant events.

```php
public function warning( string $message, array $context = [] ): void;
```
Normal but significant events.

Source: https://docs.phalcon.io/5.4/api/phalcon_logger/index.mdx