@friggframework/core 2.0.0-next.102 → 2.0.0-next.104

package/README.md

@@ -200,6 +200,46 @@ const secureData = cryptor.encrypt(JSON.stringify({
 }));
 ```
 
+### 4b. Telemetry & Usage Tracking (`/telemetry`, `/usage`)
+
+Vendor-neutral OpenTelemetry observability plus durable, per-integration usage
+counters (ADR-011). No-op by default (zero cold-start cost); framework seams are
+auto-instrumented so integrations get handler/API-module/webhook metrics for free.
+
+**Usage:**
+```javascript
+// App definition — turn on export + declare a North Star:
+const Definition = {
+    name: 'my-app',
+    telemetry: {
+        exporter: { type: 'otlp', endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT },
+        northStar: { default: { name: 'records.synced' } },
+    },
+};
+
+// Integration code — custom metrics/spans (this.telemetry is auto-tagged):
+await this.telemetry.span('delta_sync', async () => {
+    this.telemetry.count('records.synced', batch.length, { entity: 'contact' });
+});
+
+// Declare which usage counters an integration reports (opts into reporting):
+class HubSpotIntegration extends IntegrationBase {
+    static Definition = {
+        name: 'hubspot',
+        usage: { canonical: ['records.synced', 'api.requests'] },
+    };
+}
+
+// Read the durable usage store (never an APM):
+const frigg = createFriggCommands({ integrationClass: HubSpotIntegration });
+await frigg.usage.getTotalsByDimension({ metric: 'records.synced', groupBy: 'integrationType' });
+```
+
+**See:** [`telemetry/README.md`](telemetry/README.md) for the full guide
+(exporters, custom metrics, the Usage-Counter contract, North Star, the plugin
+tap, cardinality rules, and caveats) and [`usage/README.md`](usage/README.md) for
+the store internals.
+
 ### 5. Error Handling (`/errors`)
 
 Standardized error types with proper HTTP status codes.

package/application/commands/usage-commands.js

@@ -0,0 +1,56 @@
+// `frigg.usage.*` — the read/write surface over the durable usage store.
+const {
+    createUsageRepository,
+} = require('../../usage/repositories/usage-repository-factory');
+const { computeUsageWindows } = require('../../usage/usage-windows');
+const { resolveNorthStarEntry } = require('../../telemetry/north-star');
+
+function createUsageCommands({ usageRepository } = {}) {
+    const repository = usageRepository || createUsageRepository();
+
+    return {
+        // Increments both the day and hour window rows for `at`.
+        async recordUsageCounter({
+            integrationId,
+            integrationType,
+            metric,
+            value = 1,
+            at = new Date(),
+        }) {
+            const windows = computeUsageWindows(at);
+            for (const window of windows) {
+                await repository.increment({
+                    integrationId,
+                    integrationType,
+                    metric,
+                    window,
+                    value,
+                });
+            }
+        },
+
+        async getTotalsByDimension(args) {
+            return repository.getTotalsByDimension(args);
+        },
+
+        async getTimeSeries(args) {
+            return repository.getTimeSeries(args);
+        },
+
+        // Caller supplies the North Star config (Definition.telemetry.northStar);
+        // resolves the counter for the type (byType > default), null if none.
+        async getNorthStarTotals({ northStar, integrationType, since, groupBy = 'integrationType', bucket } = {}) {
+            const entry = resolveNorthStarEntry(northStar, integrationType);
+            if (!entry) return null;
+            const totals = await repository.getTotalsByDimension({
+                metric: entry.name,
+                groupBy,
+                since,
+                bucket,
+            });
+            return { metric: entry.name, totals };
+        },
+    };
+}
+
+module.exports = { createUsageCommands };

package/application/index.js

@@ -4,15 +4,10 @@ const {
 } = require('./commands/integration-commands');
 const { createUserCommands } = require('./commands/user-commands');
 const { createEntityCommands } = require('./commands/entity-commands');
-const {
-    createCredentialCommands,
-} = require('./commands/credential-commands');
-const {
-    createProcessCommands,
-} = require('./commands/process-commands');
-const {
-    createSchedulerCommands,
-} = require('./commands/scheduler-commands');
+const { createCredentialCommands } = require('./commands/credential-commands');
+const { createProcessCommands } = require('./commands/process-commands');
+const { createSchedulerCommands } = require('./commands/scheduler-commands');
+const { createUsageCommands } = require('./commands/usage-commands');
 
 /**
  * Create a unified command factory with all CRUD operations
@@ -56,6 +51,11 @@ function createFriggCommands({ integrationClass }) {
 
         // Process commands
         ...processCommands,
+
+        // Usage read/write — nested to match `frigg.usage.*`. The North Star
+        // read takes its config as a call argument, so nothing telemetry-specific
+        // is threaded through this general factory.
+        usage: createUsageCommands(),
     };
 }
 
@@ -70,6 +70,7 @@ module.exports = {
     createCredentialCommands,
     createProcessCommands,
     createSchedulerCommands,
+    createUsageCommands,
 
     // Legacy standalone function
     findIntegrationContextByExternalEntityId,

package/core/create-handler.js

@@ -5,6 +5,91 @@
 const { initDebugLog, flushDebugLog } = require('../logs');
 const { secretsToEnv } = require('./secrets-to-env');
 const { parametersToEnv } = require('./parameters-to-env');
+const {
+    getTelemetry,
+    getUsageRollupSubscriber,
+    getPluginTelemetrySubscribers,
+} = require('../telemetry/telemetry-runtime');
+
+// Bounds the tail latency telemetry adds to every warm invocation. Kept low so
+// an unreachable OTLP endpoint (e.g. a VPC Lambda with no NAT/egress) costs at
+// most this, not multiple seconds. Override with OTEL_FLUSH_TIMEOUT_MS.
+const DEFAULT_FLUSH_TIMEOUT_MS =
+    Number(process.env.OTEL_FLUSH_TIMEOUT_MS) || 500;
+
+/**
+ * Fold the invocation's buffered usage counters into the durable store, then
+ * clear the buffer. On an SQS redelivery (ApproximateReceiveCount > 1) we
+ * DISCARD rather than flush — the prior delivery already counted, and the usage
+ * accuracy contract is "approximate, skip obvious redeliveries". Fully guarded.
+ */
+async function flushUsageRollup(subscriber, eventSummary, shouldUseDatabase) {
+    if (!subscriber) return;
+    try {
+        // Persisting usage requires a DB connection. DB-free handlers (e.g. the
+        // webhook-receipt route) never called connectPrisma, so drop the buffer
+        // instead of issuing a connectionless Prisma write.
+        if (!shouldUseDatabase) {
+            subscriber.discard();
+            return;
+        }
+        // Discard only when EVERY record in the batch is a redelivery. The buffer
+        // is invocation-scoped (not per-message), so discarding on *any*
+        // redelivery would drop the fresh records' counts too (silent
+        // under-count). For a mixed batch we flush: preserving fresh counts and
+        // at worst re-counting the one redelivered record is strictly better than
+        // losing fresh data for an approximate store. (Integration queue workers
+        // are batchSize:1 today, so a batch is all-or-nothing; this keeps it
+        // correct if batchSize is ever raised.)
+        const records = Array.isArray(eventSummary?.records)
+            ? eventSummary.records
+            : [];
+        const allRedelivered =
+            records.length > 0 &&
+            records.every((r) => Number(r.receiveCount) > 1);
+        if (allRedelivered) {
+            subscriber.discard();
+        } else {
+            await subscriber.flush();
+        }
+    } catch (_) {
+        // Usage rollup must never break the handler.
+    }
+}
+
+/**
+ * Flush telemetry before the Lambda container freezes. Because
+ * `callbackWaitsForEmptyEventLoop=false` (below) stops the event loop the moment
+ * the handler returns, OTel's timer-driven batch processors would never fire —
+ * so spans/metrics must be flushed synchronously here. Bounded by a timeout so a
+ * stalled exporter can never block the response, and fully guarded so a flush
+ * failure never breaks the handler.
+ */
+async function flushTelemetry(telemetry, timeoutMs) {
+    try {
+        if (
+            !telemetry ||
+            typeof telemetry.isEnabled !== 'function' ||
+            !telemetry.isEnabled()
+        ) {
+            return;
+        }
+        let timer;
+        const deadline = new Promise((resolve) => {
+            timer = setTimeout(resolve, timeoutMs);
+        });
+        try {
+            await Promise.race([
+                Promise.resolve(telemetry.forceFlush()),
+                deadline,
+            ]);
+        } finally {
+            clearTimeout(timer);
+        }
+    } catch (_) {
+        // Telemetry flush must never break the handler.
+    }
+}
 
 // Best-effort extraction of correlation identifiers from a Lambda event.
 // For SQS: pulls messageIds + parsed event/processId/integrationId from each
@@ -37,8 +122,7 @@ const summarizeLambdaEvent = (event) => {
     if (event.httpMethod || event.requestContext?.http) {
         return {
             source: 'http',
-            method:
-                event.httpMethod || event.requestContext?.http?.method,
+            method: event.httpMethod || event.requestContext?.http?.method,
             path: event.path || event.rawPath,
         };
     }
@@ -51,6 +135,9 @@ const createHandler = (optionByName = {}) => {
         isUserFacingResponse = true,
         method,
         shouldUseDatabase = true,
+        telemetry,
+        flushTimeoutMs = DEFAULT_FLUSH_TIMEOUT_MS,
+        usageRollup,
     } = optionByName;
 
     if (!method) {
@@ -59,16 +146,23 @@ const createHandler = (optionByName = {}) => {
 
     return async (event, context) => {
         const eventSummary = summarizeLambdaEvent(event);
+        const activeTelemetry = telemetry || getTelemetry();
+        const activeUsageRollup =
+            usageRollup !== undefined
+                ? usageRollup
+                : getUsageRollupSubscriber();
+
+        // Wire adopter-declared telemetry subscribers once per cold start.
+        // Memoized in the singleton, so this is a cheap
+        // no-op after the first invocation.
+        getPluginTelemetrySubscribers();
 
         try {
-            console.info(
-                `[createHandler] ${eventName}: handler entry`,
-                {
-                    eventName,
-                    awsRequestId: context?.awsRequestId,
-                    ...eventSummary,
-                }
-            );
+            console.info(`[createHandler] ${eventName}: handler entry`, {
+                eventName,
+                awsRequestId: context?.awsRequestId,
+                ...eventSummary,
+            });
 
             initDebugLog(eventName, event);
 
@@ -143,6 +237,14 @@ const createHandler = (optionByName = {}) => {
 
             // Here we can just rethrow and let AWS build the response.
             throw error;
+        } finally {
+            // Flush telemetry + usage before the container freezes.
+            await flushTelemetry(activeTelemetry, flushTimeoutMs);
+            await flushUsageRollup(
+                activeUsageRollup,
+                eventSummary,
+                shouldUseDatabase
+            );
         }
     };
 };

package/database/use-cases/resolve-migration-via-worker-use-case.js

@@ -0,0 +1,49 @@
+/**
+ * Resolve Migration Via Worker Use Case
+ *
+ * Resolves a failed Prisma migration (P3009) by invoking the worker Lambda,
+ * which has the Prisma CLI installed. Keeps the router Lambda lightweight —
+ * same delegation pattern as GetDatabaseStateViaWorkerUseCase.
+ */
+class ResolveMigrationViaWorkerUseCase {
+    /**
+     * @param {Object} dependencies
+     * @param {LambdaInvoker} dependencies.lambdaInvoker - Lambda invocation adapter
+     * @param {string} dependencies.workerFunctionName - Worker Lambda function name
+     */
+    constructor({ lambdaInvoker, workerFunctionName }) {
+        if (!lambdaInvoker) {
+            throw new Error('lambdaInvoker dependency is required');
+        }
+        if (!workerFunctionName) {
+            throw new Error('workerFunctionName is required');
+        }
+        this.lambdaInvoker = lambdaInvoker;
+        this.workerFunctionName = workerFunctionName;
+    }
+
+    /**
+     * @param {Object} params
+     * @param {string} params.migrationName - Migration to resolve
+     * @param {'applied'|'rolled-back'} [params.action] - Resolution mode
+     * @param {string} [params.stage] - Deployment stage
+     * @returns {Promise<Object>} Worker result body
+     */
+    async execute({ migrationName, action = 'applied', stage }) {
+        const dbType = process.env.DB_TYPE || 'postgresql';
+
+        console.log(
+            `Invoking worker Lambda to resolve migration "${migrationName}" as ${action}: ${this.workerFunctionName}`
+        );
+
+        return this.lambdaInvoker.invoke(this.workerFunctionName, {
+            action: 'resolve',
+            migrationName,
+            resolveAction: action,
+            dbType,
+            stage,
+        });
+    }
+}
+
+module.exports = { ResolveMigrationViaWorkerUseCase };

package/database/utils/prisma-runner.js

@@ -405,14 +405,25 @@ async function runPrismaMigrateResolve(migrationName, action = 'applied', verbos
             const [executable, ...executableArgs] = prismaBin.split(' ');
             const fullArgs = [...executableArgs, ...args];
 
+            let stdout = '';
+            let stderr = '';
             const proc = spawn(executable, fullArgs, {
-                stdio: 'inherit',
+                stdio: ['inherit', 'pipe', 'pipe'],
                 env: {
                     ...process.env,
                     PRISMA_HIDE_UPDATE_MESSAGE: '1'
                 }
             });
 
+            proc.stdout.on('data', (data) => {
+                stdout += data.toString();
+                if (verbose) process.stdout.write(data);
+            });
+            proc.stderr.on('data', (data) => {
+                stderr += data.toString();
+                if (verbose) process.stderr.write(data);
+            });
+
             proc.on('error', (error) => {
                 resolve({
                     success: false,
@@ -427,9 +438,12 @@ async function runPrismaMigrateResolve(migrationName, action = 'applied', verbos
                         output: `Migration ${migrationName} marked as ${action}`
                     });
                 } else {
+                    const detail = (stderr || stdout).trim();
                     resolve({
                         success: false,
-                        error: `Resolve process exited with code ${code}`
+                        error: detail
+                            ? `Prisma migrate resolve failed (exit ${code}): ${detail}`
+                            : `Resolve process exited with code ${code}`
                     });
                 }
             });