Use extractRelevantLogInfo() to extract relevant log information from worker log event in order to avoid issues with overwhelming models with too much context

Author: Maximo-Guk

apps/workers-observability/src/index.ts

@@ -24,7 +24,7 @@ export type Props = {
 
 export type State = { activeAccountId: string | null }
 
-export class MyMCP extends McpAgent<Env, State, Props> {
+export class ObservabilityMCP extends McpAgent<Env, State, Props> {
 	server = new McpServer({
 		name: 'Remote MCP Server with Workers Observability',
 		version: '1.0.0',
@@ -69,7 +69,7 @@ export class MyMCP extends McpAgent<Env, State, Props> {
 export default new OAuthProvider({
 	apiRoute: '/sse',
 	// @ts-ignore
-	apiHandler: MyMCP.mount('/sse'),
+	apiHandler: ObservabilityMCP.mount('/sse'),
 	// @ts-ignore
 	defaultHandler: CloudflareAuthHandler,
 	authorizeEndpoint: '/oauth/authorize',

apps/workers-observability/src/tools/logs.ts

@@ -2,7 +2,90 @@ import { z } from 'zod'
 
 import { handleWorkerLogs, handleWorkerLogsKeys } from '@repo/mcp-common/src/api/workers-logs'
 
-import type { MyMCP } from '../index'
+import type { zReturnedQueryRunEvents } from '@repo/mcp-common/src/types/workers-logs-schemas'
+import type { ObservabilityMCP } from '../index'
+
+type RelevantLogInfo = z.infer<typeof RelevantLogInfoSchema>
+const RelevantLogInfoSchema = z.object({
+	timestamp: z.string(),
+	path: z.string().nullable(),
+	method: z.string().nullable(),
+	status: z.number().nullable(),
+	outcome: z.string(),
+	eventType: z.string(),
+	duration: z.number().nullable(),
+	error: z.string().nullable(),
+	message: z.string().nullable(),
+	requestId: z.string(),
+	rayId: z.string().nullable(),
+	exceptionStack: z.string().nullable(),
+})
+
+/**
+ * Extracts only the most relevant information from a worker log event ( this is to avoid crashing Claude when returning too much data )
+ * @param event z.array(zReturnedTelemetryEvent).optional()
+ * @returns Relevant information extracted from the log
+ */
+function extractRelevantLogInfo(events: zReturnedQueryRunEvents['events'] = []): RelevantLogInfo[] {
+	return events.map((event) => {
+		const workers = event.$workers
+		const metadata = event.$metadata
+		const source = event.source
+
+		let path = null
+		let method = null
+		let status = null
+		if (workers?.event?.request) {
+			path = workers.event.request.path ?? null
+			method = workers.event.request.method ?? null
+		}
+
+		if (workers?.event?.response) {
+			status = workers.event.response.status ?? null
+		}
+
+		let error = null
+		if (metadata.error) {
+			error = metadata.error
+		}
+
+		let message = metadata?.message ?? null
+		if (!message) {
+			if (workers?.event?.rpcMethod) {
+				message = `RPC: ${workers.event.rpcMethod}`
+			} else if (path && method) {
+				message = `${method} ${path}`
+			}
+		}
+
+		// Calculate duration
+		const duration = (workers?.wallTimeMs || 0) + (workers?.cpuTimeMs || 0)
+
+		// Extract rayId if available
+		const rayId = workers?.event?.rayId ?? null
+
+		let exceptionStack = null
+		// Extract exception stack if available
+		if (typeof source !== 'string') {
+			exceptionStack = source?.exception?.stack ?? null
+		}
+
+		return {
+			timestamp: new Date(event.timestamp).toISOString(),
+			path,
+			method,
+			status,
+			outcome: workers?.outcome || 'unknown',
+			eventType: workers?.eventType || 'unknown',
+			duration: duration || null,
+			error,
+			message,
+			requestId: workers?.requestId || metadata?.id || 'unknown',
+			rayId,
+			exceptionStack,
+		}
+	})
+}
 
 // Worker logs parameter schema
 const workerNameParam = z.string().describe('The name of the worker to analyze logs for')
@@ -27,7 +110,7 @@ const rayIdParam = z.string().optional().describe('Filter logs by specific Cloud
  * @param accountId Cloudflare account ID
  * @param apiToken Cloudflare API token
  */
-export function registerLogsTools(agent: MyMCP) {
+export function registerLogsTools(agent: ObservabilityMCP) {
 	// Register the worker logs analysis tool by worker name
 	agent.server.tool(
 		'worker_logs_by_worker_name',
@@ -125,12 +208,13 @@ export function registerLogsTools(agent: MyMCP) {
 					shouldFilterErrors,
 					rayId,
 				})
+				const events = logs?.events?.events ?? []
 				return {
 					content: [
 						{
 							type: 'text',
 							text: JSON.stringify({
-								logs,
+								events: extractRelevantLogInfo(events),
 								stats: {
 									timeRange: {
 										from,

packages/mcp-common/src/api/workers-logs.ts

@@ -1,5 +1,5 @@
 import { fetchCloudflareApi } from '../cloudflare-api'
-import { zKeysResponse, zReturnedQueryRunResult } from '../schemas/workers-logs-schemas'
+import { zKeysResponse, zReturnedQueryRunResult } from '../types/workers-logs-schemas'
 import { V4Schema } from '../v4-api'
 
 /**

packages/mcp-common/src/schemas/workers-logs-schemas.ts renamed to packages/mcp-common/src/types/workers-logs-schemas.ts

@@ -115,8 +115,27 @@ export const zStatistics = z.object({
 	bytes_read: z.number(),
 })
 
+const zCloudflareMiniEventDetailsRequest = z.object({
+	url: z.string().optional(),
+	method: z.string().optional(),
+	path: z.string().optional(),
+	search: z.record(z.string()).optional(),
+})
+
+const zCloudflareMiniEventDetailsResponse = z.object({
+	status: z.number().optional(),
+})
+
+const zCloudflareMiniEventDetails = z.object({
+	request: zCloudflareMiniEventDetailsRequest.optional(),
+	response: zCloudflareMiniEventDetailsResponse.optional(),
+	rpcMethod: z.string().optional(),
+	rayId: z.string().optional(),
+	executionModel: z.string().optional(),
+})
+
 export const zCloudflareMiniEvent = z.object({
-	event: z.record(z.string(), z.unknown()).optional(),
+	event: zCloudflareMiniEventDetails,
 	scriptName: z.string(),
 	outcome: z.string(),
 	eventType: z.enum([
@@ -161,10 +180,21 @@ export const zCloudflareEvent = zCloudflareMiniEvent.extend({
 	cpuTimeMs: z.number(),
 })
 
+const zSourceSchema = z.object({
+	exception: z
+		.object({
+			stack: z.string().optional(),
+			name: z.string().optional(),
+			message: z.string().optional(),
+			timestamp: z.number().optional(),
+		})
+		.optional(),
+})
+
 export const zReturnedTelemetryEvent = z.object({
 	dataset: z.string(),
 	timestamp: z.number().int().positive(),
-	source: z.union([z.string(), z.object({})]),
+	source: z.union([z.string(), zSourceSchema]),
 	$workers: z.union([zCloudflareMiniEvent, zCloudflareEvent]).optional(),
 	$metadata: z.object({
 		id: z.string(),
@@ -198,6 +228,7 @@ export const zReturnedTelemetryEvent = z.object({
 	}),
 })
 
+export type zReturnedQueryRunEvents = z.infer<typeof zReturnedQueryRunEvents>
 export const zReturnedQueryRunEvents = z.object({
 	events: z.array(zReturnedTelemetryEvent).optional(),
 	fields: z