Back to Details

metrics

Compare original and translation side by side

🇺🇸

Original

English
🇨🇳

Translation

Chinese

Metrics - Complete API Reference

Metrics - 完整API参考文档

Monitor system health, track performance metrics, and analyze telemetry data.
监控系统健康状态，追踪性能指标，分析遥测数据。

Chat Commands

聊天命令

System Metrics

系统指标

/metrics                               Show current metrics
/metrics system                        CPU, memory, latency
/metrics api                           API performance stats
/metrics ws                            WebSocket health
/metrics                               显示当前指标
/metrics system                        CPU、内存、延迟
/metrics api                           API性能统计
/metrics ws                            WebSocket健康状态

Trading Metrics

交易指标

/metrics trades                        Trade execution stats
/metrics fills                         Fill rate metrics
/metrics latency                       Order latency stats
/metrics errors                        Error rates
/metrics trades                        交易执行统计
/metrics fills                         成交率指标
/metrics latency                       订单延迟统计
/metrics errors                        错误率

Custom Metrics

自定义指标

/metrics track <name> <value>          Track custom metric
/metrics query <name>                  Query metric history
/metrics alert <name> > 100            Set metric alert
/metrics track <name> <value>          追踪自定义指标
/metrics query <name>                  查询指标历史
/metrics alert <name> > 100            设置指标告警

Export & Reports

导出与报告

/metrics export csv                    Export to CSV
/metrics report daily                  Generate daily report
/metrics dashboard                     Open metrics dashboard
/metrics export csv                    导出为CSV格式
/metrics report daily                  生成日报
/metrics dashboard                     打开指标仪表盘

TypeScript API Reference

TypeScript API参考文档

Create Metrics Service

创建Metrics服务

typescript
import { createMetricsService } from 'clodds/metrics';

const metrics = createMetricsService({
  // Collection
  collectInterval: 5000,  // ms
  retention: '30d',

  // Storage
  storage: 'sqlite',
  dbPath: './metrics.db',

  // Export
  enablePrometheus: true,
  prometheusPort: 9090,
});

// Start collection
await metrics.start();
typescript
import { createMetricsService } from 'clodds/metrics';

const metrics = createMetricsService({
  // 采集配置
  collectInterval: 5000,  // ms
  retention: '30d',

  // 存储配置
  storage: 'sqlite',
  dbPath: './metrics.db',

  // 导出配置
  enablePrometheus: true,
  prometheusPort: 9090,
});

// 启动采集
await metrics.start();

System Metrics

系统指标

typescript
const system = await metrics.getSystemMetrics();

console.log('=== System Health ===');
console.log(`CPU Usage: ${system.cpuUsage}%`);
console.log(`Memory: ${system.memoryUsed}MB / ${system.memoryTotal}MB`);
console.log(`Uptime: ${system.uptimeHours}h`);
console.log(`Active connections: ${system.activeConnections}`);
console.log(`Event loop lag: ${system.eventLoopLag}ms`);
typescript
const system = await metrics.getSystemMetrics();

console.log('=== 系统健康状态 ===');
console.log(`CPU使用率: ${system.cpuUsage}%`);
console.log(`内存: ${system.memoryUsed}MB / ${system.memoryTotal}MB`);
console.log(`运行时长: ${system.uptimeHours}h`);
console.log(`活跃连接数: ${system.activeConnections}`);
console.log(`事件循环延迟: ${system.eventLoopLag}ms`);

API Metrics

API指标

typescript
const api = await metrics.getApiMetrics();

console.log('=== API Performance ===');
console.log(`Total requests: ${api.totalRequests}`);
console.log(`Requests/sec: ${api.requestsPerSecond}`);
console.log(`Avg latency: ${api.avgLatency}ms`);
console.log(`P50 latency: ${api.p50Latency}ms`);
console.log(`P95 latency: ${api.p95Latency}ms`);
console.log(`P99 latency: ${api.p99Latency}ms`);
console.log(`Error rate: ${api.errorRate}%`);

console.log('\nBy Endpoint:');
for (const endpoint of api.byEndpoint) {
  console.log(`  ${endpoint.path}: ${endpoint.avgLatency}ms (${endpoint.calls} calls)`);
}
typescript
const api = await metrics.getApiMetrics();

console.log('=== API性能 ===');
console.log(`总请求数: ${api.totalRequests}`);
console.log(`每秒请求数: ${api.requestsPerSecond}`);
console.log(`平均延迟: ${api.avgLatency}ms`);
console.log(`P50延迟: ${api.p50Latency}ms`);
console.log(`P95延迟: ${api.p95Latency}ms`);
console.log(`P99延迟: ${api.p99Latency}ms`);
console.log(`错误率: ${api.errorRate}%`);

console.log('\n按端点统计:');
for (const endpoint of api.byEndpoint) {
  console.log(`  ${endpoint.path}: ${endpoint.avgLatency}ms (调用次数: ${endpoint.calls})`);
}

WebSocket Metrics

WebSocket指标

typescript
const ws = await metrics.getWebSocketMetrics();

console.log('=== WebSocket Health ===');
console.log(`Active connections: ${ws.activeConnections}`);
console.log(`Messages/sec: ${ws.messagesPerSecond}`);
console.log(`Avg message size: ${ws.avgMessageSize} bytes`);
console.log(`Reconnections: ${ws.reconnections}`);
console.log(`Dropped messages: ${ws.droppedMessages}`);

console.log('\nBy Feed:');
for (const feed of ws.byFeed) {
  console.log(`  ${feed.name}: ${feed.messagesPerSecond}/s, ${feed.latency}ms lag`);
}
typescript
const ws = await metrics.getWebSocketMetrics();

console.log('=== WebSocket健康状态 ===');
console.log(`活跃连接数: ${ws.activeConnections}`);
console.log(`每秒消息数: ${ws.messagesPerSecond}`);
console.log(`平均消息大小: ${ws.avgMessageSize} 字节`);
console.log(`重连次数: ${ws.reconnections}`);
console.log(`丢失消息数: ${ws.droppedMessages}`);

console.log('\n按Feed统计:');
for (const feed of ws.byFeed) {
  console.log(`  ${feed.name}: ${feed.messagesPerSecond}/秒, 延迟: ${feed.latency}ms`);
}

Trade Execution Metrics

交易执行指标

typescript
const trades = await metrics.getTradeMetrics();

console.log('=== Trade Execution ===');
console.log(`Total orders: ${trades.totalOrders}`);
console.log(`Fill rate: ${trades.fillRate}%`);
console.log(`Partial fills: ${trades.partialFillRate}%`);
console.log(`Rejections: ${trades.rejectionRate}%`);
console.log(`Avg fill time: ${trades.avgFillTime}ms`);
console.log(`Avg slippage: ${trades.avgSlippage}%`);

console.log('\nBy Platform:');
for (const platform of trades.byPlatform) {
  console.log(`  ${platform.name}:`);
  console.log(`    Fill rate: ${platform.fillRate}%`);
  console.log(`    Avg latency: ${platform.avgLatency}ms`);
}
typescript
const trades = await metrics.getTradeMetrics();

console.log('=== 交易执行 ===');
console.log(`总订单数: ${trades.totalOrders}`);
console.log(`成交率: ${trades.fillRate}%`);
console.log(`部分成交率: ${trades.partialFillRate}%`);
console.log(`订单拒绝率: ${trades.rejectionRate}%`);
console.log(`平均成交时间: ${trades.avgFillTime}ms`);
console.log(`平均滑点: ${trades.avgSlippage}%`);

console.log('\n按平台统计:');
for (const platform of trades.byPlatform) {
  console.log(`  ${platform.name}:`);
  console.log(`    成交率: ${platform.fillRate}%`);
  console.log(`    平均延迟: ${platform.avgLatency}ms`);
}

Latency Breakdown

延迟细分

typescript
const latency = await metrics.getLatencyBreakdown();

console.log('=== Latency Breakdown ===');
console.log(`Total order latency: ${latency.total}ms`);
console.log(`  Signal processing: ${latency.signalProcessing}ms`);
console.log(`  Order construction: ${latency.orderConstruction}ms`);
console.log(`  Network round-trip: ${latency.networkRoundTrip}ms`);
console.log(`  Exchange processing: ${latency.exchangeProcessing}ms`);
console.log(`  Confirmation: ${latency.confirmation}ms`);
typescript
const latency = await metrics.getLatencyBreakdown();

console.log('=== 延迟细分 ===');
console.log(`总订单延迟: ${latency.total}ms`);
console.log(`  信号处理: ${latency.signalProcessing}ms`);
console.log(`  订单构建: ${latency.orderConstruction}ms`);
console.log(`  网络往返: ${latency.networkRoundTrip}ms`);
console.log(`  交易所处理: ${latency.exchangeProcessing}ms`);
console.log(`  确认时间: ${latency.confirmation}ms`);

Error Metrics

错误指标

typescript
const errors = await metrics.getErrorMetrics();

console.log('=== Error Rates ===');
console.log(`Total errors: ${errors.totalErrors}`);
console.log(`Error rate: ${errors.errorRate}%`);
console.log(`Errors/hour: ${errors.errorsPerHour}`);

console.log('\nBy Type:');
for (const type of errors.byType) {
  console.log(`  ${type.name}: ${type.count} (${type.percentage}%)`);
}

console.log('\nBy Platform:');
for (const platform of errors.byPlatform) {
  console.log(`  ${platform.name}: ${platform.errorRate}%`);
}
typescript
const errors = await metrics.getErrorMetrics();

console.log('=== 错误率 ===');
console.log(`总错误数: ${errors.totalErrors}`);
console.log(`错误率: ${errors.errorRate}%`);
console.log(`每小时错误数: ${errors.errorsPerHour}`);

console.log('\n按类型统计:');
for (const type of errors.byType) {
  console.log(`  ${type.name}: ${type.count} (占比: ${type.percentage}%)`);
}

console.log('\n按平台统计:');
for (const platform of errors.byPlatform) {
  console.log(`  ${platform.name}: 错误率 ${platform.errorRate}%`);
}

Custom Metrics

自定义指标

typescript
// Track custom metric
metrics.track('edge_detected', 1, {
  market: 'trump-2028',
  edgeSize: 0.05,
});

// Increment counter
metrics.increment('trades_executed');

// Set gauge
metrics.gauge('active_positions', 5);

// Record timing
const timer = metrics.startTimer('order_execution');
// ... execute order ...
timer.end();

// Histogram
metrics.histogram('slippage', 0.003, {
  platform: 'polymarket',
});
typescript
// 追踪自定义指标
metrics.track('edge_detected', 1, {
  market: 'trump-2028',
  edgeSize: 0.05,
});

// 递增计数器
metrics.increment('trades_executed');

// 设置仪表盘指标
metrics.gauge('active_positions', 5);

// 记录耗时
const timer = metrics.startTimer('order_execution');
// ... 执行订单 ...
timer.end();

// 直方图
metrics.histogram('slippage', 0.003, {
  platform: 'polymarket',
});

Query Metrics

查询指标

typescript
const query = await metrics.query({
  metric: 'edge_detected',
  period: '7d',
  aggregation: 'sum',
  groupBy: 'market',
});

console.log('Edge Detection by Market:');
for (const row of query.results) {
  console.log(`  ${row.market}: ${row.value} detections`);
}
typescript
const query = await metrics.query({
  metric: 'edge_detected',
  period: '7d',
  aggregation: 'sum',
  groupBy: 'market',
});

console.log('按市场统计的信号检测数:');
for (const row of query.results) {
  console.log(`  ${row.market}: ${row.value} 次检测`);
}

Metric Alerts

指标告警

typescript
// Set alert threshold
metrics.setAlert({
  metric: 'error_rate',
  condition: '>',
  threshold: 5,  // > 5% error rate
  window: '5m',
  action: 'notify',
});

metrics.setAlert({
  metric: 'latency_p99',
  condition: '>',
  threshold: 1000,  // > 1000ms
  window: '1m',
  action: 'escalate',
});

// Alert handlers
metrics.on('alert', (alert) => {
  console.log(`🚨 Alert: ${alert.metric} ${alert.condition} ${alert.threshold}`);
  console.log(`  Current value: ${alert.currentValue}`);
});
typescript
// 设置告警阈值
metrics.setAlert({
  metric: 'error_rate',
  condition: '>',
  threshold: 5,  // 错误率 > 5%
  window: '5m',
  action: 'notify',
});

metrics.setAlert({
  metric: 'latency_p99',
  condition: '>',
  threshold: 1000,  // 延迟 > 1000ms
  window: '1m',
  action: 'escalate',
});

// 告警处理器
metrics.on('alert', (alert) => {
  console.log(`🚨 告警: ${alert.metric} ${alert.condition} ${alert.threshold}`);
  console.log(`  当前值: ${alert.currentValue}`);
});

Export Metrics

导出指标

typescript
// Export to CSV
await metrics.export({
  format: 'csv',
  metrics: ['api_latency', 'trade_fill_rate', 'error_rate'],
  period: '30d',
  outputPath: './metrics-export.csv',
});

// Export to Prometheus
const prometheusFormat = metrics.toPrometheus();

// Export to JSON
const jsonMetrics = await metrics.toJSON({
  period: '24h',
});
typescript
// 导出为CSV
await metrics.export({
  format: 'csv',
  metrics: ['api_latency', 'trade_fill_rate', 'error_rate'],
  period: '30d',
  outputPath: './metrics-export.csv',
});

// 导出为Prometheus格式
const prometheusFormat = metrics.toPrometheus();

// 导出为JSON
const jsonMetrics = await metrics.toJSON({
  period: '24h',
});

Generate Reports

生成报告

typescript
const report = await metrics.generateReport({
  type: 'daily',
  include: ['summary', 'api', 'trades', 'errors'],
});

console.log('=== Daily Metrics Report ===');
console.log(`Date: ${report.date}`);
console.log(`\nSummary:`);
console.log(`  Uptime: ${report.summary.uptime}%`);
console.log(`  Total requests: ${report.summary.totalRequests}`);
console.log(`  Total trades: ${report.summary.totalTrades}`);
console.log(`  Error rate: ${report.summary.errorRate}%`);
console.log(`\nHighlights:`);
for (const highlight of report.highlights) {
  console.log(`  - ${highlight}`);
}
typescript
const report = await metrics.generateReport({
  type: 'daily',
  include: ['summary', 'api', 'trades', 'errors'],
});

console.log('=== 每日指标报告 ===');
console.log(`日期: ${report.date}`);
console.log(`\n摘要:`);
console.log(`  在线率: ${report.summary.uptime}%`);
console.log(`  总请求数: ${report.summary.totalRequests}`);
console.log(`  总交易数: ${report.summary.totalTrades}`);
console.log(`  错误率: ${report.summary.errorRate}%`);
console.log(`\n重点关注:`);
for (const highlight of report.highlights) {
  console.log(`  - ${highlight}`);
}

Real-time Streaming

实时流

typescript
// Stream metrics in real-time
const stream = metrics.stream(['cpu', 'memory', 'latency']);

stream.on('data', (data) => {
  console.log(`CPU: ${data.cpu}%, Memory: ${data.memory}MB, Latency: ${data.latency}ms`);
});

// Stop streaming
stream.stop();
typescript
// 实时流传输指标
const stream = metrics.stream(['cpu', 'memory', 'latency']);

stream.on('data', (data) => {
  console.log(`CPU使用率: ${data.cpu}%, 内存: ${data.memory}MB, 延迟: ${data.latency}ms`);
});

// 停止流传输
stream.stop();

Metric Types

指标类型

TypeDescriptionExample
CounterMonotonic increasing
trades_total
GaugePoint-in-time value
active_positions
HistogramDistribution
latency_ms
TimerDuration measurement
order_execution_time
类型描述示例
Counter单调递增型指标
trades_total
Gauge时间点瞬时值指标
active_positions
Histogram分布统计指标
latency_ms
Timer耗时测量指标
order_execution_time

Built-in Metrics

内置指标

CategoryMetrics
Systemcpu_usage, memory_used, uptime, connections
APIrequest_count, latency_p50/p95/p99, error_rate
WebSocketmessages_per_sec, lag, reconnections
Tradesorders_total, fill_rate, slippage, execution_time
Errorserror_count, error_rate_by_type
分类指标
系统cpu_usage、memory_used、uptime、connections
APIrequest_count、latency_p50/p95/p99、error_rate
WebSocketmessages_per_sec、lag、reconnections
交易orders_total、fill_rate、slippage、execution_time
错误error_count、error_rate_by_type

Best Practices

最佳实践

  1. Monitor latency percentiles — P99 matters more than average
  2. Set alerts proactively — Catch issues before users notice
  3. Track custom metrics — Business-specific KPIs
  4. Review daily reports — Spot trends early
  5. Export for analysis — Use external tools for deep dives
  1. 监控延迟百分位数 — P99比平均值更重要
  2. 主动设置告警 — 在用户发现问题前提前捕获
  3. 追踪自定义指标 — 业务特定的关键绩效指标（KPI）
  4. 每日查看报告 — 及早发现趋势
  5. 导出数据用于分析 — 使用外部工具进行深度分析