@klime/node 1.0.3 → 1.2.1

package/dist/index.js

@@ -1,419 +1,509 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
+// src/index.ts
+import * as https from "https";
+import * as http from "http";
+import * as url from "url";
+
+// src/types.ts
+var SendError = class extends Error {
+  constructor(message, events) {
+    super(message);
+    this.name = "SendError";
+    this.events = events;
+  }
+};
+
+// src/index.ts
+var DEFAULT_ENDPOINT = "https://i.klime.com";
+var DEFAULT_FLUSH_INTERVAL = 2e3;
+var DEFAULT_MAX_BATCH_SIZE = 20;
+var DEFAULT_MAX_QUEUE_SIZE = 1e3;
+var DEFAULT_RETRY_MAX_ATTEMPTS = 5;
+var DEFAULT_RETRY_INITIAL_DELAY = 1e3;
+var MAX_BATCH_SIZE = 100;
+var MAX_EVENT_SIZE_BYTES = 200 * 1024;
+var MAX_BATCH_SIZE_BYTES = 10 * 1024 * 1024;
+var SDK_VERSION = "1.1.0";
+var hasNativeFetch = typeof fetch !== "undefined";
+var createDefaultLogger = () => ({
+  debug: (message, ...args) => console.debug(`[Klime] ${message}`, ...args),
+  info: (message, ...args) => console.info(`[Klime] ${message}`, ...args),
+  warn: (message, ...args) => console.warn(`[Klime] ${message}`, ...args),
+  error: (message, ...args) => console.error(`[Klime] ${message}`, ...args)
 });
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
+var KlimeClient = class {
+  constructor(config) {
+    this.queue = [];
+    this.flushTimer = null;
+    this.isShutdown = false;
+    this.flushPromise = null;
+    this.shutdownHandlers = [];
+    if (!config.writeKey) {
+      throw new Error("writeKey is required");
+    }
+    this.config = {
+      writeKey: config.writeKey,
+      endpoint: config.endpoint || DEFAULT_ENDPOINT,
+      flushInterval: config.flushInterval ?? DEFAULT_FLUSH_INTERVAL,
+      maxBatchSize: Math.min(
+        config.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE,
+        MAX_BATCH_SIZE
+      ),
+      maxQueueSize: config.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE,
+      retryMaxAttempts: config.retryMaxAttempts ?? DEFAULT_RETRY_MAX_ATTEMPTS,
+      retryInitialDelay: config.retryInitialDelay ?? DEFAULT_RETRY_INITIAL_DELAY,
+      flushOnShutdown: config.flushOnShutdown ?? true,
+      logger: config.logger ?? createDefaultLogger(),
+      onError: config.onError,
+      onSuccess: config.onSuccess
     };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
+    if (this.config.flushOnShutdown) {
+      const shutdownHandler = async () => {
+        await this.shutdown();
+      };
+      process.on("SIGTERM", shutdownHandler);
+      process.on("SIGINT", shutdownHandler);
+      this.shutdownHandlers.push(() => {
+        process.removeListener("SIGTERM", shutdownHandler);
+        process.removeListener("SIGINT", shutdownHandler);
+      });
+    }
+    this.scheduleFlush();
+  }
+  track(event, properties, options) {
+    if (this.isShutdown) {
+      return;
+    }
+    const eventObj = {
+      type: "track",
+      messageId: this.generateUUID(),
+      event,
+      timestamp: this.generateTimestamp(),
+      properties: properties || {},
+      context: this.getContext()
     };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KlimeClient = void 0;
-const https = __importStar(require("https"));
-const http = __importStar(require("http"));
-const url = __importStar(require("url"));
-const DEFAULT_ENDPOINT = "https://i.klime.com";
-const DEFAULT_FLUSH_INTERVAL = 2000;
-const DEFAULT_MAX_BATCH_SIZE = 20;
-const DEFAULT_MAX_QUEUE_SIZE = 1000;
-const DEFAULT_RETRY_MAX_ATTEMPTS = 5;
-const DEFAULT_RETRY_INITIAL_DELAY = 1000;
-const MAX_BATCH_SIZE = 100;
-const MAX_EVENT_SIZE_BYTES = 200 * 1024; // 200KB
-const MAX_BATCH_SIZE_BYTES = 10 * 1024 * 1024; // 10MB
-const SDK_VERSION = "1.0.1";
-// Check if fetch is available (Node 18+)
-const hasNativeFetch = typeof fetch !== "undefined";
-class KlimeClient {
-    constructor(config) {
-        this.queue = [];
-        this.flushTimer = null;
-        this.isShutdown = false;
-        this.flushPromise = null;
-        this.shutdownHandlers = [];
-        if (!config.writeKey) {
-            throw new Error("writeKey is required");
-        }
-        this.config = {
-            writeKey: config.writeKey,
-            endpoint: config.endpoint || DEFAULT_ENDPOINT,
-            flushInterval: config.flushInterval ?? DEFAULT_FLUSH_INTERVAL,
-            maxBatchSize: Math.min(config.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE, MAX_BATCH_SIZE),
-            maxQueueSize: config.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE,
-            retryMaxAttempts: config.retryMaxAttempts ?? DEFAULT_RETRY_MAX_ATTEMPTS,
-            retryInitialDelay: config.retryInitialDelay ?? DEFAULT_RETRY_INITIAL_DELAY,
-            flushOnShutdown: config.flushOnShutdown ?? true,
-        };
-        if (this.config.flushOnShutdown) {
-            const shutdownHandler = async () => {
-                await this.shutdown();
-            };
-            process.on("SIGTERM", shutdownHandler);
-            process.on("SIGINT", shutdownHandler);
-            this.shutdownHandlers.push(() => {
-                process.removeListener("SIGTERM", shutdownHandler);
-                process.removeListener("SIGINT", shutdownHandler);
-            });
-        }
-        this.scheduleFlush();
+    if (options?.userId) {
+      eventObj.userId = options.userId;
     }
-    track(event, properties, options) {
-        if (this.isShutdown) {
-            return;
-        }
-        const eventObj = {
-            type: "track",
-            messageId: this.generateUUID(),
-            event,
-            timestamp: this.generateTimestamp(),
-            properties: properties || {},
-            context: this.getContext(options?.ip),
-        };
-        if (options?.userId) {
-            eventObj.userId = options.userId;
-        }
-        if (options?.groupId) {
-            eventObj.groupId = options.groupId;
-        }
-        this.enqueue(eventObj);
+    if (options?.groupId) {
+      eventObj.groupId = options.groupId;
     }
-    identify(userId, traits, options) {
-        if (this.isShutdown) {
-            return;
-        }
-        const eventObj = {
-            type: "identify",
-            messageId: this.generateUUID(),
-            userId,
-            timestamp: this.generateTimestamp(),
-            traits: traits || {},
-            context: this.getContext(options?.ip),
-        };
-        this.enqueue(eventObj);
-    }
-    group(groupId, traits, options) {
-        if (this.isShutdown) {
-            return;
-        }
-        const eventObj = {
-            type: "group",
-            messageId: this.generateUUID(),
-            groupId,
-            timestamp: this.generateTimestamp(),
-            traits: traits || {},
-            context: this.getContext(options?.ip),
-        };
-        if (options?.userId) {
-            eventObj.userId = options.userId;
-        }
-        this.enqueue(eventObj);
+    this.enqueue(eventObj);
+  }
+  identify(userId, traits, options) {
+    if (this.isShutdown) {
+      return;
     }
-    async flush() {
-        if (this.flushPromise) {
-            return this.flushPromise;
-        }
-        this.flushPromise = this.doFlush();
-        try {
-            await this.flushPromise;
-        }
-        finally {
-            this.flushPromise = null;
-        }
+    const eventObj = {
+      type: "identify",
+      messageId: this.generateUUID(),
+      userId,
+      timestamp: this.generateTimestamp(),
+      traits: traits || {},
+      context: this.getContext()
+    };
+    this.enqueue(eventObj);
+  }
+  group(groupId, traits, options) {
+    if (this.isShutdown) {
+      return;
     }
-    async shutdown() {
-        if (this.isShutdown) {
-            return;
-        }
-        this.isShutdown = true;
-        // Remove shutdown handlers
-        this.shutdownHandlers.forEach((handler) => handler());
-        this.shutdownHandlers = [];
-        if (this.flushTimer) {
-            clearTimeout(this.flushTimer);
-            this.flushTimer = null;
-        }
-        await this.flush();
-    }
-    enqueue(event) {
-        // Check event size
-        const eventSize = this.estimateEventSize(event);
-        if (eventSize > MAX_EVENT_SIZE_BYTES) {
-            console.error(`Klime: Event size (${eventSize} bytes) exceeds ${MAX_EVENT_SIZE_BYTES} bytes limit`);
-            return;
-        }
-        // Drop oldest if queue is full
-        if (this.queue.length >= this.config.maxQueueSize) {
-            this.queue.shift();
-        }
-        this.queue.push(event);
-        // Check if we should flush immediately
-        if (this.queue.length >= this.config.maxBatchSize) {
-            this.flush();
-        }
+    const eventObj = {
+      type: "group",
+      messageId: this.generateUUID(),
+      groupId,
+      timestamp: this.generateTimestamp(),
+      traits: traits || {},
+      context: this.getContext()
+    };
+    if (options?.userId) {
+      eventObj.userId = options.userId;
+    }
+    this.enqueue(eventObj);
+  }
+  /**
+   * Track an event synchronously. Returns BatchResponse or throws SendError.
+   */
+  async trackSync(event, properties, options) {
+    if (this.isShutdown) {
+      throw new SendError("Client is shutdown", []);
     }
-    async doFlush() {
-        if (this.queue.length === 0) {
-            return;
+    const eventObj = {
+      type: "track",
+      messageId: this.generateUUID(),
+      event,
+      timestamp: this.generateTimestamp(),
+      properties: properties || {},
+      context: this.getContext()
+    };
+    if (options?.userId) {
+      eventObj.userId = options.userId;
+    }
+    if (options?.groupId) {
+      eventObj.groupId = options.groupId;
+    }
+    return this.sendSync([eventObj]);
+  }
+  /**
+   * Identify a user synchronously. Returns BatchResponse or throws SendError.
+   */
+  async identifySync(userId, traits, options) {
+    if (this.isShutdown) {
+      throw new SendError("Client is shutdown", []);
+    }
+    const eventObj = {
+      type: "identify",
+      messageId: this.generateUUID(),
+      userId,
+      timestamp: this.generateTimestamp(),
+      traits: traits || {},
+      context: this.getContext()
+    };
+    return this.sendSync([eventObj]);
+  }
+  /**
+   * Associate a user with a group synchronously. Returns BatchResponse or throws SendError.
+   */
+  async groupSync(groupId, traits, options) {
+    if (this.isShutdown) {
+      throw new SendError("Client is shutdown", []);
+    }
+    const eventObj = {
+      type: "group",
+      messageId: this.generateUUID(),
+      groupId,
+      timestamp: this.generateTimestamp(),
+      traits: traits || {},
+      context: this.getContext()
+    };
+    if (options?.userId) {
+      eventObj.userId = options.userId;
+    }
+    return this.sendSync([eventObj]);
+  }
+  /**
+   * Return the number of events currently in the queue.
+   */
+  getQueueSize() {
+    return this.queue.length;
+  }
+  async flush() {
+    if (this.flushPromise) {
+      return this.flushPromise;
+    }
+    this.flushPromise = this.doFlush();
+    try {
+      await this.flushPromise;
+    } finally {
+      this.flushPromise = null;
+    }
+  }
+  async shutdown() {
+    if (this.isShutdown) {
+      return;
+    }
+    this.isShutdown = true;
+    this.shutdownHandlers.forEach((handler) => handler());
+    this.shutdownHandlers = [];
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flush();
+  }
+  enqueue(event) {
+    const eventSize = this.estimateEventSize(event);
+    if (eventSize > MAX_EVENT_SIZE_BYTES) {
+      this.config.logger.warn(
+        `Event size (${eventSize} bytes) exceeds ${MAX_EVENT_SIZE_BYTES} bytes limit`
+      );
+      return;
+    }
+    if (this.queue.length >= this.config.maxQueueSize) {
+      const dropped = this.queue.shift();
+      this.config.logger.warn(`Queue full, dropping oldest event: ${dropped?.type}`);
+    }
+    this.queue.push(event);
+    this.config.logger.debug(`Enqueued ${event.type} event, queue size: ${this.queue.length}`);
+    if (this.queue.length >= this.config.maxBatchSize) {
+      this.flush();
+    }
+  }
+  async doFlush() {
+    if (this.queue.length === 0) {
+      return;
+    }
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    while (this.queue.length > 0) {
+      const batch = this.extractBatch();
+      if (batch.length === 0) {
+        break;
+      }
+      await this.sendBatch(batch);
+    }
+    this.scheduleFlush();
+  }
+  extractBatch() {
+    const batch = [];
+    let batchSize = 0;
+    while (this.queue.length > 0 && batch.length < MAX_BATCH_SIZE) {
+      const event = this.queue[0];
+      const eventSize = this.estimateEventSize(event);
+      if (batchSize + eventSize > MAX_BATCH_SIZE_BYTES) {
+        break;
+      }
+      batch.push(this.queue.shift());
+      batchSize += eventSize;
+    }
+    return batch;
+  }
+  async sendBatch(batch) {
+    if (batch.length === 0) {
+      return;
+    }
+    this.config.logger.debug(`Sending batch of ${batch.length} events`);
+    const result = await this.doSend(batch);
+    if (result === null) {
+      const error = new Error(`Failed to send batch of ${batch.length} events after retries`);
+      this.invokeOnError(error, batch);
+    } else if (result.failed > 0 && result.errors) {
+      this.config.logger.warn(
+        `Batch partially failed. Accepted: ${result.accepted}, Failed: ${result.failed}`,
+        result.errors
+      );
+      this.invokeOnSuccess(result);
+    } else {
+      this.config.logger.debug(`Batch sent successfully. Accepted: ${result.accepted}`);
+      this.invokeOnSuccess(result);
+    }
+  }
+  async sendSync(events) {
+    this.config.logger.debug(`Sending ${events.length} events synchronously`);
+    const result = await this.doSend(events);
+    if (result === null) {
+      throw new SendError(`Failed to send ${events.length} events after retries`, events);
+    }
+    return result;
+  }
+  async doSend(batch) {
+    const request = { batch };
+    const requestBody = JSON.stringify(request);
+    if (hasNativeFetch) {
+      return this.doSendWithFetch(batch, requestBody);
+    } else {
+      return this.doSendWithHttps(batch, requestBody);
+    }
+  }
+  async doSendWithFetch(batch, requestBody) {
+    const requestUrl = `${this.config.endpoint}/v1/batch`;
+    let attempt = 0;
+    let delay = this.config.retryInitialDelay;
+    while (attempt < this.config.retryMaxAttempts) {
+      try {
+        const response = await fetch(requestUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.config.writeKey}`
+          },
+          body: requestBody
+        });
+        const data = await response.json();
+        if (response.ok) {
+          return data;
+        }
+        if (response.status === 400 || response.status === 401) {
+          this.config.logger.error(`Permanent error (${response.status}):`, data);
+          return null;
         }
-        // Clear the flush timer
-        if (this.flushTimer) {
-            clearTimeout(this.flushTimer);
-            this.flushTimer = null;
+        if (response.status === 429 || response.status === 503) {
+          const retryAfter = response.headers.get("Retry-After");
+          if (retryAfter) {
+            delay = parseInt(retryAfter, 10) * 1e3;
+          }
+          attempt++;
+          if (attempt < this.config.retryMaxAttempts) {
+            this.config.logger.debug(`Retrying after ${delay}ms (attempt ${attempt})`);
+            await this.sleep(delay);
+            delay = Math.min(delay * 2, 16e3);
+            continue;
+          }
         }
-        // Process batches
-        while (this.queue.length > 0) {
-            const batch = this.extractBatch();
-            if (batch.length === 0) {
-                break;
-            }
-            await this.sendBatch(batch);
+        attempt++;
+        if (attempt < this.config.retryMaxAttempts) {
+          this.config.logger.debug(`Retrying after ${delay}ms (attempt ${attempt})`);
+          await this.sleep(delay);
+          delay = Math.min(delay * 2, 16e3);
         }
-        // Schedule next flush
-        this.scheduleFlush();
-    }
-    extractBatch() {
-        const batch = [];
-        let batchSize = 0;
-        while (this.queue.length > 0 && batch.length < MAX_BATCH_SIZE) {
-            const event = this.queue[0];
-            const eventSize = this.estimateEventSize(event);
-            // Check if adding this event would exceed batch size limit
-            if (batchSize + eventSize > MAX_BATCH_SIZE_BYTES) {
-                break;
-            }
-            batch.push(this.queue.shift());
-            batchSize += eventSize;
+      } catch (error) {
+        attempt++;
+        if (attempt < this.config.retryMaxAttempts) {
+          this.config.logger.debug(`Retrying after ${delay}ms (attempt ${attempt})`);
+          await this.sleep(delay);
+          delay = Math.min(delay * 2, 16e3);
+        } else {
+          this.config.logger.error("Failed to send batch after retries:", error);
         }
-        return batch;
+      }
     }
-    async sendBatch(batch) {
-        if (batch.length === 0) {
-            return;
+    return null;
+  }
+  async doSendWithHttps(batch, requestBody) {
+    const parsedUrl = url.parse(this.config.endpoint);
+    const isHttps = parsedUrl.protocol === "https:";
+    const client = isHttps ? https : http;
+    const port = parsedUrl.port ? parseInt(parsedUrl.port, 10) : isHttps ? 443 : 80;
+    const hostname = parsedUrl.hostname || "";
+    let attempt = 0;
+    let delay = this.config.retryInitialDelay;
+    while (attempt < this.config.retryMaxAttempts) {
+      try {
+        const result = await this.makeRequest(
+          client,
+          hostname,
+          port,
+          "/v1/batch",
+          requestBody
+        );
+        if (result.statusCode === 200) {
+          const data = JSON.parse(result.body);
+          return data;
         }
-        const request = { batch };
-        const requestBody = JSON.stringify(request);
-        if (hasNativeFetch) {
-            await this.sendBatchWithFetch(batch, requestBody);
+        if (result.statusCode === 400 || result.statusCode === 401) {
+          const data = JSON.parse(result.body);
+          this.config.logger.error(`Permanent error (${result.statusCode}):`, data);
+          return null;
         }
-        else {
-            await this.sendBatchWithHttps(batch, requestBody);
+        if (result.statusCode === 429 || result.statusCode === 503) {
+          const retryAfter = result.headers["retry-after"];
+          if (retryAfter) {
+            delay = parseInt(
+              Array.isArray(retryAfter) ? retryAfter[0] : retryAfter,
+              10
+            ) * 1e3;
+          }
+          attempt++;
+          if (attempt < this.config.retryMaxAttempts) {
+            this.config.logger.debug(`Retrying after ${delay}ms (attempt ${attempt})`);
+            await this.sleep(delay);
+            delay = Math.min(delay * 2, 16e3);
+            continue;
+          }
         }
-    }
-    async sendBatchWithFetch(batch, requestBody) {
-        const requestUrl = `${this.config.endpoint}/v1/batch`;
-        let attempt = 0;
-        let delay = this.config.retryInitialDelay;
-        while (attempt < this.config.retryMaxAttempts) {
-            try {
-                const response = await fetch(requestUrl, {
-                    method: "POST",
-                    headers: {
-                        "Content-Type": "application/json",
-                        Authorization: `Bearer ${this.config.writeKey}`,
-                    },
-                    body: requestBody,
-                });
-                const data = (await response.json());
-                if (response.ok) {
-                    if (data.failed > 0 && data.errors) {
-                        console.warn(`Klime: Batch partially failed. Accepted: ${data.accepted}, Failed: ${data.failed}`, data.errors);
-                    }
-                    return;
-                }
-                if (response.status === 400 || response.status === 401) {
-                    console.error(`Klime: Permanent error (${response.status}):`, data);
-                    return;
-                }
-                if (response.status === 429 || response.status === 503) {
-                    const retryAfter = response.headers.get("Retry-After");
-                    if (retryAfter) {
-                        delay = parseInt(retryAfter, 10) * 1000;
-                    }
-                    attempt++;
-                    if (attempt < this.config.retryMaxAttempts) {
-                        await this.sleep(delay);
-                        delay = Math.min(delay * 2, 16000);
-                        continue;
-                    }
-                }
-                attempt++;
-                if (attempt < this.config.retryMaxAttempts) {
-                    await this.sleep(delay);
-                    delay = Math.min(delay * 2, 16000);
-                }
-            }
-            catch (error) {
-                attempt++;
-                if (attempt < this.config.retryMaxAttempts) {
-                    await this.sleep(delay);
-                    delay = Math.min(delay * 2, 16000);
-                }
-                else {
-                    console.error("Klime: Failed to send batch after retries:", error);
-                }
-            }
+        attempt++;
+        if (attempt < this.config.retryMaxAttempts) {
+          this.config.logger.debug(`Retrying after ${delay}ms (attempt ${attempt})`);
+          await this.sleep(delay);
+          delay = Math.min(delay * 2, 16e3);
         }
-    }
-    async sendBatchWithHttps(batch, requestBody) {
-        const parsedUrl = url.parse(this.config.endpoint);
-        const isHttps = parsedUrl.protocol === "https:";
-        const client = isHttps ? https : http;
-        const port = parsedUrl.port
-            ? parseInt(parsedUrl.port, 10)
-            : isHttps
-                ? 443
-                : 80;
-        const hostname = parsedUrl.hostname || "";
-        let attempt = 0;
-        let delay = this.config.retryInitialDelay;
-        while (attempt < this.config.retryMaxAttempts) {
-            try {
-                const result = await this.makeRequest(client, hostname, port, "/v1/batch", requestBody);
-                if (result.statusCode === 200) {
-                    const data = JSON.parse(result.body);
-                    if (data.failed > 0 && data.errors) {
-                        console.warn(`Klime: Batch partially failed. Accepted: ${data.accepted}, Failed: ${data.failed}`, data.errors);
-                    }
-                    return;
-                }
-                if (result.statusCode === 400 || result.statusCode === 401) {
-                    const data = JSON.parse(result.body);
-                    console.error(`Klime: Permanent error (${result.statusCode}):`, data);
-                    return;
-                }
-                if (result.statusCode === 429 || result.statusCode === 503) {
-                    const retryAfter = result.headers["retry-after"];
-                    if (retryAfter) {
-                        delay =
-                            parseInt(Array.isArray(retryAfter) ? retryAfter[0] : retryAfter, 10) * 1000;
-                    }
-                    attempt++;
-                    if (attempt < this.config.retryMaxAttempts) {
-                        await this.sleep(delay);
-                        delay = Math.min(delay * 2, 16000);
-                        continue;
-                    }
-                }
-                attempt++;
-                if (attempt < this.config.retryMaxAttempts) {
-                    await this.sleep(delay);
-                    delay = Math.min(delay * 2, 16000);
-                }
-            }
-            catch (error) {
-                attempt++;
-                if (attempt < this.config.retryMaxAttempts) {
-                    await this.sleep(delay);
-                    delay = Math.min(delay * 2, 16000);
-                }
-                else {
-                    console.error("Klime: Failed to send batch after retries:", error);
-                }
-            }
+      } catch (error) {
+        attempt++;
+        if (attempt < this.config.retryMaxAttempts) {
+          this.config.logger.debug(`Retrying after ${delay}ms (attempt ${attempt})`);
+          await this.sleep(delay);
+          delay = Math.min(delay * 2, 16e3);
+        } else {
+          this.config.logger.error("Failed to send batch after retries:", error);
         }
+      }
     }
-    makeRequest(client, hostname, port, path, body) {
-        return new Promise((resolve, reject) => {
-            const options = {
-                hostname,
-                port,
-                path,
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: `Bearer ${this.config.writeKey}`,
-                    "Content-Length": Buffer.byteLength(body),
-                },
-            };
-            const req = client.request(options, (res) => {
-                let data = "";
-                res.on("data", (chunk) => {
-                    data += chunk;
-                });
-                res.on("end", () => {
-                    resolve({
-                        statusCode: res.statusCode || 500,
-                        body: data,
-                        headers: res.headers,
-                    });
-                });
-            });
-            req.on("error", (error) => {
-                reject(error);
-            });
-            req.write(body);
-            req.end();
-        });
+    return null;
+  }
+  invokeOnError(error, batch) {
+    if (this.config.onError) {
+      try {
+        this.config.onError(error, batch);
+      } catch (e) {
+        this.config.logger.error("Error in onError callback:", e);
+      }
     }
-    scheduleFlush() {
-        if (this.isShutdown || this.flushTimer) {
-            return;
-        }
-        this.flushTimer = setTimeout(() => {
-            this.flush();
-        }, this.config.flushInterval);
+  }
+  invokeOnSuccess(response) {
+    if (this.config.onSuccess) {
+      try {
+        this.config.onSuccess(response);
+      } catch (e) {
+        this.config.logger.error("Error in onSuccess callback:", e);
+      }
     }
-    generateUUID() {
-        if (typeof crypto !== "undefined" && crypto.randomUUID) {
-            return crypto.randomUUID();
+  }
+  makeRequest(client, hostname, port, path, body) {
+    return new Promise((resolve, reject) => {
+      const options = {
+        hostname,
+        port,
+        path,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.writeKey}`,
+          "Content-Length": Buffer.byteLength(body)
         }
-        // Fallback for Node < 15
-        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-            const r = (Math.random() * 16) | 0;
-            const v = c === "x" ? r : (r & 0x3) | 0x8;
-            return v.toString(16);
+      };
+      const req = client.request(options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          resolve({
+            statusCode: res.statusCode || 500,
+            body: data,
+            headers: res.headers
+          });
         });
+      });
+      req.on("error", (error) => {
+        reject(error);
+      });
+      req.write(body);
+      req.end();
+    });
+  }
+  scheduleFlush() {
+    if (this.isShutdown || this.flushTimer) {
+      return;
     }
-    generateTimestamp() {
-        return new Date().toISOString();
-    }
-    getContext(ip) {
-        const context = {
-            library: {
-                name: "node-sdk",
-                version: SDK_VERSION,
-            },
-        };
-        if (ip) {
-            context.ip = ip;
-        }
-        return context;
+    this.flushTimer = setTimeout(() => {
+      this.flush();
+    }, this.config.flushInterval);
+  }
+  generateUUID() {
+    if (typeof crypto !== "undefined" && crypto.randomUUID) {
+      return crypto.randomUUID();
     }
-    estimateEventSize(event) {
-        try {
-            return JSON.stringify(event).length;
-        }
-        catch {
-            return 500;
-        }
-    }
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+  generateTimestamp() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  getContext() {
+    return {
+      library: {
+        name: "node-sdk",
+        version: SDK_VERSION
+      }
+    };
+  }
+  estimateEventSize(event) {
+    try {
+      return JSON.stringify(event).length;
+    } catch {
+      return 500;
     }
-}
-exports.KlimeClient = KlimeClient;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+export {
+  KlimeClient,
+  SendError
+};
+//# sourceMappingURL=index.js.map