Meter usage into Stripe and Prometheus

curl -s -X POST $GOBARE_API/v1/sessions \
  -H "Authorization: Bearer $GOBARE_TOKEN" -H 'content-type: application/json' \
  -d '{"metadata":{"stripe_customer":"cus_ACME"},"input":"…"}'

import { createServer } from "node:http";

const { GOBARE_API = "https://api.gobare.dev", GOBARE_TOKEN, STRIPE_API = "https://api.stripe.com", STRIPE_SECRET_KEY } = process.env as Record<string, string>;

async function gobare(method: string, path: string, body?: unknown): Promise<any> {
  for (let attempt = 1; ; attempt++) {
    const res = await fetch(`${GOBARE_API}${path}`, {
      method, body: body === undefined ? undefined : JSON.stringify(body),
      headers: { authorization: `Bearer ${GOBARE_TOKEN}`, "content-type": "application/json" },
    }).catch(() => null);
    if (res && res.status === 404) return null;
    if (res && res.status < 500) {
      if (!res.ok) throw new Error(`${method} ${path} answered ${res.status}: ${await res.text()}`);
      return res.json();
    }
    if (attempt === 4) throw new Error(`${method} ${path}: ${res ? res.status : "network error"} after ${attempt} attempts`);
    await new Promise((r) => setTimeout(r, attempt * 2000));
  }
}

async function meterEvent(identifier: string, customer: string, value: number, timestamp: number): Promise<"recorded" | "duplicate"> {
  const res = await fetch(`${STRIPE_API}/v1/billing/meter_events`, {
    method: "POST",
    headers: { authorization: `Bearer ${STRIPE_SECRET_KEY}`, "content-type": "application/x-www-form-urlencoded" },
    body: new URLSearchParams({
      event_name: "sandbox_seconds",
      "payload[stripe_customer_id]": customer,
      "payload[value]": String(value),
      identifier,
      timestamp: String(timestamp),
    }),
  });
  if (res.ok) return "recorded";
  const error = (await res.json()).error;
  if (res.status === 400 && /identifier/i.test(error?.message ?? "") && /already/i.test(error?.message ?? "")) return "duplicate";
  throw new Error(`Stripe answered ${res.status}: ${error?.message}`);
}

/**
 * Meter a session, then delete it — in that order, because a deleted session's
 * usage can no longer be read. Safe to call again after a crash at any step.
 */
export async function closeSession(sessionId: string): Promise<string> {
  const session = await gobare("GET", `/v1/sessions/${sessionId}`);
  if (!session) return "already deleted";
  const customer = session.metadata.stripe_customer;

  if (customer && !session.metadata.metered) {
    const usage = await gobare("GET", `/v1/sessions/${sessionId}/usage`);
    const outcome = await meterEvent(`gobare-${sessionId}`, customer, usage.sandbox_seconds, Math.floor(usage.as_of / 1000));
    await gobare("PATCH", `/v1/sessions/${sessionId}`, { metadata: { ...session.metadata, metered: String(usage.sandbox_seconds) } });
    await gobare("DELETE", `/v1/sessions/${sessionId}`);
    return `${outcome} ${usage.sandbox_seconds}s for ${customer}, deleted`;
  }
  await gobare("DELETE", `/v1/sessions/${sessionId}`);
  return customer ? `already metered (${session.metadata.metered}s), deleted` : "no customer to bill, deleted";
}

// ── Prometheus: what is running right now, per customer ─────────────────────

async function liveSessions(): Promise<any[]> {
  const all: any[] = [];
  let after = "";
  for (;;) {
    const page = await gobare("GET", `/v1/sessions?limit=100${after ? `&after=${after}` : ""}`);
    all.push(...page.data);
    if (!page.has_more) return all;
    after = page.last_id;
  }
}

let cache: { at: number; text: string } | undefined;

export async function metrics(): Promise<string> {
  if (cache && Date.now() - cache.at < 60_000) return cache.text;
  const sessions = await liveSessions();
  const count = new Map<string, number>();
  const seconds = new Map<string, number>();
  for (const session of sessions) {
    const customer = session.metadata?.stripe_customer ?? "none";
    const key = `customer="${customer}",status="${session.status}"`;
    count.set(key, (count.get(key) ?? 0) + 1);
    const usage = await gobare("GET", `/v1/sessions/${session.id}/usage`);
    if (usage) seconds.set(customer, (seconds.get(customer) ?? 0) + usage.sandbox_seconds);
  }
  const lines = [
    "# HELP gobare_sessions Sessions that exist right now.",
    "# TYPE gobare_sessions gauge",
    ...[...count].map(([labels, n]) => `gobare_sessions{${labels}} ${n}`),
    "# HELP gobare_live_sandbox_seconds Sandbox seconds held by sessions that still exist. Falls when a session is deleted; bill from the meter, not from this.",
    "# TYPE gobare_live_sandbox_seconds gauge",
    ...[...seconds].map(([customer, s]) => `gobare_live_sandbox_seconds{customer="${customer}"} ${s}`),
  ];
  cache = { at: Date.now(), text: `${lines.join("\n")}\n` };
  return cache.text;
}

if (import.meta.url === `file://${process.argv[1]}`) {
  createServer(async (req, res) => {
    if (req.url !== "/metrics") return res.writeHead(404).end();
    res.writeHead(200, { "content-type": "text/plain; version=0.0.4" }).end(await metrics());
  }).listen(Number(process.env.PORT ?? 9464));
}

scrape_configs:
  - job_name: gobare
    scrape_interval: 60s
    static_configs:
      - targets: ["metering.internal:9464"]