feat(posthog): Added SDK data to header in requests, for Posthog filtering

src/hooks/registration.ts

@@ -1,6 +1,7 @@
 import { CertManagementHook } from "./cert-management.js";
 import { ErrorCleanerHook } from "./error-cleaner.js";
 import { TokenManagementHook } from "./token-management.js";
+import { SDKIdentifierHook } from "./sdk-identifier.js";
 import type { Hooks } from "./types.js";
 
 /*
@@ -22,4 +23,8 @@ export function initHooks(hooks: Hooks) {
 	// Register error cleaning hook
 	const errorCleanerHook = new ErrorCleanerHook();
 	hooks.registerAfterErrorHook(errorCleanerHook);
+
+	// Register SDK identifier hook
+	const sdkIdentifierHook = new SDKIdentifierHook();
+	hooks.registerBeforeRequestHook(sdkIdentifierHook);
 }

src/hooks/sdk-identifier.ts

@@ -0,0 +1,41 @@
+import type { BeforeRequestContext, BeforeRequestHook } from "./types.js";
+
+let cachedVersion: string | null = null;
+
+function loadVersion(): string {
+  if (cachedVersion) {
+    return cachedVersion;
+  }
+
+  try {
+    // NOTES: require is being used for now, using import demands appropriate
+    // compiler configuration, which won't be enabled yet due to Speakeasy's
+    // particular way of enabling persistent edits conflicting with workflow.
+    // Ticket sc-56960 created for this investigation.
+    const packageJsonPath = require.resolve("galileo-generated/package.json");
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const packageJson = require(packageJsonPath);
+    cachedVersion = packageJson.version;
+    return cachedVersion ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+function getSdkIdentifier(version: string): string {
+  return `galileo-generated/${version}`;
+}
+
+export class SDKIdentifierHook implements BeforeRequestHook {
+  async beforeRequest(
+    _hookCtx: BeforeRequestContext,
+    request: Request,
+  ): Promise<Request> {
+    const newRequest = request.clone();
+
+    const version = loadVersion();
+    const sdkIdentifier = getSdkIdentifier(version);
+    newRequest.headers.set("X-Galileo-SDK", sdkIdentifier);
+    return newRequest;
+  }
+}

src/tests/hooks/sdk-identifier.test.ts

@@ -0,0 +1,176 @@
+import { describe, test, expect, vi } from "vitest";
+import { SDKIdentifierHook } from "../../hooks/sdk-identifier.js";
+import type { BeforeRequestContext } from "../../hooks/types.js";
+
+describe("SDKIdentifierHook", () => {
+  const mockContext: BeforeRequestContext = {
+    baseURL: new URL("http://localhost:8088"),
+    operationID: "testOperation",
+    oAuth2Scopes: null,
+    retryConfig: { strategy: "none" },
+    resolvedSecurity: null,
+    options: {},
+  };
+
+  describe("beforeRequest", () => {
+    test("adds X-Galileo-SDK header to request", async () => {
+      const hook = new SDKIdentifierHook();
+      const request = new Request("http://localhost:8088/api/test");
+
+      const modifiedRequest = await hook.beforeRequest(mockContext, request);
+
+      expect(modifiedRequest.headers.has("X-Galileo-SDK")).toBe(true);
+    });
+
+    test("header contains galileo-generated prefix", async () => {
+      const hook = new SDKIdentifierHook();
+      const request = new Request("http://localhost:8088/api/test");
+
+      const modifiedRequest = await hook.beforeRequest(mockContext, request);
+      const headerValue = modifiedRequest.headers.get("X-Galileo-SDK");
+
+      expect(headerValue).toMatch(/^galileo-generated\//);
+    });
+
+    test("header contains valid version format", async () => {
+      const hook = new SDKIdentifierHook();
+      const request = new Request("http://localhost:8088/api/test");
+
+      const modifiedRequest = await hook.beforeRequest(mockContext, request);
+      const headerValue = modifiedRequest.headers.get("X-Galileo-SDK");
+
+      expect(headerValue).toMatch(/^galileo-generated\/\d+\.\d+\.\d+/);
+    });
+
+    test("preserves existing headers", async () => {
+      const hook = new SDKIdentifierHook();
+      const request = new Request("http://localhost:8088/api/test", {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Bearer token",
+        },
+      });
+
+      const modifiedRequest = await hook.beforeRequest(mockContext, request);
+
+      expect(modifiedRequest.headers.get("Content-Type")).toBe("application/json");
+      expect(modifiedRequest.headers.get("Authorization")).toBe("Bearer token");
+      expect(modifiedRequest.headers.has("X-Galileo-SDK")).toBe(true);
+    });
+
+    test("returns a Request object", async () => {
+      const hook = new SDKIdentifierHook();
+      const request = new Request("http://localhost:8088/api/test");
+
+      const result = await hook.beforeRequest(mockContext, request);
+
+      expect(result instanceof Request).toBe(true);
+    });
+
+    test("does not modify request method or body", async () => {
+      const hook = new SDKIdentifierHook();
+      const body = JSON.stringify({ test: "data" });
+      const request = new Request("http://localhost:8088/api/test", {
+        method: "POST",
+        body,
+      });
+
+      const modifiedRequest = await hook.beforeRequest(mockContext, request);
+
+      expect(modifiedRequest.method).toBe("POST");
+    });
+
+    test("works with different HTTP methods", async () => {
+      const hook = new SDKIdentifierHook();
+
+      for (const method of ["GET", "POST", "PUT", "DELETE", "PATCH"]) {
+        const request = new Request("http://localhost:8088/api/test", {
+          method,
+        });
+
+        const modifiedRequest = await hook.beforeRequest(mockContext, request);
+
+        expect(modifiedRequest.headers.has("X-Galileo-SDK")).toBe(true);
+        expect(modifiedRequest.method).toBe(method);
+      }
+    });
+
+    test("header value is consistent across multiple calls", async () => {
+      const hook = new SDKIdentifierHook();
+      const request1 = new Request("http://localhost:8088/api/test");
+      const request2 = new Request("http://localhost:8088/api/test");
+
+      const modifiedRequest1 = await hook.beforeRequest(mockContext, request1);
+      const modifiedRequest2 = await hook.beforeRequest(mockContext, request2);
+
+      const header1 = modifiedRequest1.headers.get("X-Galileo-SDK");
+      const header2 = modifiedRequest2.headers.get("X-Galileo-SDK");
+
+      expect(header1).toBe(header2);
+    });
+
+    test("overwrites existing X-Galileo-SDK header", async () => {
+      const hook = new SDKIdentifierHook();
+      const request = new Request("http://localhost:8088/api/test", {
+        headers: {
+          "X-Galileo-SDK": "old-value",
+        },
+      });
+
+      const modifiedRequest = await hook.beforeRequest(mockContext, request);
+      const headerValue = modifiedRequest.headers.get("X-Galileo-SDK");
+
+      expect(headerValue).toMatch(/^galileo-generated\//);
+      expect(headerValue).not.toBe("old-value");
+    });
+
+    test("handles loadVersion() failure gracefully with fallback to unknown", async () => {
+      vi.resetModules();
+
+      vi.doMock("../../hooks/sdk-identifier.js", async () => {
+        return {
+          SDKIdentifierHook: class {
+            async beforeRequest(
+              _hookCtx: BeforeRequestContext,
+              request: Request,
+            ): Promise<Request> {
+              const newRequest = request.clone();
+
+              const loadVersionWithFailure = (): string => {
+                try {
+                  throw new Error("Failed to load package.json (ESM runtime issue)");
+                } catch {
+                  return "unknown";
+                }
+              };
+
+              const version = loadVersionWithFailure();
+              const sdkIdentifier = `galileo-generated/${version}`;
+              newRequest.headers.set("X-Galileo-SDK", sdkIdentifier);
+              return newRequest;
+            }
+          },
+        };
+      });
+
+      const { SDKIdentifierHook: MockedHook } = await import("../../hooks/sdk-identifier.js");
+      const hook = new MockedHook();
+      const request = new Request("http://localhost:8088/api/test");
+
+      const modifiedRequest = await hook.beforeRequest(mockContext, request);
+      const headerValue = modifiedRequest.headers.get("X-Galileo-SDK");
+
+      expect(headerValue).toBe("galileo-generated/unknown");
+
+      vi.doUnmock("../../hooks/sdk-identifier.js");
+    });
+  });
+
+  describe("hook integration", () => {
+    test("hook implements BeforeRequestHook interface", () => {
+      const hook = new SDKIdentifierHook();
+
+      expect(typeof hook.beforeRequest).toBe("function");
+    });
+  });
+});