Overview

7 days30 days

Latest CI Pipeline Executions

Fuzzy

Succeeded
35326
75a7b196 chore(core): drop explicit removeDbConnections() call from daemon shutdown The db-connection module now self-registers a process 'exit' handler that cleans up connections, so the daemon shutdown path doesn't need to call it explicitly.
by FrozenPandaz
Succeeded
35326
e53cc424 chore(core): switch lazy loads in bin/nx.ts from require() to import() [Self-Healing CI Rerun]
by nx-cloud[bot]
Failed
35326
Flaky task→
636507a7 chore(core): switch lazy loads in bin/nx.ts from require() to import() Gives proper TypeScript types on the lazily-loaded modules without 'as typeof import(...)' casts. No measurable perf difference on the --version fast path since it short-circuits before any of these fire. Directory imports (analytics/) need an explicit /index.js because dynamic import() uses ESM resolution rules.
by FrozenPandaz
Canceled
35326
636507a7 chore(core): switch lazy loads in bin/nx.ts from require() to import() Gives proper TypeScript types on the lazily-loaded modules without 'as typeof import(...)' casts. No measurable perf difference on the --version fast path since it short-circuits before any of these fire. Directory imports (analytics/) need an explicit /index.js because dynamic import() uses ESM resolution rules.
by FrozenPandaz
Canceled
35326
001b9f18 fix(core): avoid require.resolve in nx bin exit handlers The previous fast-path refactor guarded cleanup with require.cache[require.resolve(...)] so modules would only be cleaned up if they had actually been loaded. But require.resolve throws synchronously when the module can't be resolved, which broke the exit flow in published nx installs (observed as "Cannot find module '../src/utils/db-connection'" in create-nx-workspace e2e tests and masked the real error). - Move the db-connection exit handler into db-connection.ts so it only registers when the module is actually imported. - Track analyticsStarted via a plain flag in bin/nx.ts instead of probing require.cache with require.resolve.
by FrozenPandaz
Canceled
35326
8b96c413 fix(core): speed up nx --version by avoiding heavy imports on the fast path The bin/nx.ts entry point eagerly imported the daemon client, dotenv loader, analytics + perf-logging stack, and init-local for every invocation, even trivial ones like --version. That added ~225ms of unnecessary module load time before the first instruction of main() ran. This commit: - Lazy-loads those heavy modules inside the code paths that actually need them (cloud commands, local install handoff, etc.). - Adds a --version fast path at the top of main() that exits before any heavy module is touched. - Makes src/utils/perf-logging.ts lazy-require analytics / daemon logger inside the PerformanceObserver callback, so simply importing the module no longer pulls in the native binding (~63ms saved). - Updates the bench:version benchmark (and friends) to call ./node_modules/.bin/nx directly instead of pnpm exec nx, removing ~220ms of pnpm wrapper overhead from the measurement. Result for nx --version: - nx-only contribution: ~220ms -> ~10ms - end-to-end (./node_modules/.bin/nx --version): ~260ms -> ~49ms
by Jason Jean
Failed
35326
ce0d2ff5 fix(core): speed up nx --version by avoiding heavy imports on the fast path The bin/nx.ts entry point eagerly imported the daemon client, dotenv loader, analytics + perf-logging stack, and init-local for every invocation, even trivial ones like --version. That added ~225ms of unnecessary module load time before the first instruction of main() ran. This commit: - Lazy-loads those heavy modules inside the code paths that actually need them (cloud commands, local install handoff, etc.). - Adds a --version fast path at the top of main() that exits before any heavy module is touched. - Makes src/utils/perf-logging.ts lazy-require analytics / daemon logger inside the PerformanceObserver callback, so simply importing the module no longer pulls in the native binding (~63ms saved). - Updates the bench:version benchmark (and friends) to call ./node_modules/.bin/nx directly instead of pnpm exec nx, removing ~220ms of pnpm wrapper overhead from the measurement. Result for nx --version: - nx-only contribution: ~220ms -> ~10ms - end-to-end (./node_modules/.bin/nx --version): ~260ms -> ~49ms
by Jason Jean
Failed
35326
ce0d2ff5 fix(core): speed up nx --version by avoiding heavy imports on the fast path The bin/nx.ts entry point eagerly imported the daemon client, dotenv loader, analytics + perf-logging stack, and init-local for every invocation, even trivial ones like --version. That added ~225ms of unnecessary module load time before the first instruction of main() ran. This commit: - Lazy-loads those heavy modules inside the code paths that actually need them (cloud commands, local install handoff, etc.). - Adds a --version fast path at the top of main() that exits before any heavy module is touched. - Makes src/utils/perf-logging.ts lazy-require analytics / daemon logger inside the PerformanceObserver callback, so simply importing the module no longer pulls in the native binding (~63ms saved). - Updates the bench:version benchmark (and friends) to call ./node_modules/.bin/nx directly instead of pnpm exec nx, removing ~220ms of pnpm wrapper overhead from the measurement. Result for nx --version: - nx-only contribution: ~220ms -> ~10ms - end-to-end (./node_modules/.bin/nx --version): ~260ms -> ~49ms
by Jason Jean
Failed
35326
ce0d2ff5 fix(core): speed up nx --version by avoiding heavy imports on the fast path The bin/nx.ts entry point eagerly imported the daemon client, dotenv loader, analytics + perf-logging stack, and init-local for every invocation, even trivial ones like --version. That added ~225ms of unnecessary module load time before the first instruction of main() ran. This commit: - Lazy-loads those heavy modules inside the code paths that actually need them (cloud commands, local install handoff, etc.). - Adds a --version fast path at the top of main() that exits before any heavy module is touched. - Makes src/utils/perf-logging.ts lazy-require analytics / daemon logger inside the PerformanceObserver callback, so simply importing the module no longer pulls in the native binding (~63ms saved). - Updates the bench:version benchmark (and friends) to call ./node_modules/.bin/nx directly instead of pnpm exec nx, removing ~220ms of pnpm wrapper overhead from the measurement. Result for nx --version: - nx-only contribution: ~220ms -> ~10ms - end-to-end (./node_modules/.bin/nx --version): ~260ms -> ~49ms
by Jason Jean
Failed
35326
Environment issue→
ce0d2ff5 fix(core): speed up nx --version by avoiding heavy imports on the fast path The bin/nx.ts entry point eagerly imported the daemon client, dotenv loader, analytics + perf-logging stack, and init-local for every invocation, even trivial ones like --version. That added ~225ms of unnecessary module load time before the first instruction of main() ran. This commit: - Lazy-loads those heavy modules inside the code paths that actually need them (cloud commands, local install handoff, etc.). - Adds a --version fast path at the top of main() that exits before any heavy module is touched. - Makes src/utils/perf-logging.ts lazy-require analytics / daemon logger inside the PerformanceObserver callback, so simply importing the module no longer pulls in the native binding (~63ms saved). - Updates the bench:version benchmark (and friends) to call ./node_modules/.bin/nx directly instead of pnpm exec nx, removing ~220ms of pnpm wrapper overhead from the measurement. Result for nx --version: - nx-only contribution: ~220ms -> ~10ms - end-to-end (./node_modules/.bin/nx --version): ~260ms -> ~49ms
by Jason Jean
Canceled
35326
6c42e9b8 fix(core): speed up nx --version by avoiding heavy imports on the fast path The bin/nx.ts entry point eagerly imported the daemon client, dotenv loader, analytics + perf-logging stack, and init-local for every invocation, even trivial ones like --version. That added ~225ms of unnecessary module load time before the first instruction of main() ran. This commit: - Lazy-loads those heavy modules inside the code paths that actually need them (cloud commands, local install handoff, etc.). - Adds a --version fast path at the top of main() that exits before any heavy module is touched. - Makes src/utils/perf-logging.ts lazy-require analytics / daemon logger inside the PerformanceObserver callback, so simply importing the module no longer pulls in the native binding (~63ms saved). - Updates the bench:version benchmark (and friends) to call ./node_modules/.bin/nx directly instead of pnpm exec nx, removing ~220ms of pnpm wrapper overhead from the measurement. Result for nx --version: - nx-only contribution: ~220ms -> ~10ms - end-to-end (./node_modules/.bin/nx --version): ~260ms -> ~49ms
by Jason Jean
Canceled
35326
bfd63411 fix(core): speed up nx --version by avoiding heavy imports on the fast path The bin/nx.ts entry point eagerly imported the daemon client, dotenv loader, analytics + perf-logging stack, and init-local for every invocation, even trivial ones like --version. That added ~225ms of unnecessary module load time before the first instruction of main() ran. This commit: - Lazy-loads those heavy modules inside the code paths that actually need them (cloud commands, local install handoff, etc.). - Adds a --version fast path at the top of main() that exits before any heavy module is touched. - Makes src/utils/perf-logging.ts lazy-require analytics / daemon logger inside the PerformanceObserver callback, so simply importing the module no longer pulls in the native binding (~63ms saved). - Updates the bench:version benchmark (and friends) to call ./node_modules/.bin/nx directly instead of pnpm exec nx, removing ~220ms of pnpm wrapper overhead from the measurement. Result for nx --version: - nx-only contribution: ~220ms -> ~10ms - end-to-end (./node_modules/.bin/nx --version): ~260ms -> ~49ms
by Jason Jean
Canceled
35326
a032faaf fix(core): speed up nx --version by avoiding heavy imports on the fast path The bin/nx.ts entry point eagerly imported the daemon client, dotenv loader, analytics + perf-logging stack, and init-local for every invocation, even trivial ones like --version. That added ~225ms of unnecessary module load time before the first instruction of main() ran. This commit: - Lazy-loads those heavy modules inside the code paths that actually need them (cloud commands, local install handoff, etc.). - Adds a --version fast path at the top of main() that exits before any heavy module is touched. - Makes src/utils/perf-logging.ts lazy-require analytics / daemon logger inside the PerformanceObserver callback, so simply importing the module no longer pulls in the native binding (~63ms saved). - Updates the bench:version benchmark (and friends) to call ./node_modules/.bin/nx directly instead of pnpm exec nx, removing ~220ms of pnpm wrapper overhead from the measurement. Result for nx --version: - nx-only contribution: ~220ms -> ~10ms - end-to-end (./node_modules/.bin/nx --version): ~260ms -> ~49ms
by Jason Jean
Canceled
35326
3d3fcbfa fix(core): speed up nx --version by avoiding heavy imports on the fast path The bin/nx.ts entry point eagerly imported the daemon client, dotenv loader, analytics + perf-logging stack, and init-local for every invocation, even trivial ones like --version. That added ~225ms of unnecessary module load time before the first instruction of main() ran. This commit: - Lazy-loads those heavy modules inside the code paths that actually need them (cloud commands, local install handoff, etc.). - Adds a --version fast path at the top of main() that exits before any heavy module is touched. - Makes src/utils/perf-logging.ts lazy-require analytics / daemon logger inside the PerformanceObserver callback, so simply importing the module no longer pulls in the native binding (~63ms saved). - Updates the bench:version benchmark (and friends) to call ./node_modules/.bin/nx directly instead of pnpm exec nx, removing ~220ms of pnpm wrapper overhead from the measurement. Result for nx --version: - nx-only contribution: ~220ms -> ~10ms - end-to-end (./node_modules/.bin/nx --version): ~260ms -> ~49ms
by Jason Jean
Failed
35326
3d3fcbfa fix(core): speed up nx --version by avoiding heavy imports on the fast path The bin/nx.ts entry point eagerly imported the daemon client, dotenv loader, analytics + perf-logging stack, and init-local for every invocation, even trivial ones like --version. That added ~225ms of unnecessary module load time before the first instruction of main() ran. This commit: - Lazy-loads those heavy modules inside the code paths that actually need them (cloud commands, local install handoff, etc.). - Adds a --version fast path at the top of main() that exits before any heavy module is touched. - Makes src/utils/perf-logging.ts lazy-require analytics / daemon logger inside the PerformanceObserver callback, so simply importing the module no longer pulls in the native binding (~63ms saved). - Updates the bench:version benchmark (and friends) to call ./node_modules/.bin/nx directly instead of pnpm exec nx, removing ~220ms of pnpm wrapper overhead from the measurement. Result for nx --version: - nx-only contribution: ~220ms -> ~10ms - end-to-end (./node_modules/.bin/nx --version): ~260ms -> ~49ms
by Jason Jean
Failed
35326
40eeb0bf fix(core): speed up nx --version by avoiding heavy imports on the fast path The bin/nx.ts entry point eagerly imported the daemon client, dotenv loader, analytics + perf-logging stack, and init-local for every invocation, even trivial ones like --version. That added ~225ms of unnecessary module load time before the first instruction of main() ran. This commit: - Lazy-loads those heavy modules inside the code paths that actually need them (cloud commands, local install handoff, etc.). - Adds a --version fast path at the top of main() that exits before any heavy module is touched. - Makes src/utils/perf-logging.ts lazy-require analytics / daemon logger inside the PerformanceObserver callback, so simply importing the module no longer pulls in the native binding (~63ms saved). - Updates the bench:version benchmark (and friends) to call ./node_modules/.bin/nx directly instead of pnpm exec nx, removing ~220ms of pnpm wrapper overhead from the measurement. Result for nx --version: - nx-only contribution: ~220ms -> ~10ms - end-to-end (./node_modules/.bin/nx --version): ~260ms -> ~49ms
by Jason Jean
Failed
35326
5e6ea4d5 fix(core): speed up nx --version by avoiding heavy imports on the fast path The bin/nx.ts entry point eagerly imported the daemon client, dotenv loader, analytics + perf-logging stack, and init-local for every invocation, even trivial ones like --version. That added ~225ms of unnecessary module load time before the first instruction of main() ran. This commit: - Lazy-loads those heavy modules inside the code paths that actually need them (cloud commands, local install handoff, etc.). - Adds a --version fast path at the top of main() that exits before any heavy module is touched. - Makes src/utils/perf-logging.ts lazy-require analytics / daemon logger inside the PerformanceObserver callback, so simply importing the module no longer pulls in the native binding (~63ms saved). - Updates the bench:version benchmark (and friends) to call ./node_modules/.bin/nx directly instead of pnpm exec nx, removing ~220ms of pnpm wrapper overhead from the measurement. Result for nx --version: - nx-only contribution: ~220ms -> ~10ms - end-to-end (./node_modules/.bin/nx --version): ~260ms -> ~49ms
by Jason Jean