@larablox/monolog 0.1.1 → 0.2.0

package/README.md

@@ -27,7 +27,7 @@ import { Level } from "@larablox/monolog/out/Monolog/Level";
 
 // create a log channel
 const log = new Logger("name");
-log.pushHandler(new RobloxConsoleHandler({}, Level.Warning));
+log.pushHandler(new RobloxConsoleHandler(Level.Warning));
 
 // add records to the log
 log.warning("Foo");
@@ -39,36 +39,48 @@ so consumers deep-import each class the way the example above does.
 
 ## What's included
 
-- `Logger`, `Level`, `LogRecord`, `Registry`, `Utils`, `ResettableInterface`
-- Handlers: `NullHandler`, `RobloxConsoleHandler` (the output-console adaptation
-  of `PHPConsoleHandler`), and `TestHandler` for your own tests
+- 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`
+  `ScalarFormatter`, `HtmlFormatter`, and `FormatterInterface`
 - Processors: `PsrLogMessageProcessor`, `ClosureContextProcessor`,
   `IntrospectionProcessor`, `MemoryUsageProcessor`, `MemoryPeakUsageProcessor`,
-  `ProcessIdProcessor`, `TagProcessor`, `UidProcessor`
+  `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
+## 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
+## Framework Integration
 
 [`larablox/framework`](https://github.com/larablox/framework)'s
 `Illuminate\Log` is built on this package.
 
-### License
+## License
 
 MIT, matching upstream Monolog.
 
-### Acknowledgements
+## 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.
+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;

package/out/Monolog/Handler/FormattableHandlerInterface.luau

@@ -0,0 +1,36 @@
+-- Compiled with roblox-ts v3.0.0
+--[[
+	*
+	 * PHP: `Monolog\Handler\FormattableHandlerInterface`.
+	 *
+	 * Upstream pairs this with `FormattableHandlerTrait`; Luau has no traits, so
+	 * implementers carry the `$formatter` field and `getDefaultFormatter()`
+	 * themselves -- see `AbstractProcessingHandler`.
+	 
+]]
+--[[
+	*
+	 * 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.
+	 
+]]
+local function isFormattable(value)
+	local _value = value
+	if not (type(_value) == "table") then
+		return false
+	end
+	local candidate = value
+	local _setFormatter = candidate.setFormatter
+	local _condition = type(_setFormatter) == "function"
+	if _condition then
+		local _getFormatter = candidate.getFormatter
+		_condition = type(_getFormatter) == "function"
+	end
+	return _condition
+end
+return {
+	isFormattable = isFormattable,
+}

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

@@ -0,0 +1,49 @@
+import { Handler } from "./Handler";
+import type { FormatterInterface } from "../Formatter/FormatterInterface";
+import type { HandlerInterface } from "./HandlerInterface";
+import type { LogRecord } from "../LogRecord";
+import type { Processor } from "../Processor/ProcessorInterface";
+import type { ProcessableHandlerInterface } from "./ProcessableHandlerInterface";
+import type { ResettableInterface } from "../ResettableInterface";
+/**
+ * PHP: `Monolog\Handler\GroupHandler`. Forwards records to multiple handlers.
+ *
+ * Upstream gets its processor stack from `ProcessableHandlerTrait`; Luau has
+ * no traits, so the trait's members (`processors`, `processRecord()`,
+ * `resetProcessors()`, `pushProcessor()`, `popProcessor()`) are spelled out
+ * here, the same way `AbstractProcessingHandler` already folds it in.
+ */
+export declare class GroupHandler extends Handler implements ProcessableHandlerInterface, ResettableInterface {
+    protected processors: Processor[];
+    protected handlers: Array<HandlerInterface>;
+    protected bubble: boolean;
+    /**
+     * Upstream's `\InvalidArgumentException` for a non-handler in the array is
+     * kept rather than dropped: it is `GroupHandler`'s own explicit check, not
+     * PHP's parameter type-check, and this port is consumed from plain Luau
+     * too, where TypeScript's `Array<HandlerInterface>` proves nothing. There
+     * is no exception class hierarchy on this platform, so it is a plain
+     * `error()` carrying upstream's message.
+     */
+    constructor(handlers: Array<HandlerInterface>, bubble?: boolean);
+    /** Checks whether any of the grouped handlers will handle the record. */
+    isHandling(record: LogRecord): boolean;
+    /** Handles a record, forwarding a clone of it to every grouped handler. */
+    handle(record: LogRecord): boolean;
+    /** Handles a set of records at once. */
+    handleBatch(records: Array<LogRecord>): void;
+    /** 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;
+    /** Resets this handler's processors and every grouped handler. */
+    reset(): void;
+    /** Closes every grouped handler. */
+    close(): void;
+    /** Sets the formatter on every grouped handler that supports one. */
+    setFormatter(formatter: FormatterInterface): this;
+}

package/out/Monolog/Handler/GroupHandler.luau

@@ -0,0 +1,139 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local Handler = TS.import(script, script.Parent, "Handler").Handler
+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 runProcessor = TS.import(script, script.Parent.Parent, "Processor", "ProcessorInterface").runProcessor
+--[[
+	*
+	 * PHP: `Monolog\Handler\GroupHandler`. Forwards records to multiple handlers.
+	 *
+	 * Upstream gets its processor stack from `ProcessableHandlerTrait`; Luau has
+	 * no traits, so the trait's members (`processors`, `processRecord()`,
+	 * `resetProcessors()`, `pushProcessor()`, `popProcessor()`) are spelled out
+	 * here, the same way `AbstractProcessingHandler` already folds it in.
+	 
+]]
+local GroupHandler
+do
+	local super = Handler
+	GroupHandler = setmetatable({}, {
+		__tostring = function()
+			return "GroupHandler"
+		end,
+		__index = super,
+	})
+	GroupHandler.__index = GroupHandler
+	function GroupHandler.new(...)
+		local self = setmetatable({}, GroupHandler)
+		return self:constructor(...) or self
+	end
+	function GroupHandler:constructor(handlers, bubble)
+		if bubble == nil then
+			bubble = true
+		end
+		super.constructor(self)
+		self.processors = {}
+		for _, handler in handlers do
+			if not isHandler(handler) then
+				error("The first argument of the GroupHandler must be an array of HandlerInterface instances.")
+			end
+		end
+		self.handlers = handlers
+		self.bubble = bubble
+	end
+	function GroupHandler:isHandling(record)
+		for _, handler in self.handlers do
+			if handler:isHandling(record) then
+				return true
+			end
+		end
+		return false
+	end
+	function GroupHandler:handle(record)
+		local processed = record
+		if not (#self.processors == 0) then
+			processed = self:processRecord(processed)
+		end
+		for _, handler in self.handlers do
+			handler:handle(processed:clone())
+		end
+		return self.bubble == false
+	end
+	function GroupHandler:handleBatch(records)
+		local batch = records
+		if not (#self.processors == 0) then
+			-- ▼ ReadonlyArray.map ▼
+			local _newValue = table.create(#records)
+			local _callback = function(record)
+				return self:processRecord(record)
+			end
+			for _k, _v in records do
+				_newValue[_k] = _callback(_v, _k - 1, records)
+			end
+			-- ▲ ReadonlyArray.map ▲
+			batch = _newValue
+		end
+		for _, handler in self.handlers do
+			-- ▼ ReadonlyArray.map ▼
+			local _newValue = table.create(#batch)
+			local _callback = function(record)
+				return record:clone()
+			end
+			for _k, _v in batch do
+				_newValue[_k] = _callback(_v, _k - 1, batch)
+			end
+			-- ▲ ReadonlyArray.map ▲
+			handler:handleBatch(_newValue)
+		end
+	end
+	function GroupHandler:pushProcessor(processor)
+		local _processors = self.processors
+		local _processor = processor
+		table.insert(_processors, 1, _processor)
+		return self
+	end
+	function GroupHandler:popProcessor()
+		return table.remove(self.processors, 1)
+	end
+	function GroupHandler:processRecord(record)
+		local processed = record
+		for _, processor in self.processors do
+			processed = runProcessor(processor, processed)
+		end
+		return processed
+	end
+	function GroupHandler:resetProcessors()
+		for _, processor in self.processors do
+			if isResettable(processor) then
+				processor:reset()
+			end
+		end
+	end
+	function GroupHandler:reset()
+		self:resetProcessors()
+		for _, handler in self.handlers do
+			if isResettable(handler) then
+				handler:reset()
+			end
+		end
+	end
+	function GroupHandler:close()
+		super.close(self)
+		for _, handler in self.handlers do
+			handler:close()
+		end
+	end
+	function GroupHandler:setFormatter(formatter)
+		for _, handler in self.handlers do
+			if isFormattable(handler) then
+				handler:setFormatter(formatter)
+			end
+		end
+		return self
+	end
+end
+return {
+	GroupHandler = GroupHandler,
+}

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

@@ -10,3 +10,13 @@ export interface HandlerInterface {
     /** Closes the handler. */
     close(): void;
 }
+/**
+ * True when the given value implements `HandlerInterface`.
+ *
+ * PHP checks this with `instanceof` -- `GroupHandler`'s constructor and
+ * `FingersCrossedHandler::getHandler()` both reject a non-handler at runtime.
+ * There is no `instanceof` for an interface here, so this checks structurally
+ * for the four callable members, as `isResettable()`
+ * (`ResettableInterface.ts`) already does for its own interface.
+ */
+export declare function isHandler(value: unknown): value is HandlerInterface;

package/out/Monolog/Handler/HandlerInterface.luau

@@ -1,3 +1,38 @@
 -- Compiled with roblox-ts v3.0.0
 --* PHP: `Monolog\Handler\HandlerInterface`. 
-return nil
+--[[
+	*
+	 * True when the given value implements `HandlerInterface`.
+	 *
+	 * PHP checks this with `instanceof` -- `GroupHandler`'s constructor and
+	 * `FingersCrossedHandler::getHandler()` both reject a non-handler at runtime.
+	 * There is no `instanceof` for an interface here, so this checks structurally
+	 * for the four callable members, as `isResettable()`
+	 * (`ResettableInterface.ts`) already does for its own interface.
+	 
+]]
+local function isHandler(value)
+	local _value = value
+	if not (type(_value) == "table") then
+		return false
+	end
+	local candidate = value
+	local _isHandling = candidate.isHandling
+	local _condition = type(_isHandling) == "function"
+	if _condition then
+		local _handle = candidate.handle
+		_condition = type(_handle) == "function"
+		if _condition then
+			local _handleBatch = candidate.handleBatch
+			_condition = type(_handleBatch) == "function"
+			if _condition then
+				local _close = candidate.close
+				_condition = type(_close) == "function"
+			end
+		end
+	end
+	return _condition
+end
+return {
+	isHandler = isHandler,
+}

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

@@ -0,0 +1,26 @@
+import type { HandlerInterface } from "./HandlerInterface";
+import type { Processor } from "../Processor/ProcessorInterface";
+/**
+ * PHP: `Monolog\Handler\ProcessableHandlerInterface`.
+ *
+ * Upstream pairs this with `ProcessableHandlerTrait`, which carries the
+ * `$processors` stack and the `processRecord()`/`resetProcessors()` helpers.
+ * Luau has no traits, so every implementer in this port spells those members
+ * out itself -- `AbstractProcessingHandler`, `GroupHandler` and
+ * `FingersCrossedHandler` each carry their own copy, the same way
+ * `AbstractProcessingHandler` already folded the trait in before this
+ * interface existed.
+ */
+export interface ProcessableHandlerInterface extends HandlerInterface {
+    /** Adds a processor in the stack. */
+    pushProcessor(processor: Processor): this;
+    /**
+     * Removes the processor on top of the stack and returns it.
+     *
+     * Upstream throws `\LogicException` when the stack is empty; every
+     * pop-style method in this port (`Logger.popHandler()`,
+     * `AbstractProcessingHandler.popProcessor()`) returns `undefined` instead,
+     * and this signature follows them rather than upstream.
+     */
+    popProcessor(): Processor | undefined;
+}

package/out/Monolog/Handler/ProcessableHandlerInterface.luau

@@ -0,0 +1,15 @@
+-- Compiled with roblox-ts v3.0.0
+--[[
+	*
+	 * PHP: `Monolog\Handler\ProcessableHandlerInterface`.
+	 *
+	 * Upstream pairs this with `ProcessableHandlerTrait`, which carries the
+	 * `$processors` stack and the `processRecord()`/`resetProcessors()` helpers.
+	 * Luau has no traits, so every implementer in this port spells those members
+	 * out itself -- `AbstractProcessingHandler`, `GroupHandler` and
+	 * `FingersCrossedHandler` each carry their own copy, the same way
+	 * `AbstractProcessingHandler` already folded the trait in before this
+	 * interface existed.
+	 
+]]
+return nil

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

@@ -1,55 +1,28 @@
 import { AbstractProcessingHandler } from "./AbstractProcessingHandler";
 import { Level } from "../Level";
-import type { FormatterInterface } from "../Formatter/FormatterInterface";
 import type { LogRecord } from "../LogRecord";
 /**
- * PHP: `Monolog\Handler\PHPConsoleHandler`.
+ * Writes formatted records to the Roblox output console.
  *
- * Upstream streams debug/error/exception data to the (now abandoned) "PHP
- * Console" Chrome extension via `PhpConsole\Connector`. There is no such
- * target on Roblox, so this adapts the same handler shape -- the `options`
- * bag, the record-kind branching in `write()`, the default formatter -- to
- * the platform's own output console (`print`/`warn`) instead, superseding
- * what the old, not-a-real-upstream-class `ConsoleHandler` used to do.
- */
-/**
- * Reduced from upstream's `Options`: everything else there
- * (`classesPartialsTraceIgnore`, `useOwnErrorsHandler`/`useOwnExceptionsHandler`,
- * `sourcesBasePath`, `registerHelper`, `serverEncoding`, `headersLimit`,
- * `password`, `enableSslOnlyMode`, `ipMasks`, `enableEvalListener`, every
- * `dumper*` key, `detectDumpTraceAndSource`, `dataStorage`) is either specific
- * to the PHP Console wire protocol or paired with `ErrorHandler`/`SignalHandler`,
- * both out of scope for this port -- there is no connector object left to
- * configure with them.
+ * No upstream ancestor: this is an original class for this platform.
+ *
+ * By shape it is this platform's `Monolog\Handler\StreamHandler`: hand
+ * `record.formatted` to the sink and nothing more. Roblox's console is that
+ * sink, and none of `StreamHandler`'s own API survives the swap -- there is
+ * no stream to open, no url/resource to accept, no file permissions, no
+ * `close()`, no buffering to flush. What is left is the level/bubble pair
+ * every handler has, plus the one choice the console does offer: records
+ * below `Level.Warning` go out through `print` (`MessageOutput`), the rest
+ * through `warn` (`MessageWarning`), so Studio colors them accordingly and
+ * `LogService` reports the right `Enum.MessageType`. `error` is deliberately
+ * not used for higher levels -- on Luau it throws and unwinds the caller
+ * instead of merely writing a line.
+ *
+ * The formatter is respected, unlike the PHP Console port that preceded this
+ * one: it is what turns the record into the printed text. The default is
+ * `AbstractProcessingHandler`'s own `LineFormatter`.
  */
-export interface Options {
-    /** Whether this handler is active at all. */
-    enabled: boolean;
-    /** Context keys checked, in order, for a debug "tag" to prefix the message with. */
-    debugTagsKeysInContext: Array<string>;
-}
 export declare class RobloxConsoleHandler extends AbstractProcessingHandler {
-    private readonly options;
-    constructor(options?: Partial<Options>, level?: Level, bubble?: boolean);
-    /** PHP: `PHPConsoleHandler::getOptions()`. */
-    getOptions(): Options;
-    /** PHP: `PHPConsoleHandler::handle()`. */
-    handle(record: LogRecord): boolean;
-    /** PHP: `PHPConsoleHandler::write()`. */
+    constructor(level?: Level, bubble?: boolean);
     protected write(record: LogRecord): void;
-    /** PHP: `PHPConsoleHandler::handleDebugRecord()`. */
-    private writeDebugRecord;
-    /** PHP: `PHPConsoleHandler::handleExceptionRecord()`. */
-    private writeExceptionRecord;
-    /** PHP: `PHPConsoleHandler::handleErrorRecord()`. */
-    private writeErrorRecord;
-    /**
-     * PHP: `PHPConsoleHandler::getRecordTags()`. Upstream also checks
-     * `$filteredContext[0]`, PHP's implicit first-array-index -- Luau/TS have
-     * no positional index on a `RecordBag`, so only the named
-     * `debugTagsKeysInContext` keys are checked.
-     */
-    private getRecordTags;
-    /** PHP: `PHPConsoleHandler::getDefaultFormatter()`. */
-    protected getDefaultFormatter(): FormatterInterface;
 }

package/out/Monolog/Handler/RobloxConsoleHandler.luau

@@ -4,36 +4,29 @@ local AbstractProcessingHandler = TS.import(script, script.Parent, "AbstractProc
 local _Level = TS.import(script, script.Parent.Parent, "Level")
 local Level = _Level.Level
 local Levels = _Level.Levels
-local LineFormatter = TS.import(script, script.Parent.Parent, "Formatter", "LineFormatter").LineFormatter
-local Utils = TS.import(script, script.Parent.Parent, "Utils").Utils
 --[[
 	*
-	 * PHP: `Monolog\Handler\PHPConsoleHandler`.
+	 * Writes formatted records to the Roblox output console.
 	 *
-	 * Upstream streams debug/error/exception data to the (now abandoned) "PHP
-	 * Console" Chrome extension via `PhpConsole\Connector`. There is no such
-	 * target on Roblox, so this adapts the same handler shape -- the `options`
-	 * bag, the record-kind branching in `write()`, the default formatter -- to
-	 * the platform's own output console (`print`/`warn`) instead, superseding
-	 * what the old, not-a-real-upstream-class `ConsoleHandler` used to do.
-	 
-]]
---[[
-	*
-	 * Reduced from upstream's `Options`: everything else there
-	 * (`classesPartialsTraceIgnore`, `useOwnErrorsHandler`/`useOwnExceptionsHandler`,
-	 * `sourcesBasePath`, `registerHelper`, `serverEncoding`, `headersLimit`,
-	 * `password`, `enableSslOnlyMode`, `ipMasks`, `enableEvalListener`, every
-	 * `dumper*` key, `detectDumpTraceAndSource`, `dataStorage`) is either specific
-	 * to the PHP Console wire protocol or paired with `ErrorHandler`/`SignalHandler`,
-	 * both out of scope for this port -- there is no connector object left to
-	 * configure with them.
+	 * No upstream ancestor: this is an original class for this platform.
+	 *
+	 * By shape it is this platform's `Monolog\Handler\StreamHandler`: hand
+	 * `record.formatted` to the sink and nothing more. Roblox's console is that
+	 * sink, and none of `StreamHandler`'s own API survives the swap -- there is
+	 * no stream to open, no url/resource to accept, no file permissions, no
+	 * `close()`, no buffering to flush. What is left is the level/bubble pair
+	 * every handler has, plus the one choice the console does offer: records
+	 * below `Level.Warning` go out through `print` (`MessageOutput`), the rest
+	 * through `warn` (`MessageWarning`), so Studio colors them accordingly and
+	 * `LogService` reports the right `Enum.MessageType`. `error` is deliberately
+	 * not used for higher levels -- on Luau it throws and unwinds the caller
+	 * instead of merely writing a line.
+	 *
+	 * The formatter is respected, unlike the PHP Console port that preceded this
+	 * one: it is what turns the record into the printed text. The default is
+	 * `AbstractProcessingHandler`'s own `LineFormatter`.
 	 
 ]]
-local DEFAULT_OPTIONS = {
-	enabled = true,
-	debugTagsKeysInContext = { "tag" },
-}
 local RobloxConsoleHandler
 do
 	local super = AbstractProcessingHandler
@@ -48,10 +41,7 @@ do
 		local self = setmetatable({}, RobloxConsoleHandler)
 		return self:constructor(...) or self
 	end
-	function RobloxConsoleHandler:constructor(options, level, bubble)
-		if options == nil then
-			options = {}
-		end
+	function RobloxConsoleHandler:constructor(level, bubble)
 		if level == nil then
 			level = Level.Debug
 		end
@@ -59,81 +49,20 @@ do
 			bubble = true
 		end
 		super.constructor(self, level, bubble)
-		local _object = {}
-		local _left = "enabled"
-		local _condition = options.enabled
-		if _condition == nil then
-			_condition = DEFAULT_OPTIONS.enabled
-		end
-		_object[_left] = _condition
-		_object.debugTagsKeysInContext = options.debugTagsKeysInContext or DEFAULT_OPTIONS.debugTagsKeysInContext
-		self.options = _object
-	end
-	function RobloxConsoleHandler:getOptions()
-		return self.options
-	end
-	function RobloxConsoleHandler:handle(record)
-		if self.options.enabled then
-			return super.handle(self, record)
-		end
-		-- Upstream also requires `connector.isActiveClient()` here; there is no
-		-- connector to ask, so `enabled` is the only gate left.
-		return not self.bubble
 	end
 	function RobloxConsoleHandler:write(record)
-		if Levels:isLowerThan(record.level, Level.Notice) then
-			self:writeDebugRecord(record)
-		elseif record.context.exception ~= nil then
-			self:writeExceptionRecord(record)
-		else
-			self:writeErrorRecord(record)
-		end
-	end
-	function RobloxConsoleHandler:writeDebugRecord(record)
-		local _binding = self:getRecordTags(record)
-		local tags = _binding[1]
-		local filteredContext = _binding[2]
-		local message = record.message
-		if (next(filteredContext)) ~= nil then
-			message = `{message} {Utils:jsonEncode(filteredContext)}`
+		-- `handle()` always fills `formatted` in before calling `write()`;
+		-- the fallback is for a direct call that did not go through it.
+		local _condition = record.formatted
+		if _condition == nil then
+			_condition = record.message
 		end
-		print(`[{tags}] {message}`)
-	end
-	function RobloxConsoleHandler:writeExceptionRecord(record)
-		warn(tostring(record.context.exception))
-	end
-	function RobloxConsoleHandler:writeErrorRecord(record)
-		local context = record.context
-		local message = if context.message ~= nil then tostring(context.message) else record.message
-		if context.file == nil and context.line == nil then
-			warn(message)
+		local message = _condition
+		if Levels:isLowerThan(record.level, Level.Warning) then
+			print(message)
 			return nil
 		end
-		local file = if context.file ~= nil then tostring(context.file) else "?"
-		local line = if context.line ~= nil then tostring(context.line) else "?"
-		warn(`{message} ({file}:{line})`)
-	end
-	function RobloxConsoleHandler:getRecordTags(record)
-		local filteredContext = {}
-		for key, value in pairs(record.context) do
-			filteredContext[key] = value
-		end
-		local tag
-		for _, key in self.options.debugTagsKeysInContext do
-			if filteredContext[key] ~= nil then
-				tag = tostring(filteredContext[key])
-				filteredContext[key] = nil
-				break
-			end
-		end
-		local _condition = tag
-		if _condition == nil then
-			_condition = Levels:toPsrLogLevel(record.level)
-		end
-		return { _condition, filteredContext }
-	end
-	function RobloxConsoleHandler:getDefaultFormatter()
-		return LineFormatter.new("%message%")
+		warn(message)
 	end
 end
 return {

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

@@ -0,0 +1,26 @@
+import { GroupHandler } from "./GroupHandler";
+import type { LogRecord } from "../LogRecord";
+/**
+ * PHP: `Monolog\Handler\WhatFailureGroupHandler`.
+ *
+ * Forwards records to multiple handlers, suppressing failures of each handler
+ * and continuing through to give every handler a chance to succeed.
+ *
+ * Upstream wraps each call in `try { ... } catch (Throwable) {}`. Luau's
+ * error mechanism is `error()`/`pcall()`, not exceptions, so each call goes
+ * through `pcall()` and its failure result is discarded -- same "what
+ * failure?" semantics, same swallow-everything breadth.
+ */
+export declare class WhatFailureGroupHandler extends GroupHandler {
+    /** Handles a record, letting every grouped handler fail independently. */
+    handle(record: LogRecord): boolean;
+    /** Handles a set of records at once, ignoring any handler that fails. */
+    handleBatch(records: Array<LogRecord>): void;
+    /**
+     * Closes every grouped handler, ignoring any that fails.
+     *
+     * Upstream deliberately does not call `parent::close()` here (unlike
+     * `GroupHandler::close()`), so neither does this.
+     */
+    close(): void;
+}

package/out/Monolog/Handler/WhatFailureGroupHandler.luau

@@ -0,0 +1,85 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local GroupHandler = TS.import(script, script.Parent, "GroupHandler").GroupHandler
+--[[
+	*
+	 * PHP: `Monolog\Handler\WhatFailureGroupHandler`.
+	 *
+	 * Forwards records to multiple handlers, suppressing failures of each handler
+	 * and continuing through to give every handler a chance to succeed.
+	 *
+	 * Upstream wraps each call in `try { ... } catch (Throwable) {}`. Luau's
+	 * error mechanism is `error()`/`pcall()`, not exceptions, so each call goes
+	 * through `pcall()` and its failure result is discarded -- same "what
+	 * failure?" semantics, same swallow-everything breadth.
+	 
+]]
+local WhatFailureGroupHandler
+do
+	local super = GroupHandler
+	WhatFailureGroupHandler = setmetatable({}, {
+		__tostring = function()
+			return "WhatFailureGroupHandler"
+		end,
+		__index = super,
+	})
+	WhatFailureGroupHandler.__index = WhatFailureGroupHandler
+	function WhatFailureGroupHandler.new(...)
+		local self = setmetatable({}, WhatFailureGroupHandler)
+		return self:constructor(...) or self
+	end
+	function WhatFailureGroupHandler:constructor(...)
+		super.constructor(self, ...)
+	end
+	function WhatFailureGroupHandler:handle(record)
+		local processed = record
+		if not (#self.processors == 0) then
+			processed = self:processRecord(processed)
+		end
+		for _, handler in self.handlers do
+			pcall(function()
+				return handler:handle(processed:clone())
+			end)
+		end
+		return self.bubble == false
+	end
+	function WhatFailureGroupHandler:handleBatch(records)
+		local batch = records
+		if not (#self.processors == 0) then
+			-- ▼ ReadonlyArray.map ▼
+			local _newValue = table.create(#records)
+			local _callback = function(record)
+				return self:processRecord(record)
+			end
+			for _k, _v in records do
+				_newValue[_k] = _callback(_v, _k - 1, records)
+			end
+			-- ▲ ReadonlyArray.map ▲
+			batch = _newValue
+		end
+		for _, handler in self.handlers do
+			pcall(function()
+				-- ▼ ReadonlyArray.map ▼
+				local _newValue = table.create(#batch)
+				local _callback = function(record)
+					return record:clone()
+				end
+				for _k, _v in batch do
+					_newValue[_k] = _callback(_v, _k - 1, batch)
+				end
+				-- ▲ ReadonlyArray.map ▲
+				return handler:handleBatch(_newValue)
+			end)
+		end
+	end
+	function WhatFailureGroupHandler:close()
+		for _, handler in self.handlers do
+			pcall(function()
+				return handler:close()
+			end)
+		end
+	end
+end
+return {
+	WhatFailureGroupHandler = WhatFailureGroupHandler,
+}

package/package.json

@@ -1,10 +1,15 @@
 {
     "$schema": "https://www.schemastore.org/package.json",
     "name": "@larablox/monolog",
-    "version": "0.1.1",
+    "version": "0.2.0",
     "description": "The Larablox port of Monolog.",
     "license": "MIT",
-    "keywords": ["monolog", "logging", "larablox", "roblox-ts"],
+    "keywords": [
+        "monolog",
+        "logging",
+        "larablox",
+        "roblox-ts"
+    ],
     "homepage": "https://github.com/larablox/monolog",
     "repository": {
         "type": "git",
@@ -16,7 +21,10 @@
     "publishConfig": {
         "access": "public"
     },
-    "files": ["out/Monolog", "out/index.d.ts"],
+    "files": [
+        "out/Monolog",
+        "out/index.d.ts"
+    ],
     "types": "out/index.d.ts",
     "type": "module",
     "scripts": {