feat: move away from opentelemetry

The current setup with OpenTelemetry sucks because no data is being emitted anywhere. So I think it'd be best if we revert all that and just use plain Sentry with their built-in performance integration.

Dockerfile

@@ -17,4 +17,4 @@ ENV PORT=3000
 
 EXPOSE ${PORT}
 
-CMD [ "node", "--import", "./dist/src/tracing.js", "./dist/src/index.js" ]
+CMD ["node", "./dist/src/index.js"]

env.d.ts

@@ -11,6 +11,7 @@ declare global {
       DEV_PROXY_URL: string;
       PORT: string;
       IGNORE_PRIVATE_REPOSITORY?: string
+      SENTRY_DSN?: string;
     }
   }
 }

package.json

@@ -5,7 +5,7 @@
   "main": "dist/index.js",
   "type": "module",
   "scripts": {
-    "dev:start": "node --experimental-loader @esbuild-kit/esm-loader --env-file .env -r src/tracing.ts src/index.ts",
+    "dev:start": "node --experimental-loader @esbuild-kit/esm-loader --env-file .env src/index.ts",
     "dev": "nodemon -e ts --watch src --exec \"npm run dev:start\"",
     "build": "tsc && tsc-alias",
     "test:unit": "vitest run",
@@ -49,15 +49,7 @@
   "dependencies": {
     "@hono/node-server": "^1.8.0",
     "@octokit/webhooks-types": "^7.3.2",
-    "@opentelemetry/api": "^1.7.0",
-    "@opentelemetry/context-async-hooks": "^1.21.0",
-    "@opentelemetry/exporter-trace-otlp-grpc": "^0.48.0",
-    "@opentelemetry/instrumentation-http": "^0.48.0",
-    "@opentelemetry/sdk-metrics": "^1.21.0",
-    "@opentelemetry/sdk-node": "^0.48.0",
-    "@opentelemetry/sdk-trace-node": "^1.21.0",
     "@sentry/node": "^7.101.1",
-    "@sentry/opentelemetry": "^7.101.1",
     "cheerio": "1.0.0-rc.12",
     "colorette": "^2.0.20",
     "eventsource": "^2.0.2",

src/application/adapters/GithubAdapter.ts

@@ -1,5 +1,5 @@
 import type { WebhookEvent } from "@octokit/webhooks-types";
-import { trace } from "@opentelemetry/api";
+import * as Sentry from "@sentry/node";
 import type {
   Comment,
   CommentChanges,
@@ -14,8 +14,6 @@ import type {
   WebhookEventName
 } from "~/application/webhook/types";
 
-const tracer = trace.getTracer("application.adaptersGithubAdapter");
-
 export class GithubAdapter {
   private readonly _repository?: Repository;
   private readonly _issue?: Issue;
@@ -137,9 +135,13 @@ export class GithubAdapter {
   }
 
   get(eventName: WebhookEventName) {
-    return tracer.startActiveSpan("get", (span) => {
-      span.setAttribute("event_name", eventName);
-
+    return Sentry.startSpan({
+      name: "get",
+      op: "application.adaptersGithubAdapter",
+      attributes: {
+        "event_name": eventName
+      }
+    }, () => {
       // issue related events
       if (eventName.startsWith("issue")) {
         const payload = {

src/application/webhook/GithubWebhook.ts

@@ -1,13 +1,11 @@
 import { createHmac, timingSafeEqual } from "node:crypto";
 import type { WebhookEvent } from "@octokit/webhooks-types";
-import { trace } from "@opentelemetry/api";
+import * as Sentry from "@sentry/node";
 import { GithubAdapter } from "../adapters/GithubAdapter";
 import type { ILogger } from "../interfaces/ILogger";
 import type { HandlerFunction, IWebhook, WebhookEventName } from "./types";
 import { IGNORE_PRIVATE_REPOSITORY } from "~/env";
 
-const tracer = trace.getTracer("application.webhook.GithubWebhook");
-
 export class GithubWebhook implements IWebhook<WebhookEvent> {
   public readonly secretToken: string;
   private readonly _handlers: Partial<Record<WebhookEventName, HandlerFunction<WebhookEventName>[]>> = {};
@@ -20,7 +18,10 @@ export class GithubWebhook implements IWebhook<WebhookEvent> {
   }
 
   public verify(payload: string, signature: string) {
-    return tracer.startActiveSpan("verify", async () => {
+    return Sentry.startSpan({
+      name: "verify",
+      op: "application.webhook.GithubWebhook"
+    }, async () => {
       if (payload.length === 0 || signature.length === 0) throw Error("payload or signature wasn't provided.");
 
       const signatureBuffer = Buffer.from(signature);
@@ -35,15 +36,23 @@ export class GithubWebhook implements IWebhook<WebhookEvent> {
   }
 
   public sign(payload: string): Promise<string> {
-    return tracer.startActiveSpan("sign", () => {
+    return Sentry.startSpan({
+      name: "sign", 
+      op: "application.webhook.GithubWebhook"
+    }, () => {
       if (payload.length === 0) throw Error("payload wasn't provided.");
       return Promise.resolve(`sha256=${createHmac("sha256", this.secretToken).update(payload).digest("hex")}`);
     });
   }
 
   public on<E extends WebhookEventName>(event: E, handler: HandlerFunction<E>): void {
-    return tracer.startActiveSpan("on", (span) => {
-      span.setAttribute("event", event);
+    return Sentry.startSpan({
+      name: "on",
+      op: "application.webhook.GithubWebhook",
+      attributes: {
+        event: event
+      }
+    }, () => {
       if (this._handlers[event] === undefined) {
         this._handlers[event] = [];
       }
@@ -52,8 +61,13 @@ export class GithubWebhook implements IWebhook<WebhookEvent> {
   }
 
   public handle(eventName: WebhookEventName, payload: WebhookEvent, targetsId: bigint[]): Promise<void> {
-    return tracer.startActiveSpan("handle", async (span) => {
-      span.setAttribute("event_name", eventName);
+    return Sentry.startSpan({
+      name: "handle",
+      op: "application.webhook.GithubWebhook",
+      attributes: {
+        "event_name": eventName
+      }
+    }, async () => {
       const handlers = this._handlers[eventName] as HandlerFunction<WebhookEventName>[];
 
       // no handler available

src/index.ts

@@ -3,7 +3,8 @@ import path from "path";
 import { Bot } from "grammy";
 import { parse as parseGura } from "gura";
 import { Hono } from "hono";
-import { otelTracer } from "./utils/honoOtelTracer";
+import * as Sentry from "@sentry/node";
+import { sentryMiddleware } from "./utils/honoSentryTracer";
 import { appConfigSchema } from "~/schema";
 import { BOT_TOKEN, GITHUB_WEBHOOK_SECRET, PORT, HOME_GROUP } from "~/env";
 import { InMemoryGroupMapping } from "~/infrastructure/InMemoryGroupMapping";
@@ -22,6 +23,15 @@ import { GithubRoute } from "~/presentation/routes/GithubRoute";
 import { GithubWebhook } from "~/application/webhook/GithubWebhook";
 import { TelegramPresenter } from "~/presentation/TelegramPresenter";
 
+Sentry.init({
+  dsn: process.env.SENTRY_DSN ?? "",
+  sampleRate: 1.0,
+  tracesSampleRate: 0.3,
+  integrations: [
+    Sentry.httpIntegration({ tracing: true })
+  ]
+});
+
 // configurations
 const configFile = await readFile(path.resolve("config", "config.ura"), { encoding: "utf-8" });
 const config = appConfigSchema.parse(parseGura(configFile));
@@ -56,7 +66,11 @@ const eventHandlers: EventHandlerMapping = {
 // webhook server and handlers
 const serverInstance = new Hono();
 serverInstance.get("/", (c) => c.text("OK"));
-serverInstance.use("*", otelTracer("gitgram"));
+serverInstance.use(sentryMiddleware());
+serverInstance.onError((_, c) => {
+  c.status(500);
+  return c.json({ message: "Internal server error" });
+});
 const githubRoute = new GithubRoute(serverInstance, {
   path: "/github",
   webhook: new GithubWebhook(GITHUB_WEBHOOK_SECRET, logger),

src/presentation/event-handlers/Deployment.ts

@@ -1,12 +1,10 @@
-import { trace } from "@opentelemetry/api";
+import * as Sentry from "@sentry/node";
 import { z } from "zod";
 import type { IDeploymentEvent } from "~/application/interfaces/events/IDeploymentEvent";
 import type { IPresenter } from "~/application/interfaces/IPresenter";
 import type { HandlerFunction } from "~/application/webhook/types";
 import { interpolate } from "~/utils/interpolate";
 
-const tracer = trace.getTracer("presentation.event-handlers.Deployment");
-
 export const deploymentTemplateSchema = z.object({
   status: z.object({
     base: z.string(),
@@ -22,7 +20,10 @@ export class DeploymentEventHandler implements IDeploymentEvent {
 
   status(): HandlerFunction<"deployment_status"> {
     return (event) => {
-      return tracer.startActiveSpan("status", () => {
+      return Sentry.startSpan({
+        name: "status",
+        op: "presentation.event-handlers.Deployment"
+      }, () => {
         const description = event.payload.deploymentStatus.description;
         const response = interpolate(
           this._templates.status.statuses[event.payload.deploymentStatus.state.toLowerCase()] +

src/presentation/event-handlers/Discussion.ts

@@ -1,12 +1,10 @@
-import { trace } from "@opentelemetry/api";
+import * as Sentry from "@sentry/node";
 import { z } from "zod";
 import type { IPresenter } from "~/application/interfaces/IPresenter";
 import type { IDiscussionEvent } from "~/application/interfaces/events/IDiscussionEvent";
 import type { HandlerFunction } from "~/application/webhook/types";
 import { interpolate } from "~/utils/interpolate";
 
-const tracer = trace.getTracer("presentation.event-handlers.Discussion");
-
 export const discussionTemplateSchema = z.object({
   created: z.string().trim(),
   closed: z.string().trim(),
@@ -27,7 +25,10 @@ export class DiscussionEventHandler implements IDiscussionEvent {
 
   created(): HandlerFunction<"discussion.created"> {
     return (event) => {
-      return tracer.startActiveSpan("created", () => {
+      return Sentry.startSpan({
+        name: "created",
+        op: "presentation.event-handlers.Discussion"
+      }, () => {
         const message = this._templates.created;
         const payload = interpolate(message, {
           url: event.payload.discussion.url,
@@ -49,7 +50,10 @@ export class DiscussionEventHandler implements IDiscussionEvent {
 
   closed(): HandlerFunction<"discussion.closed"> {
     return (event) => {
-      return tracer.startActiveSpan("closed", () => {
+      return Sentry.startSpan({ 
+        name: "closed",
+        op: "presentation.event-handlers.Discussion"
+      }, () => {
         const message = this._templates.closed;
         const payload = interpolate(message, {
           url: event.payload.discussion.url,
@@ -71,7 +75,10 @@ export class DiscussionEventHandler implements IDiscussionEvent {
 
   reopened(): HandlerFunction<"discussion.reopened"> {
     return (event) => {
-      return tracer.startActiveSpan("reopened", () => {
+      return Sentry.startSpan({ 
+        name: "reopened",
+        op: "presentation.event-handlers.Discussion"
+      }, () => {
         const message = this._templates.reopened;
         const payload = interpolate(message, {
           url: event.payload.discussion.url,
@@ -93,7 +100,10 @@ export class DiscussionEventHandler implements IDiscussionEvent {
 
   edited(): HandlerFunction<"discussion.edited"> {
     return (event) => {
-      return tracer.startActiveSpan("edited", () => {
+      return Sentry.startSpan({ 
+        name: "edited",
+        op: "presentation.event-handlers.Discussion"
+      }, () => {
         const message = this._templates.edited;
         const payload = interpolate(message, {
           url: event.payload.discussion.url,
@@ -115,7 +125,10 @@ export class DiscussionEventHandler implements IDiscussionEvent {
 
   deleted(): HandlerFunction<"discussion.deleted"> {
     return (event) => {
-      return tracer.startActiveSpan("deleted", () => {
+      return Sentry.startSpan({ 
+        name: "deleted",
+        op: "presentation.event-handlers.Discussion"
+      }, () => {
         const message = this._templates.deleted;
         const payload = interpolate(message, {
           url: event.payload.discussion.url,
@@ -137,7 +150,10 @@ export class DiscussionEventHandler implements IDiscussionEvent {
 
   pinned(): HandlerFunction<"discussion.pinned"> {
     return (event) => {
-      return tracer.startActiveSpan("pinned", () => {
+      return Sentry.startSpan({ 
+        name: "pinned",
+        op: "presentation.event-handlers.Discussion"
+      }, () => {
         const message = this._templates.pinned;
         const payload = interpolate(message, {
           url: event.payload.discussion.url,