aziosxjs 1.0.0 → 1.0.2

package/src/monitoring/RequestMonitor.ts

@@ -0,0 +1,326 @@
+import { AziosRequestConfig } from "../types/config"
+import { AziosResponse } from "../types/response"
+
+/**
+ * Represents a single tracked request/response cycle
+ */
+export interface RequestLog {
+  id: string
+  timestamp: number
+  method: string
+  url: string
+  status?: number
+  statusText?: string
+  duration: number
+  retries: number
+  cached: boolean
+  error?: {
+    message: string
+    code?: string
+  }
+  requestHeaders?: Record<string, any>
+  responseHeaders?: Record<string, any>
+  dataSize?: number
+}
+
+/**
+ * Request Monitor - Track all requests for debugging and monitoring
+ * Production-grade request tracking system with history, filtering, and export
+ */
+export default class RequestMonitor {
+  private enabled: boolean = false
+  private maxEntries: number = 100
+  private logs: Map<string, RequestLog> = new Map()
+  private requestMetadata: Map<string, { startTime: number; retries: number; cached: boolean }> = new Map()
+
+  constructor(maxEntries: number = 100, enabled: boolean = false) {
+    this.maxEntries = maxEntries
+    this.enabled = enabled
+  }
+
+  /**
+   * Enable monitoring
+   */
+  enable(): void {
+    this.enabled = true
+  }
+
+  /**
+   * Disable monitoring
+   */
+  disable(): void {
+    this.enabled = false
+  }
+
+  /**
+   * Check if monitoring is enabled
+   */
+  isEnabled(): boolean {
+    return this.enabled
+  }
+
+  /**
+   * Mark the start of a request
+   */
+  startRequest(config: AziosRequestConfig): string {
+    if (!this.enabled) return ""
+
+    const requestId = this.generateId()
+    this.requestMetadata.set(requestId, {
+      startTime: Date.now(),
+      retries: config.retry || 0,
+      cached: config.cache || false
+    })
+
+    return requestId
+  }
+
+  /**
+   * Mark the end of a successful request
+   */
+  endRequest(requestId: string, config: AziosRequestConfig, response: AziosResponse): void {
+    if (!this.enabled || !requestId) return
+
+    const metadata = this.requestMetadata.get(requestId)
+    if (!metadata) return
+
+    const duration = Date.now() - metadata.startTime
+
+    const log: RequestLog = {
+      id: requestId,
+      timestamp: Date.now(),
+      method: config.method || "GET",
+      url: config.url || "",
+      status: response.status,
+      statusText: response.statusText,
+      duration,
+      retries: metadata.retries,
+      cached: metadata.cached,
+      requestHeaders: config.headers,
+      responseHeaders: response.headers,
+      dataSize: this.estimateSize(response.data)
+    }
+
+    this.addLog(log)
+    this.requestMetadata.delete(requestId)
+  }
+
+  /**
+   * Mark the end of a failed request
+   */
+  endRequestWithError(requestId: string, config: AziosRequestConfig, error: Error | any): void {
+    if (!this.enabled || !requestId) return
+
+    const metadata = this.requestMetadata.get(requestId)
+    if (!metadata) return
+
+    const duration = Date.now() - metadata.startTime
+
+    const log: RequestLog = {
+      id: requestId,
+      timestamp: Date.now(),
+      method: config.method || "GET",
+      url: config.url || "",
+      duration,
+      retries: metadata.retries,
+      cached: metadata.cached,
+      error: {
+        message: error?.message || "Unknown error",
+        code: error?.code
+      },
+      requestHeaders: config.headers
+    }
+
+    this.addLog(log)
+    this.requestMetadata.delete(requestId)
+  }
+
+  /**
+   * Add a log entry and maintain maxEntries limit
+   */
+  private addLog(log: RequestLog): void {
+    this.logs.set(log.id, log)
+
+    // Remove oldest entries if we exceed maxEntries
+    if (this.logs.size > this.maxEntries) {
+      const entriesToRemove = this.logs.size - this.maxEntries
+      let removed = 0
+
+      for (const [id, _] of this.logs) {
+        if (removed >= entriesToRemove) break
+        this.logs.delete(id)
+        removed++
+      }
+    }
+  }
+
+  /**
+   * Get all logged requests
+   */
+  getHistory(): RequestLog[] {
+    return Array.from(this.logs.values())
+  }
+
+  /**
+   * Get logs filtered by method
+   */
+  getByMethod(method: string): RequestLog[] {
+    return this.getHistory().filter(log => log.method.toUpperCase() === method.toUpperCase())
+  }
+
+  /**
+   * Get logs filtered by URL pattern
+   */
+  getByUrl(pattern: string | RegExp): RequestLog[] {
+    const regex = typeof pattern === "string" ? new RegExp(pattern) : pattern
+    return this.getHistory().filter(log => regex.test(log.url))
+  }
+
+  /**
+   * Get logs with errors
+   */
+  getErrors(): RequestLog[] {
+    return this.getHistory().filter(log => log.error !== undefined)
+  }
+
+  /**
+   * Get statistics
+   */
+  getStats(): {
+    totalRequests: number
+    totalErrors: number
+    totalCached: number
+    averageDuration: number
+    slowestRequest: number
+    fastestRequest: number
+  } {
+    const history = this.getHistory()
+
+    if (history.length === 0) {
+      return {
+        totalRequests: 0,
+        totalErrors: 0,
+        totalCached: 0,
+        averageDuration: 0,
+        slowestRequest: 0,
+        fastestRequest: 0
+      }
+    }
+
+    const errors = history.filter(log => log.error).length
+    const cached = history.filter(log => log.cached).length
+    const durations = history.map(log => log.duration)
+    const avgDuration = durations.reduce((a, b) => a + b, 0) / durations.length
+
+    return {
+      totalRequests: history.length,
+      totalErrors: errors,
+      totalCached: cached,
+      averageDuration: Math.round(avgDuration),
+      slowestRequest: Math.max(...durations),
+      fastestRequest: Math.min(...durations)
+    }
+  }
+
+  /**
+   * Clear all logs
+   */
+  clear(): void {
+    this.logs.clear()
+    this.requestMetadata.clear()
+  }
+
+  /**
+   * Export logs as JSON
+   */
+  exportJSON(): string {
+    return JSON.stringify(this.getHistory(), null, 2)
+  }
+
+  /**
+   * Export logs as CSV
+   */
+  exportCSV(): string {
+    const history = this.getHistory()
+
+    if (history.length === 0) {
+      return "No logs to export"
+    }
+
+    const headers = [
+      "Timestamp",
+      "Method",
+      "URL",
+      "Status",
+      "Duration (ms)",
+      "Cached",
+      "Error"
+    ]
+
+    const rows = history.map(log => [
+      new Date(log.timestamp).toISOString(),
+      log.method,
+      log.url,
+      log.status || "N/A",
+      log.duration,
+      log.cached ? "Yes" : "No",
+      log.error ? log.error.message : "None"
+    ])
+
+    const csvContent = [headers, ...rows]
+      .map(row => row.map(cell => `"${cell}"`).join(","))
+      .join("\n")
+
+    return csvContent
+  }
+
+  /**
+   * Get a formatted debug summary
+   */
+  getSummary(): string {
+    const stats = this.getStats()
+    const errors = this.getErrors()
+
+    let summary = `
+╔══════════════════════════════════════════════╗
+║         📊 AZIOS REQUEST MONITOR              ║
+╚══════════════════════════════════════════════╝
+
+📈 Statistics:
+  • Total Requests: ${stats.totalRequests}
+  • Errors: ${stats.totalErrors}
+  • Cached: ${stats.totalCached}
+  • Avg Duration: ${stats.averageDuration}ms
+  • Slowest: ${stats.slowestRequest}ms
+  • Fastest: ${stats.fastestRequest}ms
+`
+
+    if (errors.length > 0) {
+      summary += `\n❌ Recent Errors:\n`
+      errors.slice(-5).forEach(log => {
+        summary += `  • ${log.method} ${log.url}: ${log.error?.message}\n`
+      })
+    }
+
+    return summary
+  }
+
+  /**
+   * Generate unique request ID
+   */
+  private generateId(): string {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
+  }
+
+  /**
+   * Estimate data size in KB
+   */
+  private estimateSize(data: any): number {
+    try {
+      const json = JSON.stringify(data)
+      return Math.round(json.length / 1024 * 100) / 100 // KB with 2 decimals
+    } catch {
+      return 0
+    }
+  }
+}

package/src/runtimes/AdapterFactory.ts

@@ -1,6 +1,7 @@
 import type { HttpAdapter } from './HttpAdapter'
 import { currentRuntime, RuntimeType } from './detectRuntime'
 import UniversalHttpAdapter from './UniversalHttpAdapter'
+import { NodeHttpAdapter } from '../adapters'
 
 /**
  * Adapter factory for selecting the appropriate HTTP adapter
@@ -14,7 +15,22 @@ export class AdapterFactory {
    */
   static getAdapter(): HttpAdapter {
     if (!this.adapters.has(currentRuntime)) {
-      this.adapters.set(currentRuntime, new UniversalHttpAdapter())
+      let adapter: HttpAdapter
+
+      // Try UniversalHttpAdapter first (works in Node 18+, browsers, etc.)
+      const universalAdapter = new UniversalHttpAdapter()
+      if (universalAdapter.isSupported()) {
+        adapter = universalAdapter
+      } else if (currentRuntime === RuntimeType.Node) {
+        // Fallback to NodeHttpAdapter for Node.js < 18
+        adapter = new NodeHttpAdapter()
+      } else {
+        throw new Error(
+          `No supported HTTP adapter found for runtime: ${currentRuntime}`
+        )
+      }
+
+      this.adapters.set(currentRuntime, adapter)
     }
 
     const adapter = this.adapters.get(currentRuntime)!

package/src/types/request.ts

@@ -1,6 +1,7 @@
 import { AziosRequestConfig } from "./config"
 import { AziosResponse } from "./response"
 import InterceptorManager from "../interceptors/InterceptorManager"
+import RequestMonitor from "../monitoring/RequestMonitor"
 import type { AziosPlugin } from "./plugin"
 import type { AziosMiddleware } from "./middleware"
 
@@ -36,4 +37,7 @@ export interface AziosInstance {
   // Middleware system
   use(middleware: AziosMiddleware): void
 
+  // Monitoring system (NEW)
+  monitor: RequestMonitor
+
 }