Logger::addCritical()   A
last analyzed

Complexity

Conditions 1
Paths 1

Size

Total Lines 3
Code Lines 1

Duplication

Lines 0
Ratio 0 %

Importance

Changes 0
Metric Value
cc 1
eloc 1
nc 1
nop 2
dl 0
loc 3
rs 10
c 0
b 0
f 0
1
<?php
2
3
/*
4
 * This file is part of the Monolog package.
5
 *
6
 * (c) Jordi Boggiano <[email protected]>
7
 *
8
 * For the full copyright and license information, please view the LICENSE
9
 * file that was distributed with this source code.
10
 */
11
12
namespace Monolog;
13
14
use Monolog\Handler\HandlerInterface;
15
use Monolog\Handler\StreamHandler;
16
use Psr\Log\LoggerInterface;
17
use Psr\Log\InvalidArgumentException;
18
19
/**
20
 * Monolog log channel
21
 *
22
 * It contains a stack of Handlers and a stack of Processors,
23
 * and uses them to store records that are added to it.
24
 *
25
 * @author Jordi Boggiano <[email protected]>
26
 */
27
class Logger implements LoggerInterface
28
{
29
    /**
30
     * Detailed debug information
31
     */
32
    const DEBUG = 100;
33
34
    /**
35
     * Interesting events
36
     *
37
     * Examples: User logs in, SQL logs.
38
     */
39
    const INFO = 200;
40
41
    /**
42
     * Uncommon events
43
     */
44
    const NOTICE = 250;
45
46
    /**
47
     * Exceptional occurrences that are not errors
48
     *
49
     * Examples: Use of deprecated APIs, poor use of an API,
50
     * undesirable things that are not necessarily wrong.
51
     */
52
    const WARNING = 300;
53
54
    /**
55
     * Runtime errors
56
     */
57
    const ERROR = 400;
58
59
    /**
60
     * Critical conditions
61
     *
62
     * Example: Application component unavailable, unexpected exception.
63
     */
64
    const CRITICAL = 500;
65
66
    /**
67
     * Action must be taken immediately
68
     *
69
     * Example: Entire website down, database unavailable, etc.
70
     * This should trigger the SMS alerts and wake you up.
71
     */
72
    const ALERT = 550;
73
74
    /**
75
     * Urgent alert.
76
     */
77
    const EMERGENCY = 600;
78
79
    /**
80
     * Monolog API version
81
     *
82
     * This is only bumped when API breaks are done and should
83
     * follow the major version of the library
84
     *
85
     * @var int
86
     */
87
    const API = 1;
88
89
    /**
90
     * Logging levels from syslog protocol defined in RFC 5424
91
     *
92
     * @var array $levels Logging levels
93
     */
94
    protected static $levels = array(
95
        self::DEBUG     => 'DEBUG',
96
        self::INFO      => 'INFO',
97
        self::NOTICE    => 'NOTICE',
98
        self::WARNING   => 'WARNING',
99
        self::ERROR     => 'ERROR',
100
        self::CRITICAL  => 'CRITICAL',
101
        self::ALERT     => 'ALERT',
102
        self::EMERGENCY => 'EMERGENCY',
103
    );
104
105
    /**
106
     * @var \DateTimeZone
107
     */
108
    protected static $timezone;
109
110
    /**
111
     * @var string
112
     */
113
    protected $name;
114
115
    /**
116
     * The handler stack
117
     *
118
     * @var HandlerInterface[]
119
     */
120
    protected $handlers;
121
122
    /**
123
     * Processors that will process all log records
124
     *
125
     * To process records of a single handler instead, add the processor on that specific handler
126
     *
127
     * @var callable[]
128
     */
129
    protected $processors;
130
131
    /**
132
     * @var bool
133
     */
134
    protected $microsecondTimestamps = true;
135
136
    /**
137
     * @param string             $name       The logging channel
138
     * @param HandlerInterface[] $handlers   Optional stack of handlers, the first one in the array is called first, etc.
139
     * @param callable[]         $processors Optional array of processors
140
     */
141
    public function __construct($name, array $handlers = array(), array $processors = array())
142
    {
143
        $this->name = $name;
144
        $this->handlers = $handlers;
145
        $this->processors = $processors;
146
    }
147
148
    /**
149
     * @return string
150
     */
151
    public function getName()
152
    {
153
        return $this->name;
154
    }
155
156
    /**
157
     * Return a new cloned instance with the name changed
158
     *
159
     * @return static
160
     */
161
    public function withName($name)
162
    {
163
        $new = clone $this;
164
        $new->name = $name;
165
166
        return $new;
167
    }
168
169
    /**
170
     * Pushes a handler on to the stack.
171
     *
172
     * @param  HandlerInterface $handler
173
     * @return $this
174
     */
175
    public function pushHandler(HandlerInterface $handler)
176
    {
177
        array_unshift($this->handlers, $handler);
178
179
        return $this;
180
    }
181
182
    /**
183
     * Pops a handler from the stack
184
     *
185
     * @return HandlerInterface
186
     */
187
    public function popHandler()
188
    {
189
        if (!$this->handlers) {
0 ignored issues
show
Bug Best Practice introduced by
The expression $this->handlers of type Monolog\Handler\HandlerInterface[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent.

Consider making the comparison explicit by using empty(..) or ! empty(...) instead.

Loading history...
190
            throw new \LogicException('You tried to pop from an empty handler stack.');
191
        }
192
193
        return array_shift($this->handlers);
194
    }
195
196
    /**
197
     * Set handlers, replacing all existing ones.
198
     *
199
     * If a map is passed, keys will be ignored.
200
     *
201
     * @param  HandlerInterface[] $handlers
202
     * @return $this
203
     */
204
    public function setHandlers(array $handlers)
205
    {
206
        $this->handlers = array();
207
        foreach (array_reverse($handlers) as $handler) {
208
            $this->pushHandler($handler);
209
        }
210
211
        return $this;
212
    }
213
214
    /**
215
     * @return HandlerInterface[]
216
     */
217
    public function getHandlers()
218
    {
219
        return $this->handlers;
220
    }
221
222
    /**
223
     * Adds a processor on to the stack.
224
     *
225
     * @param  callable $callback
226
     * @return $this
227
     */
228
    public function pushProcessor($callback)
229
    {
230
        if (!is_callable($callback)) {
231
            throw new \InvalidArgumentException('Processors must be valid callables (callback or object with an __invoke method), '.var_export($callback, true).' given');
232
        }
233
        array_unshift($this->processors, $callback);
234
235
        return $this;
236
    }
237
238
    /**
239
     * Removes the processor on top of the stack and returns it.
240
     *
241
     * @return callable
242
     */
243
    public function popProcessor()
244
    {
245
        if (!$this->processors) {
0 ignored issues
show
Bug Best Practice introduced by
The expression $this->processors of type array<mixed,callable> is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent.

Consider making the comparison explicit by using empty(..) or ! empty(...) instead.

Loading history...
246
            throw new \LogicException('You tried to pop from an empty processor stack.');
247
        }
248
249
        return array_shift($this->processors);
250
    }
251
252
    /**
253
     * @return callable[]
254
     */
255
    public function getProcessors()
256
    {
257
        return $this->processors;
258
    }
259
260
    /**
261
     * Control the use of microsecond resolution timestamps in the 'datetime'
262
     * member of new records.
263
     *
264
     * Generating microsecond resolution timestamps by calling
265
     * microtime(true), formatting the result via sprintf() and then parsing
266
     * the resulting string via \DateTime::createFromFormat() can incur
267
     * a measurable runtime overhead vs simple usage of DateTime to capture
268
     * a second resolution timestamp in systems which generate a large number
269
     * of log events.
270
     *
271
     * @param bool $micro True to use microtime() to create timestamps
272
     */
273
    public function useMicrosecondTimestamps($micro)
274
    {
275
        $this->microsecondTimestamps = (bool) $micro;
276
    }
277
278
    /**
279
     * Adds a log record.
280
     *
281
     * @param  int     $level   The logging level
282
     * @param  string  $message The log message
283
     * @param  array   $context The log context
284
     * @return Boolean Whether the record has been processed
285
     */
286
    public function addRecord($level, $message, array $context = array())
287
    {
288
        if (!$this->handlers) {
0 ignored issues
show
Bug Best Practice introduced by
The expression $this->handlers of type Monolog\Handler\HandlerInterface[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent.

Consider making the comparison explicit by using empty(..) or ! empty(...) instead.

Loading history...
289
            $this->pushHandler(new StreamHandler('php://stderr', static::DEBUG));
290
        }
291
292
        $levelName = static::getLevelName($level);
293
294
        // check if any handler will handle this message so we can return early and save cycles
295
        $handlerKey = null;
296
        reset($this->handlers);
297
        while ($handler = current($this->handlers)) {
298
            if ($handler->isHandling(array('level' => $level))) {
299
                $handlerKey = key($this->handlers);
300
                break;
301
            }
302
303
            next($this->handlers);
304
        }
305
306
        if (null === $handlerKey) {
307
            return false;
308
        }
309
310
        if (!static::$timezone) {
311
            static::$timezone = new \DateTimeZone(date_default_timezone_get() ?: 'UTC');
312
        }
313
314
        // php7.1+ always has microseconds enabled, so we do not need this hack
315
        if ($this->microsecondTimestamps && PHP_VERSION_ID < 70100) {
316
            $ts = \DateTime::createFromFormat('U.u', sprintf('%.6F', microtime(true)), static::$timezone);
317
        } else {
318
            $ts = new \DateTime(null, static::$timezone);
319
        }
320
        $ts->setTimezone(static::$timezone);
321
322
        $record = array(
323
            'message' => (string) $message,
324
            'context' => $context,
325
            'level' => $level,
326
            'level_name' => $levelName,
327
            'channel' => $this->name,
328
            'datetime' => $ts,
329
            'extra' => array(),
330
        );
331
332
        foreach ($this->processors as $processor) {
333
            $record = call_user_func($processor, $record);
334
        }
335
336
        while ($handler = current($this->handlers)) {
337
            if (true === $handler->handle($record)) {
338
                break;
339
            }
340
341
            next($this->handlers);
342
        }
343
344
        return true;
345
    }
346
347
    /**
348
     * Adds a log record at the DEBUG level.
349
     *
350
     * @param  string  $message The log message
351
     * @param  array   $context The log context
352
     * @return Boolean Whether the record has been processed
353
     */
354
    public function addDebug($message, array $context = array())
355
    {
356
        return $this->addRecord(static::DEBUG, $message, $context);
357
    }
358
359
    /**
360
     * Adds a log record at the INFO level.
361
     *
362
     * @param  string  $message The log message
363
     * @param  array   $context The log context
364
     * @return Boolean Whether the record has been processed
365
     */
366
    public function addInfo($message, array $context = array())
367
    {
368
        return $this->addRecord(static::INFO, $message, $context);
369
    }
370
371
    /**
372
     * Adds a log record at the NOTICE level.
373
     *
374
     * @param  string  $message The log message
375
     * @param  array   $context The log context
376
     * @return Boolean Whether the record has been processed
377
     */
378
    public function addNotice($message, array $context = array())
379
    {
380
        return $this->addRecord(static::NOTICE, $message, $context);
381
    }
382
383
    /**
384
     * Adds a log record at the WARNING level.
385
     *
386
     * @param  string  $message The log message
387
     * @param  array   $context The log context
388
     * @return Boolean Whether the record has been processed
389
     */
390
    public function addWarning($message, array $context = array())
391
    {
392
        return $this->addRecord(static::WARNING, $message, $context);
393
    }
394
395
    /**
396
     * Adds a log record at the ERROR level.
397
     *
398
     * @param  string  $message The log message
399
     * @param  array   $context The log context
400
     * @return Boolean Whether the record has been processed
401
     */
402
    public function addError($message, array $context = array())
403
    {
404
        return $this->addRecord(static::ERROR, $message, $context);
405
    }
406
407
    /**
408
     * Adds a log record at the CRITICAL level.
409
     *
410
     * @param  string  $message The log message
411
     * @param  array   $context The log context
412
     * @return Boolean Whether the record has been processed
413
     */
414
    public function addCritical($message, array $context = array())
415
    {
416
        return $this->addRecord(static::CRITICAL, $message, $context);
417
    }
418
419
    /**
420
     * Adds a log record at the ALERT level.
421
     *
422
     * @param  string  $message The log message
423
     * @param  array   $context The log context
424
     * @return Boolean Whether the record has been processed
425
     */
426
    public function addAlert($message, array $context = array())
427
    {
428
        return $this->addRecord(static::ALERT, $message, $context);
429
    }
430
431
    /**
432
     * Adds a log record at the EMERGENCY level.
433
     *
434
     * @param  string  $message The log message
435
     * @param  array   $context The log context
436
     * @return Boolean Whether the record has been processed
437
     */
438
    public function addEmergency($message, array $context = array())
439
    {
440
        return $this->addRecord(static::EMERGENCY, $message, $context);
441
    }
442
443
    /**
444
     * Gets all supported logging levels.
445
     *
446
     * @return array Assoc array with human-readable level names => level codes.
447
     */
448
    public static function getLevels()
449
    {
450
        return array_flip(static::$levels);
451
    }
452
453
    /**
454
     * Gets the name of the logging level.
455
     *
456
     * @param  int    $level
457
     * @return string
458
     */
459
    public static function getLevelName($level)
460
    {
461
        if (!isset(static::$levels[$level])) {
462
            throw new InvalidArgumentException('Level "'.$level.'" is not defined, use one of: '.implode(', ', array_keys(static::$levels)));
463
        }
464
465
        return static::$levels[$level];
466
    }
467
468
    /**
469
     * Converts PSR-3 levels to Monolog ones if necessary
470
     *
471
     * @param string|int Level number (monolog) or name (PSR-3)
0 ignored issues
show
Bug introduced by
The type Monolog\Level was not found. Maybe you did not declare it correctly or list all dependencies?

The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. excluded_paths: ["lib/*"], you can move it to the dependency path list as follows:

filter:
    dependency_paths: ["lib/*"]

For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths

Loading history...
472
     * @return int
473
     */
474
    public static function toMonologLevel($level)
475
    {
476
        if (is_string($level) && defined(__CLASS__.'::'.strtoupper($level))) {
477
            return constant(__CLASS__.'::'.strtoupper($level));
478
        }
479
480
        return $level;
481
    }
482
483
    /**
484
     * Checks whether the Logger has a handler that listens on the given level
485
     *
486
     * @param  int     $level
487
     * @return Boolean
488
     */
489
    public function isHandling($level)
490
    {
491
        $record = array(
492
            'level' => $level,
493
        );
494
495
        foreach ($this->handlers as $handler) {
496
            if ($handler->isHandling($record)) {
497
                return true;
498
            }
499
        }
500
501
        return false;
502
    }
503
504
    /**
505
     * Adds a log record at an arbitrary level.
506
     *
507
     * This method allows for compatibility with common interfaces.
508
     *
509
     * @param  mixed   $level   The log level
510
     * @param  string  $message The log message
511
     * @param  array   $context The log context
512
     * @return Boolean Whether the record has been processed
513
     */
514
    public function log($level, $message, array $context = array())
515
    {
516
        $level = static::toMonologLevel($level);
517
518
        return $this->addRecord($level, $message, $context);
0 ignored issues
show
Bug Best Practice introduced by
The expression return $this->addRecord(...el, $message, $context) returns the type boolean which is incompatible with the return type mandated by Psr\Log\LoggerInterface::log() of null.

In the issue above, the returned value is violating the contract defined by the mentioned interface.

Let's take a look at an example:

interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
Loading history...
519
    }
520
521
    /**
522
     * Adds a log record at the DEBUG level.
523
     *
524
     * This method allows for compatibility with common interfaces.
525
     *
526
     * @param  string  $message The log message
527
     * @param  array   $context The log context
528
     * @return Boolean Whether the record has been processed
529
     */
530
    public function debug($message, array $context = array())
531
    {
532
        return $this->addRecord(static::DEBUG, $message, $context);
0 ignored issues
show
Bug Best Practice introduced by
The expression return $this->addRecord(...UG, $message, $context) returns the type boolean which is incompatible with the return type mandated by Psr\Log\LoggerInterface::debug() of null.

In the issue above, the returned value is violating the contract defined by the mentioned interface.

Let's take a look at an example:

interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
Loading history...
533
    }
534
535
    /**
536
     * Adds a log record at the INFO level.
537
     *
538
     * This method allows for compatibility with common interfaces.
539
     *
540
     * @param  string  $message The log message
541
     * @param  array   $context The log context
542
     * @return Boolean Whether the record has been processed
543
     */
544
    public function info($message, array $context = array())
545
    {
546
        return $this->addRecord(static::INFO, $message, $context);
0 ignored issues
show
Bug Best Practice introduced by
The expression return $this->addRecord(...FO, $message, $context) returns the type boolean which is incompatible with the return type mandated by Psr\Log\LoggerInterface::info() of null.

In the issue above, the returned value is violating the contract defined by the mentioned interface.

Let's take a look at an example:

interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
Loading history...
547
    }
548
549
    /**
550
     * Adds a log record at the NOTICE level.
551
     *
552
     * This method allows for compatibility with common interfaces.
553
     *
554
     * @param  string  $message The log message
555
     * @param  array   $context The log context
556
     * @return Boolean Whether the record has been processed
557
     */
558
    public function notice($message, array $context = array())
559
    {
560
        return $this->addRecord(static::NOTICE, $message, $context);
0 ignored issues
show
Bug Best Practice introduced by
The expression return $this->addRecord(...CE, $message, $context) returns the type boolean which is incompatible with the return type mandated by Psr\Log\LoggerInterface::notice() of null.

In the issue above, the returned value is violating the contract defined by the mentioned interface.

Let's take a look at an example:

interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
Loading history...
561
    }
562
563
    /**
564
     * Adds a log record at the WARNING level.
565
     *
566
     * This method allows for compatibility with common interfaces.
567
     *
568
     * @param  string  $message The log message
569
     * @param  array   $context The log context
570
     * @return Boolean Whether the record has been processed
571
     */
572
    public function warn($message, array $context = array())
573
    {
574
        return $this->addRecord(static::WARNING, $message, $context);
575
    }
576
577
    /**
578
     * Adds a log record at the WARNING level.
579
     *
580
     * This method allows for compatibility with common interfaces.
581
     *
582
     * @param  string  $message The log message
583
     * @param  array   $context The log context
584
     * @return Boolean Whether the record has been processed
585
     */
586
    public function warning($message, array $context = array())
587
    {
588
        return $this->addRecord(static::WARNING, $message, $context);
0 ignored issues
show
Bug Best Practice introduced by
The expression return $this->addRecord(...NG, $message, $context) returns the type boolean which is incompatible with the return type mandated by Psr\Log\LoggerInterface::warning() of null.

In the issue above, the returned value is violating the contract defined by the mentioned interface.

Let's take a look at an example:

interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
Loading history...
589
    }
590
591
    /**
592
     * Adds a log record at the ERROR level.
593
     *
594
     * This method allows for compatibility with common interfaces.
595
     *
596
     * @param  string  $message The log message
597
     * @param  array   $context The log context
598
     * @return Boolean Whether the record has been processed
599
     */
600
    public function err($message, array $context = array())
601
    {
602
        return $this->addRecord(static::ERROR, $message, $context);
603
    }
604
605
    /**
606
     * Adds a log record at the ERROR level.
607
     *
608
     * This method allows for compatibility with common interfaces.
609
     *
610
     * @param  string  $message The log message
611
     * @param  array   $context The log context
612
     * @return Boolean Whether the record has been processed
613
     */
614
    public function error($message, array $context = array())
615
    {
616
        return $this->addRecord(static::ERROR, $message, $context);
0 ignored issues
show
Bug Best Practice introduced by
The expression return $this->addRecord(...OR, $message, $context) returns the type boolean which is incompatible with the return type mandated by Psr\Log\LoggerInterface::error() of null.

In the issue above, the returned value is violating the contract defined by the mentioned interface.

Let's take a look at an example:

interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
Loading history...
617
    }
618
619
    /**
620
     * Adds a log record at the CRITICAL level.
621
     *
622
     * This method allows for compatibility with common interfaces.
623
     *
624
     * @param  string  $message The log message
625
     * @param  array   $context The log context
626
     * @return Boolean Whether the record has been processed
627
     */
628
    public function crit($message, array $context = array())
629
    {
630
        return $this->addRecord(static::CRITICAL, $message, $context);
631
    }
632
633
    /**
634
     * Adds a log record at the CRITICAL level.
635
     *
636
     * This method allows for compatibility with common interfaces.
637
     *
638
     * @param  string  $message The log message
639
     * @param  array   $context The log context
640
     * @return Boolean Whether the record has been processed
641
     */
642
    public function critical($message, array $context = array())
643
    {
644
        return $this->addRecord(static::CRITICAL, $message, $context);
0 ignored issues
show
Bug Best Practice introduced by
The expression return $this->addRecord(...AL, $message, $context) returns the type boolean which is incompatible with the return type mandated by Psr\Log\LoggerInterface::critical() of null.

In the issue above, the returned value is violating the contract defined by the mentioned interface.

Let's take a look at an example:

interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
Loading history...
645
    }
646
647
    /**
648
     * Adds a log record at the ALERT level.
649
     *
650
     * This method allows for compatibility with common interfaces.
651
     *
652
     * @param  string  $message The log message
653
     * @param  array   $context The log context
654
     * @return Boolean Whether the record has been processed
655
     */
656
    public function alert($message, array $context = array())
657
    {
658
        return $this->addRecord(static::ALERT, $message, $context);
0 ignored issues
show
Bug Best Practice introduced by
The expression return $this->addRecord(...RT, $message, $context) returns the type boolean which is incompatible with the return type mandated by Psr\Log\LoggerInterface::alert() of null.

In the issue above, the returned value is violating the contract defined by the mentioned interface.

Let's take a look at an example:

interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
Loading history...
659
    }
660
661
    /**
662
     * Adds a log record at the EMERGENCY level.
663
     *
664
     * This method allows for compatibility with common interfaces.
665
     *
666
     * @param  string  $message The log message
667
     * @param  array   $context The log context
668
     * @return Boolean Whether the record has been processed
669
     */
670
    public function emerg($message, array $context = array())
671
    {
672
        return $this->addRecord(static::EMERGENCY, $message, $context);
673
    }
674
675
    /**
676
     * Adds a log record at the EMERGENCY level.
677
     *
678
     * This method allows for compatibility with common interfaces.
679
     *
680
     * @param  string  $message The log message
681
     * @param  array   $context The log context
682
     * @return Boolean Whether the record has been processed
683
     */
684
    public function emergency($message, array $context = array())
685
    {
686
        return $this->addRecord(static::EMERGENCY, $message, $context);
0 ignored issues
show
Bug Best Practice introduced by
The expression return $this->addRecord(...CY, $message, $context) returns the type boolean which is incompatible with the return type mandated by Psr\Log\LoggerInterface::emergency() of null.

In the issue above, the returned value is violating the contract defined by the mentioned interface.

Let's take a look at an example:

interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
Loading history...
687
    }
688
689
    /**
690
     * Set the timezone to be used for the timestamp of log records.
691
     *
692
     * This is stored globally for all Logger instances
693
     *
694
     * @param \DateTimeZone $tz Timezone object
695
     */
696
    public static function setTimezone(\DateTimeZone $tz)
697
    {
698
        self::$timezone = $tz;
699
    }
700
}
701