scratch – Blame information for rev
?pathlinks?
Rev | Author | Line No. | Line |
---|---|---|---|
115 | office | 1 | <?php |
2 | |||
3 | /* |
||
4 | * This file is part of the Monolog package. |
||
5 | * |
||
6 | * (c) Jordi Boggiano <j.boggiano@seld.be> |
||
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\Handler; |
||
13 | |||
14 | use Monolog\Handler\FingersCrossed\ErrorLevelActivationStrategy; |
||
15 | use Monolog\Handler\FingersCrossed\ActivationStrategyInterface; |
||
16 | use Monolog\Logger; |
||
17 | |||
18 | /** |
||
19 | * Buffers all records until a certain level is reached |
||
20 | * |
||
21 | * The advantage of this approach is that you don't get any clutter in your log files. |
||
22 | * Only requests which actually trigger an error (or whatever your actionLevel is) will be |
||
23 | * in the logs, but they will contain all records, not only those above the level threshold. |
||
24 | * |
||
25 | * You can find the various activation strategies in the |
||
26 | * Monolog\Handler\FingersCrossed\ namespace. |
||
27 | * |
||
28 | * @author Jordi Boggiano <j.boggiano@seld.be> |
||
29 | */ |
||
30 | class FingersCrossedHandler extends AbstractHandler |
||
31 | { |
||
32 | protected $handler; |
||
33 | protected $activationStrategy; |
||
34 | protected $buffering = true; |
||
35 | protected $bufferSize; |
||
36 | protected $buffer = array(); |
||
37 | protected $stopBuffering; |
||
38 | protected $passthruLevel; |
||
39 | |||
40 | /** |
||
41 | * @param callable|HandlerInterface $handler Handler or factory callable($record, $fingersCrossedHandler). |
||
42 | * @param int|ActivationStrategyInterface $activationStrategy Strategy which determines when this handler takes action |
||
43 | * @param int $bufferSize How many entries should be buffered at most, beyond that the oldest items are removed from the buffer. |
||
44 | * @param Boolean $bubble Whether the messages that are handled can bubble up the stack or not |
||
45 | * @param Boolean $stopBuffering Whether the handler should stop buffering after being triggered (default true) |
||
46 | * @param int $passthruLevel Minimum level to always flush to handler on close, even if strategy not triggered |
||
47 | */ |
||
48 | public function __construct($handler, $activationStrategy = null, $bufferSize = 0, $bubble = true, $stopBuffering = true, $passthruLevel = null) |
||
49 | { |
||
50 | if (null === $activationStrategy) { |
||
51 | $activationStrategy = new ErrorLevelActivationStrategy(Logger::WARNING); |
||
52 | } |
||
53 | |||
54 | // convert simple int activationStrategy to an object |
||
55 | if (!$activationStrategy instanceof ActivationStrategyInterface) { |
||
56 | $activationStrategy = new ErrorLevelActivationStrategy($activationStrategy); |
||
57 | } |
||
58 | |||
59 | $this->handler = $handler; |
||
60 | $this->activationStrategy = $activationStrategy; |
||
61 | $this->bufferSize = $bufferSize; |
||
62 | $this->bubble = $bubble; |
||
63 | $this->stopBuffering = $stopBuffering; |
||
64 | |||
65 | if ($passthruLevel !== null) { |
||
66 | $this->passthruLevel = Logger::toMonologLevel($passthruLevel); |
||
67 | } |
||
68 | |||
69 | if (!$this->handler instanceof HandlerInterface && !is_callable($this->handler)) { |
||
70 | throw new \RuntimeException("The given handler (".json_encode($this->handler).") is not a callable nor a Monolog\Handler\HandlerInterface object"); |
||
71 | } |
||
72 | } |
||
73 | |||
74 | /** |
||
75 | * {@inheritdoc} |
||
76 | */ |
||
77 | public function isHandling(array $record) |
||
78 | { |
||
79 | return true; |
||
80 | } |
||
81 | |||
82 | /** |
||
83 | * Manually activate this logger regardless of the activation strategy |
||
84 | */ |
||
85 | public function activate() |
||
86 | { |
||
87 | if ($this->stopBuffering) { |
||
88 | $this->buffering = false; |
||
89 | } |
||
90 | if (!$this->handler instanceof HandlerInterface) { |
||
91 | $record = end($this->buffer) ?: null; |
||
92 | |||
93 | $this->handler = call_user_func($this->handler, $record, $this); |
||
94 | if (!$this->handler instanceof HandlerInterface) { |
||
95 | throw new \RuntimeException("The factory callable should return a HandlerInterface"); |
||
96 | } |
||
97 | } |
||
98 | $this->handler->handleBatch($this->buffer); |
||
99 | $this->buffer = array(); |
||
100 | } |
||
101 | |||
102 | /** |
||
103 | * {@inheritdoc} |
||
104 | */ |
||
105 | public function handle(array $record) |
||
106 | { |
||
107 | if ($this->processors) { |
||
108 | foreach ($this->processors as $processor) { |
||
109 | $record = call_user_func($processor, $record); |
||
110 | } |
||
111 | } |
||
112 | |||
113 | if ($this->buffering) { |
||
114 | $this->buffer[] = $record; |
||
115 | if ($this->bufferSize > 0 && count($this->buffer) > $this->bufferSize) { |
||
116 | array_shift($this->buffer); |
||
117 | } |
||
118 | if ($this->activationStrategy->isHandlerActivated($record)) { |
||
119 | $this->activate(); |
||
120 | } |
||
121 | } else { |
||
122 | $this->handler->handle($record); |
||
123 | } |
||
124 | |||
125 | return false === $this->bubble; |
||
126 | } |
||
127 | |||
128 | /** |
||
129 | * {@inheritdoc} |
||
130 | */ |
||
131 | public function close() |
||
132 | { |
||
133 | if (null !== $this->passthruLevel) { |
||
134 | $level = $this->passthruLevel; |
||
135 | $this->buffer = array_filter($this->buffer, function ($record) use ($level) { |
||
136 | return $record['level'] >= $level; |
||
137 | }); |
||
138 | if (count($this->buffer) > 0) { |
||
139 | $this->handler->handleBatch($this->buffer); |
||
140 | $this->buffer = array(); |
||
141 | } |
||
142 | } |
||
143 | } |
||
144 | |||
145 | /** |
||
146 | * Resets the state of the handler. Stops forwarding records to the wrapped handler. |
||
147 | */ |
||
148 | public function reset() |
||
149 | { |
||
150 | $this->buffering = true; |
||
151 | } |
||
152 | |||
153 | /** |
||
154 | * Clears the buffer without flushing any messages down to the wrapped handler. |
||
155 | * |
||
156 | * It also resets the handler to its initial buffering state. |
||
157 | */ |
||
158 | public function clear() |
||
159 | { |
||
160 | $this->buffer = array(); |
||
161 | $this->reset(); |
||
162 | } |
||
163 | } |