Namespace logger

The logger module provides a simple logging utility for Lua, allowing you to log messages at different levels (debug, info, warn, error).

TypeScript Example

import { logger } from "pelican";
import { describe, expect, it } from "lester";

describe("logger", () => {
    describe("debug", () => {
        logger.debug("This is a debug message");
    });

    describe("info", () => {
        logger.info("This is an info message");
    });

    describe("warn", () => {
        logger.warn("This is a warning message");
    });

    describe("error", () => {
        logger.error("This is an error message");
    });

    describe("Logger", () => {
        it("should instantiate logger using new keyword", () => {
            const my_logger = new logger.Logger("testNew");
            expect.equal(tostring(my_logger), "Logger(testNew)");
        });

        it("should instantiate logger using Logger function", () => {
            const my_logger = logger.Logger.new("testFunction");
            expect.equal(tostring(my_logger), "Logger(testFunction)");
        });

        it("should create a logger with a namespace", () => {
            const my_logger = new logger.Logger("testNamespace");
            expect.equal(type(my_logger), "userdata");
        });

        it("should log debug messages", () => {
            const my_logger = new logger.Logger("testDebug");
            expect.not_fail(() => {
                my_logger.debug("This is a debug message");
            });
        });

        it("should log info messages", () => {
            const my_logger = new logger.Logger("testInfo");
            expect.not_fail(() => {
                logger.info("This is an info message");
            });
        });

        it("should log warn messages", () => {
            const my_logger = new logger.Logger("testWarn");
            expect.not_fail(() => {
                my_logger.warn("This is a warning message");
            });
        });

        it("should log error messages", () => {
            const my_logger = new logger.Logger("testError");
            expect.not_fail(() => {
                my_logger.error("This is an error message");
            });
        });
    });
});
Copy

Lua Example

--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
local ____exports = {}
local ____pelican = require("pelican")
local logger = ____pelican.logger
local ____lester = require("tests.lester")
local describe = ____lester.describe
local expect = ____lester.expect
local it = ____lester.it
describe(
    "logger",
    function()
        describe(
            "debug",
            function()
                logger.debug("This is a debug message")
            end
        )
        describe(
            "info",
            function()
                logger.info("This is an info message")
            end
        )
        describe(
            "warn",
            function()
                logger.warn("This is a warning message")
            end
        )
        describe(
            "error",
            function()
                logger.error("This is an error message")
            end
        )
        describe(
            "Logger",
            function()
                it(
                    "should instantiate logger using new keyword",
                    function()
                        local my_logger = logger.Logger.new("testNew")
                        expect.equal(
                            tostring(my_logger),
                            "Logger(testNew)"
                        )
                    end
                )
                it(
                    "should instantiate logger using Logger function",
                    function()
                        local my_logger = logger.Logger.new("testFunction")
                        expect.equal(
                            tostring(my_logger),
                            "Logger(testFunction)"
                        )
                    end
                )
                it(
                    "should create a logger with a namespace",
                    function()
                        local my_logger = logger.Logger.new("testNamespace")
                        expect.equal(
                            type(my_logger),
                            "userdata"
                        )
                    end
                )
                it(
                    "should log debug messages",
                    function()
                        local my_logger = logger.Logger.new("testDebug")
                        expect.not_fail(function()
                            my_logger:debug("This is a debug message")
                        end)
                    end
                )
                it(
                    "should log info messages",
                    function()
                        local my_logger = logger.Logger.new("testInfo")
                        expect.not_fail(function()
                            logger.info("This is an info message")
                        end)
                    end
                )
                it(
                    "should log warn messages",
                    function()
                        local my_logger = logger.Logger.new("testWarn")
                        expect.not_fail(function()
                            my_logger:warn("This is a warning message")
                        end)
                    end
                )
                it(
                    "should log error messages",
                    function()
                        local my_logger = logger.Logger.new("testError")
                        expect.not_fail(function()
                            my_logger:error("This is an error message")
                        end)
                    end
                )
            end
        )
    end
)
return ____exports
Copy