basic sentry setup

.env.example

@@ -1,16 +1,14 @@
 HMAC_SECRET="YOUR_VERY_SECRET_CODE_GOES_HERE" # For max security, use "openssl rand -base64 64" to generate one
 DATABASE_URL="YOUR_NOT_SO_SECRET_DATABASE_URL_GOES_HERE"
 
-# Dodo Payments (replaces LEMON_SQUEEZY_*)
+# Sentry
+SENTRY_DSN="" # Your Sentry DSN for error monitoring
+
+# Dodo Payments 
 DODO_PAYMENTS_API_KEY="" # Your Dodo Payments API key (from dashboard → Developer → API)
 DODO_PAYMENTS_PRODUCT_ID="" # Your Dodo product ID (prod_xxxxx)
 DODO_PAYMENTS_WEBHOOK_SECRET= # Webhook signing secret
 
-# Legacy payment provider (deprecated - use DODO_PAYMENTS_* above)
-PAYMENT_PROVIDER_API_KEY=""
-PAYMENT_PROVIDER_STORE_ID=""
-PAYMENT_PROVIDER_VARIANT_ID=""
-PAYMENT_PROVIDER_WEBHOOK_SECRET=
 
 TEST_API_KEY=
 REDIS_URL=

package.json

@@ -11,6 +11,7 @@
     "start": "bun run src/server.ts",
     "init_key": "bun run src/utils/generateInitialAPIKey.ts",
     "format": "bunx prettier --write .",
+    "typecheck": "bunx tsgo",
     "proto:pull": "git submodule update --remote --merge proto",
     "proto:push": "cd proto && git add . && git commit -s -m \"$1\" && git push && cd .."
   },
@@ -31,7 +32,8 @@
     "typescript": "^5"
   },
   "dependencies": {
-
+    "@opentelemetry/instrumentation-pg": "^0.69.0",
+    "@sentry/bun": "^10.51.0",
     "bullmq": "^5.75.2",
     "dodopayments": "^2.30.0",
     "drizzle-orm": "^0.44.7",
@@ -45,4 +47,4 @@
     "postgres": "^3.4.7",
     "zod": "^4.1.12"
   }
-}
+}

src/errors/logger.ts

@@ -1,4 +1,5 @@
 import pino, { type Logger as PinoLogger } from "pino";
+import * as Sentry from "@sentry/bun";
 
 /**
  * Wide Event interface for structured logging.
@@ -117,6 +118,12 @@ class WideEventLogger {
    * Log fatal errors that prevent the server from operating.
    */
   fatal(message: string, error?: Error): void {
+    if (error) {
+      Sentry.captureException(error, { level: "fatal" });
+    } else {
+      Sentry.captureMessage(message, { level: "fatal" });
+    }
+
     this.pino.fatal(
       {
         error: error

src/interceptors/logging.ts

@@ -1,5 +1,6 @@
 import { status as grpcStatus } from "@grpc/grpc-js";
 import type { sendUnaryData, ServerErrorResponse } from "@grpc/grpc-js";
+import * as Sentry from "@sentry/bun";
 import { logger } from "../errors/logger";
 import {
   wideEventContextKey,
@@ -25,13 +26,24 @@ export function loggingInterceptor(
     // Attach builder to call object
     call[wideEventContextKey] = builder;
 
+    Sentry.addBreadcrumb({
+      category: "request",
+      message: `gRPC: ${url}`,
+      data: { requestId, method },
+      level: "info",
+    });
+
     // Wrap callback to capture errors
     const originalCallback = callback;
     const wrappedCallback: sendUnaryData<unknown> = (error, response, trailer, flags) => {
       if (error) {
         const errorDetails = extractErrorDetails(error);
         const statusCode = grpcStatusToHttpStatus(errorDetails.code);
 
+        Sentry.captureException(error, {
+          extra: { requestId, method: url, statusCode },
+        });
+
         builder.setError(statusCode, {
           type: errorDetails.type,
           message: errorDetails.message,
@@ -58,6 +70,11 @@ export function loggingInterceptor(
         if (!builder['event'].outcome) {
           const errorDetails = extractErrorDetails(error);
           const statusCode = grpcStatusToHttpStatus(errorDetails.code);
+
+          Sentry.captureException(error, {
+            extra: { requestId, method: url, statusCode },
+          });
+
           builder.setError(statusCode, {
             type: errorDetails.type,
             message: errorDetails.message,

src/routes/gRPC/events/streamEvents.ts

@@ -1,4 +1,5 @@
 import type { ServerReadableStream, sendUnaryData } from "@grpc/grpc-js";
+import * as Sentry from "@sentry/bun";
 import {
   StreamEventRequest,
   StreamEventResponse,
@@ -38,7 +39,12 @@ export async function streamEvents(
         await storeEvent(event, apiKeyId);
         eventsProcessed++;
       } catch (innerError) {
-        console.log(innerError);
+        Sentry.addBreadcrumb({
+          category: "streamEvents",
+          message: `Event processing failed: ${innerError instanceof Error ? innerError.message : String(innerError)}`,
+          level: "error",
+        });
+        Sentry.captureException(innerError);
         callback(innerError as Error, null);
         return;
       }

src/routes/http/api/onboarding.ts

@@ -1,4 +1,5 @@
 import type { FastifyRequest, FastifyReply } from "fastify";
+import * as Sentry from "@sentry/bun";
 import { ZodError } from "zod";
 import { onboardingCronSchema } from "../../../zod/internals.ts";
 import { addOnboardingCronJob } from "../../../queues/onboarding.ts";
@@ -53,6 +54,10 @@ export async function handleOnboarding(
     reply.code(201);
     return { crons };
   } catch (error) {
+    Sentry.captureException(error, {
+      extra: { context: "onboarding route handler" },
+    });
+
     if (error instanceof ZodError) {
       const issues = error.issues
         .map((issue) => `${issue.path.join(".")}: ${issue.message}`)

src/routes/http/createdCheckout.ts

@@ -1,4 +1,5 @@
 import DodoPayments from "dodopayments";
+import * as Sentry from "@sentry/bun";
 import { Payment } from "../../events/RawEvents/Payment.ts";
 import { StorageAdapterFactory } from "../../factory/EventStorageAdapterFactory.ts";
 import type { WideEventBuilder } from "../../context/requestContext.ts";
@@ -55,7 +56,10 @@ export async function handleDodoWebhook(
       webhookPayload = client.webhooks.unwrap(rawBody, {
         headers,
       }) as unknown as DodoWebhookPayload;
-    } catch {
+    } catch (error) {
+      Sentry.captureException(error, {
+        extra: { context: "webhook signature verification" },
+      });
       builder.setError(401, {
         type: "AuthenticationError",
         message: "Invalid webhook signature",
@@ -186,6 +190,13 @@ export async function handleDodoWebhook(
         body: { message: "Webhook processed successfully" },
       };
     } catch (dbError) {
+      Sentry.captureException(dbError, {
+        extra: {
+          context: "payment event storage",
+          checkoutSessionId: checkout_session_id,
+          paymentId: payment_id,
+        },
+      });
       const errorMessage =
         dbError instanceof Error ? dbError.message : String(dbError);
       builder.setError(500, {
@@ -197,6 +208,9 @@ export async function handleDodoWebhook(
       return { statusCode: 500, body: { error: "Database error" } };
     }
   } catch (error) {
+    Sentry.captureException(error, {
+      extra: { context: "unexpected webhook error" },
+    });
     const errorMessage = error instanceof Error ? error.message : String(error);
     builder.setError(500, {
       type: "InternalError",

src/routes/http/registerWebhookRoutes.ts

@@ -1,4 +1,5 @@
 import type { FastifyInstance, FastifyRequest, FastifyReply } from "fastify";
+import * as Sentry from "@sentry/bun";
 import { createWideEventBuilder, generateRequestId } from "../../context/requestContext.ts";
 import { logger } from "../../errors/logger.ts";
 import { handleDodoWebhook } from "./createdCheckout.ts";
@@ -61,6 +62,9 @@ export async function registerWebhookRoutes(
         reply.code(result.statusCode);
         return result.body;
       } catch (error) {
+        Sentry.captureException(error, {
+          extra: { context: "webhook route handler" },
+        });
         const err = error instanceof Error ? error : new Error(String(error));
         builder.setError(500, {
           type: "InternalError",

src/server.ts

@@ -4,6 +4,29 @@ import { startRawGrpcServer } from "./servers/rawGrpcServer.ts";
 import { startFastifyServer } from "./servers/fastifyServer.ts";
 import { OnboardingWorker } from "./workers/onboarding.ts";
 import { getRedisConnection } from "./storage/db/redis.ts";
+import * as Sentry from "@sentry/bun";
+
+const isProduction = process.env.NODE_ENV === "production";
+
+Sentry.init({
+  dsn: process.env.SENTRY_DSN,
+  environment: isProduction ? "production" : "development",
+  release: process.env.GIT_COMMIT_SHA ?? "dev",
+  integrations: [Sentry.fastifyIntegration(), Sentry.httpIntegration()],
+  tracesSampleRate: isProduction ? 0.1 : 1.0,
+  ignoreErrors: ["ConnectionRefusedError", "ECONNREFUSED"],
+  maxBreadcrumbs: 10,
+});
+
+process.on("uncaughtException", (error) => {
+  Sentry.captureException(error);
+  Sentry.flush().then(() => process.exit(1));
+});
+
+process.on("unhandledRejection", (reason) => {
+  Sentry.captureException(reason);
+  Sentry.flush().then(() => process.exit(1));
+});
 
 const DATABASE_URL = process.env.DATABASE_URL;
 const HMAC_SECRET = process.env.HMAC_SECRET;
@@ -24,6 +47,10 @@ if (!REDIS_URL) {
   throw new Error("REDIS_URL environmentvariable is not set");
 }
 
+if (!process.env.SENTRY_DSN) {
+  logger.fatal("SENTRY_DSN environment variable is not set — errors will NOT be reported to Sentry");
+}
+
 getPostgresDB(DATABASE_URL);
 getRedisConnection(REDIS_URL);
 
@@ -44,6 +71,7 @@ process.on("beforeExit", async () => {
   if (onboardingWorker) {
     await onboardingWorker.close();
   }
+  await Sentry.flush(2000);
 });
 
 void main();

src/zod/event.ts

@@ -35,7 +35,7 @@ const SDKCallDataSchema: z.ZodType<SDKCallEventData> = z
     } else if (v.expr) {
       debitAmount = await parseAndEvaluateExpr(v.expr);
     } else {
-      debitAmount = Math.floor(v.amount * 100);
+      debitAmount = v.amount;
     }
     return { sdkCallType: v.sdkcalltype, debitAmount };
   });
@@ -62,7 +62,7 @@ const AITokenUsageDataSchema: z.ZodType<AITokenUsageEventData> = z
     } else if (v.inputexpr) {
       inputDebitAmount = await parseAndEvaluateExpr(v.inputexpr);
     } else {
-      inputDebitAmount = Math.floor(v.inputamount * 100);
+      inputDebitAmount = v.inputamount;
     }
 
     let outputDebitAmount: number;
@@ -74,7 +74,7 @@ const AITokenUsageDataSchema: z.ZodType<AITokenUsageEventData> = z
     } else if (v.outputexpr) {
       outputDebitAmount = await parseAndEvaluateExpr(v.outputexpr);
     } else {
-      outputDebitAmount = Math.floor(v.outputamount * 100);
+      outputDebitAmount = v.outputamount;
     }
 
     return {