@larablox/monolog 0.1.0

package/out/Monolog/Processor/ProcessIdProcessor.luau

@@ -0,0 +1,33 @@
+-- Compiled with roblox-ts v3.0.0
+--[[
+	*
+	 * 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"`.
+	 
+]]
+local ProcessIdProcessor
+do
+	ProcessIdProcessor = setmetatable({}, {
+		__tostring = function()
+			return "ProcessIdProcessor"
+		end,
+	})
+	ProcessIdProcessor.__index = ProcessIdProcessor
+	function ProcessIdProcessor.new(...)
+		local self = setmetatable({}, ProcessIdProcessor)
+		return self:constructor(...) or self
+	end
+	function ProcessIdProcessor:constructor()
+	end
+	function ProcessIdProcessor:process(record)
+		record.extra.process_id = if game.JobId ~= "" then game.JobId else "studio"
+		return record
+	end
+end
+return {
+	ProcessIdProcessor = ProcessIdProcessor,
+}

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

@@ -0,0 +1,13 @@
+import type { LogRecord } from "../LogRecord";
+/**
+ * PHP: `Monolog\Processor\ProcessorInterface`, whose instances are invoked
+ * through `__invoke`. Luau has no callable objects, so a processor is either a
+ * plain function or an object with a `process` method.
+ */
+export interface ProcessorInterface {
+    process(record: LogRecord): LogRecord;
+}
+/** What `pushProcessor()` accepts. */
+export type Processor = ProcessorInterface | ((record: LogRecord) => LogRecord);
+/** Run a processor whichever shape it has. */
+export declare function runProcessor(processor: Processor, record: LogRecord): LogRecord;

package/out/Monolog/Processor/ProcessorInterface.luau

@@ -0,0 +1,20 @@
+-- Compiled with roblox-ts v3.0.0
+--[[
+	*
+	 * PHP: `Monolog\Processor\ProcessorInterface`, whose instances are invoked
+	 * through `__invoke`. Luau has no callable objects, so a processor is either a
+	 * plain function or an object with a `process` method.
+	 
+]]
+--* What `pushProcessor()` accepts. 
+--* Run a processor whichever shape it has. 
+local function runProcessor(processor, record)
+	local _processor = processor
+	if type(_processor) == "function" then
+		return processor(record)
+	end
+	return processor:process(record)
+end
+return {
+	runProcessor = runProcessor,
+}

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

@@ -0,0 +1,12 @@
+import type { LogRecord } from "../LogRecord";
+import type { ProcessorInterface } from "./ProcessorInterface";
+/**
+ * PHP: `Monolog\Processor\PsrLogMessageProcessor`.
+ *
+ * Replaces `{placeholder}` in the message with the matching context value.
+ */
+export declare class PsrLogMessageProcessor implements ProcessorInterface {
+    protected readonly removeUsedContextFields: boolean;
+    constructor(removeUsedContextFields?: boolean);
+    process(record: LogRecord): LogRecord;
+}

package/out/Monolog/Processor/PsrLogMessageProcessor.luau

@@ -0,0 +1,62 @@
+-- Compiled with roblox-ts v3.0.0
+--[[
+	*
+	 * PHP: `Monolog\Processor\PsrLogMessageProcessor`.
+	 *
+	 * Replaces `{placeholder}` in the message with the matching context value.
+	 
+]]
+local PsrLogMessageProcessor
+do
+	PsrLogMessageProcessor = setmetatable({}, {
+		__tostring = function()
+			return "PsrLogMessageProcessor"
+		end,
+	})
+	PsrLogMessageProcessor.__index = PsrLogMessageProcessor
+	function PsrLogMessageProcessor.new(...)
+		local self = setmetatable({}, PsrLogMessageProcessor)
+		return self:constructor(...) or self
+	end
+	function PsrLogMessageProcessor:constructor(removeUsedContextFields)
+		if removeUsedContextFields == nil then
+			removeUsedContextFields = false
+		end
+		self.removeUsedContextFields = removeUsedContextFields
+	end
+	function PsrLogMessageProcessor:process(record)
+		if (string.find(record.message, "{", 1, true)) == nil then
+			return record
+		end
+		local message = record.message
+		local context = {}
+		for key, value in pairs(record.context) do
+			context[key] = value
+		end
+		for key, value in pairs(record.context) do
+			local placeholder = `\{{key}\}`
+			if (string.find(message, placeholder, 1, true)) == nil then
+				continue
+			end
+			local _exp = string.split(message, placeholder)
+			local _arg0 = tostring(value)
+			-- ▼ ReadonlyArray.join ▼
+			local _arg0_1 = _arg0
+			if _arg0_1 == nil then
+				_arg0_1 = ", "
+			end
+			-- ▲ ReadonlyArray.join ▲
+			message = table.concat(_exp, _arg0_1)
+			if self.removeUsedContextFields then
+				context[key] = nil
+			end
+		end
+		return record:with({
+			message = message,
+			context = context,
+		})
+	end
+end
+return {
+	PsrLogMessageProcessor = PsrLogMessageProcessor,
+}

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

@@ -0,0 +1,12 @@
+import type { LogRecord } from "../LogRecord";
+import type { ProcessorInterface } from "./ProcessorInterface";
+/** PHP: `Monolog\Processor\TagProcessor`. */
+export declare class TagProcessor implements ProcessorInterface {
+    private tags;
+    constructor(tags?: Array<string>);
+    /** Adds to the existing tag list. */
+    addTags(tags?: Array<string>): this;
+    /** Replaces the tag list. */
+    setTags(tags?: Array<string>): this;
+    process(record: LogRecord): LogRecord;
+}

package/out/Monolog/Processor/TagProcessor.luau

@@ -0,0 +1,46 @@
+-- Compiled with roblox-ts v3.0.0
+--* PHP: `Monolog\Processor\TagProcessor`. 
+local TagProcessor
+do
+	TagProcessor = setmetatable({}, {
+		__tostring = function()
+			return "TagProcessor"
+		end,
+	})
+	TagProcessor.__index = TagProcessor
+	function TagProcessor.new(...)
+		local self = setmetatable({}, TagProcessor)
+		return self:constructor(...) or self
+	end
+	function TagProcessor:constructor(tags)
+		if tags == nil then
+			tags = {}
+		end
+		self.tags = {}
+		self:setTags(tags)
+	end
+	function TagProcessor:addTags(tags)
+		if tags == nil then
+			tags = {}
+		end
+		for _, tag in tags do
+			local _exp = self.tags
+			table.insert(_exp, tag)
+		end
+		return self
+	end
+	function TagProcessor:setTags(tags)
+		if tags == nil then
+			tags = {}
+		end
+		self.tags = tags
+		return self
+	end
+	function TagProcessor:process(record)
+		record.extra.tags = self.tags
+		return record
+	end
+end
+return {
+	TagProcessor = TagProcessor,
+}

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

@@ -0,0 +1,18 @@
+import type { LogRecord } from "../LogRecord";
+import type { ProcessorInterface } from "./ProcessorInterface";
+import type { ResettableInterface } from "../ResettableInterface";
+/**
+ * PHP: `Monolog\Processor\UidProcessor`.
+ *
+ * `bin2hex(random_bytes())` has no equivalent here; the uid instead comes from
+ * `HttpService:GenerateGUID(false)`, with dashes stripped, lowercased, and cut
+ * to `length` characters.
+ */
+export declare class UidProcessor implements ProcessorInterface, ResettableInterface {
+    private readonly length;
+    private uid;
+    constructor(length?: number);
+    process(record: LogRecord): LogRecord;
+    getUid(): string;
+    reset(): void;
+}

package/out/Monolog/Processor/UidProcessor.luau

@@ -0,0 +1,53 @@
+-- Compiled with roblox-ts v3.0.0
+local HttpService = game:GetService("HttpService")
+local function generateUid(length)
+	local guid = string.gsub(HttpService:GenerateGUID(false), "-", "")
+	local _exp = string.lower(guid)
+	local _length = length
+	return string.sub(_exp, 1, _length)
+end
+--[[
+	*
+	 * PHP: `Monolog\Processor\UidProcessor`.
+	 *
+	 * `bin2hex(random_bytes())` has no equivalent here; the uid instead comes from
+	 * `HttpService:GenerateGUID(false)`, with dashes stripped, lowercased, and cut
+	 * to `length` characters.
+	 
+]]
+local UidProcessor
+do
+	UidProcessor = setmetatable({}, {
+		__tostring = function()
+			return "UidProcessor"
+		end,
+	})
+	UidProcessor.__index = UidProcessor
+	function UidProcessor.new(...)
+		local self = setmetatable({}, UidProcessor)
+		return self:constructor(...) or self
+	end
+	function UidProcessor:constructor(length)
+		if length == nil then
+			length = 7
+		end
+		self.length = length
+		if length > 32 or length < 1 then
+			error("The uid length must be an integer between 1 and 32")
+		end
+		self.uid = generateUid(length)
+	end
+	function UidProcessor:process(record)
+		record.extra.uid = self.uid
+		return record
+	end
+	function UidProcessor:getUid()
+		return self.uid
+	end
+	function UidProcessor:reset()
+		self.uid = generateUid(#self.uid)
+	end
+end
+return {
+	UidProcessor = UidProcessor,
+}

package/out/Monolog/Registry.d.ts

@@ -0,0 +1,21 @@
+import type { Logger } from "./Logger";
+/**
+ * PHP: `Monolog\Registry`.
+ *
+ * `__callStatic` (`Registry::api()` reading back as a named accessor) is not
+ * ported -- Luau has no magic static-method dispatch. Callers use
+ * `Registry.getInstance(name)` explicitly instead.
+ */
+export declare class Registry {
+    private static loggers;
+    /** PHP: `Registry::addLogger()`. */
+    static addLogger(logger: Logger, name?: string, overwrite?: boolean): void;
+    /** PHP: `Registry::hasLogger()`. */
+    static hasLogger(logger: string | Logger): boolean;
+    /** PHP: `Registry::removeLogger()`. */
+    static removeLogger(logger: string | Logger): void;
+    /** PHP: `Registry::clear()`. */
+    static clear(): void;
+    /** PHP: `Registry::getInstance()`. */
+    static getInstance(name: string): Logger;
+}

package/out/Monolog/Registry.luau

@@ -0,0 +1,86 @@
+-- Compiled with roblox-ts v3.0.0
+--[[
+	*
+	 * PHP: `Monolog\Registry`.
+	 *
+	 * `__callStatic` (`Registry::api()` reading back as a named accessor) is not
+	 * ported -- Luau has no magic static-method dispatch. Callers use
+	 * `Registry.getInstance(name)` explicitly instead.
+	 
+]]
+local Registry
+do
+	Registry = setmetatable({}, {
+		__tostring = function()
+			return "Registry"
+		end,
+	})
+	Registry.__index = Registry
+	function Registry.new(...)
+		local self = setmetatable({}, Registry)
+		return self:constructor(...) or self
+	end
+	function Registry:constructor()
+	end
+	function Registry:addLogger(logger, name, overwrite)
+		if overwrite == nil then
+			overwrite = false
+		end
+		local _condition = name
+		if _condition == nil then
+			_condition = logger:getName()
+		end
+		local key = _condition
+		if Registry.loggers[key] ~= nil and not overwrite then
+			error("Logger with the given name already exists")
+		end
+		local _loggers = Registry.loggers
+		local _logger = logger
+		_loggers[key] = _logger
+	end
+	function Registry:hasLogger(logger)
+		local _logger = logger
+		if type(_logger) == "string" then
+			local _loggers = Registry.loggers
+			local _logger_1 = logger
+			return _loggers[_logger_1] ~= nil
+		end
+		for _, value in Registry.loggers do
+			if value == logger then
+				return true
+			end
+		end
+		return false
+	end
+	function Registry:removeLogger(logger)
+		local _logger = logger
+		if type(_logger) == "string" then
+			local _loggers = Registry.loggers
+			local _logger_1 = logger
+			_loggers[_logger_1] = nil
+			return nil
+		end
+		for key, value in Registry.loggers do
+			if value == logger then
+				Registry.loggers[key] = nil
+				return nil
+			end
+		end
+	end
+	function Registry:clear()
+		table.clear(Registry.loggers)
+	end
+	function Registry:getInstance(name)
+		local _loggers = Registry.loggers
+		local _name = name
+		local logger = _loggers[_name]
+		if logger == nil then
+			error(`Requested "{name}" logger instance is not in the registry`)
+		end
+		return logger
+	end
+	Registry.loggers = {}
+end
+return {
+	Registry = Registry,
+}

package/out/Monolog/ResettableInterface.d.ts

@@ -0,0 +1,11 @@
+/** PHP: `Monolog\ResettableInterface`. Handlers/processors reset by `Logger::reset()`. */
+export interface ResettableInterface {
+    reset(): void;
+}
+/**
+ * True when the given value implements `ResettableInterface`.
+ *
+ * PHP checks this with `instanceof`; Luau/TypeScript have no `instanceof` for
+ * interfaces, so this checks structurally for a callable `reset` member instead.
+ */
+export declare function isResettable(value: unknown): value is ResettableInterface;

package/out/Monolog/ResettableInterface.luau

@@ -0,0 +1,21 @@
+-- Compiled with roblox-ts v3.0.0
+--* PHP: `Monolog\ResettableInterface`. Handlers/processors reset by `Logger::reset()`. 
+--[[
+	*
+	 * True when the given value implements `ResettableInterface`.
+	 *
+	 * PHP checks this with `instanceof`; Luau/TypeScript have no `instanceof` for
+	 * interfaces, so this checks structurally for a callable `reset` member instead.
+	 
+]]
+local function isResettable(value)
+	local _value = value
+	if not (type(_value) == "table") then
+		return false
+	end
+	local _reset = value.reset
+	return type(_reset) == "function"
+end
+return {
+	isResettable = isResettable,
+}

package/out/Monolog/Test/MonologTestCase.d.ts

@@ -0,0 +1,26 @@
+import { Level } from "../Level";
+import { LogRecord } from "../LogRecord";
+import type { FormatterInterface } from "../Formatter/FormatterInterface";
+import type { LogLevel } from "../LoggerInterface";
+import type { RecordBag } from "../LogRecord";
+/**
+ * PHP: `Monolog\Test\MonologTestCase`.
+ *
+ * Lets you easily generate log records and a dummy formatter for testing
+ * purposes. Upstream extends PHPUnit's `TestCase`; there is no test-framework
+ * ancestor on this platform (`CLAUDE.md`: "Tests: none") to extend instead, so
+ * these are plain `public static` methods on a class that extends nothing.
+ */
+export declare class MonologTestCase {
+    /** PHP: `MonologTestCase::getRecord()`. */
+    static getRecord(level?: Level | LogLevel, message?: string, context?: RecordBag, channel?: string, extra?: RecordBag): LogRecord;
+    /** PHP: `MonologTestCase::getMultipleRecords()`. */
+    static getMultipleRecords(): Array<LogRecord>;
+    /**
+     * PHP: `MonologTestCase::getIdentityFormatter()`. Upstream builds this
+     * with PHPUnit's `createMock()`; there is no mocking library here to
+     * replicate that with, and none is needed for something this trivial --
+     * this is a plain object literal implementing `FormatterInterface`.
+     */
+    static getIdentityFormatter(): FormatterInterface;
+}

package/out/Monolog/Test/MonologTestCase.luau

@@ -0,0 +1,73 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local Level = TS.import(script, script.Parent.Parent, "Level").Level
+local Logger = TS.import(script, script.Parent.Parent, "Logger").Logger
+local LogRecord = TS.import(script, script.Parent.Parent, "LogRecord").LogRecord
+--[[
+	*
+	 * PHP: `Monolog\Test\MonologTestCase`.
+	 *
+	 * Lets you easily generate log records and a dummy formatter for testing
+	 * purposes. Upstream extends PHPUnit's `TestCase`; there is no test-framework
+	 * ancestor on this platform (`CLAUDE.md`: "Tests: none") to extend instead, so
+	 * these are plain `public static` methods on a class that extends nothing.
+	 
+]]
+local MonologTestCase
+do
+	MonologTestCase = setmetatable({}, {
+		__tostring = function()
+			return "MonologTestCase"
+		end,
+	})
+	MonologTestCase.__index = MonologTestCase
+	function MonologTestCase.new(...)
+		local self = setmetatable({}, MonologTestCase)
+		return self:constructor(...) or self
+	end
+	function MonologTestCase:constructor()
+	end
+	function MonologTestCase:getRecord(level, message, context, channel, extra)
+		if level == nil then
+			level = Level.Warning
+		end
+		if message == nil then
+			message = "test"
+		end
+		if context == nil then
+			context = {}
+		end
+		if channel == nil then
+			channel = "test"
+		end
+		if extra == nil then
+			extra = {}
+		end
+		return LogRecord.new(os.time(), channel, Logger:toMonologLevel(level), message, context, extra)
+	end
+	function MonologTestCase:getMultipleRecords()
+		return { MonologTestCase:getRecord(Level.Debug, "debug message 1"), MonologTestCase:getRecord(Level.Debug, "debug message 2"), MonologTestCase:getRecord(Level.Info, "information"), MonologTestCase:getRecord(Level.Warning, "warning"), MonologTestCase:getRecord(Level.Error, "error") }
+	end
+	function MonologTestCase:getIdentityFormatter()
+		return {
+			format = function(self, record)
+				return record.message
+			end,
+			formatBatch = function(self, records)
+				-- ▼ ReadonlyArray.map ▼
+				local _newValue = table.create(#records)
+				local _callback = function(record)
+					return record.message
+				end
+				for _k, _v in records do
+					_newValue[_k] = _callback(_v, _k - 1, records)
+				end
+				-- ▲ ReadonlyArray.map ▲
+				return table.concat(_newValue, "\n")
+			end,
+		}
+	end
+end
+return {
+	MonologTestCase = MonologTestCase,
+}

package/out/Monolog/Test/TestCase.d.ts

@@ -0,0 +1,4 @@
+import { MonologTestCase } from "./MonologTestCase";
+/** PHP: `Monolog\Test\TestCase`, a deprecated alias for `MonologTestCase`. */
+export declare class TestCase extends MonologTestCase {
+}

package/out/Monolog/Test/TestCase.luau

@@ -0,0 +1,25 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local MonologTestCase = TS.import(script, script.Parent, "MonologTestCase").MonologTestCase
+--* PHP: `Monolog\Test\TestCase`, a deprecated alias for `MonologTestCase`. 
+local TestCase
+do
+	local super = MonologTestCase
+	TestCase = setmetatable({}, {
+		__tostring = function()
+			return "TestCase"
+		end,
+		__index = super,
+	})
+	TestCase.__index = TestCase
+	function TestCase.new(...)
+		local self = setmetatable({}, TestCase)
+		return self:constructor(...) or self
+	end
+	function TestCase:constructor(...)
+		super.constructor(self, ...)
+	end
+end
+return {
+	TestCase = TestCase,
+}

package/out/Monolog/Utils.d.ts

@@ -0,0 +1,21 @@
+import type { LogRecord } from "./LogRecord";
+/**
+ * Marks a table so `jsonEncode` renders it as a JSON object (`{}`) rather than
+ * an array (`[]`) when it is empty. Luau tables can't tell an empty array from
+ * an empty object apart the way PHP's `\stdClass` vs `[]` can -- see
+ * `JsonFormatter.ts`, which is the one caller that needs this.
+ */
+export declare function markAsJsonObject<T extends object>(value: T): T;
+export declare class Utils {
+    /**
+     * PHP: `Utils::jsonEncode()`/`Utils::handleJsonError()`. There is no
+     * `json_encode` on this platform, so this is a small deterministic encoder
+     * instead: Luau tables carry no key order, so object keys are sorted before
+     * being written, and there is nothing that can fail the way `json_encode`
+     * can (invalid UTF-8, unsupported resource types) -- so there is nothing to
+     * recover from and no `handleJsonError` equivalent.
+     */
+    static jsonEncode(data: unknown, pretty?: boolean): string;
+    /** PHP: `Utils::getRecordMessageForException()`. */
+    static getRecordMessageForException(record: LogRecord): string;
+}