@observa/sdk 2.4.0 → 2.4.5

package/dist/index.js

@@ -1,583 +1,18 @@
-// src/apis/ingestApi.ts
-import { randomUUID } from "crypto";
-
-// src/http/errors.ts
-var SdkError = class extends Error {
-  status;
-  code;
-  details;
-  /**
-   * Creates an error with optional metadata.
-   */
-  constructor(message, details) {
-    super(message);
-    this.name = new.target.name;
-    this.status = details?.status;
-    this.code = details?.code;
-    this.details = details?.details;
-  }
-};
-var ValidationError = class extends SdkError {
-};
-var AuthError = class extends SdkError {
-};
-var ForbiddenError = class extends SdkError {
-};
-var NotFoundError = class extends SdkError {
-};
-var ConflictError = class extends SdkError {
-};
-var RateLimitError = class extends SdkError {
-  retryAfter;
-  constructor(message, details) {
-    super(message, details);
-    this.retryAfter = details?.retryAfter;
-  }
-};
-var ServerError = class extends SdkError {
-};
-var NetworkError = class extends SdkError {
-};
-var TimeoutError = class extends SdkError {
-};
-function mapHttpError(status, details, retryAfter) {
-  const info = { status, details, retryAfter };
-  if (status === 400) return new ValidationError("Invalid request", info);
-  if (status === 401) return new AuthError("Unauthorized", info);
-  if (status === 403) return new ForbiddenError("Forbidden", info);
-  if (status === 404) return new NotFoundError("Resource not found", info);
-  if (status === 409) return new ConflictError("Conflict", info);
-  if (status === 429) return new RateLimitError("Rate limit exceeded", info);
-  if (status >= 500) return new ServerError("Server error", info);
-  return new SdkError("HTTP error", info);
-}
-
-// src/utils/processContext.ts
-function getProcessContext(options) {
-  const includeStatic = options?.includeStatic ?? true;
-  const includeDynamic = options?.includeDynamic ?? true;
-  const includeVersions = options?.includeVersions ?? true;
-  const includeRuntime = options?.includeRuntime ?? true;
-  const includePid = options?.includePid ?? true;
-  const includeUptime = options?.includeUptime ?? true;
-  const includeMemory = options?.includeMemory ?? true;
-  const context = {};
-  if (includeDynamic) {
-    if (includePid) context.pid = process.pid;
-    if (includeUptime) context.uptimeSeconds = Math.round(process.uptime());
-    if (includeMemory) context.memory = process.memoryUsage();
-  }
-  if (includeStatic) {
-    if (includeVersions) context.versions = process.versions;
-    if (includeRuntime) {
-      context.node = process.versions.node;
-      context.platform = process.platform;
-      context.arch = process.arch;
-      context.releaseName = process.release?.name;
-    }
-  }
-  return context;
-}
-function getProcessContextStatic(options) {
-  return getProcessContext({
-    includeDynamic: false,
-    includeStatic: true,
-    includeVersions: options?.includeVersions,
-    includeRuntime: options?.includeRuntime
-  });
-}
-function getProcessContextDynamic(options) {
-  return getProcessContext({
-    includeStatic: false,
-    includeDynamic: true,
-    includePid: options?.includePid,
-    includeUptime: options?.includeUptime,
-    includeMemory: options?.includeMemory
-  });
-}
-
-// src/utils/validate.ts
-function ensureNonEmpty(value, name) {
-  if (!value || value.trim().length === 0) {
-    throw new ValidationError(`${name} is required`);
-  }
-}
-function ensureDefined(value, name) {
-  if (value === null || value === void 0) {
-    throw new ValidationError(`${name} is required`);
-  }
-}
-
-// src/apis/ingestApi.ts
-var DEFAULT_NORMALIZATION = {
-  schemaVersion: 1,
-  includeContext: true,
-  includeSystemContext: true,
-  includeRuntimeContext: true,
-  maxEventBytes: 64 * 1024,
-  maxFrames: 60,
-  maxMessageLength: 4e3,
-  maxExceptionValueLength: 4e3
-};
-var IngestApi = class {
-  /**
-   * Creates the ingestion client with an optional default DSN and PublicKey.
-   */
-  constructor(http, defaultDsnKey, normalization, defaultPublicKey) {
-    this.http = http;
-    this.defaultDsnKey = defaultDsnKey;
-    this.normalization = normalization;
-    this.defaultPublicKey = defaultPublicKey;
-  }
-  /**
-   * Sends an event to the ingestion backend.
-   */
-  async event(input) {
-    ensureDefined(input, "input");
-    const dsnKey = input.dsnKey ?? this.defaultDsnKey;
-    const publicKey = input.publicKey ?? this.defaultPublicKey;
-    ensureDefined(dsnKey, "dsnKey");
-    ensureNonEmpty(dsnKey, "dsnKey");
-    ensureDefined(input.event, "event");
-    if (!this.http.hasApiKey() && !publicKey) {
-      throw new ValidationError("publicKey is required when apiKey is not provided");
-    }
-    if (input.idempotencyKey && input.idempotencyKey.length > 128) {
-      throw new ValidationError("idempotencyKey must be at most 128 characters");
-    }
-    const headers = {};
-    if (input.idempotencyKey) headers["x-idempotency-key"] = input.idempotencyKey;
-    if (input.sdkVersion) headers["x-sdk-version"] = input.sdkVersion;
-    const { idempotencyKey, sdkVersion, event, ...body } = input;
-    const normalizedEvent = normalizeEvent(event, this.normalization);
-    const authMode = this.http.hasApiKey() ? "apiKey" : "none";
-    return this.http.post("/ingest/events", { ...body, dsnKey, publicKey, event: normalizedEvent }, { auth: authMode, headers });
-  }
-  async health(dsnKey, publicKey) {
-    const resolvedDsnKey = dsnKey ?? this.defaultDsnKey;
-    const resolvedPublicKey = publicKey ?? this.defaultPublicKey;
-    ensureDefined(resolvedDsnKey, "dsnKey");
-    ensureNonEmpty(resolvedDsnKey, "dsnKey");
-    const authMode = this.http.hasApiKey() ? "apiKey" : "none";
-    return this.http.post("/ingest/health", { dsnKey: resolvedDsnKey, publicKey: resolvedPublicKey }, { auth: authMode });
-  }
-};
-function normalizeEvent(event, options) {
-  const config = { ...DEFAULT_NORMALIZATION, ...options };
-  const normalizedTimestamp = normalizeTimestamp(event.timestamp);
-  const normalizedLevel = event.level ? event.level.toLowerCase() : void 0;
-  const normalizedMessage = event.message ? truncate(event.message, config.maxMessageLength) : void 0;
-  const normalizedException = normalizeException(event.exception, config);
-  if (!normalizedMessage && !normalizedException) {
-    throw new ValidationError("event message or exception is required");
-  }
-  const normalizedContext = normalizeContext(event.context, config);
-  const normalizedEvent = {
-    ...event,
-    event_id: event.event_id ?? randomUUID(),
-    timestamp: normalizedTimestamp,
-    schema_version: event.schema_version ?? config.schemaVersion,
-    level: normalizedLevel,
-    message: normalizedMessage,
-    exception: normalizedException,
-    context: normalizedContext
-  };
-  return enforceSizeLimit(normalizedEvent, config);
-}
-function normalizeTimestamp(timestamp) {
-  if (!timestamp) return (/* @__PURE__ */ new Date()).toISOString();
-  const parsed = new Date(timestamp);
-  if (Number.isNaN(parsed.getTime())) {
-    throw new ValidationError("timestamp must be a valid ISO date");
-  }
-  return parsed.toISOString();
-}
-function normalizeException(exception, config) {
-  if (!exception) return void 0;
-  if (!exception.type || !exception.value) {
-    throw new ValidationError("exception.type and exception.value are required");
-  }
-  return {
-    ...exception,
-    value: truncate(exception.value, config.maxExceptionValueLength),
-    stacktrace: normalizeStacktrace(exception.stacktrace, config.maxFrames)
-  };
-}
-function normalizeStacktrace(stacktrace, maxFrames) {
-  if (!stacktrace || !Array.isArray(stacktrace.frames)) return void 0;
-  const frames = stacktrace.frames;
-  const normalizedFrames = frames.slice(0, maxFrames).map((frame) => {
-    const filename = typeof frame?.filename === "string" ? frame.filename : void 0;
-    const functionName = typeof frame?.function === "string" ? frame.function : void 0;
-    const lineno = typeof frame?.lineno === "number" ? frame.lineno : void 0;
-    const colno = typeof frame?.colno === "number" ? frame.colno : void 0;
-    const inferredInApp = filename ? !filename.includes("node_modules") : false;
-    return {
-      filename,
-      function: functionName,
-      lineno,
-      colno,
-      in_app: typeof frame?.in_app === "boolean" ? frame.in_app : inferredInApp
-    };
-  });
-  return { frames: normalizedFrames };
-}
-function normalizeContext(context, config) {
-  if (!config.includeContext) return context;
-  const systemContext = config.includeSystemContext ? getProcessContextDynamic() : void 0;
-  const runtimeContext = config.includeRuntimeContext ? getProcessContextStatic({ includeVersions: false }) : void 0;
-  const mergedContext = {
-    ...context,
-    system: context?.system ?? systemContext,
-    runtime: context?.runtime ?? runtimeContext
-  };
-  return mergedContext;
-}
-function enforceSizeLimit(event, config) {
-  let normalized = event;
-  if (getSize(normalized) <= config.maxEventBytes) return normalized;
-  if (normalized.extra) {
-    normalized = { ...normalized, extra: void 0 };
-  }
-  if (getSize(normalized) <= config.maxEventBytes) return normalized;
-  if (normalized.tags) {
-    normalized = { ...normalized, tags: void 0 };
-  }
-  if (getSize(normalized) <= config.maxEventBytes) return normalized;
-  if (normalized.exception?.stacktrace) {
-    normalized = {
-      ...normalized,
-      exception: { ...normalized.exception, stacktrace: void 0 }
-    };
-  }
-  if (getSize(normalized) <= config.maxEventBytes) return normalized;
-  if (normalized.message) {
-    normalized = { ...normalized, message: truncate(normalized.message, config.maxMessageLength) };
-  }
-  if (normalized.exception?.value) {
-    normalized = {
-      ...normalized,
-      exception: { ...normalized.exception, value: truncate(normalized.exception.value, config.maxExceptionValueLength) }
-    };
-  }
-  if (getSize(normalized) <= config.maxEventBytes) return normalized;
-  throw new ValidationError("event payload exceeds size limit");
-}
-function getSize(value) {
-  return Buffer.byteLength(JSON.stringify(value), "utf8");
-}
-function truncate(value, maxLength) {
-  if (value.length <= maxLength) return value;
-  return value.slice(0, maxLength);
-}
-
-// src/apis/uptimeApi.ts
-var UptimeApi = class {
-  /**
-   * Creates the uptime client with an optional default DSN.
-   */
-  constructor(http, defaultDsnKey) {
-    this.http = http;
-    this.defaultDsnKey = defaultDsnKey;
-  }
-  /**
-   * Records an uptime heartbeat.
-   */
-  async recordHeartbeat(input) {
-    ensureDefined(input, "input");
-    const dsnKey = input.dsnKey ?? this.defaultDsnKey;
-    ensureDefined(dsnKey, "dsnKey");
-    ensureNonEmpty(dsnKey, "dsnKey");
-    ensureNonEmpty(input.status, "status");
-    return this.http.post("/uptime/heartbeats", { ...input, dsnKey }, { auth: "apiKey" });
-  }
-  /**
-   * Lists a project's daily uptime history.
-   */
-  async history(projectId, date) {
-    ensureNonEmpty(projectId, "projectId");
-    ensureNonEmpty(date, "date");
-    return this.http.get(`/projects/${encodeURIComponent(projectId)}/uptime/history`, {
-      query: { date },
-      auth: "none"
-    });
-  }
-  /**
-   * Gets the latest uptime event for a project.
-   */
-  async latest(projectId) {
-    ensureNonEmpty(projectId, "projectId");
-    return this.http.get(`/projects/${encodeURIComponent(projectId)}/uptime/latest`, {
-      auth: "none"
-    });
-  }
-  /**
-   * Summarizes daily uptime.
-   */
-  async summary(projectId, days, delayThresholdMinutes) {
-    ensureNonEmpty(projectId, "projectId");
-    return this.http.get(`/projects/${encodeURIComponent(projectId)}/uptime/summary`, {
-      query: { days, delayThresholdMinutes },
-      auth: "none"
-    });
-  }
-};
-
-// src/http/httpClient.ts
-var HttpClient = class {
-  apiKey;
-  baseUrl;
-  timeoutMs;
-  headers;
-  retry;
-  healthCheckPromise;
-  /**
-   * Creates an HTTP client with baseUrl and optional apiKey.
-   */
-  constructor(options) {
-    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
-    this.apiKey = options.apiKey;
-    this.timeoutMs = options.timeoutMs ?? 5e3;
-    this.headers = options.headers ?? {};
-    this.retry = options.retry;
-  }
-  /**
-   * Updates the API key at runtime.
-   */
-  setApiKey(apiKey) {
-    this.apiKey = apiKey;
-  }
-  /**
-   * Checks if an API key is configured.
-   */
-  hasApiKey() {
-    return !!this.apiKey;
-  }
-  startHealthCheck(healthCheck) {
-    if (!this.healthCheckPromise) {
-      const promise = healthCheck();
-      this.healthCheckPromise = promise;
-      promise.catch(() => void 0);
-    }
-  }
-  /**
-   * GET request.
-   */
-  async get(path, options) {
-    return this.request({ method: "GET", path, ...options });
-  }
-  /**
-   * POST request.
-   */
-  async post(path, body, options) {
-    return this.request({ method: "POST", path, body, ...options });
-  }
-  /**
-   * PUT request.
-   */
-  async put(path, body, options) {
-    return this.request({ method: "PUT", path, body, ...options });
-  }
-  /**
-   * PATCH request.
-   */
-  async patch(path, body, options) {
-    return this.request({ method: "PATCH", path, body, ...options });
-  }
-  /**
-   * DELETE request.
-   */
-  async delete(path, options) {
-    return this.request({ method: "DELETE", path, ...options });
-  }
-  /**
-   * Executes a request with retry logic.
-   */
-  async request(options) {
-    if (this.healthCheckPromise) {
-      await this.healthCheckPromise;
-    }
-    const retry = this.retry ?? { retries: 0 };
-    const retryOn = retry.retryOn ?? ((response, error) => {
-      if (response) return response.status === 429 || response.status >= 500;
-      return error instanceof NetworkError || error instanceof TimeoutError || error instanceof TypeError;
-    });
-    const retryDelayMs = retry.retryDelayMs ?? ((attempt) => Math.min(1e3 * 2 ** (attempt - 1), 8e3));
-    let lastError;
-    for (let attempt = 0; attempt <= retry.retries; attempt += 1) {
-      try {
-        const { response, data } = await this.execute(options);
-        if (!response.ok) {
-          const retryAfter = this.parseRetryAfter(response.headers.get("retry-after"));
-          const error = mapHttpError(response.status, data, retryAfter);
-          if (retryOn(response, error) && attempt < retry.retries) {
-            await this.delay(retryDelayMs(attempt + 1, response, error));
-            continue;
-          }
-          throw error;
-        }
-        return data;
-      } catch (error) {
-        lastError = error;
-        if (retryOn(void 0, error) && attempt < retry.retries) {
-          await this.delay(retryDelayMs(attempt + 1, void 0, error));
-          continue;
-        }
-        throw error;
-      }
-    }
-    throw lastError;
-  }
-  /**
-   * Executes a request without retry and returns response + data.
-   */
-  async execute(options) {
-    const url = this.buildUrl(options.path, options.query);
-    const headers = { ...this.headers, ...options.headers };
-    if (options.body !== void 0) headers["content-type"] = "application/json";
-    const authMode = options.auth ?? "none";
-    if (authMode === "apiKey") {
-      if (!this.apiKey) throw new AuthError("API key is required");
-      headers["x-api-key"] = this.apiKey;
-    }
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
-    try {
-      const response = await fetch(url, {
-        method: options.method,
-        headers,
-        body: options.body === void 0 ? void 0 : JSON.stringify(options.body),
-        signal: controller.signal
-      });
-      const data = await this.readBody(response);
-      return { response, data };
-    } catch (error) {
-      if (error?.name === "AbortError") {
-        throw new TimeoutError("Request timeout");
-      }
-      if (error instanceof NetworkError || error instanceof TimeoutError) throw error;
-      if (error instanceof Error) {
-        if (error instanceof AuthError) throw error;
-      }
-      if (error instanceof Error && "status" in error) throw error;
-      throw new NetworkError("Network error", { details: error });
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-  /**
-   * Builds the final URL with query params.
-   */
-  buildUrl(path, query) {
-    const base = this.baseUrl;
-    const fullPath = path.startsWith("http") ? path : `${base}${path.startsWith("/") ? "" : "/"}${path}`;
-    if (!query) return fullPath;
-    const params = new URLSearchParams();
-    for (const [key, value] of Object.entries(query)) {
-      if (value === void 0) continue;
-      params.set(key, String(value));
-    }
-    const suffix = params.toString();
-    return suffix ? `${fullPath}?${suffix}` : fullPath;
-  }
-  /**
-   * Parses the body as JSON when possible.
-   */
-  async readBody(response) {
-    if (response.status === 204) return void 0;
-    const text = await response.text();
-    if (!text) return void 0;
-    try {
-      return JSON.parse(text);
-    } catch {
-      return text;
-    }
-  }
-  parseRetryAfter(value) {
-    if (!value) return void 0;
-    const seconds = Number(value);
-    if (!Number.isNaN(seconds) && Number.isFinite(seconds)) {
-      return Math.max(0, seconds);
-    }
-    const parsedDate = Date.parse(value);
-    if (Number.isNaN(parsedDate)) return void 0;
-    const diffMs = parsedDate - Date.now();
-    if (diffMs <= 0) return 0;
-    return Math.ceil(diffMs / 1e3);
-  }
-  /**
-   * Simple delay for retries.
-   */
-  async delay(ms) {
-    await new Promise((resolve) => setTimeout(resolve, ms));
-  }
-};
-
-// src/sdk.ts
-var DEFAULT_BASE_URL = "https://backend-observa-production.up.railway.app/v1";
-var ObservaSDK = class {
-  /**
-   * Uptime API (heartbeats and public reads).
-   */
-  uptime;
-  /**
-   * Event ingestion API.
-   */
-  ingest;
-  http;
-  /**
-   * Creates an SDK instance with required dsnKey and either apiKey or publicKey.
-   */
-  constructor(options) {
-    if (!options || !options.apiKey && !options.publicKey || !options.dsnKey) {
-      throw new Error("ObservaSDK requires dsnKey and either apiKey or publicKey");
-    }
-    const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
-    const normalizedBaseUrl = baseUrl.endsWith("/v1") ? baseUrl : `${baseUrl}/v1`;
-    this.http = new HttpClient({
-      baseUrl: normalizedBaseUrl,
-      apiKey: options.apiKey,
-      timeoutMs: options.timeoutMs,
-      retry: options.retry,
-      headers: options.headers
-    });
-    this.ingest = new IngestApi(this.http, options.dsnKey, options.ingest, options.publicKey);
-    this.uptime = new UptimeApi(this.http, options.dsnKey);
-    this.http.startHealthCheck(() => this.ingest.health(options.dsnKey, options.publicKey));
-  }
-  /**
-   * Updates the API key used by the SDK at runtime.
-   */
-  setApiKey(apiKey) {
-    this.http.setApiKey(apiKey);
-  }
-  getProcessContext(options) {
-    return getProcessContext(options);
-  }
-  getProcessContextStatic(options) {
-    return getProcessContextStatic(options);
-  }
-  getProcessContextDynamic(options) {
-    return getProcessContextDynamic(options);
-  }
-};
-export {
-  AuthError,
-  ConflictError,
-  ForbiddenError,
-  HttpClient,
-  IngestApi,
-  NetworkError,
-  NotFoundError,
-  ObservaSDK,
-  RateLimitError,
-  SdkError,
-  ServerError,
-  TimeoutError,
-  UptimeApi,
-  ValidationError,
-  getProcessContext,
-  getProcessContextDynamic,
-  getProcessContextStatic
-};
+/**
+ * Main SDK.
+ */
+export { ObservaSDK } from './sdk';
+/**
+ * Base HTTP client.
+ */
+export { HttpClient } from './http/httpClient';
+/**
+ * Typed SDK errors.
+ */
+export { SdkError, ValidationError, AuthError, ForbiddenError, NotFoundError, ConflictError, RateLimitError, ServerError, NetworkError, TimeoutError, } from './http/errors';
+/**
+ * Domain APIs.
+ */
+export { UptimeApi } from './apis/uptimeApi';
+export { IngestApi } from './apis/ingestApi';
 //# sourceMappingURL=index.js.map