adonisjs-server-stats 1.9.0 → 1.10.3

package/dist/src/provider/boot_helpers.js

@@ -0,0 +1,91 @@
+import { log, dim, bold } from '../utils/logger.js';
+import { detectGlobalAuthMiddleware, buildAuthMiddlewareWarning, } from './auth_middleware_detector.js';
+export function deriveEndpointPaths(endpoint, devToolbar) {
+    const statsEndpoint = typeof endpoint === 'string' ? endpoint : false;
+    const debugEndpoint = devToolbar?.enabled
+        ? (devToolbar.debugEndpoint ?? '/admin/api/debug')
+        : undefined;
+    return { statsEndpoint, debugEndpoint };
+}
+export function computeDashboardPath(devToolbar, depsAvailable) {
+    if (!devToolbar?.enabled || !devToolbar.dashboard || !depsAvailable)
+        return undefined;
+    return devToolbar.dashboardPath ?? '/__stats';
+}
+export function collectRegisteredPaths(statsEndpoint, debugEndpoint, dashboardPath) {
+    const paths = [];
+    if (typeof statsEndpoint === 'string')
+        paths.push(statsEndpoint);
+    if (debugEndpoint)
+        paths.push(debugEndpoint + '/*');
+    if (dashboardPath)
+        paths.push(dashboardPath + '/*');
+    return paths;
+}
+export async function checkDashboardDeps(appImport) {
+    const missing = [];
+    try {
+        await appImport('knex');
+    }
+    catch {
+        missing.push('knex');
+    }
+    try {
+        await appImport('better-sqlite3');
+    }
+    catch {
+        missing.push('better-sqlite3');
+    }
+    return missing;
+}
+export function logMissingDeps(missing) {
+    if (missing.length === 0)
+        return;
+    log.block(`Dashboard requires ${missing.join(' and ')}. Install with:`, [
+        '',
+        bold(`npm install ${missing.join(' ')}`),
+        '',
+        dim('Dashboard routes have been skipped for now.'),
+        dim('Everything else (stats bar, debug panel) works without it.'),
+    ]);
+}
+export function warnAboutAuthMiddleware(config, makePath) {
+    if (config.shouldShow)
+        return;
+    const found = detectGlobalAuthMiddleware(makePath);
+    if (found.length === 0)
+        return;
+    log.block(bold('found global auth middleware that will run on every poll:'), buildAuthMiddlewareWarning(found, dim, bold));
+}
+export function logDashboardError(category, err) {
+    if (category === 'missing-dep') {
+        log.block('Dashboard could not start — missing dependencies. Install with:', [
+            '',
+            bold('npm install knex better-sqlite3'),
+            '',
+            dim('Dashboard has been disabled for this session.'),
+            dim('Everything else (stats bar, debug panel) works without it.'),
+        ]);
+        return;
+    }
+    if (category === 'timeout') {
+        log.block('Dashboard initialization timed out', [
+            dim('SQLite setup took too long — this usually means a wrong native'),
+            dim('binary was loaded (common with symlinked/file: dependencies).'),
+            '',
+            dim('Try running:'),
+            '  ' + bold('npm install knex better-sqlite3'),
+            dim('in your app directory to ensure the correct copies are used.'),
+            '',
+            dim('Dashboard has been disabled for this session.'),
+            dim('Everything else (stats bar, debug panel) works without it.'),
+        ]);
+        return;
+    }
+    log.warn('Dashboard could not start: ' +
+        (err?.message ?? '') +
+        '\n  ' +
+        dim('Dashboard has been disabled for this session.'));
+    if (err?.stack)
+        console.error(err.stack);
+}

package/dist/src/provider/boot_initializer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Boot initialization helpers for ServerStatsProvider.
+ * Pure functions for endpoint derivation, dashboard path computation, and route path collection.
+ */
+/**
+ * Derive stats and debug endpoint paths from config.
+ */
+export declare function deriveEndpointPaths(endpoint: string | false | undefined, devToolbar?: {
+    enabled?: boolean;
+    debugEndpoint?: string;
+    dashboard?: boolean;
+    dashboardPath?: string;
+}): {
+    statsEndpoint: string | false;
+    debugEndpoint: string | undefined;
+};
+/**
+ * Compute the dashboard path from toolbar config and dependency availability.
+ */
+export declare function computeDashboardPath(devToolbar?: {
+    enabled?: boolean;
+    dashboard?: boolean;
+    dashboardPath?: string;
+}, depsAvailable?: boolean): string | undefined;
+/**
+ * Collect registered route paths for logging.
+ */
+export declare function collectRegisteredPaths(statsEndpoint: string | false, debugEndpoint?: string, dashboardPath?: string): string[];

package/dist/src/provider/boot_initializer.js

@@ -0,0 +1,35 @@
+/**
+ * Boot initialization helpers for ServerStatsProvider.
+ * Pure functions for endpoint derivation, dashboard path computation, and route path collection.
+ */
+/**
+ * Derive stats and debug endpoint paths from config.
+ */
+export function deriveEndpointPaths(endpoint, devToolbar) {
+    const statsEndpoint = typeof endpoint === 'string' ? endpoint : false;
+    const debugEndpoint = devToolbar?.enabled
+        ? (devToolbar.debugEndpoint ?? '/admin/api/debug')
+        : undefined;
+    return { statsEndpoint, debugEndpoint };
+}
+/**
+ * Compute the dashboard path from toolbar config and dependency availability.
+ */
+export function computeDashboardPath(devToolbar, depsAvailable) {
+    if (!devToolbar?.enabled || !devToolbar.dashboard || !depsAvailable)
+        return undefined;
+    return devToolbar.dashboardPath ?? '/__stats';
+}
+/**
+ * Collect registered route paths for logging.
+ */
+export function collectRegisteredPaths(statsEndpoint, debugEndpoint, dashboardPath) {
+    const paths = [];
+    if (typeof statsEndpoint === 'string')
+        paths.push(statsEndpoint);
+    if (debugEndpoint)
+        paths.push(debugEndpoint + '/*');
+    if (dashboardPath)
+        paths.push(dashboardPath + '/*');
+    return paths;
+}

package/dist/src/provider/dashboard_init.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Dashboard initialization helpers extracted from toolbar_setup.
+ * Handles SQLite store creation, log piping, request piping, and broadcasting.
+ */
+import { LogStreamService } from '../log_stream/log_stream_service.js';
+import type DashboardController from '../dashboard/dashboard_controller.js';
+import type { DashboardStore } from '../dashboard/dashboard_store.js';
+import type { DebugStore } from '../debug/debug_store.js';
+import type { DevToolbarConfig } from '../debug/types.js';
+import type { StatsEngine } from '../engine/stats_engine.js';
+import type { ApplicationService } from '@adonisjs/core/types';
+interface DashboardResult {
+    dashboardStore: DashboardStore | null;
+    dashboardController: DashboardController | null;
+    dashboardLogStream: LogStreamService | null;
+    dashboardBroadcastTimer: ReturnType<typeof setInterval> | null;
+}
+interface DashboardStoreOptions {
+    tc: DevToolbarConfig;
+    emitter: unknown;
+    app: ApplicationService;
+    debugStore: DebugStore;
+    engine: StatsEngine;
+    pinoHookActive: boolean;
+    transmitChannels: string[];
+    onResult: (r: DashboardResult) => void;
+}
+/** Initialize the full-page dashboard: SQLite store, controller, log piping, broadcasting. */
+export declare function initDashboardStore(opts: DashboardStoreOptions): Promise<void>;
+export {};

package/dist/src/provider/dashboard_init.js

@@ -0,0 +1,138 @@
+/**
+ * Dashboard initialization helpers extracted from toolbar_setup.
+ * Handles SQLite store creation, log piping, request piping, and broadcasting.
+ */
+import { getLogStreamService } from '../collectors/log_collector.js';
+import { LogStreamService } from '../log_stream/log_stream_service.js';
+import { setDashboardPath, setOnRequestComplete, } from '../middleware/request_tracking_middleware.js';
+import { log, dim, bold } from '../utils/logger.js';
+import { classifyDashboardError, createStartTimeout } from './dashboard_setup.js';
+/** Initialize the full-page dashboard: SQLite store, controller, log piping, broadcasting. */
+export async function initDashboardStore(opts) {
+    const { tc, emitter, app, debugStore, engine, pinoHookActive, transmitChannels, onResult } = opts;
+    log.info('dashboard: initializing SQLite store...');
+    const { DashboardStore: DSC } = await import('../dashboard/dashboard_store.js');
+    const dashboardStore = new DSC(tc);
+    try {
+        await createStartTimeout(dashboardStore.start(null, emitter, app.makePath('')), 15_000);
+        log.info('dashboard: SQLite store ready');
+    }
+    catch (err) {
+        logDashboardStartError(err);
+        onResult({
+            dashboardStore: null,
+            dashboardController: null,
+            dashboardLogStream: null,
+            dashboardBroadcastTimer: null,
+        });
+        return;
+    }
+    const container = app.container;
+    container.singleton('dashboard.store', () => dashboardStore);
+    setDashboardPath(tc.dashboardPath);
+    const DCC = (await import('../dashboard/dashboard_controller.js')).default;
+    const dashboardController = new DCC(dashboardStore, app);
+    const dashboardLogStream = pipeDashLogs(pinoHookActive, dashboardStore, app.makePath.bind(app));
+    pipeDashRequests(debugStore, dashboardStore);
+    const dashboardBroadcastTimer = await setupDashBroadcast({
+        container,
+        dashboardStore,
+        engine,
+        debugStore,
+        transmitChannels,
+    });
+    onResult({ dashboardStore, dashboardController, dashboardLogStream, dashboardBroadcastTimer });
+}
+async function setupDashBroadcast(deps) {
+    const { container, dashboardStore, engine, debugStore, transmitChannels } = deps;
+    let transmit = null;
+    try {
+        transmit = await container.make('transmit');
+    }
+    catch { }
+    if (!transmit)
+        return null;
+    const ch = 'server-stats/dashboard';
+    if (!transmitChannels.includes(ch))
+        transmitChannels.push(ch);
+    return setInterval(async () => {
+        try {
+            if (!dashboardStore.isReady())
+                return;
+            const o = await dashboardStore.getOverviewMetrics('1h');
+            transmit.broadcast(ch, {
+                ...o,
+                diagnostics: {
+                    collectors: engine.getCollectorHealth(),
+                    buffers: debugStore.getBufferStats(),
+                },
+            });
+        }
+        catch { }
+    }, 30_000);
+}
+function pipeDashLogs(pinoHookActive, dashboardStore, makePath) {
+    const existing = getLogStreamService();
+    if (pinoHookActive && existing && !existing['logPath']) {
+        const orig = existing['onEntry'];
+        existing['onEntry'] = (entry) => {
+            orig?.(entry);
+            dashboardStore.recordLog(entry);
+        };
+        return null;
+    }
+    const service = new LogStreamService(makePath('logs', 'adonisjs.log'), (entry) => {
+        dashboardStore.recordLog(entry);
+    });
+    service.start().catch(() => { });
+    return service;
+}
+function pipeDashRequests(debugStore, dashboardStore) {
+    let lastQueryId = 0;
+    setOnRequestComplete(({ method, url, statusCode, duration, trace, httpRequestId }) => {
+        if (!dashboardStore.isReady())
+            return;
+        const q = debugStore.queries.getQueriesSince(lastQueryId);
+        if (q.length > 0)
+            lastQueryId = q[q.length - 1].id;
+        dashboardStore.persistRequest({
+            method,
+            url,
+            statusCode,
+            duration,
+            queries: q,
+            trace: trace ?? null,
+            httpRequestId: httpRequestId ?? null,
+        });
+    });
+}
+function logDashboardStartError(err) {
+    const c = classifyDashboardError(err);
+    if (c === 'missing-dep') {
+        log.block('Dashboard could not start — missing dependencies. Install with:', [
+            '',
+            bold('npm install knex better-sqlite3'),
+            '',
+            dim('Dashboard has been disabled for this session.'),
+            dim('Everything else (stats bar, debug panel) works without it.'),
+        ]);
+        return;
+    }
+    if (c === 'timeout') {
+        log.block('Dashboard initialization timed out', [
+            dim('SQLite setup took too long — this usually means a wrong native'),
+            dim('binary was loaded (common with symlinked/file: dependencies).'),
+            '',
+            dim('Try running:'),
+            `  ${bold('npm install knex better-sqlite3')}`,
+            dim('in your app directory to ensure the correct copies are used.'),
+            '',
+            dim('Dashboard has been disabled for this session.'),
+            dim('Everything else (stats bar, debug panel) works without it.'),
+        ]);
+        return;
+    }
+    log.warn(`Dashboard could not start: ${err?.message ?? ''}\n  ${dim('Dashboard has been disabled for this session.')}`);
+    if (err?.stack)
+        console.error(err.stack);
+}

package/dist/src/provider/dashboard_setup.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Pure helper functions for dashboard setup and configuration.
+ */
+import type { DevToolbarConfig } from '../debug/types.js';
+/**
+ * Classify a dashboard start() error into a category.
+ */
+export declare function classifyDashboardError(err: unknown): 'missing-dep' | 'timeout' | 'unknown';
+/**
+ * Race a promise against a timeout.
+ */
+export declare function createStartTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T>;
+/**
+ * Build the list of URL prefixes to exclude from tracing.
+ */
+export declare function buildExcludedPrefixes(toolbarConfig: {
+    debugEndpoint?: string;
+    excludeFromTracing?: string[];
+}, statsEndpoint: string | false): string[];
+/**
+ * Resolve a partial DevToolbarConfig by filling in all defaults.
+ */
+export declare function resolveToolbarConfig(partial: Partial<DevToolbarConfig> & {
+    enabled: boolean;
+}): DevToolbarConfig;

package/dist/src/provider/dashboard_setup.js

@@ -0,0 +1,78 @@
+/**
+ * Pure helper functions for dashboard setup and configuration.
+ */
+const MISSING_DEP_MARKERS = ['better-sqlite3', 'knex', 'Cannot find module', 'Cannot find package'];
+const MISSING_DEP_CODES = new Set(['ERR_MODULE_NOT_FOUND', 'MODULE_NOT_FOUND']);
+function isMissingDependencyError(msg, code) {
+    if (MISSING_DEP_CODES.has(code))
+        return true;
+    return MISSING_DEP_MARKERS.some((marker) => msg.includes(marker));
+}
+/**
+ * Classify a dashboard start() error into a category.
+ */
+export function classifyDashboardError(err) {
+    if (!err)
+        return 'unknown';
+    const errObj = err;
+    const msg = typeof errObj.message === 'string' ? errObj.message : '';
+    const code = typeof errObj.code === 'string' ? errObj.code : '';
+    if (isMissingDependencyError(msg, code))
+        return 'missing-dep';
+    if (msg.includes('timed out'))
+        return 'timeout';
+    return 'unknown';
+}
+/**
+ * Race a promise against a timeout.
+ */
+export function createStartTimeout(promise, timeoutMs) {
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error(`Dashboard SQLite initialization timed out after ${timeoutMs / 1000}s`)), timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]);
+}
+/**
+ * Build the list of URL prefixes to exclude from tracing.
+ */
+export function buildExcludedPrefixes(toolbarConfig, statsEndpoint) {
+    const debugEndpoint = toolbarConfig.debugEndpoint ?? '/admin/api/debug';
+    const defaultExcludes = [debugEndpoint, statsEndpoint].filter((p) => typeof p === 'string');
+    const prefixes = [...(toolbarConfig.excludeFromTracing ?? defaultExcludes)];
+    if (typeof statsEndpoint === 'string' && !prefixes.includes(statsEndpoint)) {
+        prefixes.push(statsEndpoint);
+    }
+    return prefixes;
+}
+const TOOLBAR_DEFAULTS = {
+    maxQueries: 500,
+    maxEvents: 200,
+    maxEmails: 100,
+    slowQueryThresholdMs: 100,
+    persistDebugData: false,
+    tracing: true,
+    maxTraces: 200,
+    dashboard: false,
+    dashboardPath: '/__stats',
+    retentionDays: 7,
+    dbPath: '.adonisjs/server-stats/dashboard.sqlite3',
+    debugEndpoint: '/admin/api/debug',
+};
+function stripUndefined(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (value !== undefined)
+            result[key] = value;
+    }
+    return result;
+}
+/**
+ * Resolve a partial DevToolbarConfig by filling in all defaults.
+ */
+export function resolveToolbarConfig(partial) {
+    return {
+        ...TOOLBAR_DEFAULTS,
+        ...stripUndefined(partial),
+        enabled: partial.enabled,
+    };
+}

package/dist/src/provider/diagnostics.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Pure function to build the diagnostics object for the Internals endpoint.
+ * Extracted from ServerStatsProvider to reduce complexity.
+ */
+/** Minimal collector shape for diagnostics. */
+interface CollectorRef {
+    name: string;
+}
+/** Input data for building diagnostics. */
+export interface DiagnosticsInput {
+    intervalId: ReturnType<typeof setInterval> | null;
+    dashboardBroadcastTimer: ReturnType<typeof setInterval> | null;
+    debugBroadcastTimer: ReturnType<typeof setTimeout> | null;
+    flushTimer: ReturnType<typeof setInterval> | null;
+    dashboardStoreReady: boolean;
+    transmitAvailable: boolean;
+    transmitChannels: string[];
+    prometheusActive: boolean;
+    pinoHookActive: boolean;
+    edgePluginActive: boolean;
+    emailBridgeActive: boolean;
+    hasCacheCollector?: boolean;
+    hasQueueCollector?: boolean;
+    resolvedCollectors?: CollectorRef[];
+    config: DiagnosticsConfig | null;
+}
+interface DiagnosticsConfig {
+    intervalMs: number;
+    transport: string;
+    channelName: string;
+    endpoint: string | false;
+    skipInTest: boolean;
+    onStats?: unknown;
+    shouldShow?: unknown;
+    devToolbar?: DiagnosticsToolbar;
+}
+interface DiagnosticsToolbar {
+    enabled: boolean;
+    maxQueries?: number;
+    maxEvents?: number;
+    maxEmails?: number;
+    maxTraces?: number;
+    slowQueryThresholdMs?: number;
+    tracing?: boolean;
+    dashboard?: boolean;
+    dashboardPath?: string;
+    retentionDays?: number;
+    dbPath?: string;
+    persistDebugData?: boolean | string;
+    debugEndpoint?: string;
+    renderer?: string;
+    excludeFromTracing?: string[];
+    panes?: unknown[];
+}
+/**
+ * Build the full diagnostics object from provider state.
+ */
+export declare function buildDiagnostics(input: DiagnosticsInput): {
+    timers: {
+        collectionInterval: {
+            active: boolean;
+            intervalMs: number;
+        };
+        dashboardBroadcast: {
+            active: boolean;
+            intervalMs: number;
+        };
+        debugBroadcast: {
+            active: boolean;
+            debounceMs: number;
+        };
+        persistFlush: {
+            active: boolean;
+            intervalMs: number;
+        };
+        retentionCleanup: {
+            active: boolean;
+            intervalMs: number;
+        };
+    };
+    transmit: {
+        available: boolean;
+        channels: string[];
+    };
+    integrations: {
+        prometheus: {
+            active: boolean;
+        };
+        pinoHook: {
+            active: boolean;
+            mode: string;
+        };
+        edgePlugin: {
+            active: boolean;
+        };
+        emailBridge: {
+            active: boolean;
+        };
+        cacheInspector: {
+            available: boolean;
+        };
+        queueInspector: {
+            available: boolean;
+        };
+    };
+    config: {
+        intervalMs: number;
+        transport: string;
+        channelName: string;
+        endpoint: string | false;
+        skipInTest: boolean;
+        hasOnStatsCallback: boolean;
+        hasShouldShowCallback: boolean;
+    };
+    devToolbar: {
+        tracing: boolean;
+        dashboard: boolean;
+        retentionDays: number;
+        persistDebugData: string | boolean;
+        renderer: string;
+        excludeFromTracing: string[];
+        customPaneCount: number;
+        dashboardPath: string;
+        debugEndpoint: string;
+        dbPath: string;
+        maxQueries: number;
+        maxEvents: number;
+        maxEmails: number;
+        maxTraces: number;
+        slowQueryThresholdMs: number;
+        enabled: boolean;
+    };
+};
+export {};

package/dist/src/provider/diagnostics.js

@@ -0,0 +1,127 @@
+/**
+ * Pure function to build the diagnostics object for the Internals endpoint.
+ * Extracted from ServerStatsProvider to reduce complexity.
+ */
+function buildTimersDiagnostics(input) {
+    return {
+        collectionInterval: {
+            active: input.intervalId !== null,
+            intervalMs: input.config?.intervalMs ?? 0,
+        },
+        dashboardBroadcast: {
+            active: input.dashboardBroadcastTimer !== null,
+            intervalMs: 30_000,
+        },
+        debugBroadcast: {
+            active: input.debugBroadcastTimer !== null,
+            debounceMs: 200,
+        },
+        persistFlush: {
+            active: input.flushTimer !== null,
+            intervalMs: 30_000,
+        },
+        retentionCleanup: {
+            active: input.dashboardStoreReady,
+            intervalMs: 60 * 60 * 1000,
+        },
+    };
+}
+function buildIntegrationsDiagnostics(input) {
+    const collectors = input.resolvedCollectors ?? [];
+    const hasCache = input.hasCacheCollector ?? collectors.some((c) => c.name === 'redis');
+    const hasQueue = input.hasQueueCollector ?? collectors.some((c) => c.name === 'queue');
+    return {
+        prometheus: { active: input.prometheusActive },
+        pinoHook: {
+            active: input.pinoHookActive,
+            mode: input.pinoHookActive ? 'stream' : 'none',
+        },
+        edgePlugin: { active: input.edgePluginActive },
+        emailBridge: { active: input.emailBridgeActive },
+        cacheInspector: { available: hasCache },
+        queueInspector: { available: hasQueue },
+    };
+}
+function buildConfigDiagnostics(config) {
+    if (!config) {
+        return {
+            intervalMs: 0,
+            transport: 'none',
+            channelName: '',
+            endpoint: false,
+            skipInTest: true,
+            hasOnStatsCallback: false,
+            hasShouldShowCallback: false,
+        };
+    }
+    return {
+        intervalMs: config.intervalMs,
+        transport: config.transport,
+        channelName: config.channelName,
+        endpoint: config.endpoint,
+        skipInTest: config.skipInTest !== false,
+        hasOnStatsCallback: typeof config.onStats === 'function',
+        hasShouldShowCallback: typeof config.shouldShow === 'function',
+    };
+}
+function pickToolbarLimits(tb) {
+    return {
+        maxQueries: tb.maxQueries ?? 500,
+        maxEvents: tb.maxEvents ?? 200,
+        maxEmails: tb.maxEmails ?? 100,
+        maxTraces: tb.maxTraces ?? 200,
+        slowQueryThresholdMs: tb.slowQueryThresholdMs ?? 100,
+    };
+}
+function pickToolbarPaths(tb) {
+    return {
+        dashboardPath: tb.dashboardPath ?? '/__stats',
+        debugEndpoint: tb.debugEndpoint ?? '/admin/api/debug',
+        dbPath: tb.dbPath ?? '.adonisjs/server-stats/dashboard.sqlite3',
+    };
+}
+function pickToolbarFeatures(tb) {
+    return {
+        tracing: tb.tracing ?? true,
+        dashboard: tb.dashboard ?? false,
+        retentionDays: tb.retentionDays ?? 7,
+        persistDebugData: tb.persistDebugData ?? false,
+        renderer: tb.renderer ?? 'preact',
+        excludeFromTracing: tb.excludeFromTracing ?? [],
+        customPaneCount: tb.panes?.length ?? 0,
+    };
+}
+function defaultToolbarDiagnostics() {
+    return {
+        enabled: false,
+        ...pickToolbarLimits({}),
+        ...pickToolbarPaths({}),
+        ...pickToolbarFeatures({}),
+    };
+}
+function buildDevToolbarDiagnostics(config) {
+    const tb = config?.devToolbar;
+    if (!tb)
+        return defaultToolbarDiagnostics();
+    return {
+        enabled: !!tb.enabled,
+        ...pickToolbarLimits(tb),
+        ...pickToolbarPaths(tb),
+        ...pickToolbarFeatures(tb),
+    };
+}
+/**
+ * Build the full diagnostics object from provider state.
+ */
+export function buildDiagnostics(input) {
+    return {
+        timers: buildTimersDiagnostics(input),
+        transmit: {
+            available: input.transmitAvailable,
+            channels: input.transmitChannels,
+        },
+        integrations: buildIntegrationsDiagnostics(input),
+        config: buildConfigDiagnostics(input.config),
+        devToolbar: buildDevToolbarDiagnostics(input.config),
+    };
+}