@certinia/apex-log-mcp 1.0.0

package/dist/tools/findPerformanceBottlenecks.js

@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2025 Certinia Inc. All rights reserved.
+ */
+import { promises as fs } from "fs";
+import { z } from "zod";
+import { parse } from "../ApexLogParser.js";
+import { extractMethods } from "./analyzeLogPerformance.js";
+import { encode } from "@toon-format/toon";
+export const findPerformanceBottlenecksInputSchema = {
+    logFilePath: z
+        .string()
+        .describe("Absolute path to the Apex debug log file (.log)"),
+    analysisType: z
+        .enum(["cpu", "database", "methods", "all"])
+        .optional()
+        .describe('Type of analysis: "cpu" checks CPU time governor limit, "database" checks SOQL query/DML statement/query row limits, "methods" groups methods by namespace with duration totals, "all" runs all three (default)'),
+};
+export const findPerformanceBottlenecksToolConfig = {
+    title: "Find Performance Bottlenecks",
+    description: "Check whether an Apex log transaction is approaching governor limits (flags usage above 80%). Analyzes CPU time, SOQL/DML limits, query rows, and method execution patterns by namespace. Best for checking if a transaction is at risk of hitting governor limits.",
+    inputSchema: findPerformanceBottlenecksInputSchema,
+    annotations: {
+        title: "Find Performance Bottlenecks",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+};
+export const WARNING_THRESHOLD = 80;
+const NS_TO_MS = 1_000_000;
+export async function findPerformanceBottlenecks(args) {
+    const { logFilePath, analysisType = "all" } = args;
+    try {
+        await fs.access(logFilePath);
+    }
+    catch {
+        throw new Error(`Log file not found: ${logFilePath}`);
+    }
+    const logContent = await fs.readFile(logFilePath, "utf-8");
+    const apexLog = parse(logContent);
+    const hasCpuSection = analysisType === "cpu" || analysisType === "all";
+    const bottlenecks = {};
+    if (hasCpuSection) {
+        const cpu = analyzeCPUBottlenecks(apexLog);
+        if (Object.keys(cpu).length > 0) {
+            bottlenecks.cpuBottlenecks = cpu;
+        }
+    }
+    if (analysisType === "database" || analysisType === "all") {
+        const db = analyzeDatabaseBottlenecks(apexLog);
+        if (Object.keys(db).length > 0) {
+            bottlenecks.databaseBottlenecks = db;
+        }
+    }
+    if (analysisType === "methods" || analysisType === "all") {
+        const methods = analyzeMethodBottlenecks(apexLog);
+        if (Object.keys(methods).length > 0) {
+            bottlenecks.methodBottlenecks = methods;
+        }
+    }
+    const governorWarnings = analyzeGovernorLimits(apexLog, hasCpuSection && bottlenecks.cpuBottlenecks !== undefined);
+    if (Object.keys(governorWarnings).length > 0) {
+        bottlenecks.governorLimitWarnings = governorWarnings;
+    }
+    if (Object.keys(bottlenecks).length === 0) {
+        bottlenecks.note =
+            "No performance bottlenecks or governor limit warnings found.";
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: encode(bottlenecks),
+            },
+        ],
+    };
+}
+function analyzeCPUBottlenecks(apexLog) {
+    const { used, limit } = apexLog.governorLimits.cpuTime;
+    const cpuUsagePercent = limit > 0 ? (used / limit) * 100 : 0;
+    if (cpuUsagePercent > WARNING_THRESHOLD) {
+        return {
+            cpuTimeUsed: used,
+            cpuTimeLimit: limit,
+            cpuUsagePercentage: cpuUsagePercent,
+            warning: "High CPU usage detected - consider optimizing algorithms",
+        };
+    }
+    return {};
+}
+function analyzeDatabaseBottlenecks(apexLog) {
+    const governorLimits = apexLog.governorLimits;
+    const bottlenecks = {};
+    const soqlPercentage = governorLimits.soqlQueries.limit > 0
+        ? (governorLimits.soqlQueries.used / governorLimits.soqlQueries.limit) *
+            100
+        : 0;
+    if (soqlPercentage > WARNING_THRESHOLD) {
+        bottlenecks.soqlQueries = {
+            used: governorLimits.soqlQueries.used,
+            limit: governorLimits.soqlQueries.limit,
+            percentage: soqlPercentage,
+        };
+    }
+    const dmlPercentage = governorLimits.dmlStatements.limit > 0
+        ? (governorLimits.dmlStatements.used /
+            governorLimits.dmlStatements.limit) *
+            100
+        : 0;
+    if (dmlPercentage > WARNING_THRESHOLD) {
+        bottlenecks.dmlStatements = {
+            used: governorLimits.dmlStatements.used,
+            limit: governorLimits.dmlStatements.limit,
+            percentage: dmlPercentage,
+        };
+    }
+    const queryRowsPercentage = governorLimits.queryRows.limit > 0
+        ? (governorLimits.queryRows.used / governorLimits.queryRows.limit) * 100
+        : 0;
+    if (queryRowsPercentage > WARNING_THRESHOLD) {
+        bottlenecks.queryRows = {
+            used: governorLimits.queryRows.used,
+            limit: governorLimits.queryRows.limit,
+            percentage: queryRowsPercentage,
+        };
+    }
+    return bottlenecks;
+}
+function analyzeMethodBottlenecks(apexLog) {
+    const methods = extractMethods(apexLog, 0);
+    const methodsByNamespace = methods.reduce((acc, method) => {
+        if (!acc[method.namespace]) {
+            acc[method.namespace] = [];
+        }
+        acc[method.namespace].push(method);
+        return acc;
+    }, {});
+    return {
+        totalMethods: methods.length,
+        methodsByNamespace: Object.keys(methodsByNamespace).map((ns) => ({
+            namespace: ns,
+            methodCount: methodsByNamespace[ns].length,
+            totalDuration: methodsByNamespace[ns].reduce((sum, m) => sum + m.duration, 0) / NS_TO_MS,
+        })),
+    };
+}
+function analyzeGovernorLimits(apexLog, excludeCpuTime) {
+    const limits = apexLog.governorLimits;
+    const result = {};
+    Object.entries(limits).forEach(([key, value]) => {
+        if (key === "byNamespace")
+            return;
+        if (excludeCpuTime && key === "cpuTime")
+            return;
+        if (value.limit > 0) {
+            const percentage = (value.used / value.limit) * 100;
+            if (percentage > WARNING_THRESHOLD) {
+                result[key] = value;
+            }
+        }
+    });
+    return result;
+}
+//# sourceMappingURL=findPerformanceBottlenecks.js.map

package/dist/tools/getLogSummary.js

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2025 Certinia Inc. All rights reserved.
+ */
+import { promises as fs } from "fs";
+import path from "path";
+import { z } from "zod";
+import { parse } from "../ApexLogParser.js";
+import { encode } from "@toon-format/toon";
+export const getLogSummaryInputSchema = {
+    logFilePath: z
+        .string()
+        .describe("Absolute path to the Apex debug log file (.log)"),
+};
+export const getLogSummaryToolConfig = {
+    title: "Get Apex Log Summary",
+    description: "Get a high-level summary of an Apex debug log including total execution time (in ms), method count, SOQL/DML totals, governor limits, and active namespaces. Best for a quick overview before deeper analysis.",
+    inputSchema: getLogSummaryInputSchema,
+    annotations: {
+        title: "Get Apex Log Summary",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+};
+const NS_TO_MS = 1_000_000;
+export async function getLogSummary(args) {
+    const { logFilePath } = args;
+    try {
+        await fs.access(logFilePath);
+    }
+    catch {
+        throw new Error(`Log file not found: ${logFilePath}`);
+    }
+    const logContent = await fs.readFile(logFilePath, "utf-8");
+    const apexLog = parse(logContent);
+    const governorLimits = {};
+    Object.entries(apexLog.governorLimits).forEach(([key, value]) => {
+        if (key !== "byNamespace" && (value.used > 0 || value.limit > 0)) {
+            governorLimits[key] = { used: value.used, limit: value.limit };
+        }
+    });
+    const logIssues = apexLog.logIssues.map((issue) => ({
+        type: issue.type,
+        summary: issue.summary,
+    }));
+    const summary = {
+        file: path.basename(logFilePath),
+        size: apexLog.size,
+        totalExecutionTime: apexLog.duration.total / NS_TO_MS,
+        totalMethods: countMethods(apexLog),
+        totalSOQLQueries: apexLog.soqlCount.total,
+        totalDMLOperations: apexLog.dmlCount.total,
+        totalSOQLRows: apexLog.soqlRowCount.total,
+        totalDMLRows: apexLog.dmlRowCount.total,
+        governorLimits,
+        namespaces: apexLog.namespaces,
+        debugLevels: apexLog.debugLevels.map((d) => ({
+            category: d.logCategory,
+            level: d.logLevel,
+        })),
+        logIssues,
+        parsingErrors: apexLog.parsingErrors.length,
+    };
+    return {
+        content: [
+            {
+                type: "text",
+                text: encode(summary),
+            },
+        ],
+    };
+}
+function countMethods(apexLog) {
+    let count = 0;
+    const traverse = (node) => {
+        if (node.type === "METHOD_ENTRY" ||
+            node.subCategory === "Method") {
+            count++;
+        }
+        if (node.children) {
+            node.children.forEach((child) => traverse(child));
+        }
+    };
+    traverse(apexLog);
+    return count;
+}
+//# sourceMappingURL=getLogSummary.js.map

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@certinia/apex-log-mcp",
+  "version": "1.0.0",
+  "description": "MCP server that gives AI assistants tools to analyze Salesforce Apex debug logs for performance bottlenecks, slow methods, and governor limit usage.",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "apex-log-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "README.md",
+    "LICENSE.txt"
+  ],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "salesforce",
+    "apex",
+    "log-analysis",
+    "debugging",
+    "performance",
+    "ai",
+    "developer-tools",
+    "debug-logs"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": {
+    "name": "Certinia",
+    "url": "https://github.com/certinia"
+  },
+  "license": "BSD-3-Clause",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/certinia/debug-log-analyzer-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/certinia/debug-log-analyzer-mcp/issues"
+  },
+  "homepage": "https://github.com/certinia/debug-log-analyzer-mcp#readme",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@salesforce/core": "^8.26.3",
+    "@toon-format/toon": "^2.1.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@swc/core": "^1.15.18",
+    "@swc/jest": "^0.2.39",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.19.13",
+    "eslint": "^10.0.2",
+    "eslint-plugin-headers": "^1.3.4",
+    "jest": "^30.2.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.56.1"
+  },
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint ./src ./tests"
+  }
+}