sidekiq-ts 1.0.0

package/dist/job.js

@@ -0,0 +1,200 @@
+import { Client } from "./client.js";
+import { normalizeItem, verifyJson } from "./job-util.js";
+import { Sidekiq } from "./sidekiq.js";
+import { EmptyQueueError, Queues } from "./testing.js";
+const OPTIONS_KEY = Symbol("sidekiqOptions");
+export class Job {
+    jid;
+    _context;
+    static getSidekiqOptions() {
+        const base = Sidekiq.defaultJobOptions();
+        const explicit = this.sidekiqOptions ?? {};
+        const stored = this[OPTIONS_KEY] ?? {};
+        return {
+            ...base,
+            ...explicit,
+            ...stored,
+        };
+    }
+    static setSidekiqOptions(options) {
+        const stored = this[OPTIONS_KEY] ?? {};
+        this[OPTIONS_KEY] = {
+            ...stored,
+            ...options,
+        };
+    }
+    static queueAs(queue) {
+        this.setSidekiqOptions({ queue });
+    }
+    static retryIn(handler) {
+        this.sidekiqRetryIn = handler;
+    }
+    static retriesExhausted(handler) {
+        this.sidekiqRetriesExhausted = handler;
+    }
+    static set(options) {
+        return new JobSetter(this, options);
+    }
+    static performAsync(...args) {
+        return new JobSetter(this, {}).performAsync(...args);
+    }
+    static performIn(interval, ...args) {
+        return new JobSetter(this, {}).performIn(interval, ...args);
+    }
+    static performAt(timestamp, ...args) {
+        return new JobSetter(this, {}).performAt(timestamp, ...args);
+    }
+    static performBulk(args, options) {
+        return new JobSetter(this, {}).performBulk(args, options);
+    }
+    static performInline(...args) {
+        return new JobSetter(this, {}).performInline(...args);
+    }
+    static jobs() {
+        if (this === Job) {
+            return Queues.jobs();
+        }
+        return Queues.jobsForClass(this.name);
+    }
+    static clear() {
+        const queue = this.getSidekiqOptions().queue ?? "default";
+        Queues.clearFor(queue, this.name);
+    }
+    static async drain() {
+        while (this.jobs().length > 0) {
+            const nextJob = this.jobs()[0];
+            Queues.deleteFor(nextJob.jid ?? "", nextJob.queue ?? "default", this.name);
+            await this.processJob(nextJob);
+        }
+    }
+    static async performOne() {
+        if (this.jobs().length === 0) {
+            throw new EmptyQueueError();
+        }
+        const nextJob = this.jobs()[0];
+        Queues.deleteFor(nextJob.jid ?? "", nextJob.queue ?? "default", this.name);
+        await this.processJob(nextJob);
+    }
+    static async processJob(payload) {
+        const instance = new this();
+        instance.jid = payload.jid;
+        instance._context = { stopping: () => false };
+        await Sidekiq.defaultConfiguration.serverMiddleware.invoke(instance, payload, payload.queue ?? "default", async () => {
+            await instance.perform(...(payload.args ?? []));
+        });
+    }
+    static clearAll() {
+        Queues.clearAll();
+    }
+    static async drainAll() {
+        while (Queues.jobs().length > 0) {
+            const jobs = Queues.jobs();
+            const classes = Array.from(new Set(jobs.map((job) => String(job.class))));
+            for (const className of classes) {
+                const klass = Sidekiq.registeredJobClass(className);
+                if (!klass) {
+                    continue;
+                }
+                await klass.drain();
+            }
+        }
+    }
+    static clientPush(item) {
+        const config = Sidekiq.defaultConfiguration;
+        const normalized = normalizeItem(item, Sidekiq.defaultJobOptions());
+        verifyJson(normalized.args, config.strictArgs);
+        const client = new Client({ config });
+        return client.push(normalized);
+    }
+    logger() {
+        return Sidekiq.logger();
+    }
+    interrupted() {
+        return this._context?.stopping() ?? false;
+    }
+}
+export class JobSetter {
+    klass;
+    options;
+    constructor(klass, options) {
+        this.klass = klass;
+        this.options = { ...options };
+        const interval = this.options.waitUntil ?? this.options.wait;
+        if (interval !== undefined) {
+            this.at(interval);
+            this.options.wait = undefined;
+            this.options.waitUntil = undefined;
+        }
+    }
+    set(options) {
+        const merged = { ...options };
+        const interval = merged.waitUntil ?? merged.wait;
+        if (interval !== undefined) {
+            this.at(interval);
+            merged.wait = undefined;
+            merged.waitUntil = undefined;
+        }
+        this.options = {
+            ...this.options,
+            ...merged,
+        };
+        return this;
+    }
+    async performAsync(...args) {
+        if (this.options.sync === true) {
+            return (await this.performInline(...args)) ? "inline" : null;
+        }
+        const payload = {
+            ...this.options,
+            class: this.klass,
+            args,
+        };
+        return this.klass.clientPush(payload);
+    }
+    async performInline(...args) {
+        const payload = {
+            ...this.options,
+            class: this.klass,
+            args,
+        };
+        const normalized = normalizeItem(payload, Sidekiq.defaultJobOptions());
+        verifyJson(normalized.args, Sidekiq.defaultConfiguration.strictArgs);
+        const instance = new this.klass();
+        instance.jid = normalized.jid;
+        await instance.perform(...normalized.args);
+        return true;
+    }
+    performBulk(args, options) {
+        const payload = {
+            ...this.options,
+            class: this.klass,
+            args: [],
+        };
+        const client = new Client({ config: Sidekiq.defaultConfiguration });
+        return client.pushBulk({
+            ...payload,
+            args,
+            batch_size: options?.batchSize,
+            spread_interval: options?.spreadInterval,
+            at: options?.at,
+        });
+    }
+    performIn(interval, ...args) {
+        return this.at(interval).performAsync(...args);
+    }
+    performAt(timestamp, ...args) {
+        return this.at(timestamp).performAsync(...args);
+    }
+    at(interval) {
+        const int = Number(interval);
+        const now = Date.now() / 1000;
+        const ts = int < 1_000_000_000 ? now + int : int;
+        if (ts > now) {
+            this.options.at = ts;
+        }
+        else {
+            this.options.at = undefined;
+        }
+        return this;
+    }
+}

package/dist/json.d.ts

@@ -0,0 +1,3 @@
+export declare const loadJson: (value: string) => unknown;
+export declare const dumpJson: (value: unknown) => string;
+//# sourceMappingURL=json.d.ts.map

package/dist/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ,GAAI,OAAO,MAAM,KAAG,OAA4B,CAAC;AAEtE,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,MAA+B,CAAC"}

package/dist/json.js

@@ -0,0 +1,2 @@
+export const loadJson = (value) => JSON.parse(value);
+export const dumpJson = (value) => JSON.stringify(value);

package/dist/leader.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Leader election for Sidekiq processes.
+ *
+ * Follows Sidekiq Enterprise's approach:
+ * - Leaders refresh every 15 seconds
+ * - Followers check/attempt acquisition every 60 seconds
+ * - Redis is the source of truth (no Raft/Paxos)
+ * - 20 second TTL on leader key for automatic failover
+ */
+import type { Config } from "./config.js";
+export interface LeaderElectorOptions {
+    /** Leader refresh interval in milliseconds (default: 15000) */
+    refreshInterval?: number;
+    /** Follower check interval in milliseconds (default: 60000) */
+    checkInterval?: number;
+    /** Leader key TTL in seconds (default: 20) */
+    ttl?: number;
+    /** Override process identity (default: hostname:pid) */
+    identity?: string;
+}
+export declare class LeaderElector {
+    private readonly config;
+    private readonly identity;
+    private readonly refreshInterval;
+    private readonly checkInterval;
+    private readonly ttl;
+    private redis?;
+    private isLeader;
+    private running;
+    private loopPromise?;
+    private stopController?;
+    constructor(config: Config, options?: LeaderElectorOptions);
+    /**
+     * Start the leader election loop.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the leader election loop and release leadership if held.
+     */
+    stop(): Promise<void>;
+    /**
+     * Returns true if this process is currently the leader.
+     */
+    leader(): boolean;
+    /**
+     * Get the identity of the current leader (may be another process).
+     */
+    currentLeader(): Promise<string | null>;
+    /**
+     * Try to acquire leadership. Returns true if successful.
+     */
+    private tryAcquire;
+    /**
+     * Refresh leadership (extend TTL). Returns true if successful.
+     */
+    private tryRefresh;
+    /**
+     * Background loop for leader election.
+     */
+    private leaderLoop;
+    private sleepWithAbort;
+}
+//# sourceMappingURL=leader.d.ts.map

package/dist/leader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leader.d.ts","sourceRoot":"","sources":["../src/leader.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAe1C,MAAM,WAAW,oBAAoB;IACnC,+DAA+D;IAC/D,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,+DAA+D;IAC/D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,8CAA8C;IAC9C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAE7B,OAAO,CAAC,KAAK,CAAC,CAAc;IAC5B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,WAAW,CAAC,CAAgB;IACpC,OAAO,CAAC,cAAc,CAAC,CAAkB;gBAE7B,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,oBAAyB;IAS9D;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAgB5B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IA4B3B;;OAEG;IACH,MAAM,IAAI,OAAO;IAIjB;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAK7C;;OAEG;YACW,UAAU;IA4BxB;;OAEG;YACW,UAAU;IAmBxB;;OAEG;YACW,UAAU;YAkCV,cAAc;CAkB7B"}

package/dist/leader.js

@@ -0,0 +1,193 @@
+/**
+ * Leader election for Sidekiq processes.
+ *
+ * Follows Sidekiq Enterprise's approach:
+ * - Leaders refresh every 15 seconds
+ * - Followers check/attempt acquisition every 60 seconds
+ * - Redis is the source of truth (no Raft/Paxos)
+ * - 20 second TTL on leader key for automatic failover
+ */
+import { hostname } from "node:os";
+const LEADER_KEY = "leader";
+const LEADER_TTL_SECONDS = 20;
+const LEADER_REFRESH_INTERVAL_MS = 15_000;
+const FOLLOWER_CHECK_INTERVAL_MS = 60_000;
+const LUA_REFRESH_LEADER = `
+if redis.call("get", KEYS[1]) == ARGV[1] then
+  return redis.call("set", KEYS[1], ARGV[1], "ex", ARGV[2])
+end
+return nil
+`;
+export class LeaderElector {
+    config;
+    identity;
+    refreshInterval;
+    checkInterval;
+    ttl;
+    redis;
+    isLeader = false;
+    running = false;
+    loopPromise;
+    stopController;
+    constructor(config, options = {}) {
+        this.config = config;
+        this.identity = options.identity ?? `${hostname()}:${process.pid}`;
+        this.refreshInterval =
+            options.refreshInterval ?? LEADER_REFRESH_INTERVAL_MS;
+        this.checkInterval = options.checkInterval ?? FOLLOWER_CHECK_INTERVAL_MS;
+        this.ttl = options.ttl ?? LEADER_TTL_SECONDS;
+    }
+    /**
+     * Start the leader election loop.
+     */
+    async start() {
+        if (this.running) {
+            return;
+        }
+        this.redis = await this.config.getRedisClient();
+        this.running = true;
+        this.stopController = new AbortController();
+        // Try to acquire leadership immediately on start
+        await this.tryAcquire();
+        // Start the background loop
+        this.loopPromise = this.leaderLoop();
+    }
+    /**
+     * Stop the leader election loop and release leadership if held.
+     */
+    async stop() {
+        if (!this.running) {
+            return;
+        }
+        this.running = false;
+        this.stopController?.abort();
+        // Release leadership on clean shutdown
+        if (this.isLeader && this.redis) {
+            try {
+                const current = await this.redis.get(LEADER_KEY);
+                if (current === this.identity) {
+                    await this.redis.del(LEADER_KEY);
+                }
+            }
+            catch {
+                // Ignore errors during shutdown
+            }
+        }
+        this.isLeader = false;
+        // Wait for loop to finish
+        if (this.loopPromise) {
+            await this.loopPromise;
+        }
+    }
+    /**
+     * Returns true if this process is currently the leader.
+     */
+    leader() {
+        return this.isLeader;
+    }
+    /**
+     * Get the identity of the current leader (may be another process).
+     */
+    async currentLeader() {
+        const redis = this.redis ?? (await this.config.getRedisClient());
+        return redis.get(LEADER_KEY);
+    }
+    /**
+     * Try to acquire leadership. Returns true if successful.
+     */
+    async tryAcquire() {
+        if (!this.redis) {
+            return false;
+        }
+        try {
+            const result = await this.redis.set(LEADER_KEY, this.identity, {
+                NX: true,
+                EX: this.ttl,
+            });
+            if (result === "OK") {
+                if (!this.isLeader) {
+                    this.isLeader = true;
+                    await this.config.fireEvent("leader", { oneshot: false });
+                    this.config.logger.info(() => `Became leader: ${this.identity}`);
+                }
+                return true;
+            }
+        }
+        catch (error) {
+            this.config.logger.error(() => `Leader acquisition error: ${error.message}`);
+        }
+        return false;
+    }
+    /**
+     * Refresh leadership (extend TTL). Returns true if successful.
+     */
+    async tryRefresh() {
+        if (!this.redis) {
+            return false;
+        }
+        try {
+            const result = await this.redis.eval(LUA_REFRESH_LEADER, {
+                keys: [LEADER_KEY],
+                arguments: [this.identity, String(this.ttl)],
+            });
+            return result === "OK";
+        }
+        catch (error) {
+            this.config.logger.error(() => `Leader refresh error: ${error.message}`);
+            return false;
+        }
+    }
+    /**
+     * Background loop for leader election.
+     */
+    async leaderLoop() {
+        while (this.running) {
+            try {
+                if (this.isLeader) {
+                    // Leader: try to refresh
+                    const refreshed = await this.tryRefresh();
+                    if (!refreshed) {
+                        this.isLeader = false;
+                        await this.config.fireEvent("follower", { oneshot: false });
+                        this.config.logger.info(() => `Lost leadership: ${this.identity}`);
+                    }
+                }
+                else {
+                    // Follower: try to acquire
+                    await this.tryAcquire();
+                }
+            }
+            catch (error) {
+                // On unexpected errors, assume we lost leadership
+                if (this.isLeader) {
+                    this.isLeader = false;
+                    await this.config.fireEvent("follower", { oneshot: false });
+                    this.config.logger.warn(() => `Lost leadership due to error: ${error.message}`);
+                }
+            }
+            // Sleep for appropriate interval
+            const interval = this.isLeader
+                ? this.refreshInterval
+                : this.checkInterval;
+            await this.sleepWithAbort(interval);
+        }
+    }
+    async sleepWithAbort(ms) {
+        const controller = this.stopController;
+        if (!controller || controller.signal.aborted) {
+            return;
+        }
+        await new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                controller.signal.removeEventListener("abort", onAbort);
+                resolve();
+            }, ms);
+            const onAbort = () => {
+                clearTimeout(timeout);
+                controller.signal.removeEventListener("abort", onAbort);
+                resolve();
+            };
+            controller.signal.addEventListener("abort", onAbort, { once: true });
+        });
+    }
+}

package/dist/logger.d.ts

@@ -0,0 +1,53 @@
+export type LogMessage = string | (() => string);
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export interface Logger {
+    debug(message: LogMessage): void;
+    info(message: LogMessage): void;
+    warn(message: LogMessage): void;
+    error(message: LogMessage): void;
+}
+export interface Formatter {
+    format(level: LogLevel, message: string, time?: Date): string;
+}
+export declare class BaseFormatter {
+    private readonly tidToken;
+    protected tid(): string;
+    protected contextString(): string;
+}
+export declare class PrettyFormatter extends BaseFormatter implements Formatter {
+    protected colors: Record<string, string>;
+    protected useColors: boolean;
+    constructor({ useColors }?: {
+        useColors?: boolean | undefined;
+    });
+    protected label(severity: string): string;
+    format(level: LogLevel, message: string, time?: Date): string;
+}
+export declare class PlainFormatter extends BaseFormatter implements Formatter {
+    format(level: LogLevel, message: string, time?: Date): string;
+}
+export declare class WithoutTimestampFormatter extends PrettyFormatter {
+    format(level: LogLevel, message: string): string;
+}
+export declare class JsonFormatter extends BaseFormatter implements Formatter {
+    format(level: LogLevel, message: string, time?: Date): string;
+}
+export declare const Formatters: {
+    Base: typeof BaseFormatter;
+    Pretty: typeof PrettyFormatter;
+    Plain: typeof PlainFormatter;
+    WithoutTimestamp: typeof WithoutTimestampFormatter;
+    JSON: typeof JsonFormatter;
+};
+export declare class SidekiqLogger implements Logger {
+    formatter: Formatter;
+    private readonly base;
+    constructor(base?: Console, formatter?: Formatter);
+    debug(message: LogMessage): void;
+    info(message: LogMessage): void;
+    warn(message: LogMessage): void;
+    error(message: LogMessage): void;
+    private log;
+}
+export declare const createLogger: (base?: Console) => Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,CAAC;AACjD,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE3D,MAAM,WAAW,MAAM;IACrB,KAAK,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,CAAC;IACjC,IAAI,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,CAAC;IAChC,IAAI,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,CAAC;IAChC,KAAK,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,CAAC;CAClC;AAED,MAAM,WAAW,SAAS;IACxB,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;CAC/D;AA6CD,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiB;IAE1C,SAAS,CAAC,GAAG,IAAI,MAAM;IAIvB,SAAS,CAAC,aAAa,IAAI,MAAM;CAGlC;AAED,qBAAa,eAAgB,SAAQ,aAAc,YAAW,SAAS;IACrE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,SAAS,CAAC,SAAS,EAAE,OAAO,CAAC;gBAEjB,EAAE,SAAyC,EAAE;;KAAK;IAW9D,SAAS,CAAC,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAIzC,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,OAAa,GAAG,MAAM;CAOpE;AAED,qBAAa,cAAe,SAAQ,aAAc,YAAW,SAAS;IACpE,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,OAAa,GAAG,MAAM;CAMpE;AAED,qBAAa,yBAA0B,SAAQ,eAAe;IAC5D,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM;CAOjD;AAED,qBAAa,aAAc,SAAQ,aAAc,YAAW,SAAS;IACnE,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,OAAa,GAAG,MAAM;CAcpE;AAED,eAAO,MAAM,UAAU;;;;;;CAMtB,CAAC;AAEF,qBAAa,aAAc,YAAW,MAAM;IAC1C,SAAS,EAAE,SAAS,CAAC;IACrB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAU;gBAG7B,IAAI,GAAE,OAAiB,EACvB,SAAS,GAAE,SAA8B;IAM3C,KAAK,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI;IAIhC,IAAI,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI;IAI/B,IAAI,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI;IAI/B,KAAK,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI;IAIhC,OAAO,CAAC,GAAG;CAKZ;AASD,eAAO,MAAM,YAAY,GAAI,OAAM,OAAiB,KAAG,MACV,CAAC"}

package/dist/logger.js

@@ -0,0 +1,143 @@
+import { threadId } from "node:worker_threads";
+import { Context } from "./context.js";
+const resolveMessage = (message) => typeof message === "function" ? message() : message;
+const formatContext = (context) => {
+    if (!context) {
+        return "";
+    }
+    const entries = Object.entries(context).filter(([, value]) => value !== undefined);
+    if (entries.length === 0) {
+        return "";
+    }
+    return entries
+        .map(([key, value]) => {
+        if (Array.isArray(value)) {
+            return `${key}=${value.join(",")}`;
+        }
+        return `${key}=${String(value)}`;
+    })
+        .join(" ");
+};
+const upperLevel = (level) => {
+    if (level === "debug") {
+        return "DEBUG";
+    }
+    if (level === "info") {
+        return "INFO";
+    }
+    if (level === "warn") {
+        return "WARN";
+    }
+    return "ERROR";
+};
+const threadToken = () => {
+    // biome-ignore lint/suspicious/noBitwiseOperators: XOR for unique thread token
+    const token = process.pid ^ (threadId + 1);
+    // biome-ignore lint/suspicious/noBitwiseOperators: unsigned right shift for positive value
+    return (token >>> 0).toString(36);
+};
+export class BaseFormatter {
+    tidToken = threadToken();
+    tid() {
+        return this.tidToken;
+    }
+    contextString() {
+        return formatContext(Context.peek());
+    }
+}
+export class PrettyFormatter extends BaseFormatter {
+    colors;
+    useColors;
+    constructor({ useColors = Boolean(process.stdout.isTTY) } = {}) {
+        super();
+        this.useColors = useColors;
+        this.colors = {
+            DEBUG: "\u001b[1;32mDEBUG\u001b[0m",
+            INFO: "\u001b[1;34mINFO \u001b[0m",
+            WARN: "\u001b[1;33mWARN \u001b[0m",
+            ERROR: "\u001b[1;31mERROR\u001b[0m",
+        };
+    }
+    label(severity) {
+        return this.useColors ? this.colors[severity] : severity;
+    }
+    format(level, message, time = new Date()) {
+        const severity = upperLevel(level);
+        const label = this.label(severity);
+        const context = this.contextString();
+        const suffix = context ? ` ${context}` : "";
+        return `${label} ${time.toISOString()} pid=${process.pid} tid=${this.tid()}${suffix}: ${message}`;
+    }
+}
+export class PlainFormatter extends BaseFormatter {
+    format(level, message, time = new Date()) {
+        const severity = upperLevel(level);
+        const context = this.contextString();
+        const suffix = context ? ` ${context}` : "";
+        return `${severity} ${time.toISOString()} pid=${process.pid} tid=${this.tid()}${suffix}: ${message}`;
+    }
+}
+export class WithoutTimestampFormatter extends PrettyFormatter {
+    format(level, message) {
+        const severity = upperLevel(level);
+        const label = this.label(severity);
+        const context = this.contextString();
+        const suffix = context ? ` ${context}` : "";
+        return `${label} pid=${process.pid} tid=${this.tid()}${suffix}: ${message}`;
+    }
+}
+export class JsonFormatter extends BaseFormatter {
+    format(level, message, time = new Date()) {
+        const hash = {
+            ts: time.toISOString(),
+            pid: process.pid,
+            tid: this.tid(),
+            lvl: upperLevel(level),
+            msg: message,
+        };
+        const context = Context.peek();
+        if (context && Object.keys(context).length > 0) {
+            hash.ctx = context;
+        }
+        return JSON.stringify(hash);
+    }
+}
+export const Formatters = {
+    Base: BaseFormatter,
+    Pretty: PrettyFormatter,
+    Plain: PlainFormatter,
+    WithoutTimestamp: WithoutTimestampFormatter,
+    JSON: JsonFormatter,
+};
+export class SidekiqLogger {
+    formatter;
+    base;
+    constructor(base = console, formatter = defaultFormatter()) {
+        this.base = base;
+        this.formatter = formatter;
+    }
+    debug(message) {
+        this.log("debug", message);
+    }
+    info(message) {
+        this.log("info", message);
+    }
+    warn(message) {
+        this.log("warn", message);
+    }
+    error(message) {
+        this.log("error", message);
+    }
+    log(level, message) {
+        const resolved = resolveMessage(message);
+        const formatted = this.formatter.format(level, resolved);
+        this.base[level](formatted);
+    }
+}
+const defaultFormatter = () => {
+    if (process.env.DYNO) {
+        return new WithoutTimestampFormatter();
+    }
+    return new PrettyFormatter();
+};
+export const createLogger = (base = console) => new SidekiqLogger(base, defaultFormatter());