@logbrew/sdk 0.1.14 → 0.1.16

package/core.cjs

@@ -75,6 +75,7 @@ const PINO_SENSITIVE_CONTEXT_FIELDS = new Set([
 const TRACEPARENT_PATTERN = /^([0-9a-fA-F]{2})-([0-9a-fA-F]{32})-([0-9a-fA-F]{16})-([0-9a-fA-F]{2})$/u;
 const ZERO_TRACE_ID = "00000000000000000000000000000000";
 const ZERO_SPAN_ID = "0000000000000000";
+const RFC3339_TIMESTAMP_PATTERN = /^(\d{4})-(\d{2})-(\d{2})T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d{1,9})?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/u;
 const DEFAULT_MAX_QUEUE_SIZE = 1000;
 const DEFAULT_MAX_QUEUE_BYTES = 4 * 1024 * 1024;
 const DEFAULT_MAX_BATCH_EVENTS = 100;
@@ -84,6 +85,7 @@ const MAX_DELIVERY_INTERVAL_MS = 60 * 1000;
 const DEFAULT_DELIVERY_QUEUE_THRESHOLD = 50;
 const DELIVERY_HEALTH_SCHEMA_VERSION = 1;
 const EVENT_QUEUE_FACTORY = Symbol.for("@logbrew/sdk.eventQueueFactory");
+const CONTEXT_PROVIDER = Symbol.for("@logbrew/sdk.contextProvider");
 const MAX_ERROR_CAUSES = 5;
 const BUILTIN_ERROR_NAMES = new Set([
   "AggregateError",
@@ -199,6 +201,7 @@ class LogBrewClient {
     sdkName,
     sdkVersion,
     context,
+    [CONTEXT_PROVIDER]: contextProvider,
     maxRetries = 2,
     eventFilter,
     maxQueueSize = DEFAULT_MAX_QUEUE_SIZE,
@@ -217,6 +220,9 @@ class LogBrewClient {
     requireNonEmpty("sdkName", sdkName);
     requireNonEmpty("sdkVersion", sdkVersion);
     const clientContext = validateTelemetryContext(context, "client telemetry context");
+    if (contextProvider !== undefined && typeof contextProvider !== "function") {
+      throw new SdkError("validation_error", "context provider must be a function");
+    }
     requireNonNegativeInteger("maxRetries", maxRetries);
     if (eventFilter !== undefined && typeof eventFilter !== "function") {
       throw new SdkError("validation_error", "eventFilter must be a function");
@@ -265,6 +271,7 @@ class LogBrewClient {
       maxQueueSize,
       onEventDropped,
       context: clientContext,
+      contextProvider,
       sdk: {
         name: sdkName,
         language: "javascript",
@@ -286,6 +293,7 @@ class LogBrewClient {
     maxQueueSize,
     onEventDropped,
     context,
+    contextProvider,
     eventStore,
     eventQueueFactory,
     transport,
@@ -304,6 +312,7 @@ class LogBrewClient {
     this.maxQueueSize = maxQueueSize;
     this.onEventDropped = onEventDropped;
     this.context = cloneTelemetryContext(context);
+    this.contextProvider = contextProvider;
     this.transport = transport;
     this.sdk = sdk;
     this.maxRetries = maxRetries;
@@ -623,7 +632,10 @@ class LogBrewClient {
     }
     requireNonEmpty("event id", id);
     requireTimestamp(timestamp);
-    const context = mergeTelemetryContexts(this.context, attributes.context);
+    const context = mergeTelemetryContexts(
+      mergeTelemetryContexts(this.context, this.contextProvider?.()),
+      attributes.context
+    );
     const eventAttributes = context === undefined
       ? attributes
       : { ...attributes, context };
@@ -2199,17 +2211,25 @@ function requireTraceFlags(traceFlags) {
 
 function requireTimestamp(timestamp) {
   requireNonEmpty("timestamp", timestamp);
-  if (timestamp.endsWith("Z")) {
-    return;
-  }
   const timePortion = timestamp.split("T")[1];
-  if (timePortion && (timePortion.includes("+") || /.+-.+/.test(timePortion))) {
-    return;
+  if (!timestamp.endsWith("Z")
+    && !(timePortion && (timePortion.includes("+") || /.+-.+/.test(timePortion)))) {
+    throw new SdkError(
+      "validation_error",
+      `timestamp must include a timezone offset: ${timestamp}`
+    );
+  }
+  const match = timestamp.match(RFC3339_TIMESTAMP_PATTERN);
+  const calendar = new Date(0);
+  calendar.setUTCHours(0, 0, 0, 0);
+  calendar.setUTCFullYear(Number(match?.[1]), Number(match?.[2]) - 1, Number(match?.[3]));
+  if (!match
+    || Number(match[1]) === 0
+    || calendar.getUTCFullYear() !== Number(match[1])
+    || calendar.getUTCMonth() !== Number(match[2]) - 1
+    || calendar.getUTCDate() !== Number(match[3])) {
+    throw new SdkError("validation_error", `invalid timestamp: ${timestamp}`);
   }
-  throw new SdkError(
-    "validation_error",
-    `timestamp must include a timezone offset: ${timestamp}`
-  );
 }
 
 function cloneMetadata(metadata) {

package/issue-diagnostics.cjs

@@ -545,17 +545,18 @@ function buildIssueDiagnosticsHelpers({ SdkError, requireTimestamp, validateIssu
   }
 
   function boundedText(label, value, maxLength, { rejectLocationText = false } = {}) {
-    if (typeof value !== "string" || value.trim() === "") {
+    const normalized = typeof value === "string" ? value.trim() : "";
+    if (normalized === "") {
       throw validationError(`${label} must be non-empty`);
     }
     if (
-      Array.from(value).length > maxLength
-      || hasControlCharacter(value)
-      || (rejectLocationText && /[?#]/u.test(value))
+      Array.from(normalized).length > maxLength
+      || hasControlCharacter(normalized)
+      || (rejectLocationText && /[?#]/u.test(normalized))
     ) {
       throw validationError(`${label} is invalid or exceeds ${maxLength} characters`);
     }
-    return value;
+    return normalized;
   }
 
   function requireObject(label, value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logbrew/sdk",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Public LogBrew JavaScript SDK for building, validating, and flushing event batches.",
   "type": "module",
   "main": "./index.cjs",