@oxygen-agent/cli 1.1014.773 → 1.1014.779

package/README.md

@@ -34,4 +34,4 @@ oxygen update
 
 For product documentation, visit https://oxygen-agent.com/docs. For support, visit https://oxygen-agent.com.
 
-Version: 1.1014.773
+Version: 1.1014.779

package/node_modules/@oxygen/shared/dist/log.js

@@ -2,6 +2,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { sanitizeLogFields } from "./redaction.js";
 import { redactSqlParameters } from "./sql-error.js";
 import { OXYGEN_VERSION } from "./version.js";
+import { resolveLogSinkSelector } from "./log-sink-selector.js";
 const store = new AsyncLocalStorage();
 export function withLogContext(ctx, fn) {
     const merged = { ...(store.getStore() ?? {}), ...ctx };
@@ -139,7 +140,8 @@ export function getLogSink() {
 }
 const LEVEL_RANK = { debug: 10, info: 20, warn: 30, error: 40 };
 /**
- * Minimum level that reaches the Axiom SINK. stdout is deliberately untouched —
+ * Minimum level for managed or dual-write sinks. Native-only bypasses this
+ * legacy floor so every emitted level reaches its transport. stdout is untouched —
  * `flyctl logs`, `vercel logs`, and local runs keep every line, so nothing becomes
  * un-debuggable; this only decides what we pay to store and query.
  *
@@ -164,7 +166,9 @@ function shipMinRank() {
     return LEVEL_RANK.info;
 }
 function shouldShip(level) {
-    return LEVEL_RANK[level] >= shipMinRank();
+    // Native-only capture includes all emitted levels, even when a legacy floor
+    // remains inherited. This gate runs before the selected transport sees a record.
+    return resolveLogSinkSelector() === "otlp" || LEVEL_RANK[level] >= shipMinRank();
 }
 export function log(level, msg, fields) {
     const context = getLogContext();

package/node_modules/@oxygen/shared/dist/otlp-log-sink.d.ts

@@ -39,6 +39,7 @@ export type OtlpLogSinkOptions = {
     serviceName: string;
     /** Resource attributes merged after the defaults, so a caller can override them. */
     resource?: Record<string, string | null | undefined> | undefined;
+    /** Positive safe integer; invalid values use the default batch size. */
     batchSize?: number | undefined;
     /** `0` disables the interval timer, for runtimes that flush off a request lifecycle. */
     flushIntervalMs?: number | undefined;

package/node_modules/@oxygen/shared/dist/otlp-log-sink.js

@@ -210,7 +210,9 @@ function toLogRecord(record) {
     };
 }
 export function createOtlpLogSink(options) {
-    const batchSize = options.batchSize && options.batchSize > 0 ? options.batchSize : DEFAULT_BATCH_SIZE;
+    const requestedBatchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
+    const batchSize = Number.isSafeInteger(requestedBatchSize) && requestedBatchSize > 0
+        ? requestedBatchSize : DEFAULT_BATCH_SIZE;
     const maxQueue = options.maxQueue && options.maxQueue > 0 ? options.maxQueue : DEFAULT_MAX_QUEUE;
     const flushIntervalMs = options.flushIntervalMs === undefined
         ? DEFAULT_FLUSH_INTERVAL_MS
@@ -332,64 +334,66 @@ export function createOtlpLogSink(options) {
                 : {}),
         })));
     };
-    const flush = async () => {
-        if (inFlight)
-            return inFlight;
-        if (queue.length === 0)
-            return undefined;
-        const batch = queue.splice(0, batchSize);
+    const postBatch = async (batch) => {
         const payload = JSON.stringify({
-            resourceLogs: [
-                {
+            resourceLogs: [{
                     resource: { attributes: resourceAttributes },
-                    scopeLogs: [
-                        {
-                            scope: { name: "oxygen" },
-                            logRecords: batch.map(toLogRecord),
-                        },
-                    ],
-                },
-            ],
+                    scopeLogs: [{ scope: { name: "oxygen" }, logRecords: batch.map(toLogRecord) }],
+                }],
         });
-        const run = (async () => {
-            try {
-                const response = await doFetch(options.endpoint, {
-                    method: "POST",
-                    headers: { "Content-Type": "application/json", ...options.headers },
-                    body: payload,
-                    signal: AbortSignal.timeout(EXPORT_TIMEOUT_MS),
-                });
-                if (response.ok) {
-                    try {
-                        const rejected = await rejectedRecords(response, batch.length);
-                        if (rejected)
-                            report(rejected, { status: response.status, error_code: "partial_rejection" });
-                    }
-                    catch {
-                        report(batch.length, { status: response.status, error_code: "invalid_response" });
+        try {
+            const response = await doFetch(options.endpoint, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", ...options.headers },
+                body: payload,
+                signal: AbortSignal.timeout(EXPORT_TIMEOUT_MS),
+            });
+            if (response.ok) {
+                try {
+                    const rejected = await rejectedRecords(response, batch.length);
+                    if (rejected) {
+                        report(rejected, { status: response.status, error_code: "partial_rejection" });
+                        return false;
                     }
-                    return;
+                    return true;
+                }
+                catch {
+                    report(batch.length, { status: response.status, error_code: "invalid_response" });
+                    return false;
                 }
-                // Receivers/proxies can echo rejected payloads or credentials. Never
-                // read arbitrary response text into operational diagnostics.
-                await response.body?.cancel().catch(() => undefined);
-                // The batch is gone deliberately: retrying into an unhealthy collector
-                // is how a telemetry path turns an ingest blip into memory pressure.
-                report(batch.length, { status: response.status, error_code: "receiver_rejected" });
-            }
-            catch (error) {
-                report(batch.length, {
-                    error_code: "transport_failed",
-                    error_cause: sanitizedErrorCause(error),
-                });
-            }
-            finally {
-                reportOverflow();
             }
-        })();
-        inFlight = run.finally(() => {
-            inFlight = null;
-        });
+            // Receivers/proxies can echo payloads or credentials. Keep diagnostics fixed.
+            await response.body?.cancel().catch(() => undefined);
+            report(batch.length, { status: response.status, error_code: "receiver_rejected" });
+            return false;
+        }
+        catch (error) {
+            report(batch.length, {
+                error_code: "transport_failed",
+                error_cause: sanitizedErrorCause(error),
+            });
+            return false;
+        }
+        finally {
+            reportOverflow();
+        }
+    };
+    const flush = async () => {
+        if (inFlight)
+            return inFlight;
+        if (queue.length === 0)
+            return undefined;
+        // Keep one POST in flight. Healthy full batches continue immediately so the
+        // timer does not cap production at 500/2s. Failure keeps the existing loss
+        // accounting/backoff; neither a rejected batch nor a partial reply is retried.
+        const drain = async () => {
+            do {
+                const accepted = await postBatch(queue.splice(0, batchSize));
+                if (!accepted || queue.length < batchSize)
+                    return;
+            } while (queue.length > 0);
+        };
+        inFlight = Promise.resolve().then(drain).finally(() => { inFlight = null; });
         return inFlight;
     };
     const timer = flushIntervalMs > 0
@@ -404,7 +408,7 @@ export function createOtlpLogSink(options) {
         if (timer)
             clearInterval(timer);
         // Drain rather than flush once: a shutdown's final lines are usually the
-        // interesting ones, and one flush ships only the oldest `batchSize`.
+        // interesting ones. Flush the final partial batch as well as healthy full batches.
         while (queue.length > 0) {
             await flush();
         }

package/node_modules/@oxygen/shared/dist/span-volume.d.ts

@@ -0,0 +1,8 @@
+import type { SpanProcessor } from "@opentelemetry/sdk-trace-base";
+/**
+ * Count ended recording spans once per SDK, before destination filters. Stored
+ * spans cannot size full capture while quiet execution roots are suppressed.
+ * Fixed dimensions include children without retaining names or customer data.
+ * This counts generated recording spans; an upstream sampler remains a limit.
+ */
+export declare function generatedSpanVolumeProcessor(surface: "web" | "worker"): SpanProcessor;

package/node_modules/@oxygen/shared/dist/span-volume.js

@@ -0,0 +1,26 @@
+import { metrics } from "@opentelemetry/api";
+/**
+ * Count ended recording spans once per SDK, before destination filters. Stored
+ * spans cannot size full capture while quiet execution roots are suppressed.
+ * Fixed dimensions include children without retaining names or customer data.
+ * This counts generated recording spans; an upstream sampler remains a limit.
+ */
+export function generatedSpanVolumeProcessor(surface) {
+    let counter;
+    return {
+        onStart() { },
+        onEnd(span) {
+            counter ??= metrics.getMeter("oxygen.capture").createCounter("oxygen.telemetry.generated_spans", {
+                description: "Ended recording spans before destination suppression; cumulative per process",
+                unit: "{span}",
+            });
+            counter.add(1, {
+                surface,
+                relationship: span.parentSpanContext ? "child" : "root",
+                family: span.name === "bullmq.execute" ? "execution" : "other",
+            });
+        },
+        forceFlush: async () => { },
+        shutdown: async () => { },
+    };
+}

package/node_modules/@oxygen/shared/dist/telemetry-resource.js

@@ -1,5 +1,6 @@
 import { deployEnvTelemetryEnvironment, resolveDeployEnv } from "./deploy-env.js";
 import { processResourceIdentity } from "./process-resource.js";
+import { resolveLogSinkSelector } from "./log-sink-selector.js";
 export function planTelemetryResource({ declared, managedEnvironment, collectorConfigured, env = process.env, }) {
     // The label a process without a collector has always exported: `production`
     // on selfhost-prod, `development` on shadow/dev, the managed chain otherwise.
@@ -18,7 +19,7 @@ export function planTelemetryResource({ declared, managedEnvironment, collectorC
     }
     const collectorEnvironment = env.OXYGEN_DEPLOY_ENV?.trim() ? resolveDeployEnv(env).tier : axiomEnvironment;
     const collectorAttributes = withEnvironment(collectorEnvironment, { ...processResourceIdentity(), ...declared });
-    if (collectorEnvironment === "prod") {
+    if (collectorEnvironment === "prod" && resolveLogSinkSelector(env) !== "otlp") {
         return {
             deploymentEnvironment: axiomEnvironment,
             resourceAttributes: withEnvironment(axiomEnvironment, declared),

package/node_modules/@oxygen/shared/dist/version.generated.d.ts

@@ -1 +1 @@
-export declare const OXYGEN_BUILD_VERSION = "1.1014.773";
+export declare const OXYGEN_BUILD_VERSION = "1.1014.779";

package/node_modules/@oxygen/shared/dist/version.generated.js

@@ -1,2 +1,2 @@
 // GENERATED by scripts/ci/version-stamp.mjs from VERSION + git history. Do not edit; do not commit.
-export const OXYGEN_BUILD_VERSION = "1.1014.773";
+export const OXYGEN_BUILD_VERSION = "1.1014.779";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxygen-agent/cli",
-  "version": "1.1014.773",
+  "version": "1.1014.779",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",