@larablox/monolog 0.1.0 → 0.2.0

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011-2020 Jordi Boggiano
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,86 @@
+# Larablox Monolog - Logging for Roblox
+
+A roblox-ts port of [Monolog](https://github.com/Seldaek/monolog), as
+faithfully as the Roblox platform allows. Upstream Monolog sends logs to
+files, sockets, inboxes, databases, and web services; this port ships only
+what a Roblox place can actually back -- printing to the output console, and
+discarding. See [`CLAUDE.md`](CLAUDE.md)'s "Not ported" section for the full,
+maintained list of what didn't make the trip and why.
+
+This package implements the same shape as PSR-3's
+[`LoggerInterface`](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md)
+(`LoggerInterface.ts`), so code written against it stays interoperable with
+the concept even without a real `psr/log` package on this platform.
+
+## Installation
+
+```bash
+npm install @larablox/monolog
+```
+
+## Basic Usage
+
+```ts
+import { Logger } from "@larablox/monolog/out/Monolog/Logger";
+import { RobloxConsoleHandler } from "@larablox/monolog/out/Monolog/Handler/RobloxConsoleHandler";
+import { Level } from "@larablox/monolog/out/Monolog/Level";
+
+// create a log channel
+const log = new Logger("name");
+log.pushHandler(new RobloxConsoleHandler(Level.Warning));
+
+// add records to the log
+log.warning("Foo");
+log.error("Bar");
+```
+
+There is no package-level barrel export -- `src/index.ts` explains why --
+so consumers deep-import each class the way the example above does.
+
+## What's included
+
+- Core: `Logger`, `LoggerInterface` (the PSR-3 shape), `Level`, `LogRecord`,
+  `Registry`, `Utils`, `ResettableInterface`
+- Handlers: `NullHandler`, `RobloxConsoleHandler` (writes formatted records to
+  the Roblox output console), and `TestHandler` for your own tests
+- Wrapping handlers: `GroupHandler`, `WhatFailureGroupHandler`,
+  `FingersCrossedHandler` (with `ErrorLevelActivationStrategy` and
+  `ChannelLevelActivationStrategy`)
+- Handler base classes and interfaces, for writing your own: `Handler`,
+  `AbstractHandler`, `AbstractProcessingHandler`, `HandlerInterface`,
+  `FormattableHandlerInterface`, `ProcessableHandlerInterface`
+- Formatters: `NormalizerFormatter`, `LineFormatter`, `JsonFormatter`,
+  `ScalarFormatter`, `HtmlFormatter`, and `FormatterInterface`
+- Processors: `PsrLogMessageProcessor`, `ClosureContextProcessor`,
+  `IntrospectionProcessor`, `MemoryUsageProcessor`, `MemoryPeakUsageProcessor`,
+  `ProcessIdProcessor`, `TagProcessor`, `UidProcessor`, and
+  `ProcessorInterface`
+- Attributes: `WithMonologChannel`, `AsMonologProcessor`
+- Test helpers: `Test/MonologTestCase` (plus `Test/TestCase`, upstream's
+  deprecated alias for it), shipped in the published package the same way
+  upstream ships them, because consumers use them in their own suites
+
+## Submitting bugs and feature requests
+
+Bugs and feature requests are tracked on
+[GitHub](https://github.com/larablox/monolog/issues).
+
+## Requirements
+
+- TypeScript 5.x compiled with [roblox-ts](https://roblox-ts.com/) `^3.0`
+- A Rojo-synced Roblox place to run the compiled output in
+
+## Framework Integration
+
+[`larablox/framework`](https://github.com/larablox/framework)'s
+`Illuminate\Log` is built on this package.
+
+## License
+
+MIT, matching upstream Monolog.
+
+## Acknowledgements
+
+This is a TypeScript/roblox-ts port of [Monolog](https://github.com/Seldaek/monolog)
+by Jordi Boggiano, adapted to run on the Roblox platform as faithfully as it
+allows.

package/out/Monolog/Handler/AbstractProcessingHandler.d.ts

@@ -1,12 +1,14 @@
 import { AbstractHandler } from "./AbstractHandler";
+import type { FormattableHandlerInterface } from "./FormattableHandlerInterface";
 import type { FormatterInterface } from "../Formatter/FormatterInterface";
 import type { LogRecord } from "../LogRecord";
+import type { ProcessableHandlerInterface } from "./ProcessableHandlerInterface";
 import type { Processor } from "../Processor/ProcessorInterface";
 /**
  * PHP: `Monolog\Handler\AbstractProcessingHandler`, which folds in
  * `ProcessableHandlerTrait` and `FormattableHandlerTrait`.
  */
-export declare abstract class AbstractProcessingHandler extends AbstractHandler {
+export declare abstract class AbstractProcessingHandler extends AbstractHandler implements ProcessableHandlerInterface, FormattableHandlerInterface {
     protected processors: Processor[];
     protected formatter?: FormatterInterface;
     /** Handles a record. */

package/out/Monolog/Handler/FingersCrossed/ActivationStrategyInterface.d.ts

@@ -0,0 +1,19 @@
+import type { LogRecord } from "../../LogRecord";
+/**
+ * PHP: `Monolog\Handler\FingersCrossed\ActivationStrategyInterface`.
+ *
+ * Interface for activation strategies for the `FingersCrossedHandler`.
+ */
+export interface ActivationStrategyInterface {
+    /** Returns whether the given record activates the handler. */
+    isHandlerActivated(record: LogRecord): boolean;
+}
+/**
+ * True when the given value implements `ActivationStrategyInterface`.
+ *
+ * `FingersCrossedHandler`'s constructor takes either a strategy or a bare
+ * level and branches on `instanceof`; there is no `instanceof` for an
+ * interface here, so this checks structurally for the one callable member, as
+ * `isResettable()` (`ResettableInterface.ts`) already does for its own.
+ */
+export declare function isActivationStrategy(value: unknown): value is ActivationStrategyInterface;

package/out/Monolog/Handler/FingersCrossed/ActivationStrategyInterface.luau

@@ -0,0 +1,30 @@
+-- Compiled with roblox-ts v3.0.0
+--[[
+	*
+	 * PHP: `Monolog\Handler\FingersCrossed\ActivationStrategyInterface`.
+	 *
+	 * Interface for activation strategies for the `FingersCrossedHandler`.
+	 
+]]
+--[[
+	*
+	 * True when the given value implements `ActivationStrategyInterface`.
+	 *
+	 * `FingersCrossedHandler`'s constructor takes either a strategy or a bare
+	 * level and branches on `instanceof`; there is no `instanceof` for an
+	 * interface here, so this checks structurally for the one callable member, as
+	 * `isResettable()` (`ResettableInterface.ts`) already does for its own.
+	 
+]]
+local function isActivationStrategy(value)
+	local _value = value
+	if not (type(_value) == "table") then
+		return false
+	end
+	local candidate = value
+	local _isHandlerActivated = candidate.isHandlerActivated
+	return type(_isHandlerActivated) == "function"
+end
+return {
+	isActivationStrategy = isActivationStrategy,
+}

package/out/Monolog/Handler/FingersCrossed/ChannelLevelActivationStrategy.d.ts

@@ -0,0 +1,29 @@
+import type { ActivationStrategyInterface } from "./ActivationStrategyInterface";
+import type { Level } from "../../Level";
+import type { LogLevel } from "../../LoggerInterface";
+import type { LogRecord } from "../../LogRecord";
+/**
+ * PHP: `Monolog\Handler\FingersCrossed\ChannelLevelActivationStrategy`.
+ *
+ * Channel and error level based activation strategy. Allows triggering
+ * activation based on level per channel: e.g. trigger activation on level
+ * `Error` by default, except for records of the `sql` channel, which should
+ * trigger activation on level `Warning`.
+ *
+ * ```ts
+ * const activationStrategy = new ChannelLevelActivationStrategy(
+ *     Level.Critical,
+ *     { request: Level.Alert, sensitive: Level.Error },
+ * );
+ * const handler = new FingersCrossedHandler(
+ *     new RobloxConsoleHandler(),
+ *     activationStrategy,
+ * );
+ * ```
+ */
+export declare class ChannelLevelActivationStrategy implements ActivationStrategyInterface {
+    private readonly defaultActionLevel;
+    private readonly channelToActionLevel;
+    constructor(defaultActionLevel: Level | LogLevel, channelToActionLevel?: Record<string, Level | LogLevel>);
+    isHandlerActivated(record: LogRecord): boolean;
+}

package/out/Monolog/Handler/FingersCrossed/ChannelLevelActivationStrategy.luau

@@ -0,0 +1,61 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local Logger = TS.import(script, script.Parent.Parent.Parent, "Logger").Logger
+--[[
+	*
+	 * PHP: `Monolog\Handler\FingersCrossed\ChannelLevelActivationStrategy`.
+	 *
+	 * Channel and error level based activation strategy. Allows triggering
+	 * activation based on level per channel: e.g. trigger activation on level
+	 * `Error` by default, except for records of the `sql` channel, which should
+	 * trigger activation on level `Warning`.
+	 *
+	 * ```ts
+	 * const activationStrategy = new ChannelLevelActivationStrategy(
+	 *     Level.Critical,
+	 *     { request: Level.Alert, sensitive: Level.Error },
+	 * );
+	 * const handler = new FingersCrossedHandler(
+	 *     new RobloxConsoleHandler(),
+	 *     activationStrategy,
+	 * );
+	 * ```
+	 
+]]
+local ChannelLevelActivationStrategy
+do
+	ChannelLevelActivationStrategy = setmetatable({}, {
+		__tostring = function()
+			return "ChannelLevelActivationStrategy"
+		end,
+	})
+	ChannelLevelActivationStrategy.__index = ChannelLevelActivationStrategy
+	function ChannelLevelActivationStrategy.new(...)
+		local self = setmetatable({}, ChannelLevelActivationStrategy)
+		return self:constructor(...) or self
+	end
+	function ChannelLevelActivationStrategy:constructor(defaultActionLevel, channelToActionLevel)
+		if channelToActionLevel == nil then
+			channelToActionLevel = {}
+		end
+		self.channelToActionLevel = {}
+		self.defaultActionLevel = Logger:toMonologLevel(defaultActionLevel)
+		for channel, level in pairs(channelToActionLevel) do
+			local _channelToActionLevel = self.channelToActionLevel
+			local _arg1 = Logger:toMonologLevel(level)
+			_channelToActionLevel[channel] = _arg1
+		end
+	end
+	function ChannelLevelActivationStrategy:isHandlerActivated(record)
+		local _channelToActionLevel = self.channelToActionLevel
+		local _channel = record.channel
+		local channelLevel = _channelToActionLevel[_channel]
+		if channelLevel ~= nil then
+			return record.level >= channelLevel
+		end
+		return record.level >= self.defaultActionLevel
+	end
+end
+return {
+	ChannelLevelActivationStrategy = ChannelLevelActivationStrategy,
+}

package/out/Monolog/Handler/FingersCrossed/ErrorLevelActivationStrategy.d.ts

@@ -0,0 +1,14 @@
+import type { ActivationStrategyInterface } from "./ActivationStrategyInterface";
+import type { Level } from "../../Level";
+import type { LogLevel } from "../../LoggerInterface";
+import type { LogRecord } from "../../LogRecord";
+/**
+ * PHP: `Monolog\Handler\FingersCrossed\ErrorLevelActivationStrategy`.
+ *
+ * Error level based activation strategy.
+ */
+export declare class ErrorLevelActivationStrategy implements ActivationStrategyInterface {
+    private readonly actionLevel;
+    constructor(actionLevel: Level | LogLevel);
+    isHandlerActivated(record: LogRecord): boolean;
+}

package/out/Monolog/Handler/FingersCrossed/ErrorLevelActivationStrategy.luau

@@ -0,0 +1,32 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local Logger = TS.import(script, script.Parent.Parent.Parent, "Logger").Logger
+--[[
+	*
+	 * PHP: `Monolog\Handler\FingersCrossed\ErrorLevelActivationStrategy`.
+	 *
+	 * Error level based activation strategy.
+	 
+]]
+local ErrorLevelActivationStrategy
+do
+	ErrorLevelActivationStrategy = setmetatable({}, {
+		__tostring = function()
+			return "ErrorLevelActivationStrategy"
+		end,
+	})
+	ErrorLevelActivationStrategy.__index = ErrorLevelActivationStrategy
+	function ErrorLevelActivationStrategy.new(...)
+		local self = setmetatable({}, ErrorLevelActivationStrategy)
+		return self:constructor(...) or self
+	end
+	function ErrorLevelActivationStrategy:constructor(actionLevel)
+		self.actionLevel = Logger:toMonologLevel(actionLevel)
+	end
+	function ErrorLevelActivationStrategy:isHandlerActivated(record)
+		return record.level >= self.actionLevel
+	end
+end
+return {
+	ErrorLevelActivationStrategy = ErrorLevelActivationStrategy,
+}

package/out/Monolog/Handler/FingersCrossedHandler.d.ts

@@ -0,0 +1,107 @@
+import { Handler } from "./Handler";
+import { Level } from "../Level";
+import type { ActivationStrategyInterface } from "./FingersCrossed/ActivationStrategyInterface";
+import type { FormattableHandlerInterface } from "./FormattableHandlerInterface";
+import type { FormatterInterface } from "../Formatter/FormatterInterface";
+import type { HandlerInterface } from "./HandlerInterface";
+import type { LogLevel } from "../LoggerInterface";
+import type { LogRecord } from "../LogRecord";
+import type { Processor } from "../Processor/ProcessorInterface";
+import type { ProcessableHandlerInterface } from "./ProcessableHandlerInterface";
+import type { ResettableInterface } from "../ResettableInterface";
+/**
+ * PHP: the `Closure(LogRecord|null, HandlerInterface): HandlerInterface`
+ * factory `FingersCrossedHandler` accepts in place of a handler.
+ */
+export type HandlerFactory = (record: LogRecord | undefined, handler: FingersCrossedHandler) => HandlerInterface;
+/**
+ * PHP: `Monolog\Handler\FingersCrossedHandler`.
+ *
+ * Buffers all records until a certain level is reached.
+ *
+ * The advantage of this approach is that you get no clutter in your log. Only
+ * sessions which actually trigger an error (or whatever the
+ * `activationStrategy` is) end up in the log, but they contain all records,
+ * not only those above the level threshold.
+ *
+ * There is a `passthruLevel` as well, which means that at the end, even if the
+ * handler never got activated, it will still send through log records of at
+ * least that level.
+ *
+ * Upstream gets its processor stack from `ProcessableHandlerTrait`; Luau has
+ * no traits, so the trait's members are spelled out here -- see the same note
+ * on `GroupHandler` and `AbstractProcessingHandler`.
+ */
+export declare class FingersCrossedHandler extends Handler implements ProcessableHandlerInterface, ResettableInterface, FormattableHandlerInterface {
+    protected processors: Processor[];
+    /** The nested handler, or the factory that will produce it on first use. */
+    protected handler: HandlerInterface | HandlerFactory;
+    protected activationStrategy: ActivationStrategyInterface;
+    protected buffering: boolean;
+    protected bufferSize: number;
+    protected buffer: LogRecord[];
+    protected stopBuffering: boolean;
+    protected passthruLevel?: Level;
+    protected bubble: boolean;
+    /**
+     * @param handler Handler or factory `(record | undefined, fingersCrossedHandler)`.
+     * @param activationStrategy Strategy determining when this handler takes
+     *   action, or a level (name or `Level`) at which it is activated.
+     * @param bufferSize How many entries to buffer at most; beyond that the
+     *   oldest items are removed from the buffer. `0` means unbounded.
+     * @param bubble Whether the handled messages can bubble up the stack.
+     * @param stopBuffering Whether to stop buffering after being triggered.
+     * @param passthruLevel Minimum level to always flush to the nested handler
+     *   on close, even if the strategy never triggered.
+     */
+    constructor(handler: HandlerInterface | HandlerFactory, activationStrategy?: Level | LogLevel | ActivationStrategyInterface, bufferSize?: number, bubble?: boolean, stopBuffering?: boolean, passthruLevel?: Level | LogLevel);
+    /** Always true -- this handler decides what to do with a record later. */
+    isHandling(_record: LogRecord): boolean;
+    /** Manually activates this handler regardless of the activation strategy. */
+    activate(): void;
+    /** Handles a record, buffering it until the strategy activates. */
+    handle(record: LogRecord): boolean;
+    /** Flushes anything left at the passthru level, then closes the nested handler. */
+    close(): void;
+    /** Resets this handler, its processors, and the nested handler. */
+    reset(): void;
+    /**
+     * Clears the buffer without flushing any messages down to the wrapped
+     * handler. Also resets the handler to its initial buffering state.
+     */
+    clear(): void;
+    /**
+     * Resets the state of the handler. Stops forwarding records to the wrapped
+     * handler.
+     */
+    private flushBuffer;
+    /**
+     * Returns the nested handler.
+     *
+     * If the handler was provided as a factory, this triggers the handler's
+     * instantiation.
+     *
+     * Upstream's `\RuntimeException` for a factory that returns a non-handler
+     * is kept -- there is no exception class hierarchy on this platform, so it
+     * is a plain `error()` carrying upstream's message.
+     */
+    getHandler(record?: LogRecord): HandlerInterface;
+    /** Adds a processor in the stack. */
+    pushProcessor(processor: Processor): this;
+    /** Removes the processor on top of the stack and returns it. */
+    popProcessor(): Processor | undefined;
+    /** Processes a record. */
+    protected processRecord(record: LogRecord): LogRecord;
+    /** Resets any processors on this handler that support resetting. */
+    protected resetProcessors(): void;
+    /**
+     * Sets the formatter on the nested handler.
+     *
+     * Upstream's `\UnexpectedValueException` names the offending class with
+     * `get_class()`; `Utils.getClass()` is not ported (see `Utils.ts`), so the
+     * name comes from the roblox-ts class metatable's `__tostring` instead.
+     */
+    setFormatter(formatter: FormatterInterface): this;
+    /** Gets the formatter of the nested handler. */
+    getFormatter(): FormatterInterface;
+}

package/out/Monolog/Handler/FingersCrossedHandler.luau

@@ -0,0 +1,208 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local ErrorLevelActivationStrategy = TS.import(script, script.Parent, "FingersCrossed", "ErrorLevelActivationStrategy").ErrorLevelActivationStrategy
+local Handler = TS.import(script, script.Parent, "Handler").Handler
+local isActivationStrategy = TS.import(script, script.Parent, "FingersCrossed", "ActivationStrategyInterface").isActivationStrategy
+local isFormattable = TS.import(script, script.Parent, "FormattableHandlerInterface").isFormattable
+local isHandler = TS.import(script, script.Parent, "HandlerInterface").isHandler
+local isResettable = TS.import(script, script.Parent.Parent, "ResettableInterface").isResettable
+local _Level = TS.import(script, script.Parent.Parent, "Level")
+local Level = _Level.Level
+local Levels = _Level.Levels
+local Logger = TS.import(script, script.Parent.Parent, "Logger").Logger
+local runProcessor = TS.import(script, script.Parent.Parent, "Processor", "ProcessorInterface").runProcessor
+--[[
+	*
+	 * PHP: the `Closure(LogRecord|null, HandlerInterface): HandlerInterface`
+	 * factory `FingersCrossedHandler` accepts in place of a handler.
+	 
+]]
+--[[
+	*
+	 * PHP: `Monolog\Handler\FingersCrossedHandler`.
+	 *
+	 * Buffers all records until a certain level is reached.
+	 *
+	 * The advantage of this approach is that you get no clutter in your log. Only
+	 * sessions which actually trigger an error (or whatever the
+	 * `activationStrategy` is) end up in the log, but they contain all records,
+	 * not only those above the level threshold.
+	 *
+	 * There is a `passthruLevel` as well, which means that at the end, even if the
+	 * handler never got activated, it will still send through log records of at
+	 * least that level.
+	 *
+	 * Upstream gets its processor stack from `ProcessableHandlerTrait`; Luau has
+	 * no traits, so the trait's members are spelled out here -- see the same note
+	 * on `GroupHandler` and `AbstractProcessingHandler`.
+	 
+]]
+local FingersCrossedHandler
+do
+	local super = Handler
+	FingersCrossedHandler = setmetatable({}, {
+		__tostring = function()
+			return "FingersCrossedHandler"
+		end,
+		__index = super,
+	})
+	FingersCrossedHandler.__index = FingersCrossedHandler
+	function FingersCrossedHandler.new(...)
+		local self = setmetatable({}, FingersCrossedHandler)
+		return self:constructor(...) or self
+	end
+	function FingersCrossedHandler:constructor(handler, activationStrategy, bufferSize, bubble, stopBuffering, passthruLevel)
+		if bufferSize == nil then
+			bufferSize = 0
+		end
+		if bubble == nil then
+			bubble = true
+		end
+		if stopBuffering == nil then
+			stopBuffering = true
+		end
+		super.constructor(self)
+		self.processors = {}
+		self.buffering = true
+		self.buffer = {}
+		local strategy = activationStrategy
+		if strategy == nil then
+			strategy = ErrorLevelActivationStrategy.new(Level.Warning)
+		end
+		-- Convert a bare level activationStrategy to an object.
+		if not isActivationStrategy(strategy) then
+			strategy = ErrorLevelActivationStrategy.new(strategy)
+		end
+		self.handler = handler
+		self.activationStrategy = strategy
+		self.bufferSize = bufferSize
+		self.bubble = bubble
+		self.stopBuffering = stopBuffering
+		if passthruLevel ~= nil then
+			self.passthruLevel = Logger:toMonologLevel(passthruLevel)
+		end
+	end
+	function FingersCrossedHandler:isHandling(_record)
+		return true
+	end
+	function FingersCrossedHandler:activate()
+		if self.stopBuffering then
+			self.buffering = false
+		end
+		self:getHandler(self.buffer[#self.buffer]):handleBatch(self.buffer)
+		self.buffer = {}
+	end
+	function FingersCrossedHandler:handle(record)
+		local processed = record
+		if not (#self.processors == 0) then
+			processed = self:processRecord(processed)
+		end
+		if self.buffering then
+			local _buffer = self.buffer
+			local _processed = processed
+			table.insert(_buffer, _processed)
+			if self.bufferSize > 0 and #self.buffer > self.bufferSize then
+				table.remove(self.buffer, 1)
+			end
+			if self.activationStrategy:isHandlerActivated(processed) then
+				self:activate()
+			end
+		else
+			self:getHandler(processed):handle(processed)
+		end
+		return self.bubble == false
+	end
+	function FingersCrossedHandler:close()
+		self:flushBuffer()
+		self:getHandler():close()
+	end
+	function FingersCrossedHandler:reset()
+		self:flushBuffer()
+		self:resetProcessors()
+		local handler = self:getHandler()
+		if isResettable(handler) then
+			handler:reset()
+		end
+	end
+	function FingersCrossedHandler:clear()
+		self.buffer = {}
+		self:reset()
+	end
+	function FingersCrossedHandler:flushBuffer()
+		local passthruLevel = self.passthruLevel
+		if passthruLevel ~= nil then
+			local _exp = self.buffer
+			-- ▼ ReadonlyArray.filter ▼
+			local _newValue = {}
+			local _callback = function(record)
+				return Levels:includes(passthruLevel, record.level)
+			end
+			local _length = 0
+			for _k, _v in _exp do
+				if _callback(_v, _k - 1, _exp) == true then
+					_length += 1
+					_newValue[_length] = _v
+				end
+			end
+			-- ▲ ReadonlyArray.filter ▲
+			self.buffer = _newValue
+			if not (#self.buffer == 0) then
+				self:getHandler(self.buffer[#self.buffer]):handleBatch(self.buffer)
+			end
+		end
+		self.buffer = {}
+		self.buffering = true
+	end
+	function FingersCrossedHandler:getHandler(record)
+		local _handler = self.handler
+		if type(_handler) == "function" then
+			local produced = self.handler(record, self)
+			if not isHandler(produced) then
+				error("The factory Closure should return a HandlerInterface")
+			end
+			self.handler = produced
+		end
+		return self.handler
+	end
+	function FingersCrossedHandler:pushProcessor(processor)
+		local _processors = self.processors
+		local _processor = processor
+		table.insert(_processors, 1, _processor)
+		return self
+	end
+	function FingersCrossedHandler:popProcessor()
+		return table.remove(self.processors, 1)
+	end
+	function FingersCrossedHandler:processRecord(record)
+		local processed = record
+		for _, processor in self.processors do
+			processed = runProcessor(processor, processed)
+		end
+		return processed
+	end
+	function FingersCrossedHandler:resetProcessors()
+		for _, processor in self.processors do
+			if isResettable(processor) then
+				processor:reset()
+			end
+		end
+	end
+	function FingersCrossedHandler:setFormatter(formatter)
+		local handler = self:getHandler()
+		if isFormattable(handler) then
+			handler:setFormatter(formatter)
+			return self
+		end
+		return error(`The nested handler of type {tostring((getmetatable(handler)))} does not support formatters.`)
+	end
+	function FingersCrossedHandler:getFormatter()
+		local handler = self:getHandler()
+		if isFormattable(handler) then
+			return handler:getFormatter()
+		end
+		return error(`The nested handler of type {tostring((getmetatable(handler)))} does not support formatters.`)
+	end
+end
+return {
+	FingersCrossedHandler = FingersCrossedHandler,
+}

package/out/Monolog/Handler/FormattableHandlerInterface.d.ts

@@ -0,0 +1,23 @@
+import type { FormatterInterface } from "../Formatter/FormatterInterface";
+import type { HandlerInterface } from "./HandlerInterface";
+/**
+ * PHP: `Monolog\Handler\FormattableHandlerInterface`.
+ *
+ * Upstream pairs this with `FormattableHandlerTrait`; Luau has no traits, so
+ * implementers carry the `$formatter` field and `getDefaultFormatter()`
+ * themselves -- see `AbstractProcessingHandler`.
+ */
+export interface FormattableHandlerInterface extends HandlerInterface {
+    /** Sets the formatter. */
+    setFormatter(formatter: FormatterInterface): this;
+    /** Gets the formatter. */
+    getFormatter(): FormatterInterface;
+}
+/**
+ * True when the given value implements `FormattableHandlerInterface`.
+ *
+ * PHP checks this with `instanceof`; there is no `instanceof` for an
+ * interface here, so this checks structurally for the two callable members,
+ * exactly as `isResettable()` (`ResettableInterface.ts`) already does.
+ */
+export declare function isFormattable(value: unknown): value is FormattableHandlerInterface;