@openrewrite/rewrite 8.63.0 → 8.63.2

package/src/rpc/request/metrics.ts

@@ -78,69 +78,75 @@ export function initializeMetricsCsv(metricsCsv?: string, logger?: rpc.Logger):
     }
 }
 
-/**
- * Internal function to wrap a handler with metrics recording.
- */
-async function wrapWithMetrics<R>(
-    handler: () => Promise<R>,
-    target: { target: string },
-    request: string,
-    metricsCsv?: string
-): Promise<R> {
-    if (!metricsCsv) {
-        // No metrics recording requested, just execute the handler
-        return handler();
-    }
-
-    const startTime = Date.now();
-
-    try {
-        const result = await handler();
-        recordMetrics(metricsCsv, target.target, request, startTime);
-        return result;
-    } catch (error) {
-        recordMetrics(metricsCsv, target.target, request, startTime);
-        throw error;
-    }
-}
-
 /**
  * Wraps an RPC request handler to record performance metrics to a CSV file.
  *
- * @param request The request type name (e.g., "Visit", "GetObject")
- * @param target A mutable object containing the target identifier for metrics
+ * @param requestType The request type name (e.g., "Visit", "GetObject")
  * @param metricsCsv Optional path to the CSV file for recording metrics
- * @returns A function that wraps a request handler with metrics recording
+ * @param handlerFactory A function that creates the handler with a mutable context for setting the target
+ * @returns A request handler compatible with rpc.MessageConnection#onRequest
  */
 export function withMetrics<P, R>(
-    request: string,
-    target: { target: string },
-    metricsCsv?: string
-): (handler: (request: P) => Promise<R>) => (request: P) => Promise<R> {
-    return (handler: (requestParam: P) => Promise<R>) => {
-        return async (requestParam: P): Promise<R> => {
-            return wrapWithMetrics(() => handler(requestParam), target, request, metricsCsv);
-        };
+    requestType: string,
+    metricsCsv: string | undefined,
+    handlerFactory: (context: {target: string}) => (request: P) => Promise<R>
+): (request: P) => Promise<R> {
+    return async (request: P): Promise<R> => {
+        const context = {target: ''};
+        const handler = handlerFactory(context);
+
+        if (!metricsCsv) {
+            // No metrics recording requested, just execute the handler
+            return await handler(request);
+        }
+
+        const startTime = Date.now();
+
+        try {
+            const result = await handler(request);
+            recordMetrics(metricsCsv, context.target, requestType, startTime);
+            return result;
+        } catch (error) {
+            // On error, still try to record metrics with the target (maybe empty)
+            recordMetrics(metricsCsv, context.target, requestType, startTime);
+            throw error;
+        }
     };
 }
 
 /**
  * Wraps an RPC request handler without parameters (RequestType0) to record performance metrics.
  *
- * @param request The request type name (e.g., "GetLanguages", "GetRecipes")
- * @param target A mutable object containing the target identifier for metrics
+ * @param requestType The request type name (e.g., "GetLanguages", "GetRecipes")
  * @param metricsCsv Optional path to the CSV file for recording metrics
- * @returns A function that wraps a request handler with metrics recording
+ * @param handlerFactory A function that creates the handler with a mutable context for setting the target
+ * @returns A request handler compatible with rpc.MessageConnection#onRequest
  */
 export function withMetrics0<R>(
-    request: string,
-    target: { target: string },
-    metricsCsv?: string
-): (handler: () => Promise<R>) => (token: any) => Promise<R> {
-    return (handler: () => Promise<R>) => {
-        return async (_: any): Promise<R> => {
-            return wrapWithMetrics(handler, target, request, metricsCsv);
-        };
+    requestType: string,
+    metricsCsv: string | undefined,
+    handlerFactory: (context: {target: string}) => () => Promise<R>
+): (token: any) => Promise<R> {
+    return async (_: any): Promise<R> => {
+        const context = {target: ''};
+        const handler = handlerFactory(context);
+
+        if (!metricsCsv) {
+            // No metrics recording requested, just execute the handler
+            return await handler();
+        }
+
+        const startTime = Date.now();
+
+        try {
+            const result = await handler();
+            recordMetrics(metricsCsv, context.target, requestType, startTime);
+            return result;
+        } catch (error) {
+            // On error, still try to record metrics with the target (may be empty)
+            recordMetrics(metricsCsv, context.target, requestType, startTime);
+            throw error;
+        }
     };
 }
 

package/src/rpc/request/parse.ts

@@ -29,33 +29,39 @@ export class Parse {
     static handle(connection: rpc.MessageConnection,
                   localObjects: Map<string, ((input: string) => any) | any>,
                   metricsCsv?: string): void {
-        const target = { target: '' };
-        connection.onRequest(new rpc.RequestType<Parse, UUID[], Error>("Parse"), withMetrics<Parse, UUID[]>("Parse", target, metricsCsv)(async (request) => {
-            // Set target to comma-separated list of file paths
-            target.target = request.inputs.map(input =>
-                typeof input === 'string' ? input : input.sourcePath
-            ).join(',');
-            let parser = Parsers.createParser("javascript", {
-                ctx: new ExecutionContext(),
-                relativeTo: request.relativeTo
-            });
+        connection.onRequest(
+            new rpc.RequestType<Parse, UUID[], Error>("Parse"),
+            withMetrics<Parse, UUID[]>(
+                "Parse",
+                metricsCsv,
+                (context) => async (request) => {
+                    // Set target to comma-separated list of file paths
+                    context.target = request.inputs.map(input =>
+                        typeof input === 'string' ? input : input.sourcePath
+                    ).join(',');
 
-            if (!parser) {
-                return [];
-            }
-            const generator = parser.parse(...request.inputs);
-            const result: UUID[] = [];
+                    const parser = Parsers.createParser("javascript", {
+                        ctx: new ExecutionContext(),
+                        relativeTo: request.relativeTo
+                    })!;
 
-            for (let i = 0; i < request.inputs.length; i++) {
-                const id = randomId();
-                localObjects.set(id, async (id: string) => {
-                    let sourceFile: SourceFile = (await generator.next()).value;
-                    return produce(sourceFile, (draft) => {draft.id = id;});
-                });
-                result.push(id);
-            }
+                    const generator = parser.parse(...request.inputs);
+                    const resultIds: UUID[] = [];
 
-            return result;
-        }));
+                    for (let i = 0; i < request.inputs.length; i++) {
+                        const id = randomId();
+                        localObjects.set(id, async (id: string) => {
+                            const sourceFile: SourceFile = (await generator.next()).value;
+                            return produce(sourceFile, (draft) => {
+                                draft.id = id;
+                            });
+                        });
+                        resultIds.push(id);
+                    }
+
+                    return resultIds;
+                }
+            )
+        );
     }
 }

package/src/rpc/request/prepare-recipe.ts

@@ -32,33 +32,41 @@ export class PrepareRecipe {
                   preparedRecipes: Map<String, Recipe>,
                   metricsCsv?: string) {
         const snowflake = SnowflakeId();
-        const target = { target: '' };
-        connection.onRequest(new rpc.RequestType<PrepareRecipe, PrepareRecipeResponse, Error>("PrepareRecipe"), withMetrics<PrepareRecipe, PrepareRecipeResponse>("PrepareRecipe", target, metricsCsv)(async (request) => {
-            target.target = request.id;
-            const id = snowflake.generate();
-            const recipeCtor = registry.all.get(request.id);
-            if (!recipeCtor) {
-                throw new Error(`Could not find recipe with id ${request.id}`);
-            }
-            let recipe = new recipeCtor(request.options);
+        connection.onRequest(
+            new rpc.RequestType<PrepareRecipe, PrepareRecipeResponse, Error>("PrepareRecipe"),
+            withMetrics<PrepareRecipe, PrepareRecipeResponse>(
+                "PrepareRecipe",
+                metricsCsv,
+                (context) => async (request) => {
+                    context.target = request.id;
+                    const id = snowflake.generate();
+                    const recipeCtor = registry.all.get(request.id);
+                    if (!recipeCtor) {
+                        throw new Error(`Could not find recipe with id ${request.id}`);
+                    }
+                    let recipe = new recipeCtor(request.options);
 
-            const editPreconditions: Precondition[] = [];
-            recipe = await this.optimizePreconditions(recipe, "edit", editPreconditions);
+                    const editPreconditions: Precondition[] = [];
+                    recipe = await this.optimizePreconditions(recipe, "edit", editPreconditions);
 
-            const scanPreconditions: Precondition[] = [];
-            recipe = await this.optimizePreconditions(recipe, "scan", scanPreconditions);
+                    const scanPreconditions: Precondition[] = [];
+                    recipe = await this.optimizePreconditions(recipe, "scan", scanPreconditions);
 
-            preparedRecipes.set(id, recipe);
+                    preparedRecipes.set(id, recipe);
 
-            return {
-                id: id,
-                descriptor: await recipe.descriptor(),
-                editVisitor: `edit:${id}`,
-                editPreconditions: editPreconditions,
-                scanVisitor: recipe instanceof ScanningRecipe ? `scan:${id}` : undefined,
-                scanPreconditions: scanPreconditions
-            }
-        }));
+                    const result = {
+                        id: id,
+                        descriptor: await recipe.descriptor(),
+                        editVisitor: `edit:${id}`,
+                        editPreconditions: editPreconditions,
+                        scanVisitor: recipe instanceof ScanningRecipe ? `scan:${id}` : undefined,
+                        scanPreconditions: scanPreconditions
+                    };
+
+                    return result;
+                }
+            )
+        );
     }
 
     /**

package/src/rpc/request/print.ts

@@ -17,7 +17,7 @@ import * as rpc from "vscode-jsonrpc/node";
 import {isSourceFile, Tree} from "../../tree";
 import {MarkerPrinter as PrintMarkerPrinter, printer, PrintOutputCapture} from "../../print";
 import {UUID} from "../../uuid";
-import {withMetrics, extractSourcePath} from "./metrics";
+import {extractSourcePath, withMetrics} from "./metrics";
 
 export const enum MarkerPrinter {
     DEFAULT = "DEFAULT",
@@ -26,22 +26,36 @@ export const enum MarkerPrinter {
 }
 
 export class Print {
-    constructor(private readonly treeId: UUID, private readonly sourceFileType: string, readonly markerPrinter: MarkerPrinter = MarkerPrinter.DEFAULT) {
+    constructor(private readonly treeId: UUID,
+                private readonly sourceFileType: string,
+                readonly markerPrinter: MarkerPrinter = MarkerPrinter.DEFAULT) {
     }
 
     static handle(connection: rpc.MessageConnection,
-                  getObject: (id: string, sourceFileType?: string) => any,
+                  getObject: (id: string, sourceFileType: string) => any,
+                  logger?: rpc.Logger,
                   metricsCsv?: string): void {
-        const target = { target: '' };
-        connection.onRequest(new rpc.RequestType<Print, string, Error>("Print"), withMetrics<Print, string>("Print", target, metricsCsv)(async request => {
-            const tree: Tree = await getObject(request.treeId.toString(), request.sourceFileType);
-            target.target = extractSourcePath(tree);
-            const out = new PrintOutputCapture(PrintMarkerPrinter[request.markerPrinter]);
-            if (isSourceFile(tree)) {
-                return await printer(tree).print(tree, out);
-            } else {
-                return await printer(request.sourceFileType).print(tree, out);
-            }
-        }));
+        connection.onRequest(
+            new rpc.RequestType<Print, string, Error>("Print"),
+            withMetrics<Print, string>(
+                "Print",
+                metricsCsv,
+                (context) => async request => {
+                    const tree: Tree = await getObject(request.treeId.toString(), request.sourceFileType);
+                    context.target = extractSourcePath(tree);
+                    if (logger) {
+                        logger.log("Printing " + (isSourceFile(tree) ? tree.sourcePath : `tree of type ${tree.kind} in ${context.target}`));
+                    }
+                    const out = new PrintOutputCapture(PrintMarkerPrinter[request.markerPrinter]);
+                    let result: string;
+                    if (isSourceFile(tree)) {
+                        result = await printer(tree).print(tree, out);
+                    } else {
+                        result = await printer(request.sourceFileType).print(tree, out);
+                    }
+                    return result;
+                }
+            )
+        );
     }
 }

package/src/rpc/request/trace-get-object.ts

@@ -0,0 +1,4 @@
+export interface TraceGetObject {
+    receive: boolean
+    send: boolean
+}

package/src/rpc/request/visit.ts

@@ -40,24 +40,30 @@ export class Visit {
                   getObject: (id: string, sourceFileType?: string) => any,
                   getCursor: (cursorIds: string[] | undefined, sourceFileType?: string) => Promise<Cursor>,
                   metricsCsv?: string): void {
-        const target = { target: '' };
-        connection.onRequest(new rpc.RequestType<Visit, VisitResponse, Error>("Visit"), withMetrics<Visit, VisitResponse>("Visit", target, metricsCsv)(async (request) => {
-            const p = await getObject(request.p, undefined);
-            const before: Tree = await getObject(request.treeId, request.sourceFileType);
-            const cursor = await getCursor(request.cursor, request.sourceFileType);
-            target.target = extractSourcePath(before, cursor);
-            localObjects.set(before.id.toString(), before);
+        connection.onRequest(
+            new rpc.RequestType<Visit, VisitResponse, Error>("Visit"),
+            withMetrics<Visit, VisitResponse>(
+                "Visit",
+                metricsCsv,
+                (context) => async (request) => {
+                    const p = await getObject(request.p, undefined);
+                    const before: Tree = await getObject(request.treeId, request.sourceFileType);
+                    const cursor = await getCursor(request.cursor, request.sourceFileType);
+                    context.target = extractSourcePath(before, cursor);
+                    localObjects.set(before.id.toString(), before);
 
-            const visitor = await Visit.instantiateVisitor(request, preparedRecipes, recipeCursors, p);
-            const after = await visitor.visit(before, p, cursor);
-            if (!after) {
-                localObjects.delete(before.id.toString());
-            } else if (after !== before) {
-                localObjects.set(after.id.toString(), after);
-            }
+                    const visitor = await Visit.instantiateVisitor(request, preparedRecipes, recipeCursors, p);
+                    const after = await visitor.visit(before, p, cursor);
+                    if (!after) {
+                        localObjects.delete(before.id.toString());
+                    } else if (after !== before) {
+                        localObjects.set(after.id.toString(), after);
+                    }
 
-            return {modified: before !== after};
-        }));
+                    return {modified: before !== after};
+                }
+            )
+        );
     }
 
     private static async instantiateVisitor(request: Visit,

package/src/rpc/rewrite-rpc.ts

@@ -19,13 +19,15 @@ import {Cursor, isSourceFile, isTree, rootCursor, SourceFile, Tree} from "../tre
 import {Recipe, RecipeDescriptor, RecipeRegistry} from "../recipe";
 import {SnowflakeId} from "@akashrajpurohit/snowflake-id";
 import {
-    Generate, GenerateResponse,
+    Generate,
+    GenerateResponse,
     GetObject,
     GetRecipes,
     Parse,
     PrepareRecipe,
     PrepareRecipeResponse,
     Print,
+    TraceGetObject,
     Visit,
     VisitResponse
 } from "./request";
@@ -36,7 +38,6 @@ import {ExecutionContext} from "../execution";
 import {InstallRecipes, InstallRecipesResponse} from "./request/install-recipes";
 import {ParserInput} from "../parser";
 import {ReferenceMap} from "../reference";
-import {Writable} from "node:stream";
 import {GetLanguages} from "./request/get-languages";
 
 export class RewriteRpc {
@@ -53,6 +54,8 @@ export class RewriteRpc {
     readonly localRefs: ReferenceMap = new ReferenceMap();
 
     private remoteLanguages?: string[];
+    private readonly logger?: rpc.Logger;
+    private traceGetObject: TraceGetObject = {receive: false, send: false};
 
     constructor(readonly connection: MessageConnection = rpc.createMessageConnection(
                     new rpc.StreamMessageReader(process.stdin),
@@ -63,12 +66,11 @@ export class RewriteRpc {
                     registry?: RecipeRegistry,
                     logger?: rpc.Logger,
                     metricsCsv?: string,
-                    traceGetObjectOutput?: boolean,
-                    traceGetObjectInput?: Writable,
                     recipeInstallDir?: string
                 }) {
         // Initialize metrics CSV file if configured
         initializeMetricsCsv(options.metricsCsv, options.logger);
+        this.logger = options.logger;
 
         const preparedRecipes: Map<String, Recipe> = new Map();
         const recipeCursors: WeakMap<Recipe, Cursor> = new WeakMap()
@@ -76,20 +78,30 @@ export class RewriteRpc {
         // Need this indirection, otherwise `this` will be undefined when executed in the handlers.
         const getObject = (id: string, sourceFileType?: string) => this.getObject(id, sourceFileType);
         const getCursor = (cursorIds: string[] | undefined, sourceFileType?: string) => this.getCursor(cursorIds, sourceFileType);
+        const traceGetObject = () => this.traceGetObject.send;
 
         const registry = options.registry || new RecipeRegistry();
 
         Visit.handle(this.connection, this.localObjects, preparedRecipes, recipeCursors, getObject, getCursor, options.metricsCsv);
         Generate.handle(this.connection, this.localObjects, preparedRecipes, recipeCursors, getObject, options.metricsCsv);
         GetObject.handle(this.connection, this.remoteObjects, this.localObjects,
-            this.localRefs, options?.batchSize || 200, !!options?.traceGetObjectOutput, options.metricsCsv);
+            this.localRefs, options?.batchSize || 200, traceGetObject, options.metricsCsv);
         GetRecipes.handle(this.connection, registry, options.metricsCsv);
         GetLanguages.handle(this.connection, options.metricsCsv);
         PrepareRecipe.handle(this.connection, registry, preparedRecipes, options.metricsCsv);
         Parse.handle(this.connection, this.localObjects, options.metricsCsv);
-        Print.handle(this.connection, getObject, options.metricsCsv);
+        Print.handle(this.connection, getObject, options.logger, options.metricsCsv);
         InstallRecipes.handle(this.connection, options.recipeInstallDir ?? ".rewrite", registry, options.logger, options.metricsCsv);
 
+        this.connection.onRequest(
+            new rpc.RequestType<TraceGetObject, boolean, Error>("TraceGetObject"),
+            async (request) => {
+                this.traceGetObject = request;
+                return true;
+            }
+        )
+
+        RewriteRpc.set(this);
         this.connection.listen();
     }
 
@@ -112,14 +124,15 @@ export class RewriteRpc {
         const q = new RpcReceiveQueue(this.remoteRefs, sourceFileType, () => {
             return this.connection.sendRequest(
                 new rpc.RequestType<GetObject, RpcObjectData[], Error>("GetObject"),
-                new GetObject(id, sourceFileType)
+                new GetObject(id, sourceFileType),
             );
-        }, this.options.traceGetObjectInput);
+        }, this.logger, this.traceGetObject.receive);
 
         const remoteObject = await q.receive<P>(localObject);
 
         const eof = (await q.take());
         if (eof.state !== RpcObjectState.END_OF_OBJECT) {
+            RpcObjectData.logTrace(eof, this.traceGetObject.receive, this.logger);
             throw new Error(`Expected END_OF_OBJECT but got: ${eof.state}`);
         }
 
@@ -159,10 +172,10 @@ export class RewriteRpc {
             throw new Error("Cursor is required for non-SourceFile trees");
         }
         this.localObjects.set(tree.id.toString(), tree);
+        const sourceFile = isSourceFile(tree) ? tree : cursor!.firstEnclosing(t => isSourceFile(t))!;
         return await this.connection.sendRequest(
             new rpc.RequestType<Print, string, Error>("Print"),
-            new Print(tree.id, isSourceFile(tree) ? tree.kind :
-                cursor!.firstEnclosing(t => isSourceFile(t))!.kind)
+            new Print(tree.id, sourceFile.kind)
         );
     }
 

package/src/rpc/server.ts

@@ -15,12 +15,10 @@
  * limitations under the License.
  */
 import * as rpc from "vscode-jsonrpc/node";
-import {Trace, Tracer} from "vscode-jsonrpc/node";
 import {RewriteRpc} from "./rewrite-rpc";
 import * as fs from "fs";
 import {Command} from 'commander';
 import {dir} from 'tmp-promise';
-import {ChromeProfiler} from './chrome-profiler';
 
 // Include all languages you want this server to support.
 import "../text";
@@ -34,10 +32,8 @@ require('v8').setFlagsFromString('--stack-size=8000');
 interface ProgramOptions {
     logFile?: string;
     metricsCsv?: string;
-    verbose?: boolean;
+    traceRpcMessages?: boolean;
     batchSize?: number;
-    traceGetObjectOutput?: boolean;
-    traceGetObjectInput?: boolean;
     recipeInstallDir?: string;
     profile?: boolean;
 }
@@ -48,23 +44,13 @@ async function main() {
         .option('--port <number>', 'port number')
         .option('--log-file <log_path>', 'log file path')
         .option('--metrics-csv <metrics_csv_path>', 'metrics CSV output path')
-        .option('-v, --verbose', 'enable verbose output')
+        .option('--trace-rpc-messages', 'trace RPC messages at the protocol level')
         .option('--batch-size [size]', 'sets the batch size (default is 200)', s => parseInt(s, 10), 200)
-        .option('--trace-get-object-output', 'enable `GetObject` output tracing')
-        .option('--trace-get-object-input', 'enable `GetObject` input tracing')
         .option('--recipe-install-dir <install_dir>', 'Recipe installation directory (default is a temporary directory)')
-        .option('--profile', 'enable profiling')
         .parse();
 
     const options = program.opts() as ProgramOptions;
 
-    // Chrome profiling
-    let profiler: ChromeProfiler | undefined;
-    if (options.profile) {
-        profiler = new ChromeProfiler();
-        profiler.start().catch(console.error);
-    }
-
     let recipeInstallDir: string;
     if (!options.recipeInstallDir) {
         let recipeCleanup: () => Promise<void>;
@@ -77,9 +63,6 @@ async function main() {
 
         // Register cleanup on exit
         process.on('SIGINT', async () => {
-            if (profiler) {
-                await profiler.stop();
-            }
             if (recipeCleanup) {
                 await recipeCleanup();
             }
@@ -87,9 +70,6 @@ async function main() {
         });
 
         process.on('SIGTERM', async () => {
-            if (profiler) {
-                await profiler.stop();
-            }
             if (recipeCleanup) {
                 await recipeCleanup();
             }
@@ -99,31 +79,18 @@ async function main() {
         recipeInstallDir = await setupRecipeDir();
     } else {
         recipeInstallDir = options.recipeInstallDir;
-
-        // Register cleanup for profiler when no recipe cleanup is needed
-        if (profiler) {
-            process.on('SIGINT', async () => {
-                await profiler.stop();
-                process.exit(0);
-            });
-
-            process.on('SIGTERM', async () => {
-                await profiler.stop();
-                process.exit(0);
-            });
-        }
     }
 
     const log = options.logFile ? fs.createWriteStream(options.logFile, {flags: 'a'}) : undefined;
     const logger: rpc.Logger = {
-        error: (msg: string) => log && log.write(`[js-rewrite-rpc] [error] ${msg}\n`),
-        warn: (msg: string) => log && log.write(`[js-rewrite-rpc] [warn] ${msg}\n`),
-        info: (msg: string) => log && options.verbose && log.write(`[js-rewrite-rpc] [info] ${msg}\n`),
-        log: (msg: string) => log && options.verbose && log.write(`[js-rewrite-rpc] [log] ${msg}\n`)
+        error: (msg: string) => log && log.write(`[js error] ${msg}\n`),
+        warn: (msg: string) => log && log.write(`[js warn] ${msg}\n`),
+        info: (msg: string) => log && log.write(`[js info] ${msg}\n`),
+        // The RPC Tracer configured below itself writes to this "log" level for every message it sends or receives,
+        // because the Tracer type has a log method on it that matches this signature.
+        log: (msg: string) => log && options.traceRpcMessages && log.write(`[js trace] ${msg}\n`)
     };
 
-    logger.log(`starting`);
-
     // Create the connection with the custom logger
     const connection = rpc.createMessageConnection(
         new rpc.StreamMessageReader(process.stdin),
@@ -131,13 +98,13 @@ async function main() {
         logger
     );
 
-    if (options.verbose) {
+    if (options.traceRpcMessages) {
         await connection.trace(rpc.Trace.Verbose, logger).catch((err: Error) => {
             // Handle any unexpected errors during trace configuration
             logger.error(`Failed to set trace: ${err}`);
         });
     } else {
-        await connection.trace(Trace.Off, {} as Tracer);
+        await connection.trace(rpc.Trace.Off, {} as rpc.Tracer);
     }
 
     connection.onError(err => {
@@ -152,20 +119,18 @@ async function main() {
         logger.info(`connection disposed`);
     });
 
-    RewriteRpc.set(new RewriteRpc(connection, {
-        batchSize: options.batchSize,
-        logger: logger,
-        metricsCsv: options.metricsCsv,
-        traceGetObjectInput: options.traceGetObjectInput ? log : undefined,
-        traceGetObjectOutput: options.traceGetObjectOutput,
-        recipeInstallDir: recipeInstallDir
-    }));
-
     // log uncaught exceptions
     process.on('uncaughtException', (error) => {
         logger.error('Fatal error:' + error.message);
         process.exit(8);
     });
+
+    new RewriteRpc(connection, {
+        batchSize: options.batchSize,
+        logger: logger,
+        metricsCsv: options.metricsCsv,
+        recipeInstallDir: recipeInstallDir
+    });
 }
 
 main().catch(console.error);

package/src/rpc/trace.ts

@@ -18,8 +18,8 @@ import {AsyncLocalStorage} from "node:async_hooks";
 
 const stackStorage = new AsyncLocalStorage<string>();
 
-export function saveTrace<T>(condition: any | undefined, action: () => Promise<T>): Promise<T> {
-    if (condition) {
+export function saveTrace<T>(enabled: boolean, action: () => Promise<T>): Promise<T> {
+    if (enabled) {
         const entryStack = new Error().stack ?? '';
         return stackStorage.run(entryStack, action);
     }
@@ -42,7 +42,7 @@ export function trace(type: "Receiver" | "Sender"): string | undefined {
                     const codeLine = readFileSync(file, 'utf-8')
                         .split('\n')[parseInt(line, 10) - 1]
                         .trim();
-                    return `${className}:${line} => ${codeLine}`;
+                    return `${className}:${line}:depth(${stack.length}) => ${codeLine}`;
                 } catch {
                     // ignore if reading the source file fails
                 }