@logbrew/sdk 0.1.3 → 0.1.5

package/package.json

@@ -1,12 +1,20 @@
 {
   "name": "@logbrew/sdk",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Public LogBrew JavaScript SDK for building, validating, and flushing event batches.",
   "type": "module",
   "main": "./index.cjs",
+  "react-native": "./react-native.js",
   "types": "./index.d.ts",
+  "bin": {
+    "logbrew-release-artifacts": "./release-artifacts.js"
+  },
   "exports": {
     ".": {
+      "react-native": {
+        "types": "./react-native.d.ts",
+        "default": "./react-native.js"
+      },
       "import": {
         "types": "./index.d.ts",
         "default": "./index.js"
@@ -16,13 +24,42 @@
         "default": "./index.cjs"
       },
       "default": "./index.js"
+    },
+    "./vite-release-artifacts": {
+      "import": {
+        "types": "./vite-release-artifacts.d.ts",
+        "default": "./vite-release-artifacts.js"
+      },
+      "require": {
+        "types": "./vite-release-artifacts.d.cts",
+        "default": "./vite-release-artifacts.cjs"
+      },
+      "default": "./vite-release-artifacts.js"
     }
   },
   "files": [
     "index.cjs",
+    "core.cjs",
     "index.js",
     "index.d.ts",
     "index.d.cts",
+    "issue-stack.cjs",
+    "log-context.cjs",
+    "opentelemetry.cjs",
+    "react-native.js",
+    "react-native.d.ts",
+    "support-ticket.cjs",
+    "trace-context.cjs",
+    "winston.cjs",
+    "release-artifacts-common.js",
+    "release-artifacts-build.cjs",
+    "release-artifacts.js",
+    "release-artifacts-upload.js",
+    "release-artifacts-symbolication.js",
+    "vite-release-artifacts.cjs",
+    "vite-release-artifacts.js",
+    "vite-release-artifacts.d.ts",
+    "vite-release-artifacts.d.cts",
     "README.md",
     "examples"
   ],

package/react-native.d.ts

@@ -0,0 +1,103 @@
+import * as core from "./index.js";
+
+export type {
+  ActionAttributes,
+  BaggageEntry,
+  ConsoleCaptureConfig,
+  ConsoleCaptureHandle,
+  ConsoleLike,
+  ConsoleMethodName,
+  CurrentOpenTelemetryTraceContextOptions,
+  DeliveryHealthSnapshot,
+  DroppedEvent,
+  EnvironmentAttributes,
+  Event,
+  EventFilter,
+  EventStore,
+  IssueAttributes,
+  IssueStackFrame,
+  JavaScriptErrorIssueOptions,
+  LogAttributes,
+  LogCorrelationTraceContext,
+  Metadata,
+  MetadataValue,
+  MetricAttributes,
+  NetworkMilestoneInput,
+  OpenTelemetryApiLike,
+  OpenTelemetryExportResult,
+  OpenTelemetryHrTimeLike,
+  OpenTelemetryReadableSpanLike,
+  OpenTelemetryReadableSpanOptions,
+  OpenTelemetrySpanContextLike,
+  OpenTelemetrySpanExporterConfig,
+  OpenTelemetrySpanExporterHandle,
+  OpenTelemetrySpanLike,
+  OpenTelemetrySpanLinkLike,
+  OpenTelemetrySpanProcessorConfig,
+  OpenTelemetrySpanProcessorHandle,
+  OpenTelemetryTimedEventLike,
+  OpenTelemetryTraceContextOptions,
+  PinoDestinationConfig,
+  PinoDestinationHandle,
+  PinoLogRecord,
+  ProductActionInput,
+  ReleaseAttributes,
+  Severity,
+  SeverityAlias,
+  SeverityInput,
+  SpanAttributes,
+  SpanEventSummary,
+  SpanLinkSummary,
+  StoredEvent,
+  SupportDiagnosticsValue,
+  SupportTicketCategory,
+  SupportTicketDraft,
+  SupportTicketDraftInput,
+  SupportTicketSource,
+  TimelineAttributesOptions,
+  TraceContextInput,
+  TraceparentContext,
+  TraceparentInput,
+  TraceparentSpanInput,
+  TracestateEntry,
+  Transport,
+  TransportResponse
+} from "./index.js";
+
+export {
+  createBaggage,
+  createIssueAttributesFromError,
+  createLogBrewOpenTelemetrySpanExporter,
+  createLogBrewOpenTelemetrySpanProcessor,
+  createLogBrewPinoDestination,
+  createNetworkMilestoneAttributes,
+  createProductActionAttributes,
+  createSupportTicketDraft,
+  createTraceContextHeaders,
+  createTraceparent,
+  createTraceparentHeaders,
+  createTracestate,
+  installLogBrewConsoleCapture,
+  LogBrewClient,
+  logAttributesFromConsoleArgs,
+  logAttributesFromPinoRecord,
+  logbrewLevelFromConsoleMethod,
+  logbrewTraceContextFromCurrentOpenTelemetrySpan,
+  logbrewTraceContextFromOpenTelemetrySpan,
+  logbrewTraceContextFromOpenTelemetrySpanContext,
+  parseBaggage,
+  parseTraceparent,
+  parseTracestate,
+  RecordingTransport,
+  SdkError,
+  spanAttributesFromOpenTelemetryReadableSpan,
+  spanAttributesFromTraceparent,
+  TransportError
+} from "./index.js";
+
+declare const sdk: Omit<
+  typeof core,
+  "createLogBrewWinstonTransport" | "logAttributesFromWinstonInfo"
+>;
+
+export default sdk;

package/react-native.js

@@ -0,0 +1,34 @@
+import sdk from "./core.cjs";
+
+export const {
+  createBaggage,
+  createIssueAttributesFromError,
+  createNetworkMilestoneAttributes,
+  createProductActionAttributes,
+  createLogBrewOpenTelemetrySpanExporter,
+  createLogBrewOpenTelemetrySpanProcessor,
+  createSupportTicketDraft,
+  createTraceContextHeaders,
+  createTraceparent,
+  createTraceparentHeaders,
+  createTracestate,
+  createLogBrewPinoDestination,
+  installLogBrewConsoleCapture,
+  LogBrewClient,
+  logbrewTraceContextFromCurrentOpenTelemetrySpan,
+  logbrewTraceContextFromOpenTelemetrySpan,
+  logbrewTraceContextFromOpenTelemetrySpanContext,
+  logAttributesFromConsoleArgs,
+  logAttributesFromPinoRecord,
+  logbrewLevelFromConsoleMethod,
+  parseBaggage,
+  parseTraceparent,
+  parseTracestate,
+  RecordingTransport,
+  SdkError,
+  spanAttributesFromOpenTelemetryReadableSpan,
+  spanAttributesFromTraceparent,
+  TransportError
+} = sdk;
+
+export default sdk;

package/release-artifacts-build.cjs

@@ -0,0 +1,227 @@
+"use strict";
+
+const { spawnSync } = require("node:child_process");
+const net = require("node:net");
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
+const UPLOAD_OPTION_NAMES = new Set([
+  "allowHostedUpload",
+  "dryRun",
+  "endpoint",
+  "maxRetries",
+  "retryDelay",
+  "timeout",
+  "tokenEnv",
+]);
+
+function optionalBoolean(options, name, integration, defaultValue = false) {
+  const value = options?.[name];
+  if (value === undefined || value === null) {
+    return defaultValue;
+  }
+  if (typeof value !== "boolean") {
+    throw new Error(`LogBrew ${integration} release-artifact upload option ${name} must be a boolean`);
+  }
+  return value;
+}
+
+function optionalString(options, name, integration) {
+  const value = options?.[name];
+  if (value === undefined || value === null) {
+    return null;
+  }
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`LogBrew ${integration} release-artifact upload option ${name} must be a non-empty string`);
+  }
+  return value.trim();
+}
+
+function requiredString(options, name, integration) {
+  const value = optionalString(options, name, integration);
+  if (!value) {
+    throw new Error(`LogBrew ${integration} release-artifact upload requires ${name}`);
+  }
+  return value;
+}
+
+function optionalBoundedNumber(options, name, integration, minimum, maximum, integer = false) {
+  const value = options?.[name];
+  if (value === undefined || value === null) {
+    return null;
+  }
+  if (
+    typeof value !== "number" ||
+    !Number.isFinite(value) ||
+    value < minimum ||
+    value > maximum ||
+    (integer && !Number.isInteger(value))
+  ) {
+    const kind = integer ? "an integer" : "a number";
+    throw new Error(
+      `LogBrew ${integration} release-artifact upload option ${name} must be ${kind} from ${minimum} to ${maximum}`,
+    );
+  }
+  return value;
+}
+
+function normalizeReleaseArtifactProjectId(value, integration) {
+  if (value === undefined || value === null) {
+    return null;
+  }
+  if (typeof value !== "string" || !UUID_RE.test(value.trim())) {
+    throw new Error(`LogBrew ${integration} release-artifact option projectId must be a UUID`);
+  }
+  return value.trim().toLowerCase();
+}
+
+function parseUploadEndpoint(endpoint, integration) {
+  let parsed;
+  try {
+    parsed = new URL(endpoint);
+  } catch {
+    throw new Error(`LogBrew ${integration} release-artifact upload endpoint must be a valid URL`);
+  }
+  if (!new Set(["http:", "https:"]).has(parsed.protocol)) {
+    throw new Error(`LogBrew ${integration} release-artifact upload endpoint must use http or https`);
+  }
+  return parsed;
+}
+
+function isLoopbackEndpoint(parsed) {
+  const hostname = parsed.hostname.toLowerCase();
+  return (
+    hostname === "localhost" ||
+    hostname === "[::1]" ||
+    hostname === "::1" ||
+    (net.isIP(hostname) !== 0 && (hostname.startsWith("127.") || hostname === "::1"))
+  );
+}
+
+function normalizeReleaseArtifactUploadOptions(upload, { integration, projectId }) {
+  if (upload === undefined || upload === null) {
+    return null;
+  }
+  if (typeof upload !== "object" || Array.isArray(upload)) {
+    throw new Error(`LogBrew ${integration} release-artifact option upload must be an object`);
+  }
+  const unknownOption = Object.keys(upload).find((name) => !UPLOAD_OPTION_NAMES.has(name));
+  if (unknownOption) {
+    throw new Error(`LogBrew ${integration} release-artifact unknown upload option ${unknownOption}`);
+  }
+
+  const endpoint = requiredString(upload, "endpoint", integration);
+  const parsedEndpoint = parseUploadEndpoint(endpoint, integration);
+  const allowHostedUpload = optionalBoolean(upload, "allowHostedUpload", integration);
+  const hosted = !isLoopbackEndpoint(parsedEndpoint);
+  if (hosted && !allowHostedUpload) {
+    throw new Error(`LogBrew ${integration} release-artifact hosted upload requires allowHostedUpload`);
+  }
+  if (hosted && parsedEndpoint.protocol !== "https:") {
+    throw new Error(`LogBrew ${integration} hosted release-artifact upload endpoint must use https`);
+  }
+  if (hosted && (parsedEndpoint.username || parsedEndpoint.password)) {
+    throw new Error(`LogBrew ${integration} hosted release-artifact upload endpoint must not include embedded auth values`);
+  }
+  if (hosted && (parsedEndpoint.search || parsedEndpoint.hash)) {
+    throw new Error(`LogBrew ${integration} hosted release-artifact upload endpoint must not include query strings or fragments`);
+  }
+  if (hosted && !projectId) {
+    throw new Error(`LogBrew ${integration} release-artifact hosted upload requires projectId`);
+  }
+
+  const tokenEnv = optionalString(upload, "tokenEnv", integration);
+  if (tokenEnv && !/^[A-Za-z_][A-Za-z0-9_]*$/u.test(tokenEnv)) {
+    throw new Error(`LogBrew ${integration} release-artifact upload option tokenEnv must be an environment variable name`);
+  }
+
+  return {
+    endpoint,
+    allowHostedUpload,
+    tokenEnv,
+    dryRun: optionalBoolean(upload, "dryRun", integration),
+    maxRetries: optionalBoundedNumber(upload, "maxRetries", integration, 0, 10, true),
+    retryDelay: optionalBoundedNumber(upload, "retryDelay", integration, 0, 60),
+    timeout: optionalBoundedNumber(upload, "timeout", integration, 0, 300),
+  };
+}
+
+function appendOption(args, name, value) {
+  if (value !== null) {
+    args.push(name, String(value));
+  }
+}
+
+function createReleaseArtifactUploadArgs(buildDir, manifestPath, upload) {
+  const args = ["--build-dir", buildDir, "--manifest", manifestPath, "--endpoint", upload.endpoint];
+  appendOption(args, "--token-env", upload.tokenEnv);
+  if (upload.allowHostedUpload) {
+    args.push("--allow-hosted");
+  }
+  if (upload.dryRun) {
+    args.push("--dry-run");
+  }
+  appendOption(args, "--max-retries", upload.maxRetries);
+  appendOption(args, "--retry-delay", upload.retryDelay);
+  appendOption(args, "--timeout", upload.timeout);
+  return args;
+}
+
+function parseJson(stdout, command) {
+  try {
+    return JSON.parse(stdout);
+  } catch (error) {
+    throw new Error(`LogBrew release-artifact ${command} did not return JSON`, { cause: error });
+  }
+}
+
+function sanitizeValidationDiagnostic(message) {
+  const printable = Array.from(message, (character) => {
+    const codePoint = character.codePointAt(0);
+    return codePoint <= 31 || codePoint === 127 ? " " : character;
+  }).join("");
+  return printable.replace(/\s+/gu, " ").trim().slice(0, 200);
+}
+
+function validationErrors(report) {
+  if (!report?.validation || !Array.isArray(report.validation.errors)) {
+    return [];
+  }
+  return report.validation.errors
+    .filter((message) => typeof message === "string")
+    .map(sanitizeValidationDiagnostic)
+    .filter((message) => message !== "")
+    .slice(0, 3);
+}
+
+function safeReportStatus(report) {
+  const status = report?.status;
+  return typeof status === "string" && /^[a-z][a-z0-9_]{0,63}$/u.test(status) ? status : null;
+}
+
+function runReleaseArtifactCli(cliPath, command, args) {
+  const result = spawnSync(process.execPath, [cliPath, command, ...args], {
+    cwd: process.cwd(),
+    encoding: "utf8",
+    windowsHide: true,
+  });
+  const report = result.stdout ? parseJson(result.stdout, command) : null;
+  if (result.status !== 0) {
+    const details = validationErrors(report).join("; ") || safeReportStatus(report) || "execution_failed";
+    throw new Error(`LogBrew release-artifact ${command} failed: ${details}`);
+  }
+  return { report, stdout: result.stdout };
+}
+
+function formatReleaseArtifactUploadSummary(report) {
+  const artifactCount = Number.isSafeInteger(report?.artifactCount) && report.artifactCount >= 0 ? report.artifactCount : 0;
+  const artifactLabel = artifactCount === 1 ? "artifact" : "artifacts";
+  return `LogBrew release artifacts: ${safeReportStatus(report) ?? "unknown"} (${artifactCount} ${artifactLabel})`;
+}
+
+module.exports = {
+  createReleaseArtifactUploadArgs,
+  formatReleaseArtifactUploadSummary,
+  normalizeReleaseArtifactProjectId,
+  normalizeReleaseArtifactUploadOptions,
+  runReleaseArtifactCli,
+};

package/release-artifacts-common.js

@@ -0,0 +1,82 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
+
+export function sortJson(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortJson);
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.keys(value)
+        .sort()
+        .map((key) => [key, sortJson(value[key])])
+    );
+  }
+  return value;
+}
+
+export function stableJson(value) {
+  return JSON.stringify(sortJson(value));
+}
+
+export function printJson(payload) {
+  process.stdout.write(`${JSON.stringify(sortJson(payload), null, 2)}\n`);
+}
+
+export function safeResolve(candidate, root) {
+  const resolvedRoot = fs.realpathSync(root);
+  const resolved = path.resolve(candidate);
+  const comparable = fs.existsSync(resolved) ? fs.realpathSync(resolved) : resolved;
+  const relative = path.relative(resolvedRoot, comparable);
+  if (relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))) {
+    return comparable;
+  }
+  return null;
+}
+
+export function byteSize(filePath) {
+  return fs.statSync(filePath).size;
+}
+
+export function sha256File(filePath) {
+  const digest = crypto.createHash("sha256");
+  digest.update(fs.readFileSync(filePath));
+  return digest.digest("hex");
+}
+
+export function requireBuildDir(value) {
+  const buildDir = path.resolve(value);
+  if (!fs.existsSync(buildDir) || !fs.statSync(buildDir).isDirectory()) {
+    throw new Error(`build directory does not exist: ${value}`);
+  }
+  return fs.realpathSync(buildDir);
+}
+
+export function readJsonObject(filePath, label) {
+  let payload;
+  try {
+    payload = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    throw new Error(`${label} is not valid JSON: ${error.message}`, { cause: error });
+  }
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new Error(`${label} must be a JSON object`);
+  }
+  return payload;
+}
+
+export function normalizeProjectId(value, errorMessage, required = false) {
+  if (value === undefined || value === null) {
+    if (required) {
+      throw new Error(errorMessage);
+    }
+    return undefined;
+  }
+  if (typeof value !== "string" || UUID_RE.test(value.trim()) === false) {
+    throw new Error(errorMessage);
+  }
+  return value.trim().toLowerCase();
+}