@pioneer-platform/markets 8.12.0 → 8.13.0

package/lib/api-metrics-reporter.js

@@ -0,0 +1,356 @@
+"use strict";
+/*
+    API Metrics Reporter
+    
+    Collects and reports API usage metrics to Discord via alerts bridge
+    Runs hourly to track pricing API health and usage
+*/
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendHourlyMetricsReport = sendHourlyMetricsReport;
+exports.getCurrentMetrics = getCurrentMetrics;
+exports.getUnpriceableTokens = getUnpriceableTokens;
+exports.clearUnpriceableToken = clearUnpriceableToken;
+exports.startHourlyReporting = startHourlyReporting;
+var log = require('@pioneer-platform/loggerdog')();
+var redis = require('@pioneer-platform/default-redis').redis;
+var axios = require('axios');
+var TAG = ' | api-metrics-reporter | ';
+// Discord webhook via alerts bridge
+var ALERTS_BRIDGE_URL = process.env.ALERTS_BRIDGE_URL || 'http://localhost:9000/api/v1/alert';
+var ALERTS_ENABLED = process.env.ALERTS_ENABLED !== 'false';
+// Redis keys
+var REDIS_API_METRICS_KEY = 'markets:api_metrics';
+var REDIS_UNPRICEABLE_SET = 'markets:unpriceable_tokens';
+var REDIS_LAST_REPORT_KEY = 'markets:last_metrics_report';
+/**
+ * Calculate success rate percentage
+ */
+function calculateSuccessRate(success, failures) {
+    var total = success + failures;
+    if (total === 0)
+        return '0%';
+    return ((success / total) * 100).toFixed(1) + '%';
+}
+/**
+ * Get API health emoji
+ */
+function getHealthEmoji(successRate) {
+    if (successRate >= 95)
+        return '🟢';
+    if (successRate >= 80)
+        return '🟡';
+    if (successRate >= 50)
+        return '🟠';
+    return '🔴';
+}
+/**
+ * Send alert to Discord via alerts bridge
+ */
+function sendDiscordAlert(title_1, message_1) {
+    return __awaiter(this, arguments, void 0, function (title, message, level) {
+        var tag, error_1;
+        if (level === void 0) { level = 'info'; }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    tag = TAG + 'sendDiscordAlert | ';
+                    if (!ALERTS_ENABLED) {
+                        log.debug(tag, 'Alerts disabled, skipping Discord notification');
+                        return [2 /*return*/];
+                    }
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, axios.post(ALERTS_BRIDGE_URL, {
+                            service: 'pioneer-markets',
+                            level: level,
+                            title: title,
+                            message: message,
+                            timestamp: new Date().toISOString()
+                        }, {
+                            timeout: 5000
+                        })];
+                case 2:
+                    _a.sent();
+                    log.info(tag, "Sent Discord alert: ".concat(title));
+                    return [3 /*break*/, 4];
+                case 3:
+                    error_1 = _a.sent();
+                    log.error(tag, "Failed to send Discord alert: ".concat(error_1.message));
+                    return [3 /*break*/, 4];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * Generate and send hourly metrics report
+ */
+function sendHourlyMetricsReport() {
+    return __awaiter(this, void 0, void 0, function () {
+        var tag, lastReport, now, timeSinceLastReport, oneHour, metricsData, metrics, unpriceableCount, totalSuccess, totalFailures, criticalErrors, apiReport, _i, _a, _b, api, stats, success, failures, total, rate, totalRate, reportMessage, _c, apiReport_1, api, _d, criticalErrors_1, error, level, error_2;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    tag = TAG + 'sendHourlyMetricsReport | ';
+                    _e.label = 1;
+                case 1:
+                    _e.trys.push([1, 8, , 9]);
+                    return [4 /*yield*/, redis.get(REDIS_LAST_REPORT_KEY)];
+                case 2:
+                    lastReport = _e.sent();
+                    now = Date.now();
+                    if (lastReport) {
+                        timeSinceLastReport = now - parseInt(lastReport);
+                        oneHour = 60 * 60 * 1000;
+                        if (timeSinceLastReport < oneHour) {
+                            log.debug(tag, "Skipping report - last sent ".concat(Math.floor(timeSinceLastReport / 1000 / 60), " minutes ago"));
+                            return [2 /*return*/];
+                        }
+                    }
+                    return [4 /*yield*/, redis.get(REDIS_API_METRICS_KEY)];
+                case 3:
+                    metricsData = _e.sent();
+                    if (!metricsData) {
+                        log.debug(tag, 'No metrics data available yet');
+                        return [2 /*return*/];
+                    }
+                    metrics = JSON.parse(metricsData);
+                    return [4 /*yield*/, redis.scard(REDIS_UNPRICEABLE_SET)];
+                case 4:
+                    unpriceableCount = _e.sent();
+                    totalSuccess = 0;
+                    totalFailures = 0;
+                    criticalErrors = [];
+                    apiReport = [];
+                    for (_i = 0, _a = Object.entries(metrics); _i < _a.length; _i++) {
+                        _b = _a[_i], api = _b[0], stats = _b[1];
+                        if (api === 'timestamp')
+                            continue;
+                        success = stats.success || 0;
+                        failures = stats.failures || 0;
+                        total = success + failures;
+                        rate = total > 0 ? (success / total) * 100 : 0;
+                        totalSuccess += success;
+                        totalFailures += failures;
+                        apiReport.push({
+                            name: api.charAt(0).toUpperCase() + api.slice(1),
+                            success: success,
+                            failures: failures,
+                            rate: rate,
+                            emoji: getHealthEmoji(rate),
+                            lastError: stats.lastError
+                        });
+                        // Track critical errors (< 50% success rate)
+                        if (rate < 50 && total > 10) {
+                            criticalErrors.push("".concat(api, ": ").concat(rate.toFixed(1), "% success rate"));
+                        }
+                    }
+                    // Sort by success rate
+                    apiReport.sort(function (a, b) { return b.rate - a.rate; });
+                    totalRate = totalSuccess + totalFailures > 0
+                        ? ((totalSuccess / (totalSuccess + totalFailures)) * 100).toFixed(1)
+                        : '0.0';
+                    reportMessage = "**\uD83D\uDCCA Pricing API Health Report**\n\n";
+                    reportMessage += "**Period:** Last hour\n";
+                    reportMessage += "**Overall Success Rate:** ".concat(totalRate, "%\n");
+                    reportMessage += "**Total Requests:** ".concat(totalSuccess + totalFailures, "\n");
+                    reportMessage += "**Unpriceable Tokens:** ".concat(unpriceableCount, "\n\n");
+                    reportMessage += "**API Performance:**\n";
+                    for (_c = 0, apiReport_1 = apiReport; _c < apiReport_1.length; _c++) {
+                        api = apiReport_1[_c];
+                        reportMessage += "".concat(api.emoji, " **").concat(api.name, "**: ").concat(api.rate.toFixed(1), "% ");
+                        reportMessage += "(".concat(api.success, "\u2713 / ").concat(api.failures, "\u2717)\n");
+                        if (api.lastError && api.failures > 0) {
+                            reportMessage += "   \u2514\u2500 Last error: `".concat(api.lastError.substring(0, 80), "`\n");
+                        }
+                    }
+                    // Add warnings if any
+                    if (criticalErrors.length > 0) {
+                        reportMessage += "\n**\u26A0\uFE0F Critical Issues:**\n";
+                        for (_d = 0, criticalErrors_1 = criticalErrors; _d < criticalErrors_1.length; _d++) {
+                            error = criticalErrors_1[_d];
+                            reportMessage += "\u2022 ".concat(error, "\n");
+                        }
+                    }
+                    // Add unpriceable token warning
+                    if (unpriceableCount > 100) {
+                        reportMessage += "\n**\u26A0\uFE0F High number of unpriceable tokens detected**\n";
+                        reportMessage += "".concat(unpriceableCount, " tokens marked as unpriceable (likely scam/spam)\n");
+                    }
+                    level = criticalErrors.length > 0 ? 'warn' : 'info';
+                    // Send to Discord
+                    return [4 /*yield*/, sendDiscordAlert("Pricing API Metrics - ".concat(new Date().toLocaleString()), reportMessage, level)];
+                case 5:
+                    // Send to Discord
+                    _e.sent();
+                    // Update last report timestamp
+                    return [4 /*yield*/, redis.set(REDIS_LAST_REPORT_KEY, now.toString())];
+                case 6:
+                    // Update last report timestamp
+                    _e.sent();
+                    // Reset metrics for next hour
+                    return [4 /*yield*/, redis.del(REDIS_API_METRICS_KEY)];
+                case 7:
+                    // Reset metrics for next hour
+                    _e.sent();
+                    log.info(tag, "Sent hourly metrics report - Overall: ".concat(totalRate, "%, Alerts: ").concat(criticalErrors.length));
+                    return [3 /*break*/, 9];
+                case 8:
+                    error_2 = _e.sent();
+                    log.error(tag, "Error generating metrics report:", error_2);
+                    return [3 /*break*/, 9];
+                case 9: return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * Get current metrics (for API endpoint)
+ */
+function getCurrentMetrics() {
+    return __awaiter(this, void 0, void 0, function () {
+        var tag, metricsData, unpriceableCount, metrics, error_3;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    tag = TAG + 'getCurrentMetrics | ';
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 4, , 5]);
+                    return [4 /*yield*/, redis.get(REDIS_API_METRICS_KEY)];
+                case 2:
+                    metricsData = _a.sent();
+                    return [4 /*yield*/, redis.scard(REDIS_UNPRICEABLE_SET)];
+                case 3:
+                    unpriceableCount = _a.sent();
+                    if (!metricsData) {
+                        return [2 /*return*/, {
+                                message: 'No metrics data available',
+                                unpriceableTokens: unpriceableCount
+                            }];
+                    }
+                    metrics = JSON.parse(metricsData);
+                    return [2 /*return*/, {
+                            metrics: metrics,
+                            unpriceableTokens: unpriceableCount,
+                            timestamp: new Date().toISOString()
+                        }];
+                case 4:
+                    error_3 = _a.sent();
+                    log.error(tag, "Error getting metrics:", error_3);
+                    return [2 /*return*/, { error: 'Failed to retrieve metrics' }];
+                case 5: return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * Get list of unpriceable tokens
+ */
+function getUnpriceableTokens() {
+    return __awaiter(this, arguments, void 0, function (limit) {
+        var tag, tokens, error_4;
+        if (limit === void 0) { limit = 100; }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    tag = TAG + 'getUnpriceableTokens | ';
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, redis.smembers(REDIS_UNPRICEABLE_SET)];
+                case 2:
+                    tokens = _a.sent();
+                    return [2 /*return*/, tokens.slice(0, limit)];
+                case 3:
+                    error_4 = _a.sent();
+                    log.error(tag, "Error getting unpriceable tokens:", error_4);
+                    return [2 /*return*/, []];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * Clear a token from unpriceable list (for manual recovery)
+ */
+function clearUnpriceableToken(caip) {
+    return __awaiter(this, void 0, void 0, function () {
+        var tag, error_5;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    tag = TAG + 'clearUnpriceableToken | ';
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, redis.srem(REDIS_UNPRICEABLE_SET, caip)];
+                case 2:
+                    _a.sent();
+                    log.info(tag, "Removed ".concat(caip, " from unpriceable list"));
+                    return [2 /*return*/, true];
+                case 3:
+                    error_5 = _a.sent();
+                    log.error(tag, "Error clearing unpriceable token:", error_5);
+                    return [2 /*return*/, false];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * Start hourly reporting (call this on module initialization)
+ */
+function startHourlyReporting() {
+    var tag = TAG + 'startHourlyReporting | ';
+    // Send initial report after 5 minutes
+    setTimeout(function () {
+        sendHourlyMetricsReport().catch(function (err) {
+            log.error(tag, 'Error in initial metrics report:', err);
+        });
+    }, 5 * 60 * 1000);
+    // Then send every hour
+    setInterval(function () {
+        sendHourlyMetricsReport().catch(function (err) {
+            log.error(tag, 'Error in hourly metrics report:', err);
+        });
+    }, 60 * 60 * 1000);
+    log.info(tag, '✅ Hourly metrics reporting started');
+}

package/lib/ccxt-pricing.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Get price for a symbol from any available exchange
+ * Tries exchanges in order of preference until successful
+ */
+export declare function getPriceFromCCXT(symbol: string): Promise<number>;
+/**
+ * Get prices for multiple symbols in parallel
+ * More efficient than calling getPriceFromCCXT multiple times
+ */
+export declare function getBatchPricesFromCCXT(symbols: string[]): Promise<Record<string, number>>;
+/**
+ * Clear the price cache
+ * Useful for testing or when fresh prices are needed
+ */
+export declare function clearPriceCache(): void;
+/**
+ * Get cache statistics
+ */
+export declare function getCacheStats(): {
+    size: number;
+    entries: Array<{
+        symbol: string;
+        price: number;
+        age: number;
+        source: string;
+    }>;
+};
+/**
+ * Health check - verify we can connect to exchanges
+ */
+export declare function healthCheck(): Promise<{
+    healthy: boolean;
+    exchanges: Record<string, boolean>;
+}>;