hedgequantx 2.6.161 → 2.6.162

package/src/services/rithmic/handlers.js

@@ -14,151 +14,12 @@
 const { proto, decodeAccountPnL, decodeInstrumentPnL } = require('./protobuf');
 const { RES, STREAM } = require('./constants');
 const { performance } = require('perf_hooks');
+const { LatencyTracker, FillInfoPool } = require('./latency-tracker');
 
 // Debug mode - use no-op function when disabled for zero overhead
 const DEBUG = process.env.HQX_DEBUG === '1';
 const debug = DEBUG ? (...args) => console.log('[Rithmic:Handler]', ...args) : () => {};
 
-// ==================== HIGH-RESOLUTION TIMING ====================
-// Use process.hrtime.bigint for sub-millisecond precision
-
-/**
- * Get high-resolution timestamp in nanoseconds
- * @returns {bigint}
- */
-const hrNow = () => process.hrtime.bigint();
-
-/**
- * Convert nanoseconds to milliseconds with precision
- * @param {bigint} ns 
- * @returns {number}
- */
-const nsToMs = (ns) => Number(ns) / 1_000_000;
-
-// ==================== LATENCY TRACKING ====================
-// Track order-to-fill latency for performance monitoring
-// OPTIMIZED: Circular buffer (no array.shift), high-resolution timing
-
-const LatencyTracker = {
-  _pending: new Map(), // orderTag -> entryTime (bigint nanoseconds)
-  _samples: null,      // Pre-allocated Float64Array circular buffer
-  _maxSamples: 100,
-  _head: 0,            // Next write position
-  _count: 0,           // Number of valid samples
-  _initialized: false,
-  
-  /**
-   * Initialize circular buffer (lazy init)
-   * @private
-   */
-  _init() {
-    if (this._initialized) return;
-    this._samples = new Float64Array(this._maxSamples);
-    this._initialized = true;
-  },
-  
-  /**
-   * Record order sent time with high-resolution timestamp
-   * @param {string} orderTag 
-   * @param {number} entryTimeMs - Date.now() when order was sent (for compatibility)
-   */
-  recordEntry(orderTag, entryTimeMs) {
-    // Store high-resolution time for precise measurement
-    this._pending.set(orderTag, hrNow());
-  },
-  
-  /**
-   * Record fill received, calculate latency with sub-ms precision
-   * @param {string} orderTag 
-   * @returns {number|null} Round-trip latency in ms (with decimal precision), or null if not tracked
-   */
-  recordFill(orderTag) {
-    const entryTime = this._pending.get(orderTag);
-    if (!entryTime) return null;
-    
-    this._pending.delete(orderTag);
-    const latencyNs = hrNow() - entryTime;
-    const latencyMs = nsToMs(latencyNs);
-    
-    // Store in circular buffer (no shift, O(1))
-    this._init();
-    this._samples[this._head] = latencyMs;
-    this._head = (this._head + 1) % this._maxSamples;
-    if (this._count < this._maxSamples) this._count++;
-    
-    return latencyMs;
-  },
-  
-  /**
-   * Get average latency
-   * @returns {number|null}
-   */
-  getAverage() {
-    if (this._count === 0) return null;
-    let sum = 0;
-    for (let i = 0; i < this._count; i++) {
-      sum += this._samples[i];
-    }
-    return sum / this._count;
-  },
-  
-  /**
-   * Get min/max/avg stats with high precision
-   * @returns {Object}
-   */
-  getStats() {
-    if (this._count === 0) {
-      return { min: null, max: null, avg: null, p50: null, p99: null, samples: 0 };
-    }
-    
-    // Get valid samples
-    const valid = [];
-    for (let i = 0; i < this._count; i++) {
-      valid.push(this._samples[i]);
-    }
-    valid.sort((a, b) => a - b);
-    
-    const sum = valid.reduce((a, b) => a + b, 0);
-    
-    return {
-      min: valid[0],
-      max: valid[valid.length - 1],
-      avg: sum / valid.length,
-      p50: valid[Math.floor(valid.length * 0.5)],
-      p99: valid[Math.floor(valid.length * 0.99)] || valid[valid.length - 1],
-      samples: this._count,
-    };
-  },
-  
-  /**
-   * Get last N latency samples
-   * @param {number} n 
-   * @returns {number[]}
-   */
-  getRecent(n = 10) {
-    if (this._count === 0) return [];
-    const result = [];
-    const start = this._count < this._maxSamples ? 0 : this._head;
-    for (let i = 0; i < Math.min(n, this._count); i++) {
-      const idx = (start + this._count - 1 - i + this._maxSamples) % this._maxSamples;
-      result.push(this._samples[idx]);
-    }
-    return result;
-  },
-  
-  /**
-   * Clear all tracking data
-   */
-  clear() {
-    this._pending.clear();
-    this._head = 0;
-    this._count = 0;
-    if (this._samples) {
-      this._samples.fill(0);
-    }
-  }
-};
-
 /**
  * Create ORDER_PLANT message handler
  * @param {RithmicService} service - The Rithmic service instance
@@ -436,74 +297,7 @@ const handleNewOrderResponse = (service, data) => {
   }
 };
 
-// ==================== PRE-ALLOCATED OBJECTS ====================
-// Reusable objects for hot path to avoid GC pressure
-
-const FillInfoPool = {
-  // Pre-allocated fill info template
-  _template: {
-    orderTag: null,
-    basketId: null,
-    orderId: null,
-    status: null,
-    symbol: null,
-    exchange: null,
-    accountId: null,
-    fillQuantity: 0,
-    totalFillQuantity: 0,
-    remainingQuantity: 0,
-    avgFillPrice: 0,
-    lastFillPrice: 0,
-    transactionType: 0,
-    orderType: 0,
-    quantity: 0,
-    ssboe: 0,
-    usecs: 0,
-    localTimestamp: 0,
-    roundTripLatencyMs: null,
-  },
-  
-  /**
-   * Fill template with notification data
-   * @param {Object} notif - Decoded notification
-   * @param {number} receiveTime - Local receive timestamp
-   * @param {number|null} latency - Round-trip latency
-   * @returns {Object}
-   */
-  fill(notif, receiveTime, latency) {
-    const o = this._template;
-    o.orderTag = notif.userTag || null; // userTag contains our order tag
-    o.basketId = notif.basketId;
-    o.orderId = notif.exchangeOrderId || notif.orderId;
-    o.status = notif.status;
-    o.symbol = notif.symbol;
-    o.exchange = notif.exchange;
-    o.accountId = notif.accountId;
-    // Proto uses totalFillSize, not fillQuantity
-    o.fillQuantity = notif.totalFillSize || notif.fillQuantity || 0;
-    o.totalFillQuantity = notif.totalFillSize || notif.totalFillQuantity || 0;
-    o.remainingQuantity = notif.totalUnfilledSize || notif.remainingQuantity || 0;
-    o.avgFillPrice = parseFloat(notif.avgFillPrice || 0);
-    o.lastFillPrice = parseFloat(notif.price || notif.fillPrice || 0);
-    o.transactionType = notif.transactionType;
-    o.orderType = notif.priceType || notif.orderType;
-    o.quantity = notif.quantity;
-    o.ssboe = notif.ssboe;
-    o.usecs = notif.usecs;
-    o.localTimestamp = receiveTime;
-    o.roundTripLatencyMs = latency;
-    return o;
-  },
-  
-  /**
-   * Create a copy for async operations that need to keep the data
-   * @param {Object} fillInfo 
-   * @returns {Object}
-   */
-  clone(fillInfo) {
-    return { ...fillInfo };
-  }
-};
+// FillInfoPool imported from ./latency-tracker
 
 /**
  * Handle order notification (351) - CRITICAL for fill tracking