Convert src/observability to TypeScript (#56391)

Author: heiskr

src/frame/start-server.ts

@@ -4,7 +4,7 @@ import tcpPortUsed from 'tcp-port-used'
 import dotenv from 'dotenv'
 
 import { checkNodeVersion } from './lib/check-node-version'
-import '../observability/lib/handle-exceptions.js'
+import '../observability/lib/handle-exceptions'
 import createApp from './lib/app'
 import warmServer from './lib/warm-server'
 

src/observability/lib/failbot.js

@@ -0,0 +1,76 @@
+import got, { type OptionsOfTextResponseBody, type Method } from 'got'
+import { Failbot, HTTPBackend } from '@github/failbot'
+
+const HAYSTACK_APP = 'docs'
+
+async function retryingGot(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
+  const url = typeof input === 'string' ? input : input.toString()
+
+  // Extract body from fetch init for got options
+  const gotOptions: OptionsOfTextResponseBody = {
+    method: (init?.method as Method) || 'GET',
+    body: typeof init?.body === 'string' ? init.body : undefined,
+    headers: init?.headers as Record<string, string> | undefined,
+    // With the timeout at 3000 (milliseconds) and the retry.limit
+    // at 4 (times), the total worst-case is:
+    // 3000 * 4  + 1000 + 2000 + 3000 + 4000 + 8000 = 30 seconds
+    timeout: {
+      response: 3000,
+    },
+    retry: {
+      // This means it will wait...
+      // 1. 1000ms
+      // 2. 2000ms
+      // 3. 4000ms
+      // 4. 8000ms
+      // 5. give up!
+      //
+      // From the documentation:
+      //
+      //   Delays between retries counts with function
+      //   1000 * Math.pow(2, retry - 1) + Math.random() * 100,
+      //   where retry is attempt number (starts from 1).
+      //
+      limit: 4,
+    },
+  }
+
+  const gotResponse = await got(url, gotOptions)
+
+  // Convert got response to fetch-compatible Response
+  return new Response(gotResponse.body, {
+    status: gotResponse.statusCode,
+    statusText: gotResponse.statusMessage,
+    headers: gotResponse.headers as HeadersInit,
+  })
+}
+
+export function report(error: Error, metadata?: Record<string, unknown>) {
+  // If there's no HAYSTACK_URL set, bail early
+  if (!process.env.HAYSTACK_URL) {
+    return
+  }
+
+  const backends = [
+    new HTTPBackend({
+      haystackURL: process.env.HAYSTACK_URL,
+      fetchFn: retryingGot,
+    }),
+  ]
+  const failbot = new Failbot({
+    app: HAYSTACK_APP,
+    backends,
+  })
+
+  return failbot.report(error, metadata)
+}
+
+// Kept for legacy so you can continue to do:
+//
+//  import FailBot from './lib/failbot'
+//  ...
+//  FailBot.report(myError)
+//
+export default {
+  report,
+}

src/observability/lib/failbot.ts

@@ -1,7 +1,7 @@
 import FailBot from './failbot'
 
-process.on('uncaughtException', async (err) => {
-  if (err.code === 'MODULE_NOT_FOUND') {
+process.on('uncaughtException', async (err: Error) => {
+  if ((err as NodeJS.ErrnoException).code === 'MODULE_NOT_FOUND') {
     console.error('\n\n🔥 Uh oh! It looks you are missing a required npm module.')
     console.error(
       'Please run `npm install` to make sure you have all the required dependencies.\n\n',
@@ -17,10 +17,12 @@ process.on('uncaughtException', async (err) => {
   }
 })
 
-process.on('unhandledRejection', async (err) => {
+process.on('unhandledRejection', async (err: Error | unknown) => {
   console.error(err)
   try {
-    FailBot.report(err)
+    // Type guard to ensure we have an Error object for FailBot
+    const error = err instanceof Error ? err : new Error(String(err))
+    FailBot.report(error)
   } catch (failBotError) {
     console.warn('Even sending the unhandledRejection error to FailBot failed!')
     console.error(failBotError)

src/observability/lib/handle-exceptions.js renamed to src/observability/lib/handle-exceptions.ts

@@ -14,12 +14,10 @@ const mock = NODE_ENV === 'test' || MODA_PROD_SERVICE_ENV !== 'true'
 // MODA_APP_NAME gets set when the deploy target is Moda
 const modaApp = MODA_APP_NAME ? `moda_app_name:${MODA_APP_NAME}` : false
 
-export const tags = ['app:docs', modaApp].filter(Boolean)
+const tagCandidates = ['app:docs', modaApp]
+export const tags: string[] = tagCandidates.filter((tag): tag is string => Boolean(tag))
 
-/**
- * @type {import('hot-shots').StatsD}
- */
-export default new StatsD({
+const statsd = new StatsD({
   // When host and port are not set, hot-shots will default to the
   // DD_AGENT_HOST and DD_DOGSTATSD_PORT environment variables.
   // If undefined, the host will default to 'localhost' and the port
@@ -28,8 +26,10 @@ export default new StatsD({
   // For Moda, the host must be set to the Kubernetes node name, which is
   // set in KUBE_NODE_HOSTNAME.
   host: DD_AGENT_HOST || KUBE_NODE_HOSTNAME,
-  port: DD_DOGSTATSD_PORT,
+  port: DD_DOGSTATSD_PORT ? parseInt(DD_DOGSTATSD_PORT, 10) : undefined,
   prefix: 'docs.',
   mock,
   globalTags: tags,
 })
+
+export default statsd

src/observability/lib/statsd.js renamed to src/observability/lib/statsd.ts

@@ -0,0 +1,8 @@
+import type { NextFunction } from 'express'
+
+// Use type assertion to maintain compatibility with existing middleware patterns
+// This matches the original JavaScript behavior while providing some type safety
+// The assertion is necessary because Express middleware can have various request/response types
+export default function catchMiddlewareError(fn: any) {
+  return (req: any, res: any, next: NextFunction) => Promise.resolve(fn(req, res, next)).catch(next)
+}

src/observability/middleware/catch-middleware-error.js

@@ -4,7 +4,7 @@ import nock from 'nock'
 import FailBot from '../lib/failbot'
 
 describe('FailBot', () => {
-  const requestBodiesSent = []
+  const requestBodiesSent: any[] = []
 
   beforeEach(() => {
     delete process.env.HAYSTACK_URL
@@ -27,7 +27,7 @@ describe('FailBot', () => {
 
   describe('.report', () => {
     test('returns early if `HAYSTACK_URL` is not set', async () => {
-      const result = await FailBot.report()
+      const result = await FailBot.report(new Error('test'))
       expect(result).toBeUndefined()
       expect(requestBodiesSent.length).toBe(0)
     })
@@ -41,7 +41,9 @@ describe('FailBot', () => {
       // But here in the context of vitest, we need to await *now*
       // so we can assert that it did make the relevant post requests.
       // Once we've done this, we can immediate check what it did.
-      await Promise.all(await backendPromises)
+      if (backendPromises) {
+        await Promise.all(await backendPromises)
+      }
 
       // It's not interesting or relevant what the `.report()` static
       // method returns. All that matters is that it did a POST

src/observability/middleware/catch-middleware-error.ts

@@ -1,7 +1,7 @@
 /*
 This file & middleware is for when a user requests our /search page e.g. 'docs.github.com/search?query=foo'
- We make whatever search is in the ?query= parameter and attach it to req.search 
- req.search is then consumed by the search component in 'src/search/pages/search.tsx' 
+ We make whatever search is in the ?query= parameter and attach it to req.search
+ req.search is then consumed by the search component in 'src/search/pages/search.tsx'
 
 When a user directly hits our API e.g. /api/search/v1?query=foo, they will hit the routes in ./search-routes.ts
 */