@loutrejs/loutre 0.6.0 → 0.7.0

package/dist/runtime/kernel.js

@@ -1,4 +1,4 @@
-import { assertValidApplicationModel, loadArgs, loadEnv, RuntimeCapabilityRegistry, } from '../core/index.js';
+import { assertValidApplicationModel, loadArgs, loadEnv, RuntimeCapabilityRegistry, tokenName, } from '../core/index.js';
 import { Container } from './di.js';
 import { ExecutionTracker } from './execution-tracker.js';
 import { Logger } from './logger.js';
@@ -9,29 +9,39 @@ export class ApplicationKernelRuntime {
     capabilities;
     #extensionRuntimes = new Map();
     #providerInstances = new Map();
+    #providerNodes = new Map();
     #initializedModuleIds = new Set();
     #executions = new ExecutionTracker();
     #extensionDrainOperations = new Map();
     #environmentSource;
     #argumentsSource;
     #forceShutdownTimeoutMs;
+    #instrumentation;
     #state = 'created';
     #initialization;
     #shutdown;
     constructor(model, options = {}) {
         this.model = assertValidApplicationModel(model);
+        for (const node of this.model.nodes) {
+            if (node.kind === 'provider')
+                this.#providerNodes.set(node.provider, node);
+        }
         this.capabilities = new RuntimeCapabilityRegistry(options.capabilities ?? []);
         this.#environmentSource = options.environmentSource;
         this.#argumentsSource =
             'argumentsSource' in options ? options.argumentsSource : Object.freeze({});
         this.#forceShutdownTimeoutMs =
             options.forceShutdownTimeoutMs ?? defaultForceShutdownTimeoutMs;
+        this.#instrumentation = options.instrumentation;
         if (!Number.isFinite(this.#forceShutdownTimeoutMs) ||
             this.#forceShutdownTimeoutMs < 0) {
             throw new TypeError('LUTRE_FORCE_SHUTDOWN_TIMEOUT: forceShutdownTimeoutMs must be a non-negative finite number.');
         }
         this.container = new Container(model.providers, {
             logger: options.logger ?? new Logger(),
+            hooks: {
+                created: (provider, value) => this.#notifyProviderCreated(provider, value),
+            },
         });
     }
     initialize() {
@@ -149,10 +159,48 @@ export class ApplicationKernelRuntime {
         }
         return runtime;
     }
-    beginExecution() {
+    beginExecution(metadata, invocation) {
         if (this.#state !== 'running')
             throw applicationStateError(this.#state);
-        return this.#executions.begin();
+        const tracked = this.#executions.begin();
+        if (metadata === undefined)
+            return tracked;
+        const scope = safely(() => this.#instrumentation?.beginExecution?.(metadata, invocation));
+        if (!scope)
+            return tracked;
+        const instrumented = instrumentationLease(scope);
+        return {
+            signal: tracked.signal,
+            run: instrumented.run,
+            abort(reason) {
+                callInstrumentation(() => scope.abort?.(reason));
+                tracked.abort(reason);
+            },
+            fail: instrumented.fail,
+            annotate: instrumented.annotate,
+            complete(...result) {
+                instrumented.complete(...result);
+                tracked.complete();
+            },
+        };
+    }
+    beginOperation(metadata, invocation) {
+        return instrumentationLease(safely(() => this.#instrumentation?.beginOperation?.(metadata, invocation)));
+    }
+    #notifyProviderCreated(provider, value) {
+        const instrumentation = this.#instrumentation;
+        if (!instrumentation?.providerCreated)
+            return;
+        const providerNode = this.#providerNodes.get(provider);
+        if (!providerNode)
+            return;
+        callInstrumentation(() => instrumentation.providerCreated({
+            providerId: providerNode.id,
+            graphNodeId: providerNode.id,
+            name: tokenName(providerNode.token),
+            scope: provider.scope,
+            providerKind: provider.kind,
+        }, value));
     }
     shutdown(signal) {
         if (this.#state === 'stopped')
@@ -171,6 +219,7 @@ export class ApplicationKernelRuntime {
             await this.#initialization.catch(() => undefined);
         if (this.#state === 'created') {
             this.#state = 'stopped';
+            await closeInstrumentation(this.#instrumentation);
             return;
         }
         if (this.#state === 'stopped')
@@ -225,6 +274,7 @@ export class ApplicationKernelRuntime {
         this.#extensionDrainOperations.clear();
         await this.#cleanupProviders(signal, errors);
         this.#state = 'stopped';
+        await closeInstrumentation(this.#instrumentation);
         if (errors.length > 0) {
             throw new AggregateError(errors, 'Application shutdown failed.');
         }
@@ -281,6 +331,7 @@ export class ApplicationKernelRuntime {
                 await collectError(() => callLifecycle(instance, 'onModuleDestroy'), errors);
             }
         }
+        await closeInstrumentation(this.#instrumentation);
         return errors;
     }
     async #runHook(hook) {
@@ -306,6 +357,48 @@ function lifecycleHookOf(model, moduleId, phase) {
         node.moduleId === moduleId &&
         node.phase === phase)?.hook;
 }
+function instrumentationLease(scope) {
+    return {
+        run(operation) {
+            if (!scope?.run)
+                return operation();
+            return scope.run(operation);
+        },
+        fail(reason) {
+            callInstrumentation(() => scope?.fail?.(reason));
+        },
+        annotate(attributes) {
+            callInstrumentation(() => scope?.annotate?.(attributes));
+        },
+        complete(...result) {
+            callInstrumentation(() => scope?.complete(...result));
+        },
+    };
+}
+function safely(operation) {
+    try {
+        return operation();
+    }
+    catch {
+        return undefined;
+    }
+}
+function callInstrumentation(operation) {
+    try {
+        operation();
+    }
+    catch {
+        // instrumentation障害をApplication semanticsへ伝播させてはならない。
+    }
+}
+async function closeInstrumentation(instrumentation) {
+    try {
+        await instrumentation?.close?.();
+    }
+    catch {
+        // instrumentationのcleanup失敗をshutdown失敗として扱わない。
+    }
+}
 async function withTimeout(operation, timeoutMs, createTimeoutError) {
     let timer;
     try {

package/dist/tasks/extension.js

@@ -238,6 +238,7 @@ export function consume(declaration) {
 }
 function createTasksRuntime(executions, applicationRuntime) {
     const runtimes = new Map();
+    const runtimeExecutionIds = new Map();
     const triggers = [];
     for (const execution of executions) {
         const compiled = execution.compiled;
@@ -254,6 +255,7 @@ function createTasksRuntime(executions, applicationRuntime) {
             resolve: (dependency) => applicationRuntime.resolve(dependency, execution.id),
         }, () => compiled.factory());
         runtimes.set(compiled.taskExecutionId, runtime);
+        runtimeExecutionIds.set(compiled.taskExecutionId, execution.id);
     }
     let triggerHandles = [];
     let triggerStartup;
@@ -261,7 +263,7 @@ function createTasksRuntime(executions, applicationRuntime) {
     let triggersStarted = false;
     let state = 'running';
     const activeInvocations = new Set();
-    const run = (taskExecutionId, taskName, ...arguments_) => {
+    const invokeTask = (taskExecutionId, taskName, arguments_) => {
         if (state !== 'running') {
             return Promise.reject(new Error(`LUTRE_TASKS_${state.toUpperCase()}`));
         }
@@ -270,18 +272,42 @@ function createTasksRuntime(executions, applicationRuntime) {
             return Promise.reject(new Error(`LUTRE_TASK_NOT_REGISTERED: ${taskName}`));
         }
         const invocation = (async () => {
-            const lease = applicationRuntime.beginExecution();
+            const executionId = runtimeExecutionIds.get(taskExecutionId) ?? taskName;
+            const hasInput = arguments_.length > 0;
+            const input = hasInput ? arguments_[0] : undefined;
+            const lease = applicationRuntime.beginExecution({
+                executionId,
+                executionKind: 'task.invocation',
+                graphNodeId: executionId,
+                name: taskName,
+            }, {
+                input,
+                invoke: (nextInput) => invokeTask(taskExecutionId, taskName, hasInput ? [nextInput] : []),
+            });
+            let result;
+            let hasResult = false;
             try {
-                return await Reflect.apply(runtime, undefined, arguments_);
+                const invoke = () => Reflect.apply(runtime, undefined, arguments_);
+                result = await (lease.run ? lease.run(invoke) : invoke());
+                hasResult = true;
+                return result;
+            }
+            catch (error) {
+                lease.fail?.(error);
+                throw error;
             }
             finally {
-                lease.complete();
+                if (hasResult)
+                    lease.complete(result);
+                else
+                    lease.complete();
             }
         })();
         activeInvocations.add(invocation);
         void invocation.then(() => activeInvocations.delete(invocation), () => activeInvocations.delete(invocation));
         return invocation;
     };
+    const run = (taskExecutionId, taskName, ...arguments_) => invokeTask(taskExecutionId, taskName, arguments_);
     const stopTriggers = () => {
         if (triggerStop)
             return triggerStop;

package/dist/websocket/extension.js

@@ -240,7 +240,12 @@ function createWebSocketRuntime(executions, driver, applicationRuntime) {
             }
             let lease;
             try {
-                lease = applicationRuntime.beginExecution();
+                lease = applicationRuntime.beginExecution({
+                    executionId: match.executionId,
+                    executionKind: 'websocket.session',
+                    graphNodeId: match.executionId,
+                    name: `WS ${match.route.path}`,
+                });
             }
             catch (error) {
                 completePendingIngress();
@@ -251,11 +256,12 @@ function createWebSocketRuntime(executions, driver, applicationRuntime) {
                 upgraded = await driver.upgrade(request);
             }
             catch (error) {
+                lease.fail?.(error);
                 lease.complete();
                 completePendingIngress();
                 throw error;
             }
-            const session = createSession(upgraded.connection, match.route, input, lease, handlers.get(match.executionId)?.[match.route.name]);
+            const session = createSession(upgraded.connection, match.route, input, lease, handlers.get(match.executionId)?.[match.route.name], lease.run);
             sessions.add(session.active);
             void session.completion.then(() => sessions.delete(session.active), () => sessions.delete(session.active));
             completePendingIngress();
@@ -341,7 +347,7 @@ function decodeQuery(searchParams) {
     }
     return query;
 }
-function createSession(connection, route, input, lease, handler) {
+function createSession(connection, route, input, lease, handler, runInExecution) {
     let state = 'open';
     let transportFailed = false;
     let sendTail = Promise.resolve();
@@ -352,6 +358,7 @@ function createSession(connection, route, input, lease, handler) {
         return normalizeCloseInfo(info);
     }, (error) => {
         state = 'closed';
+        lease.fail?.(error);
         lease.abort(error);
         throw error;
     });
@@ -406,11 +413,13 @@ function createSession(connection, route, input, lease, handler) {
             if (!handler) {
                 throw new Error(`LUTRE_WEBSOCKET_HANDLER_MISSING: ${route.name}`);
             }
-            await handler(context);
+            const invoke = () => handler(context);
+            await (runInExecution ? runInExecution(invoke) : invoke());
             if (state === 'open')
                 await close(1000, '');
         }
-        catch {
+        catch (error) {
+            lease.fail?.(error);
             if (state === 'open')
                 await close(1011, '');
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loutrejs/loutre",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "license": "MIT",
   "type": "module",
   "files": [
@@ -20,6 +20,10 @@
       "types": "./dist/graph/index.d.ts",
       "import": "./dist/graph/index.js"
     },
+    "./devtools": {
+      "types": "./dist/devtools/index.d.ts",
+      "import": "./dist/devtools/index.js"
+    },
     "./runtime": {
       "types": "./dist/runtime/index.d.ts",
       "import": "./dist/runtime/index.js"