@servicetitan/startup 38.0.0 → 38.2.0

package/src/telemetry/__tests__/telemetry.test.ts

@@ -0,0 +1,326 @@
+/**
+ * @jest-environment node
+ */
+import os from 'os';
+import { gitGetContext } from '../../cli/utils/cli-git';
+import { getStartupVersion } from '../../core';
+import { Telemetry } from '../telemetry';
+
+jest.mock('../../cli/utils/cli-git', () => ({ gitGetContext: jest.fn() }));
+jest.mock('../../core', () => ({ getStartupVersion: jest.fn() }));
+jest.mock('os', () => ({ ...jest.requireActual('os'), hostname: jest.fn() }));
+
+jest.mock('@servicetitan/secrets', () => ({}), { virtual: true });
+
+describe(`[startup] ${Telemetry.name}`, () => {
+    const OLD_ENV = process.env;
+    const token = 'pub-test-token';
+    const gitContext = {
+        repo: 'monolith',
+        branch: 'main',
+        userEmail: 'dev@st.com',
+        userName: 'dev',
+    };
+    const hostname = 'test-host';
+    const startupVersion = '38.0.0';
+    const intakeUrl = (clientToken: string) =>
+        `https://browser-intake-datadoghq.com/api/v2/logs?dd-api-key=${clientToken}&ddsource=frontend-platform`;
+    const secrets = jest.requireMock('@servicetitan/secrets') as {
+        datadogStartupClientToken?: string;
+    };
+
+    let fetchMock: jest.Mock;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.env = {};
+        secrets.datadogStartupClientToken = token;
+        jest.mocked(gitGetContext).mockResolvedValue(gitContext);
+        jest.mocked(getStartupVersion).mockReturnValue(startupVersion);
+        jest.mocked(os.hostname).mockReturnValue(hostname);
+        fetchMock = jest.fn(() => Promise.resolve({ ok: true } as Response));
+        global.fetch = fetchMock as unknown as typeof fetch;
+    });
+
+    afterAll(() => {
+        process.env = OLD_ENV;
+    });
+
+    const sentBody = () => JSON.parse(fetchMock.mock.calls[0][1].body)[0];
+
+    const emit = async (act: (telemetry: Telemetry) => void): Promise<void> => {
+        const telemetry = new Telemetry();
+        act(telemetry);
+        await telemetry.flush();
+    };
+
+    describe('construction', () => {
+        const subject = () => new Telemetry();
+
+        test('does not spawn git', () => {
+            subject();
+
+            expect(gitGetContext).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('info', () => {
+        let attributes: Record<string, string>;
+
+        beforeEach(() => (attributes = {}));
+
+        const subject = () => emit(telemetry => telemetry.info('command.started', attributes));
+
+        test('posts to the browser logs intake with the client token', async () => {
+            await subject();
+
+            expect(fetchMock).toHaveBeenCalledWith(
+                intakeUrl(token),
+                expect.objectContaining({
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                })
+            );
+        });
+
+        test('includes the base context', async () => {
+            await subject();
+
+            expect(sentBody()).toEqual(
+                expect.objectContaining({
+                    service: 'startup',
+                    repo: gitContext.repo,
+                    branch: gitContext.branch,
+                    startupVersion,
+                    hostname,
+                    os: process.platform,
+                    node: process.versions.node,
+                    message: 'command.started',
+                    status: 'info',
+                    date: expect.any(Number),
+                    agent: false,
+                    usr: { email: gitContext.userEmail, name: gitContext.userName },
+                })
+            );
+        });
+
+        describe('with event attributes', () => {
+            beforeEach(() => {
+                attributes.command = 'build';
+                attributes.bundler = 'vite';
+            });
+
+            test('merges them into the payload', async () => {
+                await subject();
+
+                expect(sentBody()).toEqual(expect.objectContaining(attributes));
+            });
+        });
+
+        describe('when AI_AGENT is set', () => {
+            beforeEach(() => (process.env.AI_AGENT = 'claude-code'));
+
+            test('sets the agent flag', async () => {
+                await subject();
+
+                expect(sentBody()).toEqual(expect.objectContaining({ agent: true }));
+            });
+        });
+
+        describe('when CURSOR_AGENT is set', () => {
+            beforeEach(() => (process.env.CURSOR_AGENT = '1'));
+
+            test('sets the agent flag', async () => {
+                await subject();
+
+                expect(sentBody()).toEqual(expect.objectContaining({ agent: true }));
+            });
+        });
+
+        describe('without a client token', () => {
+            beforeEach(() => (secrets.datadogStartupClientToken = undefined));
+
+            test('does not send anything', async () => {
+                await subject();
+
+                expect(fetchMock).not.toHaveBeenCalled();
+            });
+
+            test('does not collect git context', async () => {
+                await subject();
+
+                expect(gitGetContext).not.toHaveBeenCalled();
+            });
+        });
+
+        describe('with DATADOG_CLIENT_TOKEN set', () => {
+            beforeEach(() => (process.env.DATADOG_CLIENT_TOKEN = 'env-token'));
+
+            test('overrides the secrets token', async () => {
+                await subject();
+
+                expect(fetchMock).toHaveBeenCalledWith(
+                    intakeUrl('env-token'),
+                    expect.objectContaining({ method: 'POST' })
+                );
+            });
+        });
+
+        describe('when fetch throws', () => {
+            beforeEach(() => {
+                global.fetch = (() => {
+                    throw new Error('boom');
+                }) as unknown as typeof fetch;
+            });
+
+            test('does not reject', async () => {
+                await expect(subject()).resolves.toBeUndefined();
+            });
+        });
+
+        describe('when base context gathering fails', () => {
+            beforeEach(() => {
+                jest.mocked(gitGetContext).mockRejectedValue(new Error('git blew up'));
+            });
+
+            test('still sends the event', async () => {
+                await subject();
+
+                expect(sentBody()).toEqual(expect.objectContaining({ message: 'command.started' }));
+            });
+        });
+    });
+
+    describe('warn', () => {
+        const subject = () => emit(telemetry => telemetry.warn('node.version.unsupported'));
+
+        test('sends with warn status', async () => {
+            await subject();
+
+            expect(sentBody()).toEqual(
+                expect.objectContaining({ message: 'node.version.unsupported', status: 'warn' })
+            );
+        });
+    });
+
+    describe('error', () => {
+        const message = 'compile blew up';
+
+        let error: unknown;
+
+        beforeEach(() => (error = new TypeError(message)));
+
+        const subject = () => emit(telemetry => telemetry.error('command.finished', error));
+
+        test('sends with error status, message, and kind', async () => {
+            await subject();
+
+            expect(sentBody()).toEqual(
+                expect.objectContaining({
+                    message: 'command.finished',
+                    status: 'error',
+                    error: {
+                        message,
+                        kind: TypeError.name,
+                        stack: expect.any(String),
+                    },
+                })
+            );
+        });
+
+        describe('with a string', () => {
+            const stringError = 'boom';
+
+            beforeEach(() => (error = stringError));
+
+            test('uses it as the message', async () => {
+                await subject();
+
+                expect(sentBody()).toEqual(
+                    expect.objectContaining({ error: { message: stringError } })
+                );
+            });
+        });
+
+        describe('with a non-Error object', () => {
+            const objectError = { code: 42 };
+
+            beforeEach(() => (error = objectError));
+
+            test('serializes it', async () => {
+                await subject();
+
+                expect(sentBody()).toEqual(
+                    expect.objectContaining({ error: { message: JSON.stringify(objectError) } })
+                );
+            });
+        });
+
+        describe('with a circular value', () => {
+            beforeEach(() => {
+                const circular: Record<string, unknown> = {};
+                circular.self = circular;
+                error = circular;
+            });
+
+            test('falls back to a safe message', async () => {
+                await subject();
+
+                expect(sentBody()).toEqual(
+                    expect.objectContaining({ error: { message: 'unserializable error value' } })
+                );
+            });
+        });
+    });
+
+    describe('flush', () => {
+        const subject = () => {
+            const telemetry = new Telemetry();
+            telemetry.info('command.started');
+            telemetry.info('command.finished');
+            return telemetry;
+        };
+
+        describe('with in-flight sends', () => {
+            let resolvers: (() => void)[];
+
+            beforeEach(() => {
+                resolvers = [];
+                fetchMock.mockImplementation(
+                    () =>
+                        new Promise<Response>(resolve => {
+                            resolvers.push(() => resolve({ ok: true } as Response));
+                        })
+                );
+            });
+
+            test('waits for all of them, not just the last', async () => {
+                let done = false;
+                const flushing = subject()
+                    .flush()
+                    .then(() => (done = true));
+
+                await new Promise(resolve => setImmediate(resolve));
+                expect(resolvers).toHaveLength(2);
+
+                resolvers[1]();
+                await Promise.resolve();
+                expect(done).toBe(false);
+
+                resolvers[0]();
+                await flushing;
+                expect(done).toBe(true);
+            });
+        });
+
+        describe('when a send rejects', () => {
+            beforeEach(() => {
+                fetchMock.mockRejectedValue(new Error('network down'));
+            });
+
+            test('resolves without rejecting', async () => {
+                await expect(subject().flush()).resolves.toBeUndefined();
+            });
+        });
+    });
+});

package/src/telemetry/index.ts

@@ -0,0 +1,2 @@
+export { Telemetry, telemetry } from './telemetry';
+export type { AttributeValue, Attributes } from './telemetry';

package/src/telemetry/telemetry.ts

@@ -0,0 +1,134 @@
+import { isCI } from '@servicetitan/install';
+import os from 'os';
+import { gitGetContext } from '../cli/utils/cli-git';
+import { getStartupVersion } from '../core';
+
+const DDSOURCE = 'frontend-platform';
+const SERVICE = 'startup';
+const SITE = 'datadoghq.com';
+const REQUEST_TIMEOUT_MS = 2000;
+
+type Status = 'info' | 'warn' | 'error';
+export type AttributeValue = string | number | boolean | undefined;
+export type Attributes = Record<string, AttributeValue | Record<string, AttributeValue>>;
+
+interface Context {
+    clientToken: string;
+    baseAttributes: Attributes;
+}
+
+function toError(error: unknown): { message: string; kind?: string; stack?: string } {
+    if (error instanceof Error) {
+        return { message: error.message, kind: error.name, stack: error.stack };
+    }
+    if (typeof error === 'string') {
+        return { message: error };
+    }
+    try {
+        return { message: JSON.stringify(error) };
+    } catch {
+        return { message: 'unserializable error value' };
+    }
+}
+
+function getClientToken(): string | undefined {
+    if (process.env.DATADOG_CLIENT_TOKEN) {
+        return process.env.DATADOG_CLIENT_TOKEN;
+    }
+    try {
+        const secrets = require('@servicetitan/secrets') as {
+            datadogStartupClientToken?: string;
+        };
+        return secrets.datadogStartupClientToken;
+    } catch {
+        return undefined;
+    }
+}
+
+async function getBaseContext(): Promise<Attributes> {
+    const git = await gitGetContext();
+    return {
+        service: SERVICE,
+        repo: git.repo,
+        branch: git.branch,
+        startupVersion: getStartupVersion(),
+        ci: isCI(),
+        agent: Boolean(process.env.AI_AGENT ?? process.env.CURSOR_AGENT),
+        hostname: os.hostname(),
+        os: process.platform,
+        node: process.versions.node,
+        usr: { email: git.userEmail, name: git.userName },
+    };
+}
+
+async function resolveContext(): Promise<Context | undefined> {
+    const clientToken = getClientToken();
+    if (!clientToken) {
+        return undefined;
+    }
+    const baseAttributes = await getBaseContext().catch(() => ({}));
+    return { clientToken, baseAttributes };
+}
+
+export class Telemetry {
+    private initPromise?: Promise<Context | undefined>;
+    private readonly pendingRequests = new Set<Promise<unknown>>();
+
+    info(name: string, attributes: Attributes = {}): void {
+        this.event(name, 'info', attributes);
+    }
+
+    warn(name: string, attributes: Attributes = {}): void {
+        this.event(name, 'warn', attributes);
+    }
+
+    error(name: string, error: unknown, attributes: Attributes = {}): void {
+        this.event(name, 'error', { ...attributes, error: toError(error) });
+    }
+
+    async flush(): Promise<void> {
+        /*
+         * Promise.all, not allSettled: pending requests never reject, and swallowing
+         * here would leave failures asymmetric on whether flush ran (a race).
+         */
+        await Promise.all([...this.pendingRequests]);
+    }
+
+    private init(): Promise<Context | undefined> {
+        this.initPromise ??= resolveContext();
+        return this.initPromise;
+    }
+
+    private event(name: string, status: Status, attributes: Attributes): void {
+        try {
+            this.send({ message: name, status, date: Date.now(), ...attributes });
+        } catch {} // eslint-disable-line no-empty
+    }
+
+    private send(event: Attributes): void {
+        const request = this.init()
+            .then(context => {
+                if (!context) {
+                    return;
+                }
+                const { clientToken, baseAttributes } = context;
+                const controller = new AbortController();
+                const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+                timer.unref();
+                const url =
+                    `https://browser-intake-${SITE}/api/v2/logs` +
+                    `?dd-api-key=${encodeURIComponent(clientToken)}&ddsource=${DDSOURCE}`;
+                return fetch(url, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify([{ ...baseAttributes, ...event }]),
+                    signal: controller.signal,
+                }).finally(() => clearTimeout(timer));
+            })
+            .catch(() => {})
+            .finally(() => this.pendingRequests.delete(request));
+        this.pendingRequests.add(request);
+    }
+}
+
+export const telemetry = new Telemetry();

package/src/utils/__tests__/exit-when-parent-exits.test.ts

@@ -0,0 +1,87 @@
+/**
+ * @jest-environment node
+ */
+import { exitWhenParentExits } from '../exit-when-parent-exits';
+import { log } from '../log';
+
+jest.mock('../log', () => ({ log: { info: jest.fn() } }));
+
+describe(`[startup] ${exitWhenParentExits.name}`, () => {
+    const command = 'some-task';
+    const parentPid = 4321;
+    let callback: (() => void) | undefined;
+    let killSpy: jest.SpyInstance;
+    let exitSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.useFakeTimers();
+        callback = undefined;
+        killSpy = jest.spyOn(process, 'kill').mockImplementation(jest.fn());
+        exitSpy = jest.spyOn(process, 'exit').mockImplementation(jest.fn() as any);
+        process.env.STARTUP_PARENT_PID = String(parentPid);
+    });
+
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+
+    const subject = () => {
+        exitWhenParentExits(command, callback);
+        jest.advanceTimersByTime(1000);
+    };
+
+    test('polls whether the parent process is still running', () => {
+        subject();
+
+        expect(killSpy).toHaveBeenCalledWith(parentPid, 0);
+    });
+
+    describe('with no process.env.STARTUP_PARENT_PID', () => {
+        beforeEach(() => delete process.env.STARTUP_PARENT_PID);
+
+        test('does not poll', () => {
+            subject();
+
+            expect(killSpy).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('when the parent process has exited', () => {
+        beforeEach(() => {
+            killSpy.mockImplementation(() => {
+                throw new Error('ESRCH');
+            });
+        });
+
+        test('logs shutdown message', () => {
+            subject();
+
+            expect(log.info).toHaveBeenCalledWith(`${command} shutting down`);
+        });
+
+        test('exits the process', () => {
+            subject();
+
+            expect(exitSpy).toHaveBeenCalledWith(0);
+        });
+
+        describe('with a callback', () => {
+            beforeEach(() => (callback = jest.fn()));
+
+            test('does not exit the process', () => {
+                subject();
+
+                expect(exitSpy).not.toHaveBeenCalled();
+            });
+
+            test('calls the callback', () => {
+                subject();
+
+                jest.advanceTimersByTime(1000);
+
+                expect(callback).toHaveBeenCalled();
+            });
+        });
+    });
+});

package/src/utils/__tests__/find-up.test.ts

@@ -0,0 +1,49 @@
+import path from 'path';
+import { findUp } from '../find-up';
+
+describe(findUp.name, () => {
+    let callback: jest.Mock;
+    let from: string | undefined;
+
+    const subject = () => findUp(callback, from);
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        callback = jest.fn();
+        from = undefined;
+    });
+
+    test('searches upward from the current working directory', () => {
+        subject();
+
+        ['.', '..', '../..'].forEach((dir, index) =>
+            expect(callback).toHaveBeenNthCalledWith(index + 1, path.resolve(dir))
+        );
+    });
+
+    test('returns undefined', () => {
+        expect(subject()).toBeUndefined();
+    });
+
+    describe('when a directory matches', () => {
+        const result = 'foo';
+
+        beforeEach(() => callback.mockReturnValueOnce(undefined).mockReturnValueOnce(result));
+
+        test('returns the callback result', () => {
+            expect(subject()).toBe(result);
+        });
+    });
+
+    describe('with a starting directory', () => {
+        beforeEach(() => (from = path.resolve('a/b/c')));
+
+        test('searches upward from the specified directory', () => {
+            subject();
+
+            ['.', '..', '../..'].forEach((dir, index) =>
+                expect(callback).toHaveBeenNthCalledWith(index + 1, path.resolve(from!, dir))
+            );
+        });
+    });
+});

package/src/utils/__tests__/get-configuration.test.ts

@@ -7,6 +7,7 @@ import {
     getExposeProcessEnv,
     getJestConfiguration,
     getReviewConfiguration,
+    getSharedDependencies,
     getStylelintConfiguration,
     getViteConfiguration,
     getVitestConfiguration,
@@ -243,6 +244,67 @@ describe('[startup] Utils', () => {
         });
     });
 
+    describe(getSharedDependencies.name, () => {
+        const sharedDependencies = { react: 'SharedDependencies.React' };
+        let locationOrJson: Parameters<typeof getSharedDependencies>[0];
+
+        beforeEach(() => (locationOrJson = undefined));
+
+        const subject = () => getSharedDependencies(locationOrJson);
+
+        itReturns(subject, undefined);
+
+        describe('with "cli.shared-dependencies"', () => {
+            beforeEach(() =>
+                mockPackageJson({ cli: { 'shared-dependencies': sharedDependencies } })
+            );
+
+            test('returns "cli.shared-dependencies"', () => {
+                expect(subject()).toEqual(sharedDependencies);
+            });
+        });
+
+        describe('with "cli.webpack.shared-dependencies"', () => {
+            beforeEach(() =>
+                mockPackageJson({ cli: { webpack: { 'shared-dependencies': sharedDependencies } } })
+            );
+
+            test('returns "cli.webpack.shared-dependencies"', () => {
+                expect(subject()).toEqual(sharedDependencies);
+            });
+        });
+
+        describe('with both top-level and webpack "shared-dependencies"', () => {
+            beforeEach(() =>
+                mockPackageJson({
+                    cli: {
+                        'shared-dependencies': sharedDependencies,
+                        'webpack': { 'shared-dependencies': { mobx: 'SharedDependencies.MobX' } },
+                    },
+                })
+            );
+
+            test('returns top-level "cli.shared-dependencies"', () => {
+                expect(subject()).toEqual(sharedDependencies);
+            });
+        });
+
+        describe('with a location', () => {
+            beforeEach(() => {
+                locationOrJson = 'packages/foo';
+                vol.fromJSON({
+                    [`packages/foo/${packageJson}`]: JSON.stringify({
+                        cli: { 'shared-dependencies': sharedDependencies },
+                    }),
+                });
+            });
+
+            test("returns location's shared dependencies", () => {
+                expect(subject()).toEqual(sharedDependencies);
+            });
+        });
+    });
+
     describe(getViteConfiguration.name, () => {
         const subject = () => getViteConfiguration();