@larablox/monolog 0.1.0

package/out/Monolog/Logger.luau

@@ -0,0 +1,248 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _Level = TS.import(script, script.Parent, "Level")
+local Level = _Level.Level
+local Levels = _Level.Levels
+local LogRecord = TS.import(script, script.Parent, "LogRecord").LogRecord
+local isResettable = TS.import(script, script.Parent, "ResettableInterface").isResettable
+local runProcessor = TS.import(script, script.Parent, "Processor", "ProcessorInterface").runProcessor
+--* PHP: `Closure` passed to `Logger::setExceptionHandler()`. 
+--* PHP: `Logger::RFC_5424_LEVELS`, reversed (RFC 5424 number -> Monolog `Level`). 
+local RFC_5424_LEVELS = {
+	[7] = Level.Debug,
+	[6] = Level.Info,
+	[5] = Level.Notice,
+	[4] = Level.Warning,
+	[3] = Level.Error,
+	[2] = Level.Critical,
+	[1] = Level.Alert,
+	[0] = Level.Emergency,
+}
+--[[
+	*
+	 * PHP: `Monolog\Logger`.
+	 *
+	 * Holds the handler stack and the processor stack, builds a `LogRecord` and
+	 * walks the handlers until one stops the bubbling chain.
+	 *
+	 * Not ported: timezones and microsecond timestamps (`os.time` is what a place
+	 * has) and the serialization hooks (`__serialize`/`__unserialize`, no PHP
+	 * magic serialization here). The infinite-logging-loop guard is kept, but
+	 * keyed by a single instance counter rather than a `Fiber`-keyed `WeakMap` --
+	 * there is no fiber concept on this platform.
+	 
+]]
+local Logger
+do
+	Logger = setmetatable({}, {
+		__tostring = function()
+			return "Logger"
+		end,
+	})
+	Logger.__index = Logger
+	function Logger.new(...)
+		local self = setmetatable({}, Logger)
+		return self:constructor(...) or self
+	end
+	function Logger:constructor(name, handlers, processors)
+		if handlers == nil then
+			handlers = {}
+		end
+		if processors == nil then
+			processors = {}
+		end
+		self.name = name
+		self.handlers = {}
+		self.processors = {}
+		self.logDepth = 0
+		self:setHandlers(handlers)
+		for _, processor in processors do
+			local _exp = self.processors
+			table.insert(_exp, processor)
+		end
+	end
+	function Logger:getName()
+		return self.name
+	end
+	function Logger:withName(name)
+		return Logger.new(name, self.handlers, self.processors)
+	end
+	function Logger:pushHandler(handler)
+		local _handlers = self.handlers
+		local _handler = handler
+		table.insert(_handlers, 1, _handler)
+		return self
+	end
+	function Logger:popHandler()
+		return table.remove(self.handlers, 1)
+	end
+	function Logger:setHandlers(handlers)
+		table.clear(self.handlers)
+		for index = #handlers - 1, 0, -1 do
+			self:pushHandler(handlers[index + 1])
+		end
+		return self
+	end
+	function Logger:getHandlers()
+		return self.handlers
+	end
+	function Logger:pushProcessor(processor)
+		local _processors = self.processors
+		local _processor = processor
+		table.insert(_processors, 1, _processor)
+		return self
+	end
+	function Logger:popProcessor()
+		return table.remove(self.processors, 1)
+	end
+	function Logger:getProcessors()
+		return self.processors
+	end
+	function Logger:addRecord(level, message, context)
+		if context == nil then
+			context = {}
+		end
+		self.logDepth += 1
+		local handled = self:addRecordAtDepth(Logger:remapRFC5424(level), message, context)
+		self.logDepth -= 1
+		return handled
+	end
+	function Logger:addRecordAtDepth(level, message, context)
+		if self.logDepth == 3 then
+			self:warning("A possible infinite logging loop was detected and aborted. It appears some of your handler code is triggering logging, see the previous log record for a hint as to what may be the cause.")
+			return false
+		elseif self.logDepth >= 5 then
+			-- log depth 4 is let through, so we can log the warning above
+			return false
+		end
+		local record = LogRecord.new(os.time(), self.name, Logger:toMonologLevel(level), message, context, {})
+		local recordInitialized = #self.processors == 0
+		local handled = false
+		for _, handler in self.handlers do
+			if not recordInitialized then
+				-- Skip initializing the record as long as no handler will take it.
+				if not handler:isHandling(record) then
+					continue
+				end
+				local processedOk, processedResult = pcall(function()
+					local processed = record
+					for _1, processor in self.processors do
+						processed = runProcessor(processor, processed)
+					end
+					return processed
+				end)
+				if not processedOk then
+					self:handleException(processedResult, record)
+					return true
+				end
+				record = processedResult
+				recordInitialized = true
+			end
+			handled = true
+			local handledOk, handledResult = pcall(function()
+				return handler:handle(record:clone())
+			end)
+			if not handledOk then
+				self:handleException(handledResult, record)
+				return true
+			end
+			if handledResult == true then
+				break
+			end
+		end
+		return handled
+	end
+	function Logger:toMonologLevel(level)
+		local _level = level
+		if not (type(_level) == "string") then
+			return level
+		end
+		local found = Levels:fromName(level)
+		if found == nil then
+			error(`Level "{level}" is not defined, use one of: {table.concat(Levels.NAMES, ", ")}`)
+		end
+		return found
+	end
+	function Logger:remapRFC5424(level)
+		local _level = level
+		local _condition = type(_level) == "number"
+		if _condition then
+			local _level_1 = level
+			_condition = RFC_5424_LEVELS[_level_1] ~= nil
+		end
+		if _condition then
+			local _level_1 = level
+			return RFC_5424_LEVELS[_level_1]
+		end
+		return level
+	end
+	function Logger:isHandling(level)
+		local record = LogRecord.new(os.time(), self.name, Logger:toMonologLevel(level), "")
+		for _, handler in self.handlers do
+			if handler:isHandling(record) then
+				return true
+			end
+		end
+		return false
+	end
+	function Logger:setExceptionHandler(callback)
+		self.exceptionHandler = callback
+		return self
+	end
+	function Logger:getExceptionHandler()
+		return self.exceptionHandler
+	end
+	function Logger:handleException(error_, record)
+		if self.exceptionHandler == nil then
+			error(error_)
+		end
+		self.exceptionHandler(error_, record)
+	end
+	function Logger:close()
+		for _, handler in self.handlers do
+			handler:close()
+		end
+	end
+	function Logger:reset()
+		for _, handler in self.handlers do
+			if isResettable(handler) then
+				handler:reset()
+			end
+		end
+		for _, processor in self.processors do
+			if isResettable(processor) then
+				processor:reset()
+			end
+		end
+	end
+	function Logger:emergency(message, context)
+		self:addRecord(Level.Emergency, tostring(message), context or {})
+	end
+	function Logger:alert(message, context)
+		self:addRecord(Level.Alert, tostring(message), context or {})
+	end
+	function Logger:critical(message, context)
+		self:addRecord(Level.Critical, tostring(message), context or {})
+	end
+	function Logger:error(message, context)
+		self:addRecord(Level.Error, tostring(message), context or {})
+	end
+	function Logger:warning(message, context)
+		self:addRecord(Level.Warning, tostring(message), context or {})
+	end
+	function Logger:notice(message, context)
+		self:addRecord(Level.Notice, tostring(message), context or {})
+	end
+	function Logger:info(message, context)
+		self:addRecord(Level.Info, tostring(message), context or {})
+	end
+	function Logger:debug(message, context)
+		self:addRecord(Level.Debug, tostring(message), context or {})
+	end
+	function Logger:log(level, message, context)
+		self:addRecord(Logger:toMonologLevel(Logger:remapRFC5424(level)), tostring(message), context or {})
+	end
+end
+return {
+	Logger = Logger,
+}

package/out/Monolog/LoggerInterface.d.ts

@@ -0,0 +1,33 @@
+/** PHP: the levels `Psr\Log\LogLevel` defines, in ascending severity. */
+export type LogLevel = "debug" | "info" | "notice" | "warning" | "error" | "critical" | "alert" | "emergency";
+/** PHP: `array $context`. */
+export type LogContext = Record<string, unknown>;
+/**
+ * PHP: `Psr\Log\LoggerInterface`.
+ *
+ * Real Monolog implements this from the separate `psr/log` package, not from
+ * `laravel/framework`. There is no Luau port of `psr/log` to depend on
+ * instead, so the shape lives here, where the class that actually implements
+ * it lives -- `Illuminate\Contracts\Log\Logger` re-exports it rather than
+ * declaring its own copy.
+ */
+export interface LoggerInterface {
+    /** System is unusable. */
+    emergency(message: unknown, context?: LogContext): void;
+    /** Action must be taken immediately. */
+    alert(message: unknown, context?: LogContext): void;
+    /** Critical conditions. */
+    critical(message: unknown, context?: LogContext): void;
+    /** Runtime errors that do not require immediate action. */
+    error(message: unknown, context?: LogContext): void;
+    /** Exceptional occurrences that are not errors. */
+    warning(message: unknown, context?: LogContext): void;
+    /** Normal but significant events. */
+    notice(message: unknown, context?: LogContext): void;
+    /** Interesting events. */
+    info(message: unknown, context?: LogContext): void;
+    /** Detailed debug information. */
+    debug(message: unknown, context?: LogContext): void;
+    /** Logs with an arbitrary level. */
+    log(level: LogLevel, message: unknown, context?: LogContext): void;
+}

package/out/Monolog/LoggerInterface.luau

@@ -0,0 +1,15 @@
+-- Compiled with roblox-ts v3.0.0
+--* PHP: the levels `Psr\Log\LogLevel` defines, in ascending severity. 
+--* PHP: `array $context`. 
+--[[
+	*
+	 * PHP: `Psr\Log\LoggerInterface`.
+	 *
+	 * Real Monolog implements this from the separate `psr/log` package, not from
+	 * `laravel/framework`. There is no Luau port of `psr/log` to depend on
+	 * instead, so the shape lives here, where the class that actually implements
+	 * it lives -- `Illuminate\Contracts\Log\Logger` re-exports it rather than
+	 * declaring its own copy.
+	 
+]]
+return nil

package/out/Monolog/Processor/ClosureContextProcessor.d.ts

@@ -0,0 +1,13 @@
+import type { LogRecord } from "../LogRecord";
+import type { ProcessorInterface } from "./ProcessorInterface";
+/**
+ * PHP: `Monolog\Processor\ClosureContextProcessor`.
+ *
+ * Upstream keys this off `$context[0]`, PHP's implicit first-array-index; a
+ * `RecordBag` has no positional index, so this checks whether context has
+ * exactly one entry and that entry's value is a function, regardless of its
+ * key name.
+ */
+export declare class ClosureContextProcessor implements ProcessorInterface {
+    process(record: LogRecord): LogRecord;
+}

package/out/Monolog/Processor/ClosureContextProcessor.luau

@@ -0,0 +1,76 @@
+-- Compiled with roblox-ts v3.0.0
+--* True when `bag` has exactly one entry; returns that entry. 
+local function soleEntry(bag)
+	local firstKey, firstValue = next(bag)
+	if firstKey == nil then
+		return nil
+	end
+	local secondKey = next(bag, firstKey)
+	if secondKey ~= nil then
+		return nil
+	end
+	return {
+		key = firstKey,
+		value = firstValue,
+	}
+end
+--[[
+	*
+	 * PHP: `Monolog\Processor\ClosureContextProcessor`.
+	 *
+	 * Upstream keys this off `$context[0]`, PHP's implicit first-array-index; a
+	 * `RecordBag` has no positional index, so this checks whether context has
+	 * exactly one entry and that entry's value is a function, regardless of its
+	 * key name.
+	 
+]]
+local ClosureContextProcessor
+do
+	ClosureContextProcessor = setmetatable({}, {
+		__tostring = function()
+			return "ClosureContextProcessor"
+		end,
+	})
+	ClosureContextProcessor.__index = ClosureContextProcessor
+	function ClosureContextProcessor.new(...)
+		local self = setmetatable({}, ClosureContextProcessor)
+		return self:constructor(...) or self
+	end
+	function ClosureContextProcessor:constructor()
+	end
+	function ClosureContextProcessor:process(record)
+		local sole = soleEntry(record.context)
+		local _condition = sole == nil
+		if not _condition then
+			local _value = sole.value
+			_condition = not (type(_value) == "function")
+		end
+		if _condition then
+			return record
+		end
+		local ok, result = pcall(sole.value)
+		local context
+		if not ok then
+			context = {
+				error_on_context_generation = tostring(result),
+				exception = result,
+			}
+		elseif type(result) == "table" then
+			context = result
+		else
+			-- Upstream wraps a non-array result as `[$context]`, which lands back
+			-- at key `0` -- the same key it started under, since PHP's implicit
+			-- index was always `0`. Re-using the original key name here is this
+			-- port's equivalent, since there is no positional index to fall back to.
+			context = {
+				[sole.key] = result,
+			}
+		end
+		return record:with({
+			context = context,
+		})
+	end
+end
+return {
+	ClosureContextProcessor = ClosureContextProcessor,
+}

package/out/Monolog/Processor/IntrospectionProcessor.d.ts

@@ -0,0 +1,33 @@
+import { Level } from "../Level";
+import type { LogLevel } from "../LoggerInterface";
+import type { LogRecord } from "../LogRecord";
+import type { ProcessorInterface } from "./ProcessorInterface";
+/**
+ * PHP: `Monolog\Processor\IntrospectionProcessor`.
+ *
+ * Upstream walks `debug_backtrace()`, skipping frames belonging to
+ * `skipClassesPartials` (default `["Monolog\\"]`) and PHP's
+ * `call_user_func`/`call_user_func_array` wrappers, to find the frame that
+ * actually logged the message. Luau's `debug.info` reports one stack level at
+ * a time with no per-frame "class" the way a PHP trace frame has, so there is
+ * nothing for a class-partial skip list to match against -- `skipClassesPartials`
+ * is dropped entirely rather than faked.
+ *
+ * `BASE_STACK_OFFSET` is this port's analog of upstream's two `array_shift()`
+ * calls (its own frame, then the generic invoker frame -- `runProcessor()`
+ * here, `call_user_func` there). Unlike upstream's flat PHP call stack,
+ * `Logger.addRecord()` on this platform adds its own internal frames before
+ * reaching a processor, so the reported file/line will typically land inside
+ * that dispatch machinery rather than the original log call site. Tune
+ * `skipStackFramesCount` to compensate if more precision is needed.
+ *
+ * Warning: this only works if the handler processes the logs directly -- see
+ * upstream's own caveat, which applies here unchanged.
+ */
+export declare class IntrospectionProcessor implements ProcessorInterface {
+    protected skipStackFramesCount: number;
+    private static readonly BASE_STACK_OFFSET;
+    protected level: Level;
+    constructor(level?: Level | LogLevel, skipStackFramesCount?: number);
+    process(record: LogRecord): LogRecord;
+}

package/out/Monolog/Processor/IntrospectionProcessor.luau

@@ -0,0 +1,69 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+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
+--[[
+	*
+	 * PHP: `Monolog\Processor\IntrospectionProcessor`.
+	 *
+	 * Upstream walks `debug_backtrace()`, skipping frames belonging to
+	 * `skipClassesPartials` (default `["Monolog\\"]`) and PHP's
+	 * `call_user_func`/`call_user_func_array` wrappers, to find the frame that
+	 * actually logged the message. Luau's `debug.info` reports one stack level at
+	 * a time with no per-frame "class" the way a PHP trace frame has, so there is
+	 * nothing for a class-partial skip list to match against -- `skipClassesPartials`
+	 * is dropped entirely rather than faked.
+	 *
+	 * `BASE_STACK_OFFSET` is this port's analog of upstream's two `array_shift()`
+	 * calls (its own frame, then the generic invoker frame -- `runProcessor()`
+	 * here, `call_user_func` there). Unlike upstream's flat PHP call stack,
+	 * `Logger.addRecord()` on this platform adds its own internal frames before
+	 * reaching a processor, so the reported file/line will typically land inside
+	 * that dispatch machinery rather than the original log call site. Tune
+	 * `skipStackFramesCount` to compensate if more precision is needed.
+	 *
+	 * Warning: this only works if the handler processes the logs directly -- see
+	 * upstream's own caveat, which applies here unchanged.
+	 
+]]
+local IntrospectionProcessor
+do
+	IntrospectionProcessor = setmetatable({}, {
+		__tostring = function()
+			return "IntrospectionProcessor"
+		end,
+	})
+	IntrospectionProcessor.__index = IntrospectionProcessor
+	function IntrospectionProcessor.new(...)
+		local self = setmetatable({}, IntrospectionProcessor)
+		return self:constructor(...) or self
+	end
+	function IntrospectionProcessor:constructor(level, skipStackFramesCount)
+		if level == nil then
+			level = Level.Debug
+		end
+		if skipStackFramesCount == nil then
+			skipStackFramesCount = 0
+		end
+		self.skipStackFramesCount = skipStackFramesCount
+		self.level = Logger:toMonologLevel(level)
+	end
+	function IntrospectionProcessor:process(record)
+		if Levels:isLowerThan(record.level, self.level) then
+			return record
+		end
+		local source, line, name = debug.info(IntrospectionProcessor.BASE_STACK_OFFSET + self.skipStackFramesCount, "sln")
+		record.extra.file = source
+		record.extra.line = line
+		record.extra["function"] = name
+		-- `class`/`callType` are left unset -- Luau has no reflective notion of
+		-- "the class this call happened in" the way `$trace[$i]['class']` does.
+		return record
+	end
+	IntrospectionProcessor.BASE_STACK_OFFSET = 3
+end
+return {
+	IntrospectionProcessor = IntrospectionProcessor,
+}

package/out/Monolog/Processor/MemoryPeakUsageProcessor.d.ts

@@ -0,0 +1,17 @@
+import { MemoryProcessor } from "./MemoryProcessor";
+import type { LogRecord } from "../LogRecord";
+/**
+ * PHP: `Monolog\Processor\MemoryPeakUsageProcessor`.
+ *
+ * There is no `memory_get_peak_usage()` equivalent -- Luau only reports
+ * *current* GC memory, not a running peak, so this tracks one itself: a
+ * private field updated to the highest reading seen so far on every call,
+ * seeded at construction. "Peak" here means the highest reading this
+ * processor instance has observed since it was created, not an OS-level
+ * peak -- a real, necessary behavioral divergence, not a cosmetic one.
+ */
+export declare class MemoryPeakUsageProcessor extends MemoryProcessor {
+    private peakBytes;
+    constructor(realUsage?: boolean, useFormatting?: boolean);
+    process(record: LogRecord): LogRecord;
+}

package/out/Monolog/Processor/MemoryPeakUsageProcessor.luau

@@ -0,0 +1,49 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local MemoryProcessor = TS.import(script, script.Parent, "MemoryProcessor").MemoryProcessor
+--[[
+	*
+	 * PHP: `Monolog\Processor\MemoryPeakUsageProcessor`.
+	 *
+	 * There is no `memory_get_peak_usage()` equivalent -- Luau only reports
+	 * *current* GC memory, not a running peak, so this tracks one itself: a
+	 * private field updated to the highest reading seen so far on every call,
+	 * seeded at construction. "Peak" here means the highest reading this
+	 * processor instance has observed since it was created, not an OS-level
+	 * peak -- a real, necessary behavioral divergence, not a cosmetic one.
+	 
+]]
+local MemoryPeakUsageProcessor
+do
+	local super = MemoryProcessor
+	MemoryPeakUsageProcessor = setmetatable({}, {
+		__tostring = function()
+			return "MemoryPeakUsageProcessor"
+		end,
+		__index = super,
+	})
+	MemoryPeakUsageProcessor.__index = MemoryPeakUsageProcessor
+	function MemoryPeakUsageProcessor.new(...)
+		local self = setmetatable({}, MemoryPeakUsageProcessor)
+		return self:constructor(...) or self
+	end
+	function MemoryPeakUsageProcessor:constructor(realUsage, useFormatting)
+		if realUsage == nil then
+			realUsage = true
+		end
+		if useFormatting == nil then
+			useFormatting = true
+		end
+		super.constructor(self, realUsage, useFormatting)
+		self.peakBytes = gcinfo() * 1024
+	end
+	function MemoryPeakUsageProcessor:process(record)
+		local currentBytes = gcinfo() * 1024
+		self.peakBytes = math.max(self.peakBytes, currentBytes)
+		record.extra.memory_peak_usage = self:formatBytes(self.peakBytes)
+		return record
+	end
+end
+return {
+	MemoryPeakUsageProcessor = MemoryPeakUsageProcessor,
+}

package/out/Monolog/Processor/MemoryProcessor.d.ts

@@ -0,0 +1,20 @@
+import type { LogRecord } from "../LogRecord";
+import type { ProcessorInterface } from "./ProcessorInterface";
+/**
+ * PHP: `Monolog\Processor\MemoryProcessor`.
+ *
+ * `realUsage` has no real platform distinction here: `gcinfo()` (Roblox's
+ * replacement for the deprecated `collectgarbage("count")`) is the only
+ * memory reading source Luau exposes, and there is no PHP
+ * `emalloc()`-vs-OS-allocated split to choose between. The constructor
+ * parameter is kept for API-shape parity but does not change behavior in
+ * either subclass -- said once here rather than repeated in each.
+ */
+export declare abstract class MemoryProcessor implements ProcessorInterface {
+    protected realUsage: boolean;
+    protected useFormatting: boolean;
+    constructor(realUsage?: boolean, useFormatting?: boolean);
+    abstract process(record: LogRecord): LogRecord;
+    /** Formats bytes into a human-readable string if `useFormatting` is true, otherwise returns `bytes` as-is. */
+    protected formatBytes(bytes: number): string | number;
+}

package/out/Monolog/Processor/MemoryProcessor.luau

@@ -0,0 +1,41 @@
+-- Compiled with roblox-ts v3.0.0
+--[[
+	*
+	 * PHP: `Monolog\Processor\MemoryProcessor`.
+	 *
+	 * `realUsage` has no real platform distinction here: `gcinfo()` (Roblox's
+	 * replacement for the deprecated `collectgarbage("count")`) is the only
+	 * memory reading source Luau exposes, and there is no PHP
+	 * `emalloc()`-vs-OS-allocated split to choose between. The constructor
+	 * parameter is kept for API-shape parity but does not change behavior in
+	 * either subclass -- said once here rather than repeated in each.
+	 
+]]
+local MemoryProcessor
+do
+	MemoryProcessor = {}
+	function MemoryProcessor:constructor(realUsage, useFormatting)
+		if realUsage == nil then
+			realUsage = true
+		end
+		if useFormatting == nil then
+			useFormatting = true
+		end
+		self.realUsage = realUsage
+		self.useFormatting = useFormatting
+	end
+	function MemoryProcessor:formatBytes(bytes)
+		if not self.useFormatting then
+			return bytes
+		end
+		if bytes > 1024 * 1024 then
+			return `{math.round((bytes / 1024 / 1024) * 100) / 100} MB`
+		elseif bytes > 1024 then
+			return `{math.round((bytes / 1024) * 100) / 100} KB`
+		end
+		return `{bytes} B`
+	end
+end
+return {
+	MemoryProcessor = MemoryProcessor,
+}

package/out/Monolog/Processor/MemoryUsageProcessor.d.ts

@@ -0,0 +1,12 @@
+import { MemoryProcessor } from "./MemoryProcessor";
+import type { LogRecord } from "../LogRecord";
+/**
+ * PHP: `Monolog\Processor\MemoryUsageProcessor`.
+ *
+ * `gcinfo()` (Roblox's replacement for the deprecated `collectgarbage("count")`)
+ * reports kilobytes; multiplied by 1024 so `formatBytes()` sees the same unit
+ * PHP's `memory_get_usage()` returns.
+ */
+export declare class MemoryUsageProcessor extends MemoryProcessor {
+    process(record: LogRecord): LogRecord;
+}

package/out/Monolog/Processor/MemoryUsageProcessor.luau

@@ -0,0 +1,38 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local MemoryProcessor = TS.import(script, script.Parent, "MemoryProcessor").MemoryProcessor
+--[[
+	*
+	 * PHP: `Monolog\Processor\MemoryUsageProcessor`.
+	 *
+	 * `gcinfo()` (Roblox's replacement for the deprecated `collectgarbage("count")`)
+	 * reports kilobytes; multiplied by 1024 so `formatBytes()` sees the same unit
+	 * PHP's `memory_get_usage()` returns.
+	 
+]]
+local MemoryUsageProcessor
+do
+	local super = MemoryProcessor
+	MemoryUsageProcessor = setmetatable({}, {
+		__tostring = function()
+			return "MemoryUsageProcessor"
+		end,
+		__index = super,
+	})
+	MemoryUsageProcessor.__index = MemoryUsageProcessor
+	function MemoryUsageProcessor.new(...)
+		local self = setmetatable({}, MemoryUsageProcessor)
+		return self:constructor(...) or self
+	end
+	function MemoryUsageProcessor:constructor(...)
+		super.constructor(self, ...)
+	end
+	function MemoryUsageProcessor:process(record)
+		local usage = gcinfo() * 1024
+		record.extra.memory_usage = self:formatBytes(usage)
+		return record
+	end
+end
+return {
+	MemoryUsageProcessor = MemoryUsageProcessor,
+}

package/out/Monolog/Processor/ProcessIdProcessor.d.ts

@@ -0,0 +1,13 @@
+import type { LogRecord } from "../LogRecord";
+import type { ProcessorInterface } from "./ProcessorInterface";
+/**
+ * PHP: `Monolog\Processor\ProcessIdProcessor`.
+ *
+ * There is no OS process id on Roblox. `game.JobId` is the closest identifier
+ * for "which running process is this" -- a string, not the int
+ * `getmypid()` returns, and empty outside a real server (e.g. Studio Play
+ * testing), where it falls back to `"studio"`.
+ */
+export declare class ProcessIdProcessor implements ProcessorInterface {
+    process(record: LogRecord): LogRecord;
+}