qualink 0.1.1 → 0.2.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Allan Kimmer Jensen
+Copyright (c) 2026 Allan Kimmer Jensen
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -71,6 +71,7 @@ If needed, you can still pass explicit values with `--repo`, `--branch`, `--comm
 Sink configuration:
 
 - `--sink elastic` (default) requires `ELASTIC_URL` and `ELASTIC_API_KEY`
+- `--sink loki` requires `LOKI_URL`. Optional: `LOKI_USERNAME`, `LOKI_PASSWORD` (basic auth), `LOKI_TENANT_ID` (`X-Scope-OrgID` header for multi-tenant setups)
 - `--sink stdout` prints normalized documents for debugging
 
 Dry run mode:

package/dist/cli/command-factory.d.ts

@@ -59,6 +59,18 @@ export declare function createCollectorCommand<TExtra extends Record<string, unk
     "elastic-api-key": {
         readonly type: "string";
     };
+    "loki-url": {
+        readonly type: "string";
+    };
+    "loki-username": {
+        readonly type: "string";
+    };
+    "loki-password": {
+        readonly type: "string";
+    };
+    "loki-tenant-id": {
+        readonly type: "string";
+    };
     "retry-max": {
         readonly type: "string";
     };

package/dist/cli/commands/biome.d.ts

@@ -47,6 +47,18 @@ export declare const biomeCommand: import("citty").CommandDef<{
     "elastic-api-key": {
         readonly type: "string";
     };
+    "loki-url": {
+        readonly type: "string";
+    };
+    "loki-username": {
+        readonly type: "string";
+    };
+    "loki-password": {
+        readonly type: "string";
+    };
+    "loki-tenant-id": {
+        readonly type: "string";
+    };
     "retry-max": {
         readonly type: "string";
     };

package/dist/cli/commands/coverage-dotnet.d.ts

@@ -47,6 +47,18 @@ export declare const coverageDotnetCommand: import("citty").CommandDef<{
     "elastic-api-key": {
         readonly type: "string";
     };
+    "loki-url": {
+        readonly type: "string";
+    };
+    "loki-username": {
+        readonly type: "string";
+    };
+    "loki-password": {
+        readonly type: "string";
+    };
+    "loki-tenant-id": {
+        readonly type: "string";
+    };
     "retry-max": {
         readonly type: "string";
     };

package/dist/cli/commands/coverage-js.d.ts

@@ -47,6 +47,18 @@ export declare const coverageJsCommand: import("citty").CommandDef<{
     "elastic-api-key": {
         readonly type: "string";
     };
+    "loki-url": {
+        readonly type: "string";
+    };
+    "loki-username": {
+        readonly type: "string";
+    };
+    "loki-password": {
+        readonly type: "string";
+    };
+    "loki-tenant-id": {
+        readonly type: "string";
+    };
     "retry-max": {
         readonly type: "string";
     };

package/dist/cli/commands/eslint.d.ts

@@ -47,6 +47,18 @@ export declare const eslintCommand: import("citty").CommandDef<{
     "elastic-api-key": {
         readonly type: "string";
     };
+    "loki-url": {
+        readonly type: "string";
+    };
+    "loki-username": {
+        readonly type: "string";
+    };
+    "loki-password": {
+        readonly type: "string";
+    };
+    "loki-tenant-id": {
+        readonly type: "string";
+    };
     "retry-max": {
         readonly type: "string";
     };

package/dist/cli/commands/lighthouse.d.ts

@@ -47,6 +47,18 @@ export declare const lighthouseCommand: import("citty").CommandDef<{
     "elastic-api-key": {
         readonly type: "string";
     };
+    "loki-url": {
+        readonly type: "string";
+    };
+    "loki-username": {
+        readonly type: "string";
+    };
+    "loki-password": {
+        readonly type: "string";
+    };
+    "loki-tenant-id": {
+        readonly type: "string";
+    };
     "retry-max": {
         readonly type: "string";
     };

package/dist/cli/commands/meta.d.ts

@@ -47,6 +47,18 @@ export declare const metaCommand: import("citty").CommandDef<{
     "elastic-api-key": {
         readonly type: "string";
     };
+    "loki-url": {
+        readonly type: "string";
+    };
+    "loki-username": {
+        readonly type: "string";
+    };
+    "loki-password": {
+        readonly type: "string";
+    };
+    "loki-tenant-id": {
+        readonly type: "string";
+    };
     "retry-max": {
         readonly type: "string";
     };

package/dist/cli/commands/sarif.d.ts

@@ -47,6 +47,18 @@ export declare const sarifCommand: import("citty").CommandDef<{
     "elastic-api-key": {
         readonly type: "string";
     };
+    "loki-url": {
+        readonly type: "string";
+    };
+    "loki-username": {
+        readonly type: "string";
+    };
+    "loki-password": {
+        readonly type: "string";
+    };
+    "loki-tenant-id": {
+        readonly type: "string";
+    };
     "retry-max": {
         readonly type: "string";
     };

package/dist/cli/common-args.d.ts

@@ -15,6 +15,10 @@ export interface CommonArgs {
     collectorVersion?: unknown;
     elasticUrl?: unknown;
     elasticApiKey?: unknown;
+    lokiUrl?: unknown;
+    lokiUsername?: unknown;
+    lokiPassword?: unknown;
+    lokiTenantId?: unknown;
     retryMax?: unknown;
     retryBackoffMs?: unknown;
     allowEmpty?: unknown;
@@ -71,6 +75,18 @@ export declare const commonArgs: {
     readonly "elastic-api-key": {
         readonly type: "string";
     };
+    readonly "loki-url": {
+        readonly type: "string";
+    };
+    readonly "loki-username": {
+        readonly type: "string";
+    };
+    readonly "loki-password": {
+        readonly type: "string";
+    };
+    readonly "loki-tenant-id": {
+        readonly type: "string";
+    };
     readonly "retry-max": {
         readonly type: "string";
     };

package/dist/cli/common-args.js

@@ -37,6 +37,10 @@ export const commonArgs = {
     "collector-version": { type: "string" },
     "elastic-url": { type: "string" },
     "elastic-api-key": { type: "string" },
+    "loki-url": { type: "string" },
+    "loki-username": { type: "string" },
+    "loki-password": { type: "string" },
+    "loki-tenant-id": { type: "string" },
     "retry-max": { type: "string" },
     "retry-backoff-ms": { type: "string" },
     "allow-empty": { type: "boolean", default: false },

package/dist/cli/send-to-sink.js

@@ -27,26 +27,43 @@ export async function sendToSink(metricType, args, documents) {
         return;
     }
     const sinkKindRaw = (envOrArg(argValue(args, "sink"), "QUALINK_SINK") ?? "elastic").toLowerCase();
-    if (sinkKindRaw !== "elastic" && sinkKindRaw !== "stdout") {
-        throw new CliError(`Unsupported sink '${sinkKindRaw}'. Expected elastic|stdout`, 2);
+    if (sinkKindRaw !== "elastic" && sinkKindRaw !== "loki" && sinkKindRaw !== "stdout") {
+        throw new CliError(`Unsupported sink '${sinkKindRaw}'. Expected elastic|loki|stdout`, 2);
     }
-    const sinkKind = sinkKindRaw === "elastic" ? "elastic" : "stdout";
+    const sinkKind = sinkKindRaw;
     const retryMax = parseNumberInput(argValue(args, "retryMax", "retry-max"), 2);
     const retryBackoffMs = parseNumberInput(argValue(args, "retryBackoffMs", "retry-backoff-ms"), 500);
     const elasticUrl = envOrArg(argValue(args, "elasticUrl", "elastic-url"), "ELASTIC_URL");
     const elasticApiKey = envOrArg(argValue(args, "elasticApiKey", "elastic-api-key"), "ELASTIC_API_KEY");
+    const lokiUrl = envOrArg(argValue(args, "lokiUrl", "loki-url"), "LOKI_URL");
+    const lokiUsername = envOrArg(argValue(args, "lokiUsername", "loki-username"), "LOKI_USERNAME");
+    const lokiPassword = envOrArg(argValue(args, "lokiPassword", "loki-password"), "LOKI_PASSWORD");
+    const lokiTenantId = envOrArg(argValue(args, "lokiTenantId", "loki-tenant-id"), "LOKI_TENANT_ID");
     const sinkConfigBase = {
         kind: sinkKind,
         retryMax,
         retryBackoffMs,
     };
-    const sinkConfig = sinkKind === "elastic"
-        ? {
+    let sinkConfig;
+    if (sinkKind === "elastic") {
+        sinkConfig = {
             ...sinkConfigBase,
             ...(elasticUrl ? { elasticUrl } : {}),
             ...(elasticApiKey ? { elasticApiKey } : {}),
-        }
-        : sinkConfigBase;
+        };
+    }
+    else if (sinkKind === "loki") {
+        sinkConfig = {
+            ...sinkConfigBase,
+            ...(lokiUrl ? { lokiUrl } : {}),
+            ...(lokiUsername ? { lokiUsername } : {}),
+            ...(lokiPassword ? { lokiPassword } : {}),
+            ...(lokiTenantId ? { lokiTenantId } : {}),
+        };
+    }
+    else {
+        sinkConfig = sinkConfigBase;
+    }
     const sink = createSink(sinkConfig);
     await sink.send({
         metricType,

package/dist/sinks/index.d.ts

@@ -1,9 +1,13 @@
 import type { Sink } from "./types.js";
-export type SinkKind = "elastic" | "stdout";
+export type SinkKind = "elastic" | "loki" | "stdout";
 export interface SinkConfig {
     kind: SinkKind;
     elasticUrl?: string;
     elasticApiKey?: string;
+    lokiUrl?: string;
+    lokiUsername?: string;
+    lokiPassword?: string;
+    lokiTenantId?: string;
     retryMax: number;
     retryBackoffMs: number;
 }

package/dist/sinks/index.js

@@ -1,9 +1,23 @@
 import { ElasticSink } from "./elastic.js";
+import { LokiSink } from "./loki.js";
 import { StdoutSink } from "./stdout.js";
 export function createSink(config) {
     if (config.kind === "stdout") {
         return new StdoutSink();
     }
+    if (config.kind === "loki") {
+        if (!config.lokiUrl) {
+            throw new Error("Loki sink requires LOKI_URL (or --loki-url)");
+        }
+        return new LokiSink({
+            url: config.lokiUrl,
+            username: config.lokiUsername,
+            password: config.lokiPassword,
+            tenantId: config.lokiTenantId,
+            retryMax: config.retryMax,
+            retryBackoffMs: config.retryBackoffMs,
+        });
+    }
     if (!config.elasticUrl || !config.elasticApiKey) {
         throw new Error("Elastic sink requires ELASTIC_URL and ELASTIC_API_KEY (or CLI overrides)");
     }

package/dist/sinks/loki.d.ts

@@ -0,0 +1,30 @@
+import type { NormalizedDocument } from "../types.js";
+import type { SendInput, Sink } from "./types.js";
+export interface LokiSinkOptions {
+    url: string;
+    username?: string | undefined;
+    password?: string | undefined;
+    tenantId?: string | undefined;
+    retryMax: number;
+    retryBackoffMs: number;
+}
+interface LokiStream {
+    stream: Record<string, string>;
+    values: [string, string][];
+}
+interface LokiPushPayload {
+    streams: LokiStream[];
+}
+export declare function toNanosecondEpoch(isoTimestamp: string): string;
+export declare function buildLokiPayload(documents: NormalizedDocument[]): LokiPushPayload;
+export declare class LokiSink implements Sink {
+    private readonly url;
+    private readonly username;
+    private readonly password;
+    private readonly tenantId;
+    private readonly retryMax;
+    private readonly retryBackoffMs;
+    constructor(options: LokiSinkOptions);
+    send(input: SendInput): Promise<void>;
+}
+export {};

package/dist/sinks/loki.js

@@ -0,0 +1,84 @@
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isRetryableStatus(status) {
+    return status === 429 || status >= 500;
+}
+function toLabelKey(doc) {
+    return `${doc.metric_type}|${doc.repo}|${doc.environment}`;
+}
+export function toNanosecondEpoch(isoTimestamp) {
+    const ms = new Date(isoTimestamp).getTime();
+    return `${ms}000000`;
+}
+export function buildLokiPayload(documents) {
+    const streamMap = new Map();
+    for (const doc of documents) {
+        const key = toLabelKey(doc);
+        let stream = streamMap.get(key);
+        if (!stream) {
+            stream = {
+                stream: {
+                    metric_type: doc.metric_type,
+                    repo: doc.repo,
+                    environment: doc.environment,
+                },
+                values: [],
+            };
+            streamMap.set(key, stream);
+        }
+        stream.values.push([toNanosecondEpoch(doc["@timestamp"]), JSON.stringify(doc)]);
+    }
+    return { streams: Array.from(streamMap.values()) };
+}
+export class LokiSink {
+    url;
+    username;
+    password;
+    tenantId;
+    retryMax;
+    retryBackoffMs;
+    constructor(options) {
+        this.url = options.url.replace(/\/$/, "");
+        this.username = options.username;
+        this.password = options.password;
+        this.tenantId = options.tenantId;
+        this.retryMax = options.retryMax;
+        this.retryBackoffMs = options.retryBackoffMs;
+    }
+    async send(input) {
+        if (input.documents.length === 0) {
+            return;
+        }
+        const payload = buildLokiPayload(input.documents);
+        const body = JSON.stringify(payload);
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        if (this.username && this.password) {
+            const encoded = btoa(`${this.username}:${this.password}`);
+            headers.Authorization = `Basic ${encoded}`;
+        }
+        if (this.tenantId) {
+            headers["X-Scope-OrgID"] = this.tenantId;
+        }
+        let attempt = 0;
+        for (;;) {
+            attempt += 1;
+            const response = await fetch(`${this.url}/loki/api/v1/push`, {
+                method: "POST",
+                headers,
+                body,
+            });
+            if (response.status === 204 || response.ok) {
+                return;
+            }
+            const responseText = await response.text();
+            if (!isRetryableStatus(response.status) || attempt > this.retryMax) {
+                process.stderr.write(`[qualink] Dead-letter payload:\n${body}\n`);
+                throw new Error(`Loki push failed (${response.status}): ${responseText}`);
+            }
+            await sleep(this.retryBackoffMs * attempt);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qualink",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Collect, normalize, and relay code quality metrics from CI",
   "license": "MIT",
   "type": "module",