@chirpier/chirpier-js 0.1.6 → 0.2.0

package/dist/index.js

@@ -14,6 +14,17 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -63,26 +74,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.monitor = exports.initialize = exports.Chirpier = exports.ChirpierError = exports.LogLevel = void 0;
-// Import necessary dependencies
+exports.flush = exports.stop = exports.logEvent = exports.initialize = exports.createClient = exports.Client = exports.ChirpierError = void 0;
 var axios_1 = __importDefault(require("axios"));
 var axios_retry_1 = __importDefault(require("axios-retry"));
-var js_base64_1 = require("js-base64");
+var dotenv_1 = __importDefault(require("dotenv"));
 var constants_1 = require("./constants");
 var async_lock_1 = __importDefault(require("async-lock"));
-// Define logging levels
-var LogLevel;
-(function (LogLevel) {
-    LogLevel[LogLevel["None"] = 0] = "None";
-    LogLevel[LogLevel["Error"] = 1] = "Error";
-    LogLevel[LogLevel["Info"] = 2] = "Info";
-    LogLevel[LogLevel["Debug"] = 3] = "Debug";
-})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
 // Custom error class for Chirpier-specific errors
 var ChirpierError = /** @class */ (function (_super) {
     __extends(ChirpierError, _super);
-    function ChirpierError(message) {
+    function ChirpierError(message, code) {
         var _this = _super.call(this, message) || this;
+        _this.code = code;
         _this.name = "ChirpierError";
         Object.setPrototypeOf(_this, ChirpierError.prototype);
         return _this;
@@ -90,56 +93,74 @@ var ChirpierError = /** @class */ (function (_super) {
     return ChirpierError;
 }(Error));
 exports.ChirpierError = ChirpierError;
-/**
- * Main Chirpier class for monitoring events.
- */
-var Chirpier = /** @class */ (function () {
-    /**
-     * Initializes a new instance of the Chirpier class.
-     * @param options - Configuration options for the SDK.
-     */
-    function Chirpier(options) {
-        this.eventQueue = [];
+var Client = /** @class */ (function () {
+    function Client(options) {
+        if (options === void 0) { options = {}; }
+        this.logQueue = [];
         this.flushTimeoutId = null;
-        this.queueLock = new async_lock_1.default({
-            maxPending: constants_1.MAX_QUEUE_SIZE,
-        });
-        this.flushLock = new async_lock_1.default({
-            maxPending: constants_1.MAX_QUEUE_SIZE,
-        });
-        var key = options.key, _a = options.region, region = _a === void 0 ? "eu-west" : _a, _b = options.logLevel, logLevel = _b === void 0 ? LogLevel.None : _b;
-        if (!key || typeof key !== "string") {
-            throw new ChirpierError("API key is required and must be a string");
+        var providedKey = options.key, _a = options.apiEndpoint, apiEndpoint = _a === void 0 ? constants_1.DEFAULT_API_ENDPOINT : _a, _b = options.servicerEndpoint, servicerEndpoint = _b === void 0 ? constants_1.DEFAULT_SERVICER_ENDPOINT : _b, _c = options.logLevel, logLevel = _c === void 0 ? 0 /* LogLevel.None */ : _c, _d = options.retries, retries = _d === void 0 ? constants_1.DEFAULT_RETRIES : _d, _e = options.timeout, timeout = _e === void 0 ? constants_1.DEFAULT_TIMEOUT : _e, _f = options.batchSize, batchSize = _f === void 0 ? constants_1.DEFAULT_BATCH_SIZE : _f, _g = options.flushDelay, flushDelay = _g === void 0 ? constants_1.DEFAULT_FLUSH_DELAY : _g, _h = options.maxQueueSize, maxQueueSize = _h === void 0 ? constants_1.MAX_QUEUE_SIZE : _h;
+        var key = resolveAPIKey(providedKey);
+        if (!key) {
+            throw new ChirpierError("API key is required", "INVALID_KEY");
+        }
+        if (!isValidAPIKey(key)) {
+            throw new ChirpierError("Invalid API key: must start with 'chp_'", "INVALID_KEY");
+        }
+        if (apiEndpoint !== undefined) {
+            if (typeof apiEndpoint !== "string" || apiEndpoint.trim().length === 0) {
+                throw new ChirpierError("apiEndpoint must be a non-empty string", "INVALID_API_ENDPOINT");
+            }
+            var parsedURL = void 0;
+            try {
+                parsedURL = new URL(apiEndpoint);
+            }
+            catch (_j) {
+                throw new ChirpierError("apiEndpoint must be a valid absolute URL", "INVALID_API_ENDPOINT");
+            }
+            if (parsedURL.protocol !== "https:" && parsedURL.protocol !== "http:") {
+                throw new ChirpierError("apiEndpoint must use http or https", "INVALID_API_ENDPOINT");
+            }
+        }
+        // Validate numeric options
+        if (retries < 0 || !Number.isInteger(retries)) {
+            throw new ChirpierError("Retries must be a non-negative integer", "INVALID_RETRIES");
         }
-        if (typeof region !== "string" &&
-            !["us-west", "eu-west", "asia-southeast"].includes(region)) {
-            throw new ChirpierError("Region must be one of: us-west, eu-west, asia-southeast");
+        if (timeout <= 0) {
+            throw new ChirpierError("Timeout must be positive", "INVALID_TIMEOUT");
         }
-        this.apiEndpoint = "https://".concat(region, ".chirpier.co/v1.0/events");
+        if (batchSize <= 0 || !Number.isInteger(batchSize)) {
+            throw new ChirpierError("Batch size must be a positive integer", "INVALID_BATCH_SIZE");
+        }
+        if (flushDelay < 0) {
+            throw new ChirpierError("Flush delay must be non-negative", "INVALID_FLUSH_DELAY");
+        }
+        if (maxQueueSize <= 0 || !Number.isInteger(maxQueueSize)) {
+            throw new ChirpierError("Max queue size must be a positive integer", "INVALID_QUEUE_SIZE");
+        }
+        this.apiEndpoint = apiEndpoint !== null && apiEndpoint !== void 0 ? apiEndpoint : constants_1.DEFAULT_API_ENDPOINT;
+        this.servicerEndpoint = servicerEndpoint !== null && servicerEndpoint !== void 0 ? servicerEndpoint : constants_1.DEFAULT_SERVICER_ENDPOINT;
         this.apiKey = key;
-        this.retries = constants_1.DEFAULT_RETRIES;
-        this.timeout = constants_1.DEFAULT_TIMEOUT;
-        this.batchSize = constants_1.DEFAULT_BATCH_SIZE;
-        this.flushDelay = constants_1.DEFAULT_FLUSH_DELAY;
+        this.retries = retries;
+        this.timeout = timeout;
+        this.batchSize = batchSize;
+        this.flushDelay = flushDelay;
+        this.maxQueueSize = maxQueueSize;
         this.logLevel = logLevel;
-        // Create axios instance with authorization header
+        this.queueLock = new async_lock_1.default({ maxPending: this.maxQueueSize });
+        this.flushLock = new async_lock_1.default({ maxPending: this.maxQueueSize });
         this.axiosInstance = axios_1.default.create({
             headers: { Authorization: "Bearer ".concat(this.apiKey) },
             timeout: this.timeout,
         });
-        // Add the interceptor here
-        this.axiosInstance.interceptors.response.use(function (response) { return response; }, function (error) {
-            // Don't handle the error here; let axios-retry handle it
-            return Promise.reject(error);
-        });
-        // Apply axios-retry to your Axios instance
+        this.axiosInstance.interceptors.response.use(function (response) { return response; }, function (error) { return Promise.reject(error); });
         (0, axios_retry_1.default)(this.axiosInstance, {
             retries: this.retries,
             retryDelay: function (retryCount) {
-                return Math.pow(2, retryCount) * 1000; // Exponential backoff starting at 1 second
+                var baseDelay = Math.pow(2, retryCount) * 1000;
+                var jitter = Math.random() * 0.3 * baseDelay;
+                return baseDelay + jitter;
             },
             retryCondition: function (error) {
-                // Retry on network errors, 5xx errors, and 429 (Too Many Requests)
                 return (axios_retry_1.default.isNetworkError(error) ||
                     axios_retry_1.default.isRetryableError(error) ||
                     (error.response && error.response.status) === 429);
@@ -147,61 +168,91 @@ var Chirpier = /** @class */ (function () {
             shouldResetTimeout: true,
         });
     }
-    /**
-     * Gets the singleton instance of Chirpier, creating it if it doesn't exist.
-     * @param options - Configuration options for the SDK.
-     * @returns The Chirpier instance.
-     */
-    Chirpier.getInstance = function (options) {
-        if (!Chirpier.instance && options.key) {
-            Chirpier.instance = new Chirpier(options);
+    Client.prototype.isValidLog = function (log) {
+        var now = Date.now();
+        var oldestAllowed = now - 30 * 24 * 60 * 60 * 1000;
+        var newestAllowed = now + 24 * 60 * 60 * 1000;
+        if (typeof log.event !== "string" || log.event.trim().length === 0) {
+            return false;
+        }
+        if (typeof log.value !== "number" || !Number.isFinite(log.value)) {
+            return false;
+        }
+        if (log.agent_id !== undefined && typeof log.agent_id !== "string") {
+            return false;
+        }
+        if (log.meta !== undefined) {
+            try {
+                var serializedMeta = JSON.stringify(log.meta);
+                if (serializedMeta === undefined) {
+                    return false;
+                }
+            }
+            catch (_a) {
+                return false;
+            }
+        }
+        if (log.occurred_at !== undefined) {
+            var occurredAtMillis = log.occurred_at instanceof Date
+                ? log.occurred_at.getTime()
+                : new Date(log.occurred_at).getTime();
+            if (!Number.isFinite(occurredAtMillis)) {
+                return false;
+            }
+            if (occurredAtMillis < oldestAllowed || occurredAtMillis > newestAllowed) {
+                return false;
+            }
         }
-        return Chirpier.instance;
+        return true;
     };
-    /**
-     * Validates the event structure.
-     * @param event - The event to validate.
-     * @returns True if valid, false otherwise.
-     */
-    Chirpier.prototype.isValidEvent = function (event) {
-        return (typeof event.group_id === "string" &&
-            /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(event.group_id) &&
-            event.group_id.trim().length > 0 &&
-            typeof event.stream_name === "string" &&
-            event.stream_name.trim().length > 0 &&
-            typeof event.value === "number");
+    Client.prototype.normalizeLog = function (log) {
+        var normalizedLog = {
+            event: log.event.trim(),
+            value: log.value,
+        };
+        if (typeof log.agent_id === "string") {
+            var trimmedAgentID = log.agent_id.trim();
+            if (trimmedAgentID.length > 0) {
+                normalizedLog.agent_id = trimmedAgentID;
+            }
+        }
+        if (log.meta !== undefined) {
+            normalizedLog.meta = log.meta;
+        }
+        if (log.occurred_at !== undefined) {
+            var occurredAtDate = log.occurred_at instanceof Date ? log.occurred_at : new Date(log.occurred_at);
+            normalizedLog.occurred_at = occurredAtDate.toISOString();
+        }
+        return normalizedLog;
     };
-    /**
-     * Monitors an event by adding it to the queue and scheduling a flush if necessary.
-     * @param event - The event to monitor.
-     */
-    Chirpier.prototype.monitor = function (event) {
+    Client.prototype.log = function (log) {
         return __awaiter(this, void 0, void 0, function () {
+            var normalizedLog, queueFull;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        if (!this.isValidEvent(event)) {
-                            if (this.logLevel >= LogLevel.Debug) {
-                                console.debug("Invalid event format, dropping event:", event);
-                            }
-                            return [2 /*return*/]; // Silently drop the event
+                        if (!this.isValidLog(log)) {
+                            throw new ChirpierError("Invalid log format: event must not be empty, value must be a finite number, agent_id must be a string when provided, meta must be JSON-encodable, and occurred_at must be within the last 30 days and no more than 1 day in the future", "INVALID_LOG");
                         }
+                        normalizedLog = this.normalizeLog(log);
+                        queueFull = false;
                         return [4 /*yield*/, this.queueLock.acquire("queue", function () { return __awaiter(_this, void 0, void 0, function () {
                                 return __generator(this, function (_a) {
-                                    if (this.eventQueue.length >= constants_1.MAX_QUEUE_SIZE) {
-                                        if (this.logLevel >= LogLevel.Debug) {
-                                            console.debug("Event queue is full, dropping event:", event);
-                                        }
-                                        return [2 /*return*/]; // Silently drop the event
+                                    if (this.logQueue.length >= this.maxQueueSize) {
+                                        queueFull = true;
+                                        return [2 /*return*/];
                                     }
-                                    this.eventQueue.push({ event: event, timestamp: Date.now(), retryCount: 0 });
+                                    this.logQueue.push({ log: normalizedLog, timestamp: Date.now(), retryCount: 0 });
                                     return [2 /*return*/];
                                 });
                             }); })];
                     case 1:
                         _a.sent();
-                        if (!(this.eventQueue.length >= this.batchSize)) return [3 /*break*/, 3];
+                        if (queueFull) {
+                            throw new ChirpierError("Log queue is full (max size: ".concat(this.maxQueueSize, ")"), "QUEUE_FULL");
+                        }
+                        if (!(this.logQueue.length >= this.batchSize)) return [3 /*break*/, 3];
                         return [4 /*yield*/, this.flushQueue()];
                     case 2:
                         _a.sent();
@@ -216,84 +267,70 @@ var Chirpier = /** @class */ (function () {
             });
         });
     };
-    /**
-     * Flushes the event queue by sending all events to the API.
-     */
-    Chirpier.prototype.flushQueue = function () {
+    Client.prototype.flushQueue = function () {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: 
-                    // Acquire the flush lock
-                    return [4 /*yield*/, this.flushLock.acquire("flush", function () { return __awaiter(_this, void 0, void 0, function () {
-                            var eventsToSend, error_1, retryableEvents_1, _i, eventsToSend_1, queuedEvent;
+                    case 0: return [4 /*yield*/, this.flushLock.acquire("flush", function () { return __awaiter(_this, void 0, void 0, function () {
+                            var logsToSend, error_1, retryableLogs_1, _i, logsToSend_1, queuedLog;
                             var _this = this;
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
                                     case 0:
-                                        eventsToSend = [];
-                                        // Extract events from the queue under the queue lock
-                                        return [4 /*yield*/, this.queueLock.acquire("eventQueue", function () { return __awaiter(_this, void 0, void 0, function () {
+                                        logsToSend = [];
+                                        return [4 /*yield*/, this.queueLock.acquire("logQueue", function () { return __awaiter(_this, void 0, void 0, function () {
                                                 return __generator(this, function (_a) {
-                                                    if (this.eventQueue.length > 0) {
-                                                        eventsToSend = __spreadArray([], this.eventQueue, true);
-                                                        this.eventQueue = [];
+                                                    if (this.logQueue.length > 0) {
+                                                        logsToSend = __spreadArray([], this.logQueue, true);
+                                                        this.logQueue = [];
                                                     }
                                                     return [2 /*return*/];
                                                 });
                                             }); })];
                                     case 1:
-                                        // Extract events from the queue under the queue lock
                                         _a.sent();
-                                        if (eventsToSend.length === 0) {
+                                        if (logsToSend.length === 0) {
                                             return [2 /*return*/];
                                         }
                                         _a.label = 2;
                                     case 2:
                                         _a.trys.push([2, 4, , 6]);
-                                        // Clear any pending flush timeout
                                         if (this.flushTimeoutId) {
                                             clearTimeout(this.flushTimeoutId);
                                             this.flushTimeoutId = null;
                                         }
-                                        // Attempt to send events
-                                        return [4 /*yield*/, this.sendEvents(eventsToSend.map(function (qe) { return qe.event; }))];
+                                        return [4 /*yield*/, this.sendLogs(logsToSend.map(function (queuedLog) { return queuedLog.log; }))];
                                     case 3:
-                                        // Attempt to send events
                                         _a.sent();
-                                        if (this.logLevel >= LogLevel.Info) {
-                                            console.info("Successfully sent ".concat(eventsToSend.length, " events"));
+                                        if (this.logLevel >= 2 /* LogLevel.Info */) {
+                                            console.info("Successfully sent ".concat(logsToSend.length, " logs"));
                                         }
                                         return [3 /*break*/, 6];
                                     case 4:
                                         error_1 = _a.sent();
-                                        // Log failure
-                                        if (this.logLevel >= LogLevel.Error) {
-                                            console.error("Failed to send events:", error_1);
+                                        if (this.logLevel >= 1 /* LogLevel.Error */) {
+                                            console.error("Failed to send logs:", error_1);
                                         }
-                                        retryableEvents_1 = [];
-                                        for (_i = 0, eventsToSend_1 = eventsToSend; _i < eventsToSend_1.length; _i++) {
-                                            queuedEvent = eventsToSend_1[_i];
-                                            if (queuedEvent.retryCount >= this.retries) {
-                                                if (this.logLevel >= LogLevel.Error) {
-                                                    console.error("Dropping event after ".concat(this.retries, " retries:"), queuedEvent.event);
+                                        retryableLogs_1 = [];
+                                        for (_i = 0, logsToSend_1 = logsToSend; _i < logsToSend_1.length; _i++) {
+                                            queuedLog = logsToSend_1[_i];
+                                            if (queuedLog.retryCount >= this.retries) {
+                                                if (this.logLevel >= 1 /* LogLevel.Error */) {
+                                                    console.error("Dropping log after ".concat(this.retries, " retries:"), queuedLog.log);
                                                 }
-                                                continue; // Skip adding this event back to the queue
+                                                continue;
                                             }
-                                            // Increment retry count and add back to the queue
-                                            queuedEvent.retryCount++;
-                                            retryableEvents_1.push(queuedEvent);
+                                            queuedLog.retryCount++;
+                                            retryableLogs_1.push(queuedLog);
                                         }
-                                        // Requeue remaining retryable events
-                                        return [4 /*yield*/, this.queueLock.acquire("eventQueue", function () { return __awaiter(_this, void 0, void 0, function () {
+                                        return [4 /*yield*/, this.queueLock.acquire("logQueue", function () { return __awaiter(_this, void 0, void 0, function () {
                                                 return __generator(this, function (_a) {
-                                                    this.eventQueue = __spreadArray(__spreadArray([], retryableEvents_1, true), this.eventQueue, true);
+                                                    this.logQueue = __spreadArray(__spreadArray([], retryableLogs_1, true), this.logQueue, true);
                                                     return [2 /*return*/];
                                                 });
                                             }); })];
                                     case 5:
-                                        // Requeue remaining retryable events
                                         _a.sent();
                                         return [3 /*break*/, 6];
                                     case 6: return [2 /*return*/];
@@ -301,22 +338,17 @@ var Chirpier = /** @class */ (function () {
                             });
                         }); })];
                     case 1:
-                        // Acquire the flush lock
                         _a.sent();
                         return [2 /*return*/];
                 }
             });
         });
     };
-    /**
-     * Sends multiple events to the API in a batch.
-     * @param events - The array of events to send.
-     */
-    Chirpier.prototype.sendEvents = function (events) {
+    Client.prototype.sendLogs = function (logs) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.axiosInstance.post(this.apiEndpoint, events)];
+                    case 0: return [4 /*yield*/, this.axiosInstance.post(this.apiEndpoint, logs)];
                     case 1:
                         _a.sent();
                         return [2 /*return*/];
@@ -324,89 +356,299 @@ var Chirpier = /** @class */ (function () {
             });
         });
     };
-    // Stop the timeout and uninitialize the Chirpier instance
-    Chirpier.stop = function () {
+    Client.prototype.flush = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.flushQueue()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Client.prototype.shutdown = function () {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        if (!Chirpier.instance) {
-                            return [2 /*return*/];
+                        if (this.flushTimeoutId) {
+                            clearTimeout(this.flushTimeoutId);
+                            this.flushTimeoutId = null;
                         }
-                        if (Chirpier.instance.flushTimeoutId) {
-                            clearTimeout(Chirpier.instance.flushTimeoutId);
-                            Chirpier.instance.flushTimeoutId = null;
+                        return [4 /*yield*/, this.flushQueue()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Client.prototype.close = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.shutdown()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Client.prototype.listEvents = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.axiosInstance.get("".concat(this.servicerEndpoint, "/events"))];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.data];
+                }
+            });
+        });
+    };
+    Client.prototype.getEvent = function (eventID) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.axiosInstance.get("".concat(this.servicerEndpoint, "/events/").concat(eventID))];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.data];
+                }
+            });
+        });
+    };
+    Client.prototype.updateEvent = function (eventID, payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.axiosInstance.put("".concat(this.servicerEndpoint, "/events/").concat(eventID), payload)];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.data];
+                }
+            });
+        });
+    };
+    Client.prototype.listPolicies = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.axiosInstance.get("".concat(this.servicerEndpoint, "/policies"))];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.data];
+                }
+            });
+        });
+    };
+    Client.prototype.createPolicy = function (payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.axiosInstance.post("".concat(this.servicerEndpoint, "/policies"), payload)];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.data];
+                }
+            });
+        });
+    };
+    Client.prototype.listAlerts = function (status) {
+        return __awaiter(this, void 0, void 0, function () {
+            var endpoint, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        endpoint = status
+                            ? "".concat(this.servicerEndpoint, "/alerts?status=").concat(encodeURIComponent(status))
+                            : "".concat(this.servicerEndpoint, "/alerts");
+                        return [4 /*yield*/, this.axiosInstance.get(endpoint)];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.data];
+                }
+            });
+        });
+    };
+    Client.prototype.getAlertDeliveries = function (alertID, options) {
+        if (options === void 0) { options = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var params, suffix, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        params = new URLSearchParams();
+                        if (options.kind) {
+                            params.set("kind", options.kind);
+                        }
+                        if (typeof options.limit === "number") {
+                            params.set("limit", String(options.limit));
+                        }
+                        if (typeof options.offset === "number") {
+                            params.set("offset", String(options.offset));
                         }
-                        // Flush any remaining events in the queue
-                        return [4 /*yield*/, Chirpier.instance.flushQueue()];
+                        suffix = params.toString() ? "?".concat(params.toString()) : "";
+                        return [4 /*yield*/, this.axiosInstance.get("".concat(this.servicerEndpoint, "/alerts/").concat(alertID, "/deliveries").concat(suffix))];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.data];
+                }
+            });
+        });
+    };
+    Client.prototype.acknowledgeAlert = function (alertID) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.axiosInstance.post("".concat(this.servicerEndpoint, "/alerts/").concat(alertID, "/acknowledge"))];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.data];
+                }
+            });
+        });
+    };
+    Client.prototype.archiveAlert = function (alertID) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.axiosInstance.post("".concat(this.servicerEndpoint, "/alerts/").concat(alertID, "/archive"))];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.data];
+                }
+            });
+        });
+    };
+    Client.prototype.testWebhook = function (webhookID) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.axiosInstance.post("".concat(this.servicerEndpoint, "/webhooks/").concat(webhookID, "/test"))];
                     case 1:
-                        // Flush any remaining events in the queue
                         _a.sent();
-                        // Uninitialize the Chirpier instance
-                        Chirpier.instance = null;
                         return [2 /*return*/];
                 }
             });
         });
     };
-    Chirpier.instance = null;
-    return Chirpier;
+    Client.prototype.getEventLogs = function (eventID, options) {
+        if (options === void 0) { options = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var params, suffix, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        params = new URLSearchParams();
+                        if (options.period) {
+                            params.set("period", options.period);
+                        }
+                        if (typeof options.limit === "number") {
+                            params.set("limit", String(options.limit));
+                        }
+                        if (typeof options.offset === "number") {
+                            params.set("offset", String(options.offset));
+                        }
+                        suffix = params.toString() ? "?".concat(params.toString()) : "";
+                        return [4 /*yield*/, this.axiosInstance.get("".concat(this.servicerEndpoint, "/events/").concat(eventID, "/logs").concat(suffix))];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.data];
+                }
+            });
+        });
+    };
+    Client.prototype.resolveAlert = function (alertID) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.axiosInstance.post("".concat(this.servicerEndpoint, "/alerts/").concat(alertID, "/resolve"))];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.data];
+                }
+            });
+        });
+    };
+    return Client;
 }());
-exports.Chirpier = Chirpier;
-/**
- * Decodes a base64url encoded string.
- * @param str - The base64url encoded string to decode.
- * @returns The decoded string.
- */
-function base64UrlDecode(str) {
-    // Replace '-' with '+' and '_' with '/'
-    var base64 = str.replace(/-/g, "+").replace(/_/g, "/");
-    // Pad the base64 string
-    var padding = base64.length % 4;
-    if (padding !== 0) {
-        base64 += "=".repeat(4 - padding);
-    }
-    return js_base64_1.Base64.decode(base64);
+exports.Client = Client;
+var instance = null;
+function createClient(config) {
+    if (config === void 0) { config = {}; }
+    return new Client(config);
 }
-/**
- * Validates if the provided token is a valid JWT.
- * @param token - The token to validate.
- * @returns True if valid, false otherwise.
- */
-function isValidJWT(token) {
-    var parts = token.split(".");
-    if (parts.length !== 3) {
-        return false;
+exports.createClient = createClient;
+function isNodeEnvironment() {
+    return typeof process !== "undefined" && !!(process.versions && process.versions.node);
+}
+function isValidAPIKey(token) {
+    return token.startsWith("chp_") && token.length > "chp_".length;
+}
+function loadDotEnvKey() {
+    if (!isNodeEnvironment()) {
+        return undefined;
     }
     try {
-        var header = JSON.parse(base64UrlDecode(parts[0]));
-        var payload = JSON.parse(base64UrlDecode(parts[1]));
-        return typeof header === "object" && typeof payload === "object";
+        dotenv_1.default.config({ path: ".env", override: false });
     }
-    catch (error) {
-        console.error("Failed to validate JWT:", error);
-        return false;
+    catch (_a) {
+        return undefined;
     }
+    var envKey = process.env.CHIRPIER_API_KEY;
+    if (typeof envKey !== "string") {
+        return undefined;
+    }
+    var trimmedKey = envKey.trim();
+    return trimmedKey.length > 0 ? trimmedKey : undefined;
+}
+function resolveAPIKey(providedKey) {
+    if (typeof providedKey === "string" && providedKey.trim().length > 0) {
+        return providedKey.trim();
+    }
+    if (typeof process !== "undefined" && process.env && typeof process.env.CHIRPIER_API_KEY === "string") {
+        var envKey = process.env.CHIRPIER_API_KEY.trim();
+        if (envKey.length > 0) {
+            return envKey;
+        }
+    }
+    return loadDotEnvKey();
 }
-/**
- * Initializes the Chirpier SDK.
- * @param options - Configuration options for the SDK.
- */
 function initialize(options) {
-    if (!isValidJWT(options.key)) {
-        throw new ChirpierError("Invalid API key: Not a valid JWT");
+    if (options === void 0) { options = {}; }
+    var resolvedKey = resolveAPIKey(options.key);
+    if (!resolvedKey) {
+        throw new ChirpierError("API key is required", "INVALID_KEY");
+    }
+    if (!isValidAPIKey(resolvedKey)) {
+        throw new ChirpierError("Invalid API key: must start with 'chp_'", "INVALID_KEY");
+    }
+    if (instance) {
+        return;
     }
     try {
-        Chirpier.getInstance(options);
+        instance = new Client(__assign(__assign({}, options), { key: resolvedKey }));
     }
     catch (error) {
         if (error instanceof ChirpierError) {
-            if (options.logLevel && options.logLevel >= LogLevel.Error) {
+            if (options.logLevel && options.logLevel >= 1 /* LogLevel.Error */) {
                 console.error("Failed to initialize Chirpier SDK:", error.message);
             }
         }
         else {
-            if (options.logLevel && options.logLevel >= LogLevel.Error) {
+            if (options.logLevel && options.logLevel >= 1 /* LogLevel.Error */) {
                 console.error("An unexpected error occurred during Chirpier SDK initialization:", error);
             }
         }
@@ -414,17 +656,55 @@ function initialize(options) {
     }
 }
 exports.initialize = initialize;
-/**
- * Monitors an event using the Chirpier SDK.
- * @param event - The event to monitor.
- */
-function monitor(event) {
-    var instance = Chirpier.getInstance({});
-    if (!instance) {
-        throw new ChirpierError("Chirpier SDK is not initialized. Please call initialize() first.");
-    }
-    instance.monitor(event).catch(function (error) {
-        console.error("Error in monitor function:", error);
+function logEvent(log) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!instance) {
+                        throw new ChirpierError("Chirpier SDK is not initialized. Please call initialize() first.", "NOT_INITIALIZED");
+                    }
+                    return [4 /*yield*/, instance.log(log)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.logEvent = logEvent;
+function stop() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!instance) {
+                        return [2 /*return*/];
+                    }
+                    return [4 /*yield*/, instance.shutdown()];
+                case 1:
+                    _a.sent();
+                    instance = null;
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.stop = stop;
+function flush() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!instance) {
+                        throw new ChirpierError("Chirpier SDK is not initialized. Please call initialize() first.", "NOT_INITIALIZED");
+                    }
+                    return [4 /*yield*/, instance.flush()];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
     });
 }
-exports.monitor = monitor;
+exports.flush = flush;