@posthog/mcp 0.10.4 → 0.10.5

package/src/extensions/instrument-highlevel.ts

@@ -19,7 +19,7 @@ import {
 import { isContextEnabled } from './context-parameters'
 import { MCPAnalyticsEventType } from './event-types'
 import { getServerTrackingData } from './internal'
-import { log } from './logger'
+import type { LoggerFn } from './logger'
 import { createWrappedTool, getToolFunction, hasToolFunction } from './mcp-sdk-compat'
 import { handleReportMissing, resolveMissingCapabilityToolName } from './tools'
 import {
@@ -28,6 +28,7 @@ import {
   patchRequestHandlers,
   captureToolCall,
   readToolMetaCategory,
+  type HandlerPatch,
 } from './instrumentation'
 import { getContextArgument } from './tracing-helpers'
 
@@ -51,18 +52,22 @@ function isCallbackUpdate(value: unknown): value is { callback: ToolCallback } {
 
 function addTracingToToolRegistry(
   tools: Record<string, RegisteredTool>,
-  server: HighLevelMCPServerLike
+  server: HighLevelMCPServerLike,
+  logger: LoggerFn
 ): Record<string, RegisteredTool> {
   return Object.fromEntries(
-    Object.entries(tools).map(([name, tool]) => [name, addTracingToToolCallbackInternal(tool, name, server)])
+    Object.entries(tools).map(([name, tool]) => [
+      name,
+      addTracingToToolCallbackInternal(tool, name, server, () => tool.inputSchema, logger),
+    ])
   )
 }
 
-function setupListenerToRegisteredTools(server: HighLevelMCPServerLike): void {
+function setupListenerToRegisteredTools(server: HighLevelMCPServerLike, logger: LoggerFn): void {
   try {
     const data = getServerTrackingData(server.server as MCPServerLike)
     if (!data) {
-      log('Warning: Cannot setup listener - no tracking data found')
+      logger('Warning: Cannot setup listener - no tracking data found')
       return
     }
 
@@ -74,19 +79,19 @@ function setupListenerToRegisteredTools(server: HighLevelMCPServerLike): void {
               data.toolDescriptions.set(property, value.description)
             }
             if ((value as ProcessedRegisteredTool)[MCP_ANALYTICS_PROCESSED]) {
-              log(`Tool ${String(property)} already processed, skipping proxy wrapping`)
+              logger(`Tool ${String(property)} already processed, skipping proxy wrapping`)
               return Reflect.set(target, property, value)
             }
 
             if (wrappedCallbacks.has(getToolFunction(value))) {
-              log(`Tool ${String(property)} callback already wrapped, skipping proxy wrapping`)
+              logger(`Tool ${String(property)} callback already wrapped, skipping proxy wrapping`)
               return Reflect.set(target, property, value)
             }
 
             // The MCP SDK's registry copy is currently stale after update(), but keep this lookup lazy so
             // ownership follows the current schema once the registry reflects live tool state.
             const getCurrentInputSchema = () => value.inputSchema
-            const nextValue = addTracingToToolCallbackInternal(value, property, server, getCurrentInputSchema)
+            const nextValue = addTracingToToolCallbackInternal(value, property, server, getCurrentInputSchema, logger)
 
             if (typeof nextValue.update === 'function') {
               const originalUpdate = nextValue.update
@@ -98,7 +103,8 @@ function setupListenerToRegisteredTools(server: HighLevelMCPServerLike): void {
                       { callback: updateObj.callback },
                       property,
                       server,
-                      getCurrentInputSchema
+                      getCurrentInputSchema,
+                      logger
                     )
                     updateObj.callback = getToolFunction(wrappedTool)
                   }
@@ -111,7 +117,7 @@ function setupListenerToRegisteredTools(server: HighLevelMCPServerLike): void {
 
           return Reflect.set(target, property, value)
         } catch (error) {
-          log(`Warning: Error in proxy set handler for tool ${String(property)} - ${error}`)
+          logger(`Warning: Error in proxy set handler for tool ${String(property)} - ${error}`)
           return Reflect.set(target, property, value)
         }
       },
@@ -132,9 +138,9 @@ function setupListenerToRegisteredTools(server: HighLevelMCPServerLike): void {
     const originalTools = server._registeredTools || {}
     server._registeredTools = new Proxy(originalTools, handler)
 
-    log('Successfully set up listener for new tool registrations')
+    logger('Successfully set up listener for new tool registrations')
   } catch (error) {
-    log(`Warning: Failed to setup listener for registered tools - ${error}`)
+    logger(`Warning: Failed to setup listener for registered tools - ${error}`)
   }
 }
 
@@ -151,19 +157,20 @@ function addTracingToToolCallbackInternal(
   tool: RegisteredTool,
   toolName: string,
   server: HighLevelMCPServerLike,
-  getCurrentInputSchema: () => unknown = () => tool.inputSchema
+  getCurrentInputSchema: () => unknown,
+  logger: LoggerFn
 ): RegisteredTool {
   const originalCallback = getToolFunction(tool)
   const options = getServerTrackingData(server.server as MCPServerLike)?.options
   const missingToolName = resolveMissingCapabilityToolName(options)
 
   if (wrappedCallbacks.has(originalCallback)) {
-    log(`Tool ${toolName} callback already wrapped, skipping re-wrap`)
+    logger(`Tool ${toolName} callback already wrapped, skipping re-wrap`)
     return tool
   }
 
   if ((tool as ProcessedRegisteredTool)[MCP_ANALYTICS_PROCESSED]) {
-    log(`Tool ${toolName} already processed, skipping re-wrap`)
+    logger(`Tool ${toolName} already processed, skipping re-wrap`)
     return tool
   }
 
@@ -224,11 +231,12 @@ async function handleToolCallRequest(
   server: MCPServerLike,
   originalCallToolHandler: MCPRequestHandler,
   request: MCPRequest,
-  extra: MCPRequestExtra
+  extra: MCPRequestExtra,
+  logger: LoggerFn
 ): Promise<unknown> {
   const data = getServerTrackingData(server)
   if (!data) {
-    log(
+    logger(
       'Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using tool calls.'
     )
     return await originalCallToolHandler(request, extra)
@@ -243,7 +251,7 @@ async function handleToolCallRequest(
       extra,
       eventType: MCPAnalyticsEventType.mcpMissingCapability,
       explicitContextIntent: context,
-      execute: async () => handleReportMissing({ context }),
+      execute: async () => handleReportMissing({ context }, data.logger),
     })
   }
 
@@ -270,34 +278,32 @@ async function handleToolCallRequest(
   })
 }
 
-export function instrumentHighLevelServer(server: HighLevelMCPServerLike): void {
+export function instrumentHighLevelServer(server: HighLevelMCPServerLike, logger: LoggerFn): void {
   try {
     const lowLevelServer = server.server
     const mcpAnalyticsData = getServerTrackingData(lowLevelServer)
 
     // Patch already existing handlers, and patch setRequestHandler to capture dynamically created handlers.
-    const handlers = {
-      initialize: handleInitializeRequest,
-      'tools/list': handleListToolsRequest,
-      'tools/call': (
-        trackedServer: MCPServerLike,
-        originalHandler: MCPRequestHandler,
-        request: MCPRequest,
-        extra: MCPRequestExtra
-      ) => handleToolCallRequest(server, trackedServer, originalHandler, request, extra),
+    const handlers: Record<string, HandlerPatch> = {
+      initialize: (trackedServer, originalHandler, request, extra) =>
+        handleInitializeRequest(trackedServer, originalHandler, request, extra, logger),
+      'tools/list': (trackedServer, originalHandler, request, extra) =>
+        handleListToolsRequest(trackedServer, originalHandler, request, extra, logger),
+      'tools/call': (trackedServer, originalHandler, request, extra) =>
+        handleToolCallRequest(server, trackedServer, originalHandler, request, extra, logger),
     }
     patchRequestHandlers(lowLevelServer, handlers)
 
-    server._registeredTools = addTracingToToolRegistry(server._registeredTools, server)
+    server._registeredTools = addTracingToToolRegistry(server._registeredTools, server, logger)
 
     if (mcpAnalyticsData) {
       seedToolDescriptionsFromRegistry(mcpAnalyticsData.toolDescriptions, server._registeredTools)
       seedToolCategoriesFromRegistry(mcpAnalyticsData.toolCategories, server._registeredTools)
     }
 
-    setupListenerToRegisteredTools(server)
+    setupListenerToRegisteredTools(server, logger)
   } catch (error) {
-    log(`Warning: Failed to setup tool call instrumentation - ${error}`)
+    logger(`Warning: Failed to setup tool call instrumentation - ${error}`)
   }
 }
 

package/src/extensions/instrument-lowlevel.ts

@@ -7,13 +7,14 @@ import { CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js'
 import type { CompatibleRequestHandlerExtra, MCPRequestLike, MCPServerLike } from '../types'
 import { MCPAnalyticsEventType } from './event-types'
 import { getServerTrackingData } from './internal'
-import { log } from './logger'
+import type { LoggerFn } from './logger'
 import { handleReportMissing, resolveMissingCapabilityToolName } from './tools'
 import {
   handleInitializeRequest,
   handleListToolsRequest,
   patchRequestHandlers,
   captureToolCall,
+  type HandlerPatch,
 } from './instrumentation'
 import { getContextArgument } from './tracing-helpers'
 
@@ -28,22 +29,24 @@ type MCPRequestExtra = Parameters<MCPRequestHandler>[1]
  * `tools/call`. The tool-call lifecycle is delegated to {@link captureToolCall},
  * shared with the high-level wrapper.
  */
-export function instrumentLowLevelServer(server: MCPServerLike): void {
+export function instrumentLowLevelServer(server: MCPServerLike, logger: LoggerFn): void {
   try {
     // Patch already existing handlers, and patch setRequestHandler to capture dynamically created handlers.
-    const handlers = {
-      initialize: handleInitializeRequest,
-      'tools/list': handleListToolsRequest,
+    const handlers: Record<string, HandlerPatch> = {
+      initialize: (server, originalHandler, request, extra) =>
+        handleInitializeRequest(server, originalHandler, request, extra, logger),
+      'tools/list': (server, originalHandler, request, extra) =>
+        handleListToolsRequest(server, originalHandler, request, extra, logger),
     }
     patchRequestHandlers(server, handlers)
 
     const originalCallToolHandler = server._requestHandlers.get('tools/call')
     server.setRequestHandler(
       CallToolRequestSchema,
-      async (request, extra) => await handleToolCallRequest(server, originalCallToolHandler, request, extra)
+      async (request, extra) => await handleToolCallRequest(server, originalCallToolHandler, request, extra, logger)
     )
   } catch (error) {
-    log(`Warning: Failed to setup tool call instrumentation - ${error}`)
+    logger(`Warning: Failed to setup tool call instrumentation - ${error}`)
     throw error
   }
 }
@@ -52,11 +55,12 @@ async function handleToolCallRequest(
   server: MCPServerLike,
   originalCallToolHandler: MCPRequestHandler | undefined,
   request: MCPRequest,
-  extra: MCPRequestExtra
+  extra: MCPRequestExtra,
+  logger: LoggerFn
 ): Promise<unknown> {
   const data = getServerTrackingData(server)
   if (!data) {
-    log(
+    logger(
       'Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using tool calls.'
     )
     return await originalCallToolHandler?.(request, extra)
@@ -71,7 +75,7 @@ async function handleToolCallRequest(
       extra,
       eventType: MCPAnalyticsEventType.mcpMissingCapability,
       explicitContextIntent: context,
-      execute: async () => handleReportMissing({ context }),
+      execute: async () => handleReportMissing({ context }, data.logger),
     })
   }
 

package/src/extensions/instrumentation.ts

@@ -28,7 +28,7 @@ import { MCPAnalyticsEventType } from './event-types'
 import { captureException } from './exceptions'
 import { resolveToolCallIntent, setEventIntent, setExplicitContextIntent } from './intent'
 import { getServerTrackingData, handleIdentify, setServerTrackingData } from './internal'
-import { log } from './logger'
+import type { LoggerFn } from './logger'
 import { buildCapturedMcpParameters } from './mcp-payloads'
 import { getLiteralValue, getObjectShape } from './mcp-sdk-compat'
 import { getSessionId, newSessionId } from './session'
@@ -130,12 +130,12 @@ export async function captureToolCall(params: TraceToolCallParams): Promise<unkn
   try {
     result = await execute(downstreamRequest)
   } catch (error) {
-    publishFailedToolEvent(server, event, error, startTime, conversation)
+    publishFailedToolEvent(server, event, error, startTime, conversation, data.logger)
     throw error
   }
 
   const finalResult = applyConversationPromptBack(event, result, conversation)
-  publishSuccessfulToolEvent(server, event, finalResult, startTime, takeCapturedError)
+  publishSuccessfulToolEvent(server, event, finalResult, startTime, data.logger, takeCapturedError)
   return finalResult
 }
 
@@ -206,7 +206,7 @@ async function prepareToolCallEvent(
     setEventIntent(event, await resolveToolCallIntent(data, request, ownership.context, extra))
     return event
   } catch (error) {
-    log(
+    data.logger(
       `Warning: PostHog MCP analytics instrumentation failed for tool ${request.params?.name}, the tool will still run - ${error}`
     )
     return null
@@ -240,6 +240,7 @@ function publishSuccessfulToolEvent(
   event: McpEvent | null,
   result: unknown,
   startTime: Date,
+  logger: LoggerFn,
   takeCapturedError?: () => unknown
 ): void {
   if (!event) {
@@ -255,9 +256,9 @@ function publishSuccessfulToolEvent(
     }
     event.response = result
     event.duration = Date.now() - startTime.getTime()
-    captureEvent(server, event)
+    captureEvent(server, event, logger)
   } catch (error) {
-    log(`Warning: PostHog MCP analytics failed to publish tool event - ${error}`)
+    logger(`Warning: PostHog MCP analytics failed to publish tool event - ${error}`)
   }
 }
 
@@ -266,7 +267,8 @@ function publishFailedToolEvent(
   event: McpEvent | null,
   error: unknown,
   startTime: Date,
-  conversation: ConversationIdResolution
+  conversation: ConversationIdResolution,
+  logger: LoggerFn
 ): void {
   if (!event) {
     return
@@ -278,9 +280,9 @@ function publishFailedToolEvent(
     event.isError = true
     event.error = captureException(error)
     event.duration = Date.now() - startTime.getTime()
-    captureEvent(server, event)
+    captureEvent(server, event, logger)
   } catch (publishError) {
-    log(`Warning: PostHog MCP analytics failed to publish failed tool event - ${publishError}`)
+    logger(`Warning: PostHog MCP analytics failed to publish failed tool event - ${publishError}`)
   }
 }
 
@@ -336,7 +338,8 @@ export async function handleListToolsRequest(
   server: MCPServerLike,
   originalListToolsHandler: MCPRequestHandler,
   request: MCPRequestLike,
-  extra?: CompatibleRequestHandlerExtra
+  extra: CompatibleRequestHandlerExtra | undefined,
+  logger: LoggerFn
 ): Promise<{ tools: ListToolsResult['tools'] }> {
   const data = getServerTrackingData(server)
   const startTime = new Date()
@@ -352,23 +355,23 @@ export async function handleListToolsRequest(
     await applyResolvedMetadata(event, data, request, extra)
   }
 
-  const tools = await getTracedToolsList(server, originalListToolsHandler, request, extra, event)
+  const tools = await getTracedToolsList(server, originalListToolsHandler, request, extra, event, logger)
 
   if (!data) {
-    log(
+    logger(
       'Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using tool calls.'
     )
     return { tools }
   }
 
   if (tools.length === 0) {
-    log(
+    data.logger(
       'Warning: No tools found in the original list. This is likely due to the tools not being registered before PostHog MCP analytics.instrument().'
     )
     event.error = captureException('No tools were sent to MCP client.')
     event.isError = true
     event.duration = Date.now() - startTime.getTime()
-    captureEvent(server, event)
+    captureEvent(server, event, data.logger)
     return { tools }
   }
 
@@ -376,7 +379,7 @@ export async function handleListToolsRequest(
   event.listedToolNames = collectListedToolNames(tools)
   event.isError = false
   event.duration = Date.now() - startTime.getTime()
-  captureEvent(server, event)
+  captureEvent(server, event, data.logger)
   return { tools }
 }
 
@@ -405,7 +408,8 @@ async function getTracedToolsList(
   originalListToolsHandler: MCPRequestHandler,
   request: MCPRequestLike,
   extra: CompatibleRequestHandlerExtra | undefined,
-  event: McpEvent
+  event: McpEvent,
+  logger: LoggerFn
 ): Promise<ListToolsResult['tools']> {
   try {
     const data = getServerTrackingData(server)
@@ -417,11 +421,11 @@ async function getTracedToolsList(
     }
 
     if (data && isContextEnabled(data.options.context)) {
-      tools = addContextParameterToTools(tools, getContextDescription(data.options.context))
+      tools = addContextParameterToTools(tools, getContextDescription(data.options.context), data.logger)
     }
 
     if (data?.options.enableConversationId) {
-      tools = addConversationIdToTools(tools, resolveMissingCapabilityToolName(data.options))
+      tools = addConversationIdToTools(tools, resolveMissingCapabilityToolName(data.options), data.logger)
     }
 
     if (data?.options.reportMissing) {
@@ -439,13 +443,13 @@ async function getTracedToolsList(
 
     return tools
   } catch (error) {
-    log(
+    logger(
       `Warning: Original list tools handler failed, this suggests an error PostHog MCP analytics did not cause - ${error}`
     )
     event.error = captureException(error)
     event.isError = true
     event.duration = event.timestamp ? Date.now() - event.timestamp.getTime() : 0
-    captureEvent(server, event)
+    captureEvent(server, event, logger)
     throw error
   }
 }
@@ -541,7 +545,7 @@ function mintStatelessSessionOnInitialize(
     setServerTrackingData(server, data)
     return sessionId
   } catch (error) {
-    log(`Warning: PostHog MCP analytics failed to mint a stateless session id - ${error}`)
+    data.logger(`Warning: PostHog MCP analytics failed to mint a stateless session id - ${error}`)
     return undefined
   }
 }
@@ -571,7 +575,7 @@ function upgradeMintedTokenToNegotiated(
     })
     writeSessionIdToTransport(transport, token)
   } catch (error) {
-    log(`Warning: PostHog MCP analytics failed to upgrade the stateless session token - ${error}`)
+    data.logger(`Warning: PostHog MCP analytics failed to upgrade the stateless session token - ${error}`)
   }
 }
 
@@ -599,11 +603,12 @@ export async function handleInitializeRequest(
   server: MCPServerLike,
   originalInitializeHandler: MCPRequestHandler,
   request: MCPRequestLike,
-  extra?: CompatibleRequestHandlerExtra
+  extra: CompatibleRequestHandlerExtra | undefined,
+  logger: LoggerFn
 ): Promise<unknown> {
   const data = getServerTrackingData(server)
   if (!data) {
-    log(
+    logger(
       'Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using tool calls.'
     )
     return await originalInitializeHandler(request, extra)
@@ -640,7 +645,7 @@ export async function handleInitializeRequest(
   if (mintedSessionId) {
     upgradeMintedTokenToNegotiated(server, data, mintedSessionId, negotiatedProtocolVersion)
   }
-  captureEvent(server, event)
+  captureEvent(server, event, data.logger)
   return result
 }
 

package/src/extensions/intent.ts

@@ -11,7 +11,6 @@ import type {
   McpEvent,
 } from '../types'
 import { isContextEnabled } from './context-parameters'
-import { log } from './logger'
 
 interface ResolvedIntent {
   intent: string
@@ -45,7 +44,7 @@ async function runIntentFallback(
     const intent = normalizeIntent(await data.options.intentFallback(request, extra))
     return intent ? { intent, source: 'inferred' } : null
   } catch (error) {
-    log(`intentFallback callback error: ${error}`)
+    data.logger(`intentFallback callback error: ${error}`)
     return null
   }
 }

package/src/extensions/internal.ts

@@ -12,7 +12,6 @@ import type {
   UserIdentity,
 } from '../types'
 import { MCPAnalyticsEventType } from './event-types'
-import { log } from './logger'
 import { captureEvent } from './capture'
 import { stampMetaClientInfo } from './client-identity'
 
@@ -169,14 +168,16 @@ export async function handleIdentify(
       data.identifiedSessions.set(sessionId, mergedIdentity)
 
       if (shouldPublish) {
-        log(`Identified session ${sessionId} with identity: ${JSON.stringify(mergedIdentity)}`)
-        captureEvent(server, identifyEvent)
+        data.logger(`Identified session ${sessionId}`)
+        captureEvent(server, identifyEvent, data.logger)
       }
     } else {
-      log(`Warning: Supplied identify function returned null for session ${sessionId}`)
+      data.logger(`Warning: Supplied identify function returned null for session ${sessionId}`)
     }
   } catch (error) {
-    log(`Error: User supplied identify function threw an error while identifying session ${sessionId} - ${error}`)
+    data.logger(
+      `Error: User supplied identify function threw an error while identifying session ${sessionId} - ${error}`
+    )
   }
 }
 
@@ -196,7 +197,7 @@ export async function resolveEventProperties(
   try {
     return (await data.options.eventProperties(request, extra)) ?? null
   } catch (e) {
-    log(`eventProperties callback error: ${e}`)
+    data.logger(`eventProperties callback error: ${e}`)
     return null
   }
 }

package/src/extensions/logger.ts

@@ -8,10 +8,11 @@
  *
  * MCP servers running over the STDIO transport use stdout/stderr to exchange
  * protocol messages, so we cannot use the default `console.log`. We accept a
- * `logger` option on the public API; when omitted, log calls are silently
- * dropped. Errors that affect tracking should still be observable in apps that
- * want them, so the consumer can plug in any function (e.g. `console.error`
- * for non-STDIO transports, a file logger, etc.).
+ * `logger` option on the public API or the legacy logger configured through
+ * `setLogger`; when neither is configured, log calls are silently dropped.
+ * Errors that affect tracking should still be observable in apps that want
+ * them, so the consumer can plug in any function (e.g. `console.error` for
+ * non-STDIO transports, a file logger, etc.).
  */
 export type LoggerFn = (message: string) => void
 
@@ -21,12 +22,26 @@ export function setLogger(logger: LoggerFn | undefined): void {
   activeLogger = logger
 }
 
-export function log(message: string): void {
-  if (activeLogger) {
+function writeLog(logger: LoggerFn | undefined, message: string): void {
+  if (logger) {
     try {
-      activeLogger(message)
+      logger(message)
     } catch {
       // never let logging blow up the tracking pipeline
     }
   }
 }
+
+/**
+ * Creates a safe logger for one instrumented server. A server-specific logger
+ * remains isolated, while an omitted logger preserves the legacy `setLogger`
+ * fallback.
+ */
+export function createLogger(logger: LoggerFn | undefined): LoggerFn {
+  return logger ? (message) => writeLog(logger, message) : log
+}
+
+/** Logs through the legacy module-level logger configured by {@link setLogger}. */
+export function log(message: string): void {
+  writeLog(activeLogger, message)
+}

package/src/extensions/sink.ts

@@ -7,7 +7,7 @@ import type { PostHog } from 'posthog-node'
 import { uuidv7 } from '@posthog/core'
 
 import type { BeforeSendFn, Event, McpEvent } from '../types'
-import { log } from './logger'
+import { log, type LoggerFn } from './logger'
 import { type PostHogCaptureEvent, buildPostHogCaptureEvents } from './posthog-events'
 import { newPrefixedId } from './ids'
 import { sanitizeEvent } from './sanitization'
@@ -33,21 +33,22 @@ export interface McpCaptureOptions {
  */
 export async function processMcpEvent(
   event: McpEvent,
-  options: McpCaptureOptions
+  options: McpCaptureOptions,
+  logger: LoggerFn = log
 ): Promise<{ event: Event; captures: PostHogCaptureEvent[] } | null> {
   let processed: McpEvent = event
 
   try {
     processed = sanitizeEvent(processed)
   } catch (err) {
-    log(`Failed to sanitize event: ${err}`)
+    logger(`Failed to sanitize event: ${err}`)
     return null
   }
 
   try {
     processed = truncateEvent(processed)
   } catch (err) {
-    log(`Failed to truncate event: ${err}`)
+    logger(`Failed to truncate event: ${err}`)
     return null
   }
 
@@ -58,7 +59,7 @@ export async function processMcpEvent(
     enableExceptionAutocapture: options.enableExceptionAutocapture,
   })
 
-  const captures = await applyBeforeSend(built, options.beforeSend)
+  const captures = await applyBeforeSend(built, options.beforeSend, logger)
 
   return { event: fullEvent, captures }
 }
@@ -69,7 +70,8 @@ export async function processMcpEvent(
  */
 async function applyBeforeSend(
   captures: PostHogCaptureEvent[],
-  beforeSend: BeforeSendFn | undefined
+  beforeSend: BeforeSendFn | undefined,
+  logger: LoggerFn
 ): Promise<PostHogCaptureEvent[]> {
   if (!beforeSend) {
     return captures
@@ -83,7 +85,7 @@ async function applyBeforeSend(
         kept.push(result)
       }
     } catch (err) {
-      log(`beforeSend threw for event ${capture.event}; dropping it: ${err}`)
+      logger(`beforeSend threw for event ${capture.event}; dropping it: ${err}`)
     }
   }
   return kept
@@ -99,7 +101,10 @@ async function applyBeforeSend(
  * `@posthog/ai`).
  */
 export class McpEventSink {
-  constructor(private readonly posthog: PostHog) {}
+  constructor(
+    private readonly posthog: PostHog,
+    private readonly logger: LoggerFn = log
+  ) {}
 
   /**
    * Push an MCP event through the pipeline (sanitize → truncate → fan out →
@@ -107,7 +112,7 @@ export class McpEventSink {
    * dropped, never re-thrown into tool code.
    */
   async capture(event: McpEvent, options: McpCaptureOptions): Promise<void> {
-    const result = await processMcpEvent(event, options)
+    const result = await processMcpEvent(event, options, this.logger)
     if (!result) {
       return
     }
@@ -132,13 +137,13 @@ export class McpEventSink {
           uuid: uuidv7(),
         })
       }
-      log(
+      this.logger(
         `Captured PostHog event ${fullEvent.id} | ${fullEvent.eventType} | ${fullEvent.duration} ms | ${
-          fullEvent.identifyActorGivenId || 'anonymous'
+          fullEvent.identifyActorGivenId ? 'identified' : 'anonymous'
         }`
       )
     } catch (err) {
-      log(`Failed to capture PostHog event ${fullEvent.id}: ${err}`)
+      this.logger(`Failed to capture PostHog event ${fullEvent.id}: ${err}`)
     }
   }
 }