@logbrew/sdk 0.1.6 → 0.1.8

package/issue-diagnostics.cjs

@@ -0,0 +1,267 @@
+"use strict";
+
+const MAX_ISSUE_BREADCRUMBS = 64;
+const MAX_EXCEPTION_TYPE_LENGTH = 256;
+const MAX_MECHANISM_TYPE_LENGTH = 64;
+const MAX_BREADCRUMB_NAME_LENGTH = 64;
+const MAX_BREADCRUMB_MESSAGE_LENGTH = 512;
+const MAX_BREADCRUMB_DATA_FIELDS = 8;
+const MAX_BREADCRUMB_DATA_STRING_LENGTH = 256;
+const MACHINE_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_.:-]{0,63}$/u;
+const DATA_KEY_PATTERN = /^[A-Za-z][A-Za-z0-9_.-]{0,63}$/u;
+const BREADCRUMB_LEVEL_ALIASES = new Map([
+  ["trace", "debug"],
+  ["debug", "debug"],
+  ["info", "info"],
+  ["log", "info"],
+  ["warn", "warning"],
+  ["warning", "warning"],
+  ["error", "error"],
+  ["fatal", "critical"],
+  ["critical", "critical"]
+]);
+
+function buildIssueDiagnosticsHelpers({ SdkError, requireTimestamp }) {
+  function validationError(message) {
+    return new SdkError("validation_error", message);
+  }
+
+  function validateIssueException(exception) {
+    if (exception === undefined) {
+      return undefined;
+    }
+    requireObject("issue exception", exception);
+    rejectUnknownKeys("issue exception", exception, new Set(["type", "mechanism"]));
+    const type = boundedText("issue exception type", exception.type, MAX_EXCEPTION_TYPE_LENGTH, {
+      rejectLocationText: true
+    });
+    const mechanism = validateIssueExceptionMechanism(exception.mechanism);
+    return {
+      type,
+      ...(mechanism === undefined ? {} : { mechanism })
+    };
+  }
+
+  function validateIssueExceptionMechanism(mechanism) {
+    if (mechanism === undefined) {
+      return undefined;
+    }
+    requireObject("issue exception mechanism", mechanism);
+    rejectUnknownKeys(
+      "issue exception mechanism",
+      mechanism,
+      new Set(["type", "handled"])
+    );
+    if (typeof mechanism.type !== "string" || !MACHINE_NAME_PATTERN.test(mechanism.type)) {
+      throw validationError(
+        `issue exception mechanism type must match ${MACHINE_NAME_PATTERN}`
+      );
+    }
+    if (Array.from(mechanism.type).length > MAX_MECHANISM_TYPE_LENGTH) {
+      throw validationError(
+        `issue exception mechanism type must be at most ${MAX_MECHANISM_TYPE_LENGTH} characters`
+      );
+    }
+    if (typeof mechanism.handled !== "boolean") {
+      throw validationError("issue exception mechanism handled must be a boolean");
+    }
+    return { type: mechanism.type, handled: mechanism.handled };
+  }
+
+  function createIssueException(type, mechanism, handled) {
+    return validateIssueException({
+      type,
+      mechanism: { type: mechanism, handled }
+    });
+  }
+
+  function validateIssueBreadcrumb(breadcrumb, defaultTimestamp) {
+    requireObject("issue breadcrumb", breadcrumb);
+    rejectUnknownKeys(
+      "issue breadcrumb",
+      breadcrumb,
+      new Set(["timestamp", "type", "category", "level", "message", "data"])
+    );
+    const timestamp = breadcrumb.timestamp ?? defaultTimestamp;
+    requireTimestamp(timestamp);
+    if (typeof breadcrumb.category !== "string" || !MACHINE_NAME_PATTERN.test(breadcrumb.category)) {
+      throw validationError(`issue breadcrumb category must match ${MACHINE_NAME_PATTERN}`);
+    }
+    const type = optionalMachineName("issue breadcrumb type", breadcrumb.type);
+    const level = optionalBreadcrumbLevel(breadcrumb.level);
+    const message = breadcrumb.message === undefined
+      ? undefined
+      : boundedText(
+          "issue breadcrumb message",
+          breadcrumb.message,
+          MAX_BREADCRUMB_MESSAGE_LENGTH
+        );
+    const data = validateBreadcrumbData(breadcrumb.data);
+    return {
+      timestamp,
+      ...(type === undefined ? {} : { type }),
+      category: breadcrumb.category,
+      ...(level === undefined ? {} : { level }),
+      ...(message === undefined ? {} : { message }),
+      ...(data === undefined ? {} : { data })
+    };
+  }
+
+  function validateIssueBreadcrumbs(breadcrumbs) {
+    if (breadcrumbs === undefined) {
+      return undefined;
+    }
+    if (!Array.isArray(breadcrumbs) || breadcrumbs.length < 1 || breadcrumbs.length > MAX_ISSUE_BREADCRUMBS) {
+      throw validationError(
+        `issue breadcrumbs must contain 1-${MAX_ISSUE_BREADCRUMBS} entries`
+      );
+    }
+    return breadcrumbs.map((breadcrumb) => validateIssueBreadcrumb(breadcrumb));
+  }
+
+  function validateIssueDiagnostics(attributes) {
+    const exception = validateIssueException(attributes.exception);
+    const breadcrumbs = validateIssueBreadcrumbs(attributes.breadcrumbs);
+    if (
+      attributes.breadcrumbsTruncated !== undefined
+      && typeof attributes.breadcrumbsTruncated !== "boolean"
+    ) {
+      throw validationError("issue breadcrumbsTruncated must be a boolean");
+    }
+    return {
+      ...(exception === undefined ? {} : { exception }),
+      ...(breadcrumbs === undefined ? {} : { breadcrumbs }),
+      ...(attributes.breadcrumbsTruncated === true ? { breadcrumbsTruncated: true } : {})
+    };
+  }
+
+  function cloneIssueDiagnostics(attributes) {
+    const diagnostics = {};
+    if (attributes.exception !== undefined) {
+      diagnostics.exception = {
+        ...attributes.exception,
+        ...(attributes.exception.mechanism === undefined
+          ? {}
+          : { mechanism: { ...attributes.exception.mechanism } })
+      };
+    }
+    if (Array.isArray(attributes.breadcrumbs)) {
+      diagnostics.breadcrumbs = attributes.breadcrumbs.map((breadcrumb) => ({
+        ...breadcrumb,
+        ...(breadcrumb.data === undefined ? {} : { data: { ...breadcrumb.data } })
+      }));
+    }
+    if (attributes.breadcrumbsTruncated === true) {
+      diagnostics.breadcrumbsTruncated = true;
+    }
+    return diagnostics;
+  }
+
+  function validateBreadcrumbData(data) {
+    if (data === undefined) {
+      return undefined;
+    }
+    requireObject("issue breadcrumb data", data);
+    const entries = Object.entries(data);
+    if (entries.length > MAX_BREADCRUMB_DATA_FIELDS) {
+      throw validationError(
+        `issue breadcrumb data must contain at most ${MAX_BREADCRUMB_DATA_FIELDS} fields`
+      );
+    }
+    const validated = {};
+    for (const [key, value] of entries) {
+      if (!DATA_KEY_PATTERN.test(key)) {
+        throw validationError(`issue breadcrumb data key must match ${DATA_KEY_PATTERN}`);
+      }
+      if (typeof value === "string") {
+        validated[key] = boundedText(
+          `issue breadcrumb data value for ${key}`,
+          value,
+          MAX_BREADCRUMB_DATA_STRING_LENGTH
+        );
+      } else if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+          throw validationError(`issue breadcrumb data value for ${key} must be finite`);
+        }
+        validated[key] = value;
+      } else if (typeof value === "boolean" || value === null) {
+        validated[key] = value;
+      } else {
+        throw validationError(
+          `issue breadcrumb data value for ${key} must be a string, number, boolean, or null`
+        );
+      }
+    }
+    return validated;
+  }
+
+  function optionalMachineName(label, value) {
+    if (value === undefined) {
+      return undefined;
+    }
+    if (typeof value !== "string" || !MACHINE_NAME_PATTERN.test(value)) {
+      throw validationError(`${label} must match ${MACHINE_NAME_PATTERN}`);
+    }
+    if (Array.from(value).length > MAX_BREADCRUMB_NAME_LENGTH) {
+      throw validationError(`${label} must be at most ${MAX_BREADCRUMB_NAME_LENGTH} characters`);
+    }
+    return value;
+  }
+
+  function optionalBreadcrumbLevel(value) {
+    if (value === undefined) {
+      return undefined;
+    }
+    const normalized = typeof value === "string" ? BREADCRUMB_LEVEL_ALIASES.get(value) : undefined;
+    if (normalized === undefined) {
+      throw validationError(
+        `issue breadcrumb level must be one of: ${Array.from(BREADCRUMB_LEVEL_ALIASES.keys()).join(", ")}`
+      );
+    }
+    return normalized;
+  }
+
+  function boundedText(label, value, maxLength, { rejectLocationText = false } = {}) {
+    if (typeof value !== "string" || value.trim() === "") {
+      throw validationError(`${label} must be non-empty`);
+    }
+    if (
+      Array.from(value).length > maxLength
+      || hasControlCharacter(value)
+      || (rejectLocationText && /[?#]/u.test(value))
+    ) {
+      throw validationError(`${label} is invalid or exceeds ${maxLength} characters`);
+    }
+    return value;
+  }
+
+  function requireObject(label, value) {
+    if (!value || Array.isArray(value) || typeof value !== "object") {
+      throw validationError(`${label} must be an object`);
+    }
+  }
+
+  function rejectUnknownKeys(label, value, allowed) {
+    const unknown = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unknown.length > 0) {
+      throw validationError(`${label} has unsupported fields: ${unknown.sort().join(", ")}`);
+    }
+  }
+
+  function hasControlCharacter(value) {
+    return Array.from(value).some((character) => {
+      const code = character.codePointAt(0);
+      return code !== undefined && (code <= 31 || (code >= 127 && code <= 159));
+    });
+  }
+
+  return {
+    MAX_ISSUE_BREADCRUMBS,
+    cloneIssueDiagnostics,
+    createIssueException,
+    validateIssueBreadcrumb,
+    validateIssueDiagnostics
+  };
+}
+
+module.exports = { buildIssueDiagnosticsHelpers };

package/issue-stack.cjs

@@ -1,6 +1,8 @@
 "use strict";
 
 const MAX_ISSUE_STACK_FRAMES = 32;
+const MAX_ISSUE_STACK_FUNCTION_LENGTH = 256;
+const MAX_ISSUE_STACK_MODULE_LENGTH = 512;
 const SAFE_DEBUG_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
 const LOCAL_ABSOLUTE_PATH_PATTERN = /^(?:\/(?:Users|home|private|tmp|var|Volumes)\/|[A-Za-z]:[\\/])/u;
 
@@ -54,7 +56,31 @@ function buildIssueStackHelpers({ SdkError }) {
       if (debugId === null) {
         throw new SdkError("validation_error", "issue stack frame debugId is invalid");
       }
-      return { filename, line, column, ...(debugId ? { debugId } : {}) };
+      const functionName = optionalFrameIdentity(frame.function, MAX_ISSUE_STACK_FUNCTION_LENGTH);
+      if (functionName === null) {
+        throw new SdkError("validation_error", "issue stack frame function is invalid");
+      }
+      const moduleName = optionalFrameIdentity(frame.module, MAX_ISSUE_STACK_MODULE_LENGTH, true);
+      if (moduleName === null) {
+        throw new SdkError("validation_error", "issue stack frame module is invalid");
+      }
+      const inApp = frame.inApp === undefined
+        ? undefined
+        : typeof frame.inApp === "boolean"
+          ? frame.inApp
+          : null;
+      if (inApp === null) {
+        throw new SdkError("validation_error", "issue stack frame inApp is invalid");
+      }
+      return {
+        filename,
+        line,
+        column,
+        ...(functionName ? { function: functionName } : {}),
+        ...(moduleName ? { module: moduleName } : {}),
+        ...(inApp !== undefined ? { inApp } : {}),
+        ...(debugId ? { debugId } : {})
+      };
     });
   }
 
@@ -67,13 +93,18 @@ function parseJavaScriptStackFrame(rawLine) {
     return null;
   }
   let location = line;
+  let functionName;
   if (location.startsWith("at ")) {
     location = location.slice(3).trim();
     if (location.endsWith(")") && location.includes("(")) {
-      location = location.slice(location.lastIndexOf("(") + 1, -1);
+      const marker = location.lastIndexOf("(");
+      functionName = generatedFrameFunction(location.slice(0, marker));
+      location = location.slice(marker + 1, -1);
     }
   } else if (location.includes("@")) {
-    location = location.slice(location.lastIndexOf("@") + 1);
+    const marker = location.lastIndexOf("@");
+    functionName = generatedFrameFunction(location.slice(0, marker));
+    location = location.slice(marker + 1);
   }
   const parts = location.split(":");
   if (parts.length < 3) {
@@ -85,7 +116,42 @@ function parseJavaScriptStackFrame(rawLine) {
   if (!filename || lineNumber === null || column === null) {
     return null;
   }
-  return { filename, line: lineNumber, column };
+  return {
+    filename,
+    line: lineNumber,
+    column,
+    ...(functionName ? { function: functionName } : {})
+  };
+}
+
+function optionalFrameIdentity(value, maxLength, rejectLocationText = false) {
+  if (value === undefined) {
+    return undefined;
+  }
+  if (typeof value !== "string") {
+    return null;
+  }
+  const identity = value.trim();
+  if (!identity
+    || Array.from(identity).length > maxLength
+    || hasControlCharacter(identity)
+    || (rejectLocationText && (identity.includes("?") || identity.includes("#")))) {
+    return null;
+  }
+  return identity;
+}
+
+function generatedFrameFunction(value) {
+  const functionName = optionalFrameIdentity(value, MAX_ISSUE_STACK_FUNCTION_LENGTH);
+  if (!functionName
+    || functionName.includes("@")
+    || functionName.includes("/")
+    || functionName.includes("\\")
+    || functionName.includes("?")
+    || functionName.includes("#")) {
+    return undefined;
+  }
+  return functionName;
 }
 
 function positiveIntegerFromText(value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logbrew/sdk",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Public LogBrew JavaScript SDK for building, validating, and flushing event batches.",
   "type": "module",
   "main": "./index.cjs",
@@ -43,12 +43,14 @@
     "index.js",
     "index.d.ts",
     "index.d.cts",
+    "issue-diagnostics.cjs",
     "issue-stack.cjs",
     "log-context.cjs",
     "opentelemetry.cjs",
     "react-native.js",
     "react-native.d.ts",
     "support-ticket.cjs",
+    "telemetry-context.cjs",
     "trace-context.cjs",
     "winston.cjs",
     "release-artifacts-common.js",

package/react-native.d.ts

@@ -40,6 +40,7 @@ export type {
   PinoDestinationConfig,
   PinoDestinationHandle,
   PinoLogRecord,
+  ProductAnalyticsKind,
   ProductActionInput,
   ReleaseAttributes,
   Severity,
@@ -65,6 +66,8 @@ export type {
 } from "./index.js";
 
 export {
+  PRODUCT_ANALYTICS_KINDS,
+  PRODUCT_ANALYTICS_SCHEMA_VERSION,
   createBaggage,
   createIssueAttributesFromError,
   createLogBrewOpenTelemetrySpanExporter,

package/react-native.js

@@ -1,6 +1,8 @@
 import sdk from "./core.cjs";
 
 export const {
+  PRODUCT_ANALYTICS_KINDS,
+  PRODUCT_ANALYTICS_SCHEMA_VERSION,
   createBaggage,
   createIssueAttributesFromError,
   createNetworkMilestoneAttributes,