Monitor Neon Functions with Sentry

import "./instrument";

import { Sentry } from "./instrument";
import { Hono } from "hono";

const app = new Hono();

app.use("*", (c, next) =>
  Sentry.withIsolationScope(() =>
    Sentry.startSpan(
      {
        op: "http.server",
        name: `${c.req.method} ${c.req.path}`,
        forceTransaction: true,
        attributes: { "http.request.method": c.req.method, "url.path": c.req.path },
      },
      async (span) => {
        await next();
        span.setAttribute("http.response.status_code", c.res.status);
      },
    ).finally(() => Sentry.flush(2000)),
  ),
);

app.get("/health", (c) => c.json({ status: "ok" }));

app.post("/api/orders", async (c) => {
  const body = await c.req.json();
  const orderId = crypto.randomUUID();

  if (!body.items || !Array.isArray(body.items) || body.items.length === 0) {
    return c.json({ error: "orders require a non-empty items array" }, 400);
  }

  Sentry.logger.info("order received", { component: "api", orderId, items: body.items.length });

  try {
    const provider = await Sentry.startSpan(
      { name: "order.charge", attributes: { orderId } },
      () => chargeOrder(orderId, body.force_failure === true),
    );
    Sentry.logger.info("order charged", { component: "api", orderId, provider });
    return c.json({ orderId, status: "confirmed", provider });
  } catch (err) {
    // Terminal: every provider failed, so this one becomes an issue.
    Sentry.captureException(err, {
      tags: { component: "api", phase: "charge" },
      contexts: { order: { orderId, items: body.items.length } },
    });
    return c.json({ error: "charge_failed" }, 502);
  }
});

function chargeOrder(orderId: string, forceFailure: boolean) {
  const providers = ["stripe", "polar"];
  let lastError: unknown;

  for (const provider of providers) {
    try {
      callProvider(provider, orderId, forceFailure);
      return provider;
    } catch (err) {
      lastError = err;
      // Recoverable: the next provider gets a shot, so this is a log, not an issue.
      Sentry.logger.warn("payment provider failed, trying the next one", {
        component: "api",
        phase: "charge-attempt",
        provider,
        error: String(err),
      });
    }
  }

  throw lastError ?? new Error("all payment providers failed");
}

function callProvider(name: string, orderId: string, forceFailure: boolean) {
  if (forceFailure && name === "stripe") {
    throw new Error("provider declined the charge");
  }
  return { transactionId: crypto.randomUUID() };
}

app.get("/debug-sentry", () => {
  throw new Error("sentry test: unhandled route error");
});

app.onError((err, c) => {
  Sentry.captureException(err);
  return c.json({ error: "internal_error" }, 500);
});

export default app;

app.post("/chat", async (c) => {
  const { messages } = await c.req.json();

  Sentry.setConversationId(c.req.header("x-conversation-id") ?? crypto.randomUUID());

  const result = streamText({
    model: neon(MODEL),
    system: "You are a concise assistant. Use tools when they help.",
    messages,
    tools: {
      getServerTime: tool({
        description: "Get the current server time in ISO format.",
        inputSchema: z.object({}),
        execute: async () => ({ now: new Date().toISOString() }),
      }),
    },
    telemetry: { isEnabled: true },
    onError: ({ error }) => {
      Sentry.captureException(error, { tags: { component: "agent", phase: "chat-stream" } });
    },
  });

  // gen_ai spans only end with the stream, so flush from the stream's finalizer.
  const stream = result.textStream
    .pipeThrough(
      new TransformStream<string, string>({
        async flush() {
          await Sentry.flush(2000);
        },
      }),
    )
    .pipeThrough(new TextEncoderStream());

  return new Response(stream, { headers: { "content-type": "text/plain; charset=utf-8" } });
});