Feat: Add a generic webhook for sending event notifications

.env.example

@@ -16,6 +16,7 @@ SLACK_BOT_USER_ACCESS_TOKEN=''
 GOCD_WEBHOOK_SECRET=''
 KAFKA_CONTROL_PLANE_WEBHOOK_SECRET=''
 SENTRY_OPTIONS_WEBHOOK_SECRET=''
+EXAMPLE_SERVICE_SECRET=''
 
 # Silence some GCP noise
 DRY_RUN=true

.env.test

@@ -19,6 +19,7 @@ SLACK_BOT_APP_ID="5678"
 GOCD_WEBHOOK_SECRET="webhooksecret"
 KAFKA_CONTROL_PLANE_WEBHOOK_SECRET="kcpwebhooksecret"
 SENTRY_OPTIONS_WEBHOOK_SECRET="sentryoptionswebhooksecret"
+EXAMPLE_SERVICE_SECRET="examplewebhooksecret"
 
 # Other
 GOCD_SENTRYIO_FE_PIPELINE_NAME="getsentry-frontend"

src/README.md

@@ -20,6 +20,10 @@ Below are descriptions for how this application is organized. Each directory con
 
 ## Common Use Cases
 
+## Generic Event Notifier
+
+You can use this service to send a message to Sentry Slack or Datadog. All you have to do is create a small PR to create a HMAC secret for your use case, and your service can send messages to Sentry Slack and Datadog via infra-hub. See [this README](webhooks/README.md) for more details.
+
 ### Adding a New Webhook
 
 To add a new webhook, nagivate to `webhooks` and follow the directions there. Most of the logic should be self-contained within the `webhooks` directory, with handlers in `brain` being appropriate if the webhook is for receiving event streams. To send a message to external sources, use the APIs in `api`.

src/buildServer.ts

@@ -15,7 +15,6 @@ import { loadBrain } from '@utils/loadBrain';
 
 import { SENTRY_DSN } from './config';
 import { routeJobs } from './jobs';
-import { SlackRouter } from './slack';
 
 export async function buildServer(
   logger: boolean | { prettyPrint: boolean } = {
@@ -96,11 +95,5 @@ export async function buildServer(
   // Endpoints for Cloud Scheduler webhooks (Cron Jobs)
   server.register(routeJobs, { prefix: '/jobs' });
 
-  server.post<{ Params: { service: string } }>(
-    '/slack/:service/webhook',
-    {},
-    SlackRouter(server)
-  );
-
   return server;
 }

src/config/secrets.ts

@@ -0,0 +1,13 @@
+/*
+
+This file contains secrets used for verifying incoming events from different HTTP sources.
+
+*/
+
+export const EVENT_NOTIFIER_SECRETS = {
+  // Follow the pattern below to add a new secret
+  // 'example-service': process.env.EXAMPLE_SERVICE_SECRET,
+};
+if (process.env.ENV !== 'production')
+  EVENT_NOTIFIER_SECRETS['example-service'] =
+    process.env.EXAMPLE_SERVICE_SECRET;

src/types/index.ts

@@ -1,5 +1,7 @@
 import { IncomingMessage, Server, ServerResponse } from 'http';
 
+import { EventAlertType } from '@datadog/datadog-api-client/dist/packages/datadog-api-client-v1';
+import { Block, KnownBlock } from '@slack/types';
 import { FastifyInstance } from 'fastify';
 
 // e.g. the return type of `buildServer`
@@ -26,3 +28,24 @@ export interface KafkaControlPlaneResponse {
   title: string;
   body: string;
 }
+
+export type GenericEvent = {
+  source: string;
+  timestamp: number;
+  service_name?: string; // Official service registry name if applicable
+  data: {
+    title: string;
+    message: string;
+    channels: {
+      slack?: string[]; // list of Slack Channels
+      datadog?: string[]; // list of DD Monitors
+      jira?: string[]; // list of Jira Projects
+      bigquery?: string;
+    };
+    tags?: string[]; // Not used for Slack
+    misc: {
+      alertType?: EventAlertType; // Datadog alert type
+      blocks?: (KnownBlock | Block)[]; // Optional Slack blocks
+    };
+  };
+};

src/webhooks/README.md

@@ -3,6 +3,36 @@
 * Webhooks in "production" are deployed to a Google Cloud Run instance, in the project `super-big-data`. Why? (TODO insert why)
 * The webhook points to `https://product-eng-webhooks-vmrqv3f7nq-uw.a.run.app`
 
+## Generic Event Notifier
+
+The folder `generic-notifier` provides a generic webhook which can be used to send messages to Sentry Slack channels and Sentry Datadog. Using this webhook is VERY simple.
+
+Simply, go to `@/config/secrets.ts` and add an entry to the `EVENT_NOTIFIER_SECRETS` object. This entry should contain a mapping from the name of your service (for example, `example-service`) to an environment variable. [TODO: Fill in how to set the prod env var here]. Make a PR with this change and get it approved & merged.
+
+Once this has been deployed, all you have to do is send a POST request to `https://product-eng-webhooks-vmrqv3f7nq-uw.a.run.app/event-notifier/v1` with a JSON payload in the format of the type `GenericEvent` defined in `@/types/index.ts`. Example:
+
+```json
+{
+ "source": "example-service", // This must match the mapping string you define in the EVENT_NOTIFIER_SECRETS obj
+ "timestamp": 0,
+ "service_name": "official_service_name",
+ "data": {
+  "title": "This is an Example Notification",
+  "message": "Random text here",
+  "tags": [
+   "source:example-service", "sentry-region:all", "sentry-user:bob"
+  ],
+  "misc": {},
+  "channels": {
+   "slack": ["C07EH2QGGQ5"],
+   "jira": ["TEST"]
+  }
+ }
+}
+```
+
+Additionally, you must compute the HMAC SHA256 hash of the raw payload string computed with the secret key, and attach it to the `Authorization` header. EX: `Authorization: <Hash here>`
+
 ## Adding a webhook to GoCD event emitter
 
 * goto [gocd](deploy.getsentry.net)

src/webhooks/generic-notifier/generic-notifier.test.ts

@@ -0,0 +1,95 @@
+import testInvalidPayload from '@test/payloads/generic-notifier/testInvalidPayload.json';
+import testPayload from '@test/payloads/generic-notifier/testPayload.json';
+import { createNotifierRequest } from '@test/utils/createGenericMessageRequest';
+
+import { buildServer } from '@/buildServer';
+import { DATADOG_API_INSTANCE } from '@/config';
+import { bolt } from '@api/slack';
+
+import { messageSlack } from './generic-notifier';
+
+describe('generic messages webhook', function () {
+  let fastify;
+  beforeEach(async function () {
+    fastify = await buildServer(false);
+  });
+
+  afterEach(function () {
+    fastify.close();
+    jest.clearAllMocks();
+  });
+
+  it('correctly inserts generic notifier when stage starts', async function () {
+    jest.spyOn(bolt.client.chat, 'postMessage').mockImplementation(jest.fn());
+    jest
+      .spyOn(DATADOG_API_INSTANCE, 'createEvent')
+      .mockImplementation(jest.fn());
+    const response = await createNotifierRequest(fastify, testPayload);
+
+    expect(response.statusCode).toBe(200);
+  });
+
+  it('returns 400 for an invalid source', async function () {
+    const response = await fastify.inject({
+      method: 'POST',
+      url: '/event-notifier/v1',
+      payload: testInvalidPayload,
+    });
+    expect(response.statusCode).toBe(400);
+  });
+  it('returns 400 for invalid signature', async function () {
+    const response = await fastify.inject({
+      method: 'POST',
+      url: '/event-notifier/v1',
+      headers: {
+        'x-infra-hub-signature': 'invalid',
+      },
+      payload: testPayload,
+    });
+    expect(response.statusCode).toBe(400);
+  });
+
+  it('returns 400 for no signature', async function () {
+    const response = await fastify.inject({
+      method: 'POST',
+      url: '/event-notifier/v1',
+      payload: testPayload,
+    });
+    expect(response.statusCode).toBe(400);
+  });
+
+  describe('messageSlack tests', function () {
+    afterEach(function () {
+      jest.clearAllMocks();
+    });
+
+    it('writes to slack', async function () {
+      const postMessageSpy = jest.spyOn(bolt.client.chat, 'postMessage');
+      await messageSlack(testPayload);
+      expect(postMessageSpy).toHaveBeenCalledTimes(1);
+      const message = postMessageSpy.mock.calls[0][0];
+      expect(message).toEqual({
+        channel: '#aaaaaa',
+        text: 'Random text here',
+        unfurl_links: false,
+      });
+    });
+  });
+
+  it('checks that slack msg is sent', async function () {
+    const postMessageSpy = jest.spyOn(bolt.client.chat, 'postMessage');
+    const response = await createNotifierRequest(fastify, testPayload);
+
+    expect(postMessageSpy).toHaveBeenCalledTimes(1);
+
+    expect(response.statusCode).toBe(200);
+  });
+  it('checks that dd msg is sent', async function () {
+    const ddMessageSpy = jest.spyOn(DATADOG_API_INSTANCE, 'createEvent');
+    const response = await createNotifierRequest(fastify, testPayload);
+
+    expect(ddMessageSpy).toHaveBeenCalledTimes(1);
+
+    expect(response.statusCode).toBe(200);
+  });
+});

src/webhooks/generic-notifier/generic-notifier.ts

@@ -0,0 +1,84 @@
+import { v1 } from '@datadog/datadog-api-client';
+import * as Sentry from '@sentry/node';
+import { FastifyReply, FastifyRequest } from 'fastify';
+import moment from 'moment-timezone';
+
+import { GenericEvent } from '@types';
+
+import { bolt } from '@/api/slack';
+import { DATADOG_API_INSTANCE } from '@/config';
+import { EVENT_NOTIFIER_SECRETS } from '@/config/secrets';
+import { extractAndVerifySignature } from '@/utils/auth/extractAndVerifySignature';
+
+export async function genericEventNotifier(
+  request: FastifyRequest<{ Body: GenericEvent }>,
+  reply: FastifyReply
+): Promise<void> {
+  try {
+    // If the webhook secret is not defined, throw an error
+    const { body }: { body: GenericEvent } = request;
+    if (
+      body.source === undefined ||
+      EVENT_NOTIFIER_SECRETS[body.source] === undefined
+    ) {
+      reply.code(400).send('Invalid source or missing secret');
+      throw new Error('Invalid source or missing secret');
+    }
+
+    const isVerified = await extractAndVerifySignature(
+      request,
+      reply,
+      'x-infra-hub-signature',
+      EVENT_NOTIFIER_SECRETS[body.source]
+    );
+    if (!isVerified) {
+      // If the signature is not verified, return (since extractAndVerifySignature sends the response)
+      return;
+    }
+
+    await messageSlack(body);
+    await sendEventToDatadog(body, moment().unix());
+    reply.code(200).send('OK');
+    return;
+  } catch (err) {
+    console.error(err);
+    Sentry.captureException(err);
+    reply.code(500).send();
+    return;
+  }
+}
+
+export async function sendEventToDatadog(
+  message: GenericEvent,
+  timestamp: number
+) {
+  if (message.data.channels.datadog) {
+    const params: v1.EventCreateRequest = {
+      title: message.data.title,
+      text: message.data.message,
+      alertType: message.data.misc.alertType,
+      dateHappened: timestamp,
+      tags: message.data.tags,
+    };
+    await DATADOG_API_INSTANCE.createEvent({ body: params });
+  }
+}
+
+export async function messageSlack(message: GenericEvent) {
+  if (message.data.channels.slack) {
+    for (const channel of message.data.channels.slack) {
+      const text = message.data.message;
+      try {
+        await bolt.client.chat.postMessage({
+          channel: channel,
+          blocks: message.data.misc.blocks,
+          text: text,
+          unfurl_links: false,
+        });
+      } catch (err) {
+        Sentry.setContext('msg:', { text });
+        Sentry.captureException(err);
+      }
+    }
+  }
+}

src/webhooks/index.ts

@@ -6,6 +6,7 @@ import { FastifyReply, FastifyRequest } from 'fastify';
 import { Fastify } from '@/types';
 
 import { bootstrapWebhook } from './bootstrap-dev-env/bootstrap-dev-env';
+import { genericEventNotifier } from './generic-notifier/generic-notifier';
 import { gocdWebhook } from './gocd/gocd';
 import { kafkactlWebhook } from './kafka-control-plane/kafka-control-plane';
 import { sentryOptionsWebhook } from './sentry-options/sentry-options';
@@ -54,6 +55,9 @@ export async function routeHandlers(server: Fastify, _options): Promise<void> {
   server.post('/metrics/webpack/webhook', (request, reply) =>
     handleRoute(webpackWebhook, request, reply, 'webpack')
   );
+  server.post('/event-notifier/v1', (request, reply) =>
+    handleRoute(genericEventNotifier, request, reply, 'generic-notifier')
+  );
 
   // Default handler for invalid routes
   server.all('/metrics/*/webhook', async (request, reply) => {

test/payloads/generic-notifier/testAdminPayload.json

@@ -0,0 +1,5 @@
+{
+    "source": "admin",
+    "title": "this is a title",
+    "body": "this is a text body"
+}

test/payloads/generic-notifier/testBadPayload.json

@@ -0,0 +1,15 @@
+{
+	"service_name": "official_service_name",
+	"data": {
+		"message": "Random text here",
+		"tags": [
+			"source:example-service", "sentry-region:all", "sentry-user:bob"
+		],
+		"misc": {},
+		"channels": {
+			"slack": ["#C07GZR8LA82"],
+			"datadog": ["example-proj-id"],
+			"jira": ["INC"]
+		}
+	}
+}