blokctl 1.1.0 → 1.2.0

package/dist/services/observability-stack.real-prometheus.test.js

@@ -0,0 +1,95 @@
+import { spawnSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { describe, expect, it } from "vitest";
+const RUN = process.env.BLOK_INTEGRATION_PROMETHEUS;
+const d = RUN ? describe : describe.skip;
+const PROMETHEUS_API = process.env.BLOK_PROMETHEUS_API_URL ?? "http://localhost:9090";
+function run(command, args) {
+    const result = spawnSync(command, args, { encoding: "utf8" });
+    if (result.status !== 0)
+        throw new Error(result.stderr || result.stdout || `${command} ${args.join(" ")} failed`);
+    return `${result.stdout}\n${result.stderr}`;
+}
+function removeContainer(name) {
+    spawnSync("docker", ["rm", "-f", name], { encoding: "utf8" });
+}
+async function queryPrometheus(query) {
+    const response = await fetch(`${PROMETHEUS_API}/api/v1/query?query=${encodeURIComponent(query)}`);
+    expect(response.status).toBe(200);
+    return (await response.json());
+}
+async function activeTargets() {
+    const response = await fetch(`${PROMETHEUS_API}/api/v1/targets?state=active`);
+    expect(response.status).toBe(200);
+    const body = (await response.json());
+    return body.data?.activeTargets ?? [];
+}
+async function waitForTarget(instance) {
+    let target;
+    for (let i = 0; i < 30; i++) {
+        target = (await activeTargets()).find((candidate) => candidate.labels.instance === instance);
+        if (target?.health === "up")
+            return target;
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+    return target;
+}
+async function waitForQuery(query) {
+    let last;
+    for (let i = 0; i < 30; i++) {
+        last = await queryPrometheus(query);
+        if ((last.data?.result?.length ?? 0) > 0)
+            return last;
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+    return last ?? queryPrometheus(query);
+}
+d("observability stack - Prometheus live", () => {
+    it("scrapes the gRPC metrics target on the shared metrics port", async () => {
+        const name = `blok-prom-target-${randomBytes(4).toString("hex")}`;
+        const metricsServer = [
+            "from http.server import BaseHTTPRequestHandler, HTTPServer",
+            "class H(BaseHTTPRequestHandler):",
+            "    def log_message(self, *args): pass",
+            "    def do_GET(self):",
+            "        body = b'# TYPE blok_prom_port_live_test_total counter\\nblok_prom_port_live_test_total 7\\n'",
+            "        self.send_response(200)",
+            "        self.send_header('Content-Type', 'text/plain; version=0.0.4')",
+            "        self.send_header('Content-Length', str(len(body)))",
+            "        self.end_headers()",
+            "        self.wfile.write(body)",
+            "HTTPServer(('0.0.0.0', 9464), H).serve_forever()",
+        ].join("\n");
+        try {
+            run("docker", [
+                "run",
+                "--rm",
+                "-d",
+                "--name",
+                name,
+                "--network",
+                "shared-network",
+                "--network-alias",
+                "blok-grpc",
+                "python:3.12-alpine",
+                "python",
+                "-c",
+                metricsServer,
+            ]);
+            const target = await waitForTarget("blok-grpc:9464");
+            expect(target?.scrapeUrl).toBe("http://blok-grpc:9464/metrics");
+            expect(target?.health).toBe("up");
+            const up = await waitForQuery('up{job="blok-grpc",instance="blok-grpc:9464"} == 1');
+            expect(up.status).toBe("success");
+            expect(up.data?.result).toHaveLength(1);
+            expect(up.data?.result?.[0]?.value[1]).toBe("1");
+            const metric = await waitForQuery("blok_prom_port_live_test_total");
+            expect(metric.status).toBe("success");
+            expect(metric.data?.result).toHaveLength(1);
+            expect(metric.data?.result?.[0]?.value[1]).toBe("7");
+        }
+        finally {
+            removeContainer(name);
+        }
+    }, 60_000);
+});

package/dist/services/observability-stack.real-tempo.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/observability-stack.real-tempo.test.js

@@ -0,0 +1,86 @@
+import { spawnSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+const RUN = process.env.BLOK_INTEGRATION_TEMPO;
+const d = RUN ? describe : describe.skip;
+const TEMPO_API = process.env.BLOK_TEMPO_API_URL ?? "http://localhost:3201";
+const TEMPO_OTLP = process.env.BLOK_TEMPO_OTLP_URL ?? "http://localhost:4318/v1/traces";
+function findRepoRoot() {
+    let dir = import.meta.dirname;
+    for (let i = 0; i < 8; i++) {
+        if (fs.existsSync(path.join(dir, "infra", "metrics", "tempo.yaml")))
+            return dir;
+        const up = path.dirname(dir);
+        if (up === dir)
+            break;
+        dir = up;
+    }
+    return null;
+}
+function hex(bytes) {
+    return randomBytes(bytes).toString("hex");
+}
+function dockerLogs(container) {
+    const result = spawnSync("docker", ["logs", container], { encoding: "utf8" });
+    if (result.status !== 0)
+        throw new Error(result.stderr || result.stdout || `docker logs ${container} failed`);
+    return `${result.stdout}\n${result.stderr}`;
+}
+async function waitForTrace(traceId) {
+    let last;
+    for (let i = 0; i < 20; i++) {
+        last = await fetch(`${TEMPO_API}/api/traces/${traceId}`);
+        if (last.ok)
+            return last;
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    return last ?? fetch(`${TEMPO_API}/api/traces/${traceId}`);
+}
+d("observability stack - Tempo live", () => {
+    it("boots without the dangling memcached cache and ingests an OTLP span", async () => {
+        const repo = findRepoRoot();
+        if (!repo)
+            throw new Error("repo root not found");
+        const tempoConfig = fs.readFileSync(path.join(repo, "infra", "metrics", "tempo.yaml"), "utf8");
+        expect(tempoConfig).not.toContain("memcached:11211");
+        const traceId = hex(16);
+        const spanId = hex(8);
+        const now = BigInt(Date.now()) * 1000000n;
+        const response = await fetch(TEMPO_OTLP, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                resourceSpans: [
+                    {
+                        resource: { attributes: [{ key: "service.name", value: { stringValue: "blok-tempo-live-test" } }] },
+                        scopeSpans: [
+                            {
+                                scope: { name: "blokctl-live-test" },
+                                spans: [
+                                    {
+                                        traceId,
+                                        spanId,
+                                        name: "tempo-memcached-regression",
+                                        kind: 1,
+                                        startTimeUnixNano: now.toString(),
+                                        endTimeUnixNano: (now + 1000000n).toString(),
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            }),
+        });
+        expect(response.status).toBe(200);
+        const trace = await waitForTrace(traceId);
+        expect(trace.ok).toBe(true);
+        const traceBody = await trace.text();
+        expect(traceBody).toContain("blok-tempo-live-test");
+        expect(traceBody).toContain("tempo-memcached-regression");
+        const logs = dockerLogs("tempo");
+        expect(logs.toLowerCase()).not.toContain("memcached");
+    });
+});