Skip to content

Commit 82f3db6

Browse files
ericallamericallam
committed
Only bootstrap on the cold start execution, and record how many executions in the attempt span
1 parent f0bc4ad commit 82f3db6

File tree

4 files changed

+192
-129
lines changed

4 files changed

+192
-129
lines changed

‎packages/cli-v3/src/entryPoints/dev-run-worker.ts

Lines changed: 92 additions & 63 deletions
Original file line numberDiff line numberDiff line change
@@ -163,84 +163,110 @@ async function loadWorkerManifest() {
163163
return WorkerManifest.parse(raw);
164164
}
165165

166-
async function bootstrap() {
167-
const workerManifest = await loadWorkerManifest();
168-
169-
resourceCatalog.registerWorkerManifest(workerManifest);
166+
async function doBootstrap() {
167+
return await runTimelineMetrics.measureMetric("trigger.dev/start", "bootstrap", {}, async () => {
168+
log("Bootstrapping worker");
170169

171-
const { config, handleError } = await importConfig(workerManifest.configPath);
170+
const workerManifest = await loadWorkerManifest();
172171

173-
const tracingSDK = new TracingSDK({
174-
url: env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://0.0.0.0:4318",
175-
instrumentations: config.telemetry?.instrumentations ?? config.instrumentations ?? [],
176-
exporters: config.telemetry?.exporters ?? [],
177-
logExporters: config.telemetry?.logExporters ?? [],
178-
diagLogLevel: (env.OTEL_LOG_LEVEL as TracingDiagnosticLogLevel) ?? "none",
179-
forceFlushTimeoutMillis: 30_000,
180-
});
172+
resourceCatalog.registerWorkerManifest(workerManifest);
181173

182-
const otelTracer: Tracer = tracingSDK.getTracer("trigger-dev-worker", VERSION);
183-
const otelLogger: Logger = tracingSDK.getLogger("trigger-dev-worker", VERSION);
174+
const { config, handleError } = await importConfig(workerManifest.configPath);
184175

185-
const tracer = new TriggerTracer({ tracer: otelTracer, logger: otelLogger });
186-
const consoleInterceptor = new ConsoleInterceptor(
187-
otelLogger,
188-
typeof config.enableConsoleLogging === "boolean" ? config.enableConsoleLogging : true,
189-
typeof config.disableConsoleInterceptor === "boolean" ? config.disableConsoleInterceptor : false
190-
);
176+
const tracingSDK = new TracingSDK({
177+
url: env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://0.0.0.0:4318",
178+
instrumentations: config.telemetry?.instrumentations ?? config.instrumentations ?? [],
179+
exporters: config.telemetry?.exporters ?? [],
180+
logExporters: config.telemetry?.logExporters ?? [],
181+
diagLogLevel: (env.OTEL_LOG_LEVEL as TracingDiagnosticLogLevel) ?? "none",
182+
forceFlushTimeoutMillis: 30_000,
183+
});
191184

192-
const configLogLevel = triggerLogLevel ?? config.logLevel ?? "info";
185+
const otelTracer: Tracer = tracingSDK.getTracer("trigger-dev-worker", VERSION);
186+
const otelLogger: Logger = tracingSDK.getLogger("trigger-dev-worker", VERSION);
193187

194-
const otelTaskLogger = new OtelTaskLogger({
195-
logger: otelLogger,
196-
tracer: tracer,
197-
level: logLevels.includes(configLogLevel as any) ? (configLogLevel as LogLevel) : "info",
198-
});
188+
const tracer = new TriggerTracer({ tracer: otelTracer, logger: otelLogger });
189+
const consoleInterceptor = new ConsoleInterceptor(
190+
otelLogger,
191+
typeof config.enableConsoleLogging === "boolean" ? config.enableConsoleLogging : true,
192+
typeof config.disableConsoleInterceptor === "boolean"
193+
? config.disableConsoleInterceptor
194+
: false
195+
);
199196

200-
logger.setGlobalTaskLogger(otelTaskLogger);
197+
const configLogLevel = triggerLogLevel ?? config.logLevel ?? "info";
201198

202-
if (config.init) {
203-
lifecycleHooks.registerGlobalInitHook({
204-
id: "config",
205-
fn: config.init as AnyOnInitHookFunction,
199+
const otelTaskLogger = new OtelTaskLogger({
200+
logger: otelLogger,
201+
tracer: tracer,
202+
level: logLevels.includes(configLogLevel as any) ? (configLogLevel as LogLevel) : "info",
206203
});
207-
}
208204

209-
if (config.onStart) {
210-
lifecycleHooks.registerGlobalStartHook({
211-
id: "config",
212-
fn: config.onStart as AnyOnStartHookFunction,
213-
});
214-
}
205+
logger.setGlobalTaskLogger(otelTaskLogger);
215206

216-
if (config.onSuccess) {
217-
lifecycleHooks.registerGlobalSuccessHook({
218-
id: "config",
219-
fn: config.onSuccess as AnyOnSuccessHookFunction,
220-
});
221-
}
207+
if (config.init) {
208+
lifecycleHooks.registerGlobalInitHook({
209+
id: "config",
210+
fn: config.init as AnyOnInitHookFunction,
211+
});
212+
}
222213

223-
if (config.onFailure) {
224-
lifecycleHooks.registerGlobalFailureHook({
225-
id: "config",
226-
fn: config.onFailure as AnyOnFailureHookFunction,
227-
});
228-
}
214+
if (config.onStart) {
215+
lifecycleHooks.registerGlobalStartHook({
216+
id: "config",
217+
fn: config.onStart as AnyOnStartHookFunction,
218+
});
219+
}
229220

230-
if (handleError) {
231-
lifecycleHooks.registerGlobalCatchErrorHook({
232-
id: "config",
233-
fn: handleError as AnyOnCatchErrorHookFunction,
234-
});
221+
if (config.onSuccess) {
222+
lifecycleHooks.registerGlobalSuccessHook({
223+
id: "config",
224+
fn: config.onSuccess as AnyOnSuccessHookFunction,
225+
});
226+
}
227+
228+
if (config.onFailure) {
229+
lifecycleHooks.registerGlobalFailureHook({
230+
id: "config",
231+
fn: config.onFailure as AnyOnFailureHookFunction,
232+
});
233+
}
234+
235+
if (handleError) {
236+
lifecycleHooks.registerGlobalCatchErrorHook({
237+
id: "config",
238+
fn: handleError as AnyOnCatchErrorHookFunction,
239+
});
240+
}
241+
242+
log("Bootstrapped worker");
243+
244+
return {
245+
tracer,
246+
tracingSDK,
247+
consoleInterceptor,
248+
config,
249+
workerManifest,
250+
};
251+
});
252+
}
253+
254+
let bootstrapCache:
255+
| {
256+
tracer: TriggerTracer;
257+
tracingSDK: TracingSDK;
258+
consoleInterceptor: ConsoleInterceptor;
259+
config: TriggerConfig;
260+
workerManifest: WorkerManifest;
261+
}
262+
| undefined;
263+
264+
async function bootstrap() {
265+
if (!bootstrapCache) {
266+
bootstrapCache = await doBootstrap();
235267
}
236268

237-
return {
238-
tracer,
239-
tracingSDK,
240-
consoleInterceptor,
241-
config,
242-
workerManifest,
243-
};
269+
return bootstrapCache;
244270
}
245271

246272
let _execution: TaskRunExecution | undefined;
@@ -253,6 +279,7 @@ let _lastFlushPromise: Promise<void> | undefined;
253279
let _sharedWorkerRuntime: SharedRuntimeManager | undefined;
254280

255281
let _lastEnv: Record<string, string> | undefined;
282+
let _executionCount = 0;
256283

257284
function resetExecutionEnvironment() {
258285
_execution = undefined;
@@ -444,13 +471,15 @@ const zodIpc = new ZodIpcConnection({
444471
}
445472

446473
runMetadataManager.runId = execution.run.id;
474+
_executionCount++;
447475

448476
const executor = new TaskExecutor(task, {
449477
tracer,
450478
tracingSDK,
451479
consoleInterceptor,
452480
retries: config.retries,
453481
isWarmStart,
482+
executionCount: _executionCount,
454483
});
455484

456485
try {

‎packages/cli-v3/src/entryPoints/managed-run-worker.ts

Lines changed: 90 additions & 65 deletions
Original file line numberDiff line numberDiff line change
@@ -154,86 +154,108 @@ async function loadWorkerManifest() {
154154
return WorkerManifest.parse(raw);
155155
}
156156

157-
async function bootstrap() {
158-
const workerManifest = await loadWorkerManifest();
157+
async function doBootstrap() {
158+
return await runTimelineMetrics.measureMetric("trigger.dev/start", "bootstrap", {}, async () => {
159+
const workerManifest = await loadWorkerManifest();
160+
161+
resourceCatalog.registerWorkerManifest(workerManifest);
162+
163+
const { config, handleError } = await importConfig(
164+
normalizeImportPath(workerManifest.configPath)
165+
);
166+
167+
const tracingSDK = new TracingSDK({
168+
url: env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://0.0.0.0:4318",
169+
instrumentations: config.instrumentations ?? [],
170+
diagLogLevel: (env.OTEL_LOG_LEVEL as TracingDiagnosticLogLevel) ?? "none",
171+
forceFlushTimeoutMillis: 30_000,
172+
exporters: config.telemetry?.exporters ?? [],
173+
logExporters: config.telemetry?.logExporters ?? [],
174+
});
159175

160-
resourceCatalog.registerWorkerManifest(workerManifest);
176+
const otelTracer: Tracer = tracingSDK.getTracer("trigger-dev-worker", VERSION);
177+
const otelLogger: Logger = tracingSDK.getLogger("trigger-dev-worker", VERSION);
161178

162-
const { config, handleError } = await importConfig(
163-
normalizeImportPath(workerManifest.configPath)
164-
);
179+
const tracer = new TriggerTracer({ tracer: otelTracer, logger: otelLogger });
180+
const consoleInterceptor = new ConsoleInterceptor(
181+
otelLogger,
182+
typeof config.enableConsoleLogging === "boolean" ? config.enableConsoleLogging : true,
183+
typeof config.disableConsoleInterceptor === "boolean"
184+
? config.disableConsoleInterceptor
185+
: false
186+
);
165187

166-
const tracingSDK = new TracingSDK({
167-
url: env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://0.0.0.0:4318",
168-
instrumentations: config.instrumentations ?? [],
169-
diagLogLevel: (env.OTEL_LOG_LEVEL as TracingDiagnosticLogLevel) ?? "none",
170-
forceFlushTimeoutMillis: 30_000,
171-
exporters: config.telemetry?.exporters ?? [],
172-
logExporters: config.telemetry?.logExporters ?? [],
173-
});
188+
const configLogLevel = triggerLogLevel ?? config.logLevel ?? "info";
174189

175-
const otelTracer: Tracer = tracingSDK.getTracer("trigger-dev-worker", VERSION);
176-
const otelLogger: Logger = tracingSDK.getLogger("trigger-dev-worker", VERSION);
190+
const otelTaskLogger = new OtelTaskLogger({
191+
logger: otelLogger,
192+
tracer: tracer,
193+
level: logLevels.includes(configLogLevel as any) ? (configLogLevel as LogLevel) : "info",
194+
});
177195

178-
const tracer = new TriggerTracer({ tracer: otelTracer, logger: otelLogger });
179-
const consoleInterceptor = new ConsoleInterceptor(
180-
otelLogger,
181-
typeof config.enableConsoleLogging === "boolean" ? config.enableConsoleLogging : true,
182-
typeof config.disableConsoleInterceptor === "boolean" ? config.disableConsoleInterceptor : false
183-
);
196+
logger.setGlobalTaskLogger(otelTaskLogger);
184197

185-
const configLogLevel = triggerLogLevel ?? config.logLevel ?? "info";
198+
if (config.init) {
199+
lifecycleHooks.registerGlobalInitHook({
200+
id: "config",
201+
fn: config.init as AnyOnInitHookFunction,
202+
});
203+
}
186204

187-
const otelTaskLogger = new OtelTaskLogger({
188-
logger: otelLogger,
189-
tracer: tracer,
190-
level: logLevels.includes(configLogLevel as any) ? (configLogLevel as LogLevel) : "info",
191-
});
205+
if (config.onStart) {
206+
lifecycleHooks.registerGlobalStartHook({
207+
id: "config",
208+
fn: config.onStart as AnyOnStartHookFunction,
209+
});
210+
}
192211

193-
logger.setGlobalTaskLogger(otelTaskLogger);
212+
if (config.onSuccess) {
213+
lifecycleHooks.registerGlobalSuccessHook({
214+
id: "config",
215+
fn: config.onSuccess as AnyOnSuccessHookFunction,
216+
});
217+
}
194218

195-
if (config.init) {
196-
lifecycleHooks.registerGlobalInitHook({
197-
id: "config",
198-
fn: config.init as AnyOnInitHookFunction,
199-
});
200-
}
219+
if (config.onFailure) {
220+
lifecycleHooks.registerGlobalFailureHook({
221+
id: "config",
222+
fn: config.onFailure as AnyOnFailureHookFunction,
223+
});
224+
}
201225

202-
if (config.onStart) {
203-
lifecycleHooks.registerGlobalStartHook({
204-
id: "config",
205-
fn: config.onStart as AnyOnStartHookFunction,
206-
});
207-
}
226+
if (handleError) {
227+
lifecycleHooks.registerGlobalCatchErrorHook({
228+
id: "config",
229+
fn: handleError as AnyOnCatchErrorHookFunction,
230+
});
231+
}
208232

209-
if (config.onSuccess) {
210-
lifecycleHooks.registerGlobalSuccessHook({
211-
id: "config",
212-
fn: config.onSuccess as AnyOnSuccessHookFunction,
213-
});
214-
}
233+
return {
234+
tracer,
235+
tracingSDK,
236+
consoleInterceptor,
237+
config,
238+
workerManifest,
239+
};
240+
});
241+
}
215242

216-
if (config.onFailure) {
217-
lifecycleHooks.registerGlobalFailureHook({
218-
id: "config",
219-
fn: config.onFailure as AnyOnFailureHookFunction,
220-
});
221-
}
243+
let bootstrapCache:
244+
| {
245+
tracer: TriggerTracer;
246+
tracingSDK: TracingSDK;
247+
consoleInterceptor: ConsoleInterceptor;
248+
config: TriggerConfig;
249+
workerManifest: WorkerManifest;
250+
}
251+
| undefined;
222252

223-
if (handleError) {
224-
lifecycleHooks.registerGlobalCatchErrorHook({
225-
id: "config",
226-
fn: handleError as AnyOnCatchErrorHookFunction,
227-
});
253+
async function bootstrap() {
254+
if (!bootstrapCache) {
255+
bootstrapCache = await doBootstrap();
228256
}
229257

230-
return {
231-
tracer,
232-
tracingSDK,
233-
consoleInterceptor,
234-
config,
235-
workerManifest,
236-
};
258+
return bootstrapCache;
237259
}
238260

239261
let _execution: TaskRunExecution | undefined;
@@ -267,6 +289,7 @@ function resetExecutionEnvironment() {
267289
}
268290

269291
let _lastEnv: Record<string, string> | undefined;
292+
let _executionCount = 0;
270293

271294
const zodIpc = new ZodIpcConnection({
272295
listenSchema: WorkerToExecutorMessageCatalog,
@@ -449,13 +472,15 @@ const zodIpc = new ZodIpcConnection({
449472
}
450473

451474
runMetadataManager.runId = execution.run.id;
475+
_executionCount++;
452476

453477
const executor = new TaskExecutor(task, {
454478
tracer,
455479
tracingSDK,
456480
consoleInterceptor,
457481
retries: config.retries,
458482
isWarmStart,
483+
executionCount: _executionCount,
459484
});
460485

461486
try {

0 commit comments

Comments
 (0)