mcp-perforce-server 2.1.2 → 3.0.0

package/dist/server.js

@@ -77,7 +77,15 @@ const TOOL_HANDLERS = {
     'p4.shelve': tools.p4Shelve,
     'p4.unshelve': tools.p4Unshelve,
     'p4.changes': tools.p4Changes,
+    'p4.review': tools.p4Review,
+    'p4.reviews': tools.p4Reviews,
+    'p4.interchanges': tools.p4Interchanges,
+    'p4.integrated': tools.p4Integrated,
+    'p4.review.bundle': tools.p4ReviewBundle,
+    'p4.change.inspect': tools.p4ChangeInspect,
+    'p4.path.synccheck': tools.p4PathSyncCheck,
     'p4.blame': tools.p4Blame,
+    'p4.annotate': tools.p4Annotate,
     'p4.copy': tools.p4Copy,
     'p4.move': tools.p4Move,
     'p4.integrate': tools.p4Integrate,
@@ -122,6 +130,33 @@ const WRITE_TOOLS = new Set([
     'p4.merge',
 ]);
 const CACHEABLE_TOOLS = new Set(Object.keys(TOOL_HANDLERS).filter((toolName) => !WRITE_TOOLS.has(toolName)));
+const LOW_LATENCY_CACHE_TTL_TOOLS = new Set([
+    'p4.status',
+    'p4.opened',
+    'p4.changes',
+    'p4.review',
+    'p4.reviews',
+    'p4.interchanges',
+    'p4.integrated',
+    'p4.review.bundle',
+    'p4.change.inspect',
+    'p4.path.synccheck',
+]);
+const STABLE_CACHE_TTL_TOOLS = new Set([
+    'p4.info',
+    'p4.users',
+    'p4.user',
+    'p4.clients',
+    'p4.client',
+    'p4.labels',
+    'p4.label',
+    'p4.streams',
+    'p4.stream',
+    'p4.jobs',
+    'p4.job',
+    'p4.config.detect',
+    'p4.compliance',
+]);
 function getPerformanceMode() {
     const mode = (process.env.P4_PERFORMANCE_MODE || 'fast').toLowerCase();
     if (mode === 'balanced' || mode === 'secure') {
@@ -155,14 +190,52 @@ function getEnvInt(name, fallback) {
     const parsed = parseInt(process.env[name] || '', 10);
     return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
 }
+function parseToolCacheTtlOverrides(raw) {
+    const overrides = new Map();
+    if (!raw) {
+        return overrides;
+    }
+    for (const segment of raw.split(',')) {
+        const trimmed = segment.trim();
+        if (!trimmed) {
+            continue;
+        }
+        const splitIndex = trimmed.includes('=') ? trimmed.indexOf('=') : trimmed.indexOf(':');
+        if (splitIndex <= 0) {
+            continue;
+        }
+        const key = trimmed.slice(0, splitIndex).trim();
+        const valueRaw = trimmed.slice(splitIndex + 1).trim();
+        const value = parseInt(valueRaw, 10);
+        if (key && Number.isFinite(value) && value >= 0) {
+            overrides.set(key, value);
+        }
+    }
+    return overrides;
+}
 class MCPPerforceServer {
     constructor() {
         this.prettyJson = process.env.P4_PRETTY_JSON === 'true';
         this.responseCacheEnabled = process.env.P4_RESPONSE_CACHE !== 'false';
         this.responseCacheTtlMs = getEnvInt('P4_RESPONSE_CACHE_TTL_MS', getDefaultResponseCacheTtlMs());
         this.responseCacheMaxEntries = getEnvInt('P4_RESPONSE_CACHE_MAX_ENTRIES', getDefaultResponseCacheMaxEntries());
+        this.responseCacheTtlOverrides = parseToolCacheTtlOverrides(process.env.P4_RESPONSE_CACHE_TTL_MAP);
+        this.negativeCacheEnabled = process.env.P4_NEGATIVE_CACHE !== 'false';
+        this.negativeCacheTtlMs = getEnvInt('P4_NEGATIVE_CACHE_TTL_MS', Math.max(1000, Math.min(this.responseCacheTtlMs, 5000)));
+        this.negativeCacheableErrorCodes = new Set([
+            'P4_INVALID_ARGS',
+            'P4_READONLY_MODE',
+            'P4_DELETE_DISABLED',
+            'P4_AUDIT_DISABLED',
+            'P4_CONFIG_NOT_FOUND',
+        ]);
         this.responseCache = new Map();
         this.inFlightReadRequests = new Map();
+        this.toolPerformance = new Map();
+        this.perfMetricsSampleSize = getEnvInt('P4_PERF_METRICS_SAMPLE_SIZE', 200) || 200;
+        this.perfMetricsEnabled = process.env.P4_LOG_PERF_METRICS === 'true';
+        this.perfMetricsIntervalMs = getEnvInt('P4_LOG_PERF_METRICS_INTERVAL_MS', 60000) || 60000;
+        this.perfMetricsTimer = null;
         this.cacheEpoch = 0;
         this.server = new index_js_1.Server({
             name: 'mcp-perforce-server',
@@ -180,6 +253,7 @@ class MCPPerforceServer {
         };
         this.setupToolHandlers();
         this.setupErrorHandling();
+        this.setupPerformanceLogging();
     }
     setupErrorHandling() {
         this.server.onerror = (error) => {
@@ -187,15 +261,35 @@ class MCPPerforceServer {
         };
         process.on('SIGINT', async () => {
             log.info('Shutting down MCP Perforce server...');
+            this.stopPerformanceLogging();
             await this.server.close();
             process.exit(0);
         });
         process.on('SIGTERM', async () => {
             log.info('Shutting down MCP Perforce server...');
+            this.stopPerformanceLogging();
             await this.server.close();
             process.exit(0);
         });
     }
+    setupPerformanceLogging() {
+        if (!this.perfMetricsEnabled || this.perfMetricsIntervalMs <= 0) {
+            return;
+        }
+        this.perfMetricsTimer = setInterval(() => {
+            this.logPerformanceSnapshot();
+        }, this.perfMetricsIntervalMs);
+        if (typeof this.perfMetricsTimer.unref === 'function') {
+            this.perfMetricsTimer.unref();
+        }
+    }
+    stopPerformanceLogging() {
+        if (!this.perfMetricsTimer) {
+            return;
+        }
+        clearInterval(this.perfMetricsTimer);
+        this.perfMetricsTimer = null;
+    }
     serializeResult(value) {
         if (this.prettyJson) {
             return JSON.stringify(value, null, 2);
@@ -207,6 +301,19 @@ class MCPPerforceServer {
             content: [{ type: 'text', text: this.serializeResult(value) }],
         };
     }
+    getToolCacheTtlMs(toolName) {
+        const override = this.responseCacheTtlOverrides.get(toolName);
+        if (override !== undefined) {
+            return override;
+        }
+        if (LOW_LATENCY_CACHE_TTL_TOOLS.has(toolName)) {
+            return Math.max(1000, Math.floor(this.responseCacheTtlMs / 2));
+        }
+        if (STABLE_CACHE_TTL_TOOLS.has(toolName)) {
+            return Math.max(this.responseCacheTtlMs, 15000);
+        }
+        return this.responseCacheTtlMs;
+    }
     getCachedResult(cacheKey) {
         const entry = this.responseCache.get(cacheKey);
         if (!entry) {
@@ -216,21 +323,33 @@ class MCPPerforceServer {
             this.responseCache.delete(cacheKey);
             return undefined;
         }
-        return entry.value;
+        // LRU behavior: refresh recency on read hits.
+        this.responseCache.delete(cacheKey);
+        this.responseCache.set(cacheKey, entry);
+        return {
+            result: entry.value,
+            cacheStatus: entry.isNegative ? 'negative_hit' : 'hit',
+        };
     }
-    setCachedResult(cacheKey, value) {
-        if (this.responseCacheMaxEntries <= 0 || this.responseCacheTtlMs <= 0) {
+    setCachedResult(cacheKey, value, ttlMs, isNegative = false) {
+        if (this.responseCacheMaxEntries <= 0 || ttlMs <= 0) {
             return;
         }
-        if (this.responseCache.size >= this.responseCacheMaxEntries) {
+        if (this.responseCache.has(cacheKey)) {
+            this.responseCache.delete(cacheKey);
+        }
+        while (this.responseCache.size >= this.responseCacheMaxEntries) {
             const oldestKey = this.responseCache.keys().next().value;
-            if (oldestKey) {
-                this.responseCache.delete(oldestKey);
+            if (!oldestKey) {
+                break;
             }
+            this.responseCache.delete(oldestKey);
         }
         this.responseCache.set(cacheKey, {
             value,
-            expiresAt: Date.now() + this.responseCacheTtlMs,
+            expiresAt: Date.now() + ttlMs,
+            isNegative,
+            ttlMs,
         });
     }
     clearReadCache() {
@@ -242,6 +361,115 @@ class MCPPerforceServer {
     buildCacheKey(name, args) {
         return `${name}:${JSON.stringify(args ?? {})}`;
     }
+    shouldCacheNegativeResult(result) {
+        if (!this.negativeCacheEnabled || !result || typeof result !== 'object') {
+            return false;
+        }
+        const resultRecord = result;
+        if (resultRecord.ok !== false) {
+            return false;
+        }
+        const errorCode = resultRecord.error?.code;
+        return typeof errorCode === 'string' && this.negativeCacheableErrorCodes.has(errorCode);
+    }
+    recordToolPerformance(toolName, durationMs, result, cacheStatus, subcallCounts) {
+        let stats = this.toolPerformance.get(toolName);
+        if (!stats) {
+            stats = {
+                calls: 0,
+                successes: 0,
+                errors: 0,
+                cacheHits: 0,
+                negativeCacheHits: 0,
+                cacheMisses: 0,
+                inFlightHits: 0,
+                totalDurationMs: 0,
+                durationsMs: [],
+                subcallTotals: {},
+            };
+            this.toolPerformance.set(toolName, stats);
+        }
+        stats.calls += 1;
+        stats.totalDurationMs += durationMs;
+        stats.durationsMs.push(durationMs);
+        if (stats.durationsMs.length > this.perfMetricsSampleSize) {
+            stats.durationsMs.shift();
+        }
+        const ok = !!(result && typeof result === 'object' && result.ok === true);
+        if (ok) {
+            stats.successes += 1;
+        }
+        else {
+            stats.errors += 1;
+        }
+        switch (cacheStatus) {
+            case 'hit':
+                stats.cacheHits += 1;
+                break;
+            case 'negative_hit':
+                stats.negativeCacheHits += 1;
+                break;
+            case 'in_flight':
+                stats.inFlightHits += 1;
+                break;
+            case 'miss':
+                stats.cacheMisses += 1;
+                break;
+            default:
+                break;
+        }
+        if (subcallCounts) {
+            for (const [name, value] of Object.entries(subcallCounts)) {
+                if (!Number.isFinite(value) || value <= 0) {
+                    continue;
+                }
+                stats.subcallTotals[name] = (stats.subcallTotals[name] || 0) + value;
+            }
+        }
+    }
+    getPercentile(samples, percentile) {
+        if (samples.length === 0) {
+            return 0;
+        }
+        const sorted = [...samples].sort((a, b) => a - b);
+        const index = Math.min(sorted.length - 1, Math.max(0, Math.floor((percentile / 100) * (sorted.length - 1))));
+        return Math.round(sorted[index]);
+    }
+    extractSubcallCounts(result) {
+        if (!result || typeof result !== 'object') {
+            return undefined;
+        }
+        const outer = result;
+        if (!outer.result || typeof outer.result !== 'object') {
+            return undefined;
+        }
+        const meta = outer.result.meta;
+        if (!meta || !meta.subcallCounts) {
+            return undefined;
+        }
+        return meta.subcallCounts;
+    }
+    logPerformanceSnapshot() {
+        if (this.toolPerformance.size === 0) {
+            return;
+        }
+        const byCalls = [...this.toolPerformance.entries()].sort((a, b) => b[1].calls - a[1].calls);
+        const topEntries = byCalls.slice(0, 12).map(([toolName, stats]) => {
+            const cacheHitsTotal = stats.cacheHits + stats.negativeCacheHits + stats.inFlightHits;
+            const cacheHitRate = stats.calls > 0 ? Math.round((cacheHitsTotal / stats.calls) * 100) : 0;
+            const avgMs = stats.calls > 0 ? Math.round(stats.totalDurationMs / stats.calls) : 0;
+            return {
+                tool: toolName,
+                calls: stats.calls,
+                avgMs,
+                p50Ms: this.getPercentile(stats.durationsMs, 50),
+                p95Ms: this.getPercentile(stats.durationsMs, 95),
+                cacheHitRate,
+                subcalls: stats.subcallTotals,
+            };
+        });
+        log.info('Performance snapshot:', topEntries);
+    }
     async executeTool(name, args) {
         const handler = TOOL_HANDLERS[name];
         if (!handler) {
@@ -251,29 +479,33 @@ class MCPPerforceServer {
     }
     async executeToolWithCaching(name, args) {
         if (!this.responseCacheEnabled || !CACHEABLE_TOOLS.has(name)) {
-            return this.executeTool(name, args);
+            return { result: await this.executeTool(name, args), cacheStatus: 'uncacheable' };
         }
         const cacheKey = this.buildCacheKey(name, args);
         const cachedResult = this.getCachedResult(cacheKey);
-        if (cachedResult !== undefined) {
+        if (cachedResult) {
             return cachedResult;
         }
         const inFlight = this.inFlightReadRequests.get(cacheKey);
         if (inFlight) {
-            return inFlight;
+            return { result: await inFlight, cacheStatus: 'in_flight' };
         }
         const pending = this.executeTool(name, args);
         this.inFlightReadRequests.set(cacheKey, pending);
         const startedEpoch = this.cacheEpoch;
         try {
             const result = await pending;
-            if (startedEpoch === this.cacheEpoch &&
-                result &&
-                typeof result === 'object' &&
-                result.ok === true) {
-                this.setCachedResult(cacheKey, result);
+            if (startedEpoch === this.cacheEpoch) {
+                const toolTtlMs = this.getToolCacheTtlMs(name);
+                if (result && typeof result === 'object' && result.ok === true) {
+                    this.setCachedResult(cacheKey, result, toolTtlMs, false);
+                }
+                else if (this.shouldCacheNegativeResult(result)) {
+                    const negativeTtl = Math.min(toolTtlMs, this.negativeCacheTtlMs);
+                    this.setCachedResult(cacheKey, result, negativeTtl, true);
+                }
             }
-            return result;
+            return { result, cacheStatus: 'miss' };
         }
         finally {
             this.inFlightReadRequests.delete(cacheKey);
@@ -601,7 +833,7 @@ class MCPPerforceServer {
                     },
                     {
                         name: 'p4.describe',
-                        description: 'Describe a changelist with metadata and affected files (equivalent to p4 describe -s)',
+                        description: 'Describe a changelist with metadata, affected files, and optional diff content',
                         inputSchema: {
                             type: 'object',
                             properties: {
@@ -612,6 +844,15 @@ class MCPPerforceServer {
                                     ],
                                     description: 'Changelist number (required)',
                                 },
+                                includeDiff: {
+                                    type: 'boolean',
+                                    description: 'Include patch/diff content from p4 describe -d* (optional, default false)',
+                                },
+                                diffFormat: {
+                                    type: 'string',
+                                    enum: ['u', 'c', 'n', 's'],
+                                    description: 'Diff format when includeDiff=true: u=unified, c=context, n=RCS, s=summary',
+                                },
                                 workspacePath: {
                                     type: 'string',
                                     description: 'Path to workspace directory (optional, defaults to current directory)',
@@ -800,6 +1041,214 @@ class MCPPerforceServer {
                             additionalProperties: false,
                         },
                     },
+                    {
+                        name: 'p4.review',
+                        description: 'List changelists pending review',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                counter: {
+                                    type: 'string',
+                                    description: 'Review counter/token used by p4 review -t (optional)',
+                                },
+                                filespec: {
+                                    type: 'string',
+                                    description: 'Optional filespec to filter changelists',
+                                },
+                                workspacePath: {
+                                    type: 'string',
+                                    description: 'Path to workspace directory (optional, defaults to current directory)',
+                                },
+                            },
+                            additionalProperties: false,
+                        },
+                    },
+                    {
+                        name: 'p4.reviews',
+                        description: 'List reviewers for files or a changelist',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                changelist: {
+                                    type: 'string',
+                                    description: 'Optional changelist number to resolve reviewers for',
+                                },
+                                files: {
+                                    type: 'array',
+                                    items: { type: 'string' },
+                                    description: 'Optional file list/filespecs to resolve reviewers for',
+                                },
+                                workspacePath: {
+                                    type: 'string',
+                                    description: 'Path to workspace directory (optional, defaults to current directory)',
+                                },
+                            },
+                            additionalProperties: false,
+                        },
+                    },
+                    {
+                        name: 'p4.interchanges',
+                        description: 'List changelists not yet integrated between two paths',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                sourcePath: {
+                                    type: 'string',
+                                    description: 'Source depot filespec/path (required)',
+                                },
+                                targetPath: {
+                                    type: 'string',
+                                    description: 'Target depot filespec/path (required)',
+                                },
+                                max: {
+                                    type: 'number',
+                                    description: 'Maximum number of changelists to return (optional)',
+                                },
+                                longDescription: {
+                                    type: 'boolean',
+                                    description: 'Include long descriptions (optional, equivalent to -l)',
+                                },
+                                workspacePath: {
+                                    type: 'string',
+                                    description: 'Path to workspace directory (optional, defaults to current directory)',
+                                },
+                            },
+                            required: ['sourcePath', 'targetPath'],
+                            additionalProperties: false,
+                        },
+                    },
+                    {
+                        name: 'p4.integrated',
+                        description: 'Show integration history for source/target paths',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                sourcePath: {
+                                    type: 'string',
+                                    description: 'Source depot filespec/path (required)',
+                                },
+                                targetPath: {
+                                    type: 'string',
+                                    description: 'Optional target depot filespec/path',
+                                },
+                                workspacePath: {
+                                    type: 'string',
+                                    description: 'Path to workspace directory (optional, defaults to current directory)',
+                                },
+                            },
+                            required: ['sourcePath'],
+                            additionalProperties: false,
+                        },
+                    },
+                    {
+                        name: 'p4.review.bundle',
+                        description: 'Composite review workflow: pending changes with optional details/reviewers',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                counter: {
+                                    type: 'string',
+                                    description: 'Optional review counter/token for p4 review -t',
+                                },
+                                filespec: {
+                                    type: 'string',
+                                    description: 'Optional filespec filter',
+                                },
+                                maxChanges: {
+                                    type: 'number',
+                                    description: 'Maximum changelists to include (optional, default 10)',
+                                },
+                                includeDescribe: {
+                                    type: 'boolean',
+                                    description: 'Include p4 describe data per changelist (optional, default true)',
+                                },
+                                includeReviewers: {
+                                    type: 'boolean',
+                                    description: 'Include p4 reviews per changelist (optional, default true)',
+                                },
+                                workspacePath: {
+                                    type: 'string',
+                                    description: 'Path to workspace directory (optional, defaults to current directory)',
+                                },
+                            },
+                            additionalProperties: false,
+                        },
+                    },
+                    {
+                        name: 'p4.change.inspect',
+                        description: 'Composite changelist inspection: describe + fixes + reviewers (+ optional file history)',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                changelist: {
+                                    type: 'string',
+                                    description: 'Changelist number to inspect (required)',
+                                },
+                                includeDiff: {
+                                    type: 'boolean',
+                                    description: 'Include describe diff content in inspection output (optional, default false)',
+                                },
+                                diffFormat: {
+                                    type: 'string',
+                                    enum: ['u', 'c', 'n', 's'],
+                                    description: 'Diff format for describe when includeDiff=true',
+                                },
+                                includeFileHistory: {
+                                    type: 'boolean',
+                                    description: 'Include p4 filelog for affected files (optional, default false)',
+                                },
+                                maxFilesWithHistory: {
+                                    type: 'number',
+                                    description: 'Maximum files to fetch filelog for (optional, default 5)',
+                                },
+                                maxRevisions: {
+                                    type: 'number',
+                                    description: 'Maximum revisions per filelog call (optional, default 5)',
+                                },
+                                workspacePath: {
+                                    type: 'string',
+                                    description: 'Path to workspace directory (optional, defaults to current directory)',
+                                },
+                            },
+                            required: ['changelist'],
+                            additionalProperties: false,
+                        },
+                    },
+                    {
+                        name: 'p4.path.synccheck',
+                        description: 'Composite path sync analysis using interchanges/integrated in one call',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                sourcePath: {
+                                    type: 'string',
+                                    description: 'Source depot filespec/path (required)',
+                                },
+                                targetPath: {
+                                    type: 'string',
+                                    description: 'Target depot filespec/path (required)',
+                                },
+                                maxInterchanges: {
+                                    type: 'number',
+                                    description: 'Maximum interchanges per direction (optional, default 50)',
+                                },
+                                includeIntegrated: {
+                                    type: 'boolean',
+                                    description: 'Include p4 integrated history (optional, default true)',
+                                },
+                                checkBothDirections: {
+                                    type: 'boolean',
+                                    description: 'Run reverse-direction comparison too (optional, default true)',
+                                },
+                                workspacePath: {
+                                    type: 'string',
+                                    description: 'Path to workspace directory (optional, defaults to current directory)',
+                                },
+                            },
+                            required: ['sourcePath', 'targetPath'],
+                            additionalProperties: false,
+                        },
+                    },
                     {
                         name: 'p4.blame',
                         description: 'Show file annotations with change history (like git blame)',
@@ -819,6 +1268,25 @@ class MCPPerforceServer {
                             additionalProperties: false,
                         },
                     },
+                    {
+                        name: 'p4.annotate',
+                        description: 'Alias of p4.blame (line-by-line annotation)',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                file: {
+                                    type: 'string',
+                                    description: 'File to annotate (required)',
+                                },
+                                workspacePath: {
+                                    type: 'string',
+                                    description: 'Path to workspace directory (optional, defaults to current directory)',
+                                },
+                            },
+                            required: ['file'],
+                            additionalProperties: false,
+                        },
+                    },
                     // Medium Priority Tools
                     {
                         name: 'p4.copy',
@@ -1392,10 +1860,12 @@ class MCPPerforceServer {
                     }
                 }
                 const toolArgs = (args || {});
-                const result = await this.executeToolWithCaching(name, toolArgs);
+                const execution = await this.executeToolWithCaching(name, toolArgs);
+                const result = execution.result;
                 if (WRITE_TOOLS.has(name) && result && typeof result === 'object' && result.ok) {
                     this.clearReadCache();
                 }
+                this.recordToolPerformance(name, Date.now() - startTime, result, execution.cacheStatus, this.extractSubcallCounts(result));
                 // Audit log successful operation
                 this.context.security.logAuditEntry({
                     tool: name,
@@ -1411,6 +1881,7 @@ class MCPPerforceServer {
             catch (error) {
                 const duration = Date.now() - startTime;
                 const errorCode = error instanceof types_js_1.McpError ? error.code : 'INTERNAL_ERROR';
+                this.recordToolPerformance(name, duration, { ok: false, error: { code: String(errorCode) } }, 'uncacheable');
                 log.error('Tool execution error:', error);
                 // Audit log failed operation
                 this.context.security.logAuditEntry({
@@ -1470,7 +1941,14 @@ Environment Variables:
   P4_PRETTY_JSON=true         Pretty-print JSON responses (default: compact JSON)
   P4_RESPONSE_CACHE=false     Disable read-result cache (default: enabled)
   P4_RESPONSE_CACHE_TTL_MS=5000 Cache TTL in ms (default by mode: fast 5000, balanced 3000, secure 1000)
+  P4_RESPONSE_CACHE_TTL_MAP='p4.info=30000,p4.review=2000' Per-tool TTL overrides
   P4_RESPONSE_CACHE_MAX_ENTRIES=400 Max cached responses (default by mode)
+  P4_NEGATIVE_CACHE=false     Disable short-lived caching of predictable read errors
+  P4_NEGATIVE_CACHE_TTL_MS=5000 Negative-cache TTL in ms
+  P4_WORKFLOW_CONCURRENCY=6   Max concurrent subcalls in composite workflow tools
+  P4_LOG_PERF_METRICS=true    Enable periodic performance snapshot logs
+  P4_LOG_PERF_METRICS_INTERVAL_MS=60000 Performance snapshot interval in ms
+  P4_PERF_METRICS_SAMPLE_SIZE=200 Duration sample size per tool for p50/p95
 
 Compliance & Security:
   P4_ENABLE_AUDIT_LOGGING=true|false   Override audit logging (default in fast mode: false)