监控与告警 #

关键监控指标：
├── 请求量
│   ├── 读请求数
│   └── 写请求数
├── 延迟
│   ├── 查询延迟
│   └── 连接延迟
├── 错误率
│   ├── 错误数量
│   └── 错误类型
├── 存储
│   ├── 数据大小
│   └── 索引大小
└── 并发
    ├── 活跃连接
    └── 并发查询

监控工具：
├── Fauna Dashboard
├── 自定义监控
├── 日志分析
└── 第三方集成

Dashboard提供：
├── 实时指标
├── 历史数据
├── 图表展示
├── 数据库概览
└── 成本分析

访问步骤：
├── 1. 登录Fauna账户
├── 2. 选择数据库
├── 3. 点击"Metrics"选项卡
└── 4. 查看监控数据

指标说明：
├── Read Ops
│   └── 读取操作次数
├── Write Ops
│   └── 写入操作次数
├── Storage
│   └── 存储使用量
├── Latency
│   └── 查询延迟
└── Errors
    └── 错误数量

// 创建监控数据集合
CreateCollection({
  name: "monitoring_metrics",
  history_days: 7
})

// 创建索引
CreateIndex({
  name: "metrics_by_type_time",
  source: Collection("monitoring_metrics"),
  terms: [
    { field: ["data", "type"] }
  ],
  values: [
    { field: ["data", "timestamp"], order: "desc" },
    { field: ["ref"] }
  ]
})

// 创建性能记录函数
CreateFunction({
  name: "record_metric",
  body: Query(
    Lambda(["type", "value", "metadata"],
      Create(Collection("monitoring_metrics"), {
        data: {
          type: Var("type"),
          value: Var("value"),
          metadata: Var("metadata"),
          timestamp: Now()
        }
      })
    )
  )
})

// 使用示例
Call(Function("record_metric"), [
  "query_latency",
  150,
  { query: "users_by_email", success: true }
])

// 获取最近的监控数据
Paginate(
  Match(Index("metrics_by_type_time"), "query_latency"),
  { size: 100 }
)

// 计算平均延迟
Let(
  {
    metrics: Map(
      Paginate(
        Match(Index("metrics_by_type_time"), "query_latency"),
        { size: 100 }
      ),
      Lambda(["timestamp", "ref"],
        Select(["data", "value"], Get(Var("ref")))
      )
    )
  },
  Divide(
    Reduce(
      Var("metrics"),
      Lambda(["acc", "val"], Add(Var("acc"), Var("val"))),
      0
    ),
    Count(Var("metrics"))
  )
)

// 创建日志集合
CreateCollection({
  name: "application_logs",
  history_days: 30
})

// 创建日志索引
CreateIndex({
  name: "logs_by_level_time",
  source: Collection("application_logs"),
  terms: [
    { field: ["data", "level"] }
  ],
  values: [
    { field: ["data", "timestamp"], order: "desc" },
    { field: ["ref"] }
  ]
})

// 创建日志函数
CreateFunction({
  name: "log",
  body: Query(
    Lambda(["level", "message", "context"],
      Create(Collection("application_logs"), {
        data: {
          level: Var("level"),
          message: Var("message"),
          context: Var("context"),
          timestamp: Now()
        }
      })
    )
  )
})

// 使用示例
Call(Function("log"), [
  "error",
  "Query failed",
  {
    query: "users_by_email",
    error: "Timeout",
    duration: 5000
  }
])

// 查询错误日志
Map(
  Paginate(
    Match(Index("logs_by_level_time"), "error"),
    { size: 50 }
  ),
  Lambda(["timestamp", "ref"], Get(Var("ref")))
)

// 按时间范围查询
Filter(
  Paginate(Documents(Collection("application_logs"))),
  Lambda("ref",
    Let(
      { log: Get(Var("ref")) },
      And(
        GTE(Select(["data", "timestamp"], Var("log")), Time("2024-01-01T00:00:00Z")),
        LTE(Select(["data", "timestamp"], Var("log")), Time("2024-01-31T23:59:59Z"))
      )
    )
  )
)

// 创建告警规则集合
CreateCollection({
  name: "alert_rules"
})

// 创建告警规则
Create(Collection("alert_rules"), {
  data: {
    name: "High Error Rate",
    metric: "error_rate",
    threshold: 5,
    operator: "gt",
    period: 300,  // 5分钟
    enabled: true,
    actions: ["email", "webhook"]
  }
})

// 创建告警检查函数
CreateFunction({
  name: "check_alerts",
  body: Query(
    Lambda([],
      Let(
        {
          rules: Paginate(Documents(Collection("alert_rules"))),
          results: Map(
            Var("rules"),
            Lambda("ruleRef",
              Let(
                {
                  rule: Get(Var("ruleRef")),
                  metric: Select(["data", "metric"], Var("rule")),
                  threshold: Select(["data", "threshold"], Var("rule")),
                  currentValue: Call(
                    Function("get_current_metric"),
                    Var("metric")
                  )
                },
                If(
                  GT(Var("currentValue"), Var("threshold")),
                  {
                    rule: Var("rule"),
                    triggered: true,
                    currentValue: Var("currentValue")
                  },
                  {
                    rule: Var("rule"),
                    triggered: false,
                    currentValue: Var("currentValue")
                  }
                )
              )
            )
          )
        },
        Filter(
          Var("results"),
          Lambda("result", Select("triggered", Var("result")))
        )
      )
    )
  )
})

// 创建告警通知记录
Create(Collection("alert_notifications"), {
  data: {
    ruleId: "rule_001",
    metric: "error_rate",
    value: 8.5,
    threshold: 5,
    timestamp: Now(),
    status: "sent"
  }
})

// 创建健康检查函数
CreateFunction({
  name: "health_check",
  body: Query(
    Lambda([],
      Let(
        {
          dbStatus: Now(),
          collections: Count(Paginate(Collections())),
          indexes: Count(Paginate(Indexes())),
          functions: Count(Paginate(Functions()))
        },
        {
          status: "healthy",
          timestamp: Var("dbStatus"),
          stats: {
            collections: Var("collections"),
            indexes: Var("indexes"),
            functions: Var("functions")
          }
        }
      )
    )
  )
})

// 检查连接状态
Let(
  {
    startTime: Now(),
    result: Paginate(Documents(Collection("users")), { size: 1 }),
    endTime: Now(),
    latency: TimeDiff(Var("startTime"), Var("endTime"), "milliseconds")
  },
  {
    connected: true,
    latency: Var("latency")
  }
)

// 创建报告生成函数
CreateFunction({
  name: "generate_performance_report",
  body: Query(
    Lambda(["startDate", "endDate"],
      Let(
        {
          // 查询统计
          queryMetrics: Map(
            Paginate(
              Range(
                Match(Index("metrics_by_type_time"), "query_latency"),
                [Var("startDate")],
                [Var("endDate")]
              )
            ),
            Lambda(["timestamp", "ref"],
              Select(["data", "value"], Get(Var("ref")))
            )
          ),
          
          // 错误统计
          errorCount: Count(
            Filter(
              Paginate(
                Range(
                  Match(Index("logs_by_level_time"), "error"),
                  [Var("startDate")],
                  [Var("endDate")]
                )
              ),
              Lambda(["timestamp", "ref"], true)
            )
          )
        },
        {
          period: {
            start: Var("startDate"),
            end: Var("endDate")
          },
          queries: {
            total: Count(Var("queryMetrics")),
            avgLatency: If(
              GT(Count(Var("queryMetrics")), 0),
              Divide(
                Reduce(
                  Var("queryMetrics"),
                  Lambda(["acc", "val"], Add(Var("acc"), Var("val"))),
                  0
                ),
                Count(Var("queryMetrics"))
              ),
              0
            )
          },
          errors: {
            total: Var("errorCount")
          }
        }
      )
    )
  )
})

// 创建报告记录
Create(Collection("performance_reports"), {
  data: {
    type: "daily",
    period: {
      start: Time("2024-01-01T00:00:00Z"),
      end: Time("2024-01-01T23:59:59Z")
    },
    metrics: {
      totalQueries: 10000,
      avgLatency: 150,
      errorRate: 0.5
    },
    generatedAt: Now()
  }
})

监控建议：
├── 监控关键指标
├── 设置合理阈值
├── 建立基线数据
├── 定期审查告警
└── 保留历史数据

告警建议：
├── 避免告警疲劳
├── 设置优先级
├── 分级通知
├── 记录告警历史
└── 定期优化规则

日志建议：
├── 结构化日志
├── 合理日志级别
├── 定期清理
├── 敏感信息脱敏
└── 集中存储