@friggframework/core 2.0.0--canary.622.ce0381c.0 → 2.0.0--canary.623.71305f2.0

package/README.md

@@ -200,46 +200,6 @@ 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/index.js

@@ -4,10 +4,15 @@ 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 { createUsageCommands } = require('./commands/usage-commands');
+const {
+    createCredentialCommands,
+} = require('./commands/credential-commands');
+const {
+    createProcessCommands,
+} = require('./commands/process-commands');
+const {
+    createSchedulerCommands,
+} = require('./commands/scheduler-commands');
 
 /**
  * Create a unified command factory with all CRUD operations
@@ -51,11 +56,6 @@ 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,7 +70,6 @@ module.exports = {
     createCredentialCommands,
     createProcessCommands,
     createSchedulerCommands,
-    createUsageCommands,
 
     // Legacy standalone function
     findIntegrationContextByExternalEntityId,

package/core/create-handler.js

@@ -4,93 +4,6 @@
 
 const { initDebugLog, flushDebugLog } = require('../logs');
 const { secretsToEnv } = require('./secrets-to-env');
-const { getTelemetry } = require('../telemetry/telemetry-singleton');
-const {
-    getUsageRollupSubscriber,
-} = require('../telemetry/usage-rollup-singleton');
-const {
-    getPluginTelemetrySubscribers,
-} = require('../telemetry/plugin-subscribers-singleton');
-
-// 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
@@ -123,7 +36,8 @@ 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,
         };
     }
@@ -136,9 +50,6 @@ const createHandler = (optionByName = {}) => {
         isUserFacingResponse = true,
         method,
         shouldUseDatabase = true,
-        telemetry,
-        flushTimeoutMs = DEFAULT_FLUSH_TIMEOUT_MS,
-        usageRollup,
     } = optionByName;
 
     if (!method) {
@@ -147,23 +58,16 @@ 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);
 
@@ -235,14 +139,6 @@ 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
-            );
         }
     };
 };