@servicetitan/startup 38.1.0 → 38.2.0

package/src/cli/utils/cli-git.ts

@@ -1,4 +1,7 @@
-import { runCommandOutput } from './cli-os';
+import path from 'node:path';
+import { runCommandOutput, runCommandOutputAsync } from './cli-os';
+
+const GIT_TIMEOUT_MS = 2000;
 
 export function gitGetBranch(): string {
     return runCommandOutput('git rev-parse --abbrev-ref HEAD').trim();
@@ -7,3 +10,26 @@ export function gitGetBranch(): string {
 export function gitGetCommitHash(): string {
     return runCommandOutput('git rev-parse --short HEAD').trim();
 }
+
+export interface GitContext {
+    repo?: string;
+    branch?: string;
+    userEmail?: string;
+    userName?: string;
+}
+
+export async function gitGetContext(): Promise<GitContext> {
+    const options = { quiet: true, ignoreErrors: true, timeout: GIT_TIMEOUT_MS };
+    const [rev, userEmail, userName] = await Promise.all([
+        runCommandOutputAsync('git rev-parse --abbrev-ref HEAD --show-toplevel', options),
+        runCommandOutputAsync('git config user.email', options),
+        runCommandOutputAsync('git config user.name', options),
+    ]);
+    const [branch, root] = rev?.split('\n') ?? [];
+    return {
+        repo: root ? path.basename(root) : undefined,
+        branch,
+        userEmail,
+        userName,
+    };
+}

package/src/cli/utils/cli-os.ts

@@ -1,10 +1,13 @@
 import {
+    exec,
     execFileSync,
+    ExecOptions,
     execSync,
     ExecSyncOptionsWithBufferEncoding,
     spawn,
     SpawnOptionsWithoutStdio,
 } from 'child_process';
+import { promisify } from 'util';
 import { log } from '../../utils';
 
 type RunCommandOptions = SpawnOptionsWithoutStdio & { quiet?: boolean };
@@ -81,6 +84,33 @@ export function runCommandOutput(
     return result;
 }
 
+type RunCommandOutputAsyncOptions = ExecOptions & { quiet?: boolean; ignoreErrors?: boolean };
+
+export async function runCommandOutputAsync(
+    command: string,
+    { quiet, ignoreErrors, ...execOptions }: RunCommandOutputAsyncOptions = {}
+): Promise<string | undefined> {
+    if (!quiet) {
+        log.info(`Running: ${command}`);
+    }
+
+    try {
+        const { stdout } = await promisify(exec)(command, execOptions);
+        const result = stdout.toString().trim();
+
+        if (!quiet) {
+            log.info('command finished', result);
+        }
+
+        return result || undefined;
+    } catch (error) {
+        if (ignoreErrors) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+
 export function killProcessTree(pid: number, signal: NodeJS.Signals = 'SIGKILL') {
     try {
         if (process.platform === 'win32') {

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/vite/config/__tests__/create-filtering-logger.test.ts

@@ -1,4 +1,5 @@
 import { createLogger, Logger } from 'vite';
+import { EMPTY_PREFIX } from '../../plugins/ignore-modules-plugin';
 import { createFilteringLogger } from '../create-filtering-logger';
 
 jest.mock('vite', () => ({ createLogger: jest.fn() }));
@@ -50,8 +51,8 @@ describe(createFilteringLogger.name, () => {
 
         describe('when message is an ignored-module import warning', () => {
             beforeEach(() => {
-                message =
-                    "[IMPORT_IS_UNDEFINED] Import `DefaultPortalContext` will always be undefined because there is no matching export in '\\0IGNORE_EMPTY:@servicetitan/design-system'";
+                const renderedPrefix = EMPTY_PREFIX.replace('\0', '\\0');
+                message = `[IMPORT_IS_UNDEFINED] Import \`DefaultPortalContext\` will always be undefined because there is no matching export in '${renderedPrefix}@servicetitan/design-system'`;
             });
 
             itSuppressesMessage();

package/src/vite/config/create-filtering-logger.ts

@@ -1,4 +1,5 @@
 import { createLogger, type Logger } from 'vite';
+import { EMPTY_PREFIX } from '../plugins/ignore-modules-plugin';
 
 /*
  * Expected warnings when a host's HTML references the shared-bundle assets created by
@@ -13,10 +14,15 @@ const SHARED_ASSET_WARNINGS = [
 /*
  * Expected when code feature-detects an optional peer dependency (e.g. `Package.Export
  * === undefined`) and ignoreModulesPlugin has substituted an empty module for it. Matched
- * on the plugin's IGNORE_EMPTY marker so a genuinely undefined export elsewhere still warns.
+ * on the plugin's EMPTY_PREFIX marker so a genuinely undefined export elsewhere still warns.
+ * Rolldown renders the marker's leading NUL control character as the visible characters "\"
+ * and "0" when it prints a warning, so match that instead of the raw NUL, doubled here
+ * because the backslash is also a regex metacharacter.
  */
 const IGNORED_MODULE_WARNINGS = [
-    /Import `\w+` will always be undefined because there is no matching export in '\\0IGNORE_EMPTY:[^']+'/,
+    new RegExp(
+        `Import \`\\w+\` will always be undefined because there is no matching export in '${EMPTY_PREFIX.replace('\0', '\\\\0')}[^']+'`
+    ),
 ];
 
 const SUPPRESSED_WARNINGS = [...SHARED_ASSET_WARNINGS, ...IGNORED_MODULE_WARNINGS];

package/src/webpack/__tests__/create-webpack-config-shared-dependencies.test.ts

@@ -11,7 +11,7 @@ import { WebpackAssetsManifest } from 'webpack-assets-manifest';
 import RemoveEmptyScriptsPlugin from 'webpack-remove-empty-scripts';
 import VirtualModulesPlugin from 'webpack-virtual-modules';
 import yargs from 'yargs';
-import { getLaunchDarklySdkVersion } from '../../core';
+import { CHUNK_PATTERNS, getLaunchDarklySdkVersion } from '../../core';
 import {
     getFolders,
     getPackageData,
@@ -350,6 +350,32 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                         cacheGroups.servicetitan.priority ?? 0
                     );
                 });
+
+                describe.each(Object.keys(CHUNK_PATTERNS))(
+                    'optimization.splitChunks.cacheGroups.%s',
+                    name => {
+                        const cacheGroup = () =>
+                            (subject().optimization!.splitChunks as any).cacheGroups[name];
+
+                        test('excludes the design-system chunk', () => {
+                            expect(cacheGroup().chunks({ name: 'design-system' })).toBe(false);
+                        });
+
+                        test('claims other chunks', () => {
+                            expect(cacheGroup().chunks({ name: 'foo' })).toBe(true);
+                        });
+
+                        describe('when application does not share design system', () => {
+                            beforeEach(() => {
+                                jest.mocked(loadSharedDependencies).mockReturnValue({});
+                            });
+
+                            test('claims all chunks', () => {
+                                expect(cacheGroup().chunks).toBe('all');
+                            });
+                        });
+                    }
+                );
             });
 
             test('configures "output.chunkLoadingGlobal"', () => {

package/src/webpack/configs/optimization-config.ts

@@ -32,13 +32,16 @@ export function optimizationConfig(context: WebpackBuildContext, _: Overrides):
 }
 
 function hostConfig(optimization: ConfigWithCacheGroups, context: WebpackBuildContext) {
-    const { isProduction } = context.build;
-    const { isWebComponent } = context.package;
+    const { isProduction, emitExposedDependencies } = context.build;
+    const { isWebComponent, sharedDependencies } = context.package;
     if (isWebComponent || !isProduction) {
         return;
     }
 
-    Object.assign(optimization.splitChunks.cacheGroups, vendorGroups());
+    const excludeDesignSystem =
+        emitExposedDependencies && !!sharedDependencies['@servicetitan/design-system'];
+
+    Object.assign(optimization.splitChunks.cacheGroups, vendorGroups(excludeDesignSystem));
 }
 
 function minimizeConfig(optimization: ConfigWithCacheGroups, context: WebpackBuildContext) {
@@ -115,27 +118,35 @@ function webComponentConfig(optimization: ConfigWithCacheGroups, context: Webpac
     });
 }
 
-function vendorGroups() {
+function vendorGroups(excludeDesignSystem = false): Record<string, any> {
+    /*
+     * The design-system entry already gets its own chunk; excluding it here keeps
+     * its CSS from being absorbed into a vendor chunk.
+     */
+    const chunks: any = excludeDesignSystem
+        ? (chunk: { name?: string }) => chunk.name !== 'design-system'
+        : 'all';
+
     return {
         'servicetitan': {
             name: 'servicetitan',
             test: CHUNK_PATTERNS.servicetitan,
-            chunks: 'all',
+            chunks,
         },
         'vendor-core': {
             name: 'vendor-core',
             test: CHUNK_PATTERNS['vendor-core'],
-            chunks: 'all',
+            chunks,
         },
         'kendo': {
             name: 'kendo',
             test: CHUNK_PATTERNS.kendo,
-            chunks: 'all',
+            chunks,
         },
         'vendor': {
             name: 'vendor',
             test: CHUNK_PATTERNS.vendor,
-            chunks: 'all',
+            chunks,
             priority: -5,
         },
     };