PromQL函数 #

PromQL函数分类：

┌─────────────────────────────────────────────┐
│ 1. 数学函数                                 │
├─────────────────────────────────────────────┤
│ • abs(), ceil(), floor()                    │
│ • round(), sqrt(), ln()                     │
└─────────────────────────────────────────────┘

┌─────────────────────────────────────────────┐
│ 2. 时间函数                                 │
├─────────────────────────────────────────────┤
│ • rate(), increase()                        │
│ • irate(), deriv()                          │
└─────────────────────────────────────────────┘

┌─────────────────────────────────────────────┐
│ 3. 聚合函数                                 │
├─────────────────────────────────────────────┤
│ • sum(), avg(), min(), max()                │
│ • count(), stddev(), stdvar()               │
└─────────────────────────────────────────────┘

┌─────────────────────────────────────────────┐
│ 4. 变换函数                                 │
├─────────────────────────────────────────────┤
│ • histogram_quantile()                      │
│ • label_replace(), label_join()             │
└─────────────────────────────────────────────┘

┌─────────────────────────────────────────────┐
│ 5. 统计函数                                 │
├─────────────────────────────────────────────┤
│ • changes(), resets()                       │
│ • deriv(), predict_linear()                 │
└─────────────────────────────────────────────┘

# 计算每秒平均速率
rate(http_requests_total[5m])

# 计算CPU使用率
rate(node_cpu_seconds_total[5m])

# 计算网络流量速率
rate(node_network_receive_bytes_total[5m])

# 计算磁盘IO速率
rate(node_disk_io_time_seconds_total[5m])

rate计算原理：

┌─────────────────────────────────────────────┐
│ rate(v[时间范围])                           │
├─────────────────────────────────────────────┤
│ • 计算范围向量中时间序列的平均速率          │
│ • 自动处理计数器重置                        │
│ • 只适用于Counter类型                       │
│ • 返回即时向量                              │
└─────────────────────────────────────────────┘

计算公式：
rate = (最后一个值 - 第一个值) / 时间范围秒数

示例：
时间范围：5分钟 = 300秒
第一个值：100
最后一个值：400

rate = (400 - 100) / 300 = 1 请求/秒

处理计数器重置：
时间范围：5分钟
第一个值：100
中间值：50（重置）
最后一个值：150

rate = (150 - 0 + 100) / 300 = 0.83 请求/秒

# 推荐的时间范围
rate(http_requests_total[5m])   # 5分钟（常用）
rate(http_requests_total[1m])   # 1分钟（更实时）
rate(http_requests_total[15m])  # 15分钟（更平滑）

# 按标签分组
sum by (method) (rate(http_requests_total[5m]))

# 计算QPS
sum(rate(http_requests_total[5m]))

# 计算错误率
sum(rate(http_errors_total[5m])) / sum(rate(http_requests_total[5m]))

# 计算过去5分钟的增量
increase(http_requests_total[5m])

# 计算过去1小时的增量
increase(http_requests_total[1h])

# 计算过去1天的增量
increase(http_requests_total[1d])

# 按标签分组
sum by (method) (increase(http_requests_total[5m]))

increase vs rate：

┌─────────────────────────────────────────────┐
│ rate(v[时间范围])                           │
├─────────────────────────────────────────────┤
│ • 返回每秒速率                              │
│ • 单位：/秒                                 │
│ • 适合计算QPS                               │
└─────────────────────────────────────────────┘

┌─────────────────────────────────────────────┐
│ increase(v[时间范围])                       │
├─────────────────────────────────────────────┤
│ • 返回时间范围内的总增量                    │
│ • 单位：计数                                │
│ • 适合计算总数                              │
└─────────────────────────────────────────────┘

关系：
increase(v[时间范围]) = rate(v[时间范围]) * 时间范围秒数

示例：
rate(http_requests_total[5m]) = 10 请求/秒
increase(http_requests_total[5m]) = 10 * 300 = 3000 请求

# 计算瞬时速率
irate(http_requests_total[5m])

# 计算CPU瞬时使用率
irate(node_cpu_seconds_total[5m])

# 计算网络瞬时速率
irate(node_network_receive_bytes_total[5m])

irate vs rate：

┌─────────────────────────────────────────────┐
│ rate(v[时间范围])                           │
├─────────────────────────────────────────────┤
│ • 使用范围内所有数据点                      │
│ • 计算平均速率                              │
│ • 更平滑，适合告警                          │
│ • 适合长期趋势分析                          │
└─────────────────────────────────────────────┘

┌─────────────────────────────────────────────┐
│ irate(v[时间范围])                          │
├─────────────────────────────────────────────┤
│ • 只使用最后两个数据点                      │
│ • 计算瞬时速率                              │
│ • 更敏感，适合图表                          │
│ • 适合短期波动分析                          │
└─────────────────────────────────────────────┘

使用建议：
• 告警规则：使用rate()，更稳定
• 图表展示：使用irate()，更实时

# 求和
sum(http_requests_total)

# 按标签分组求和
sum by (method) (http_requests_total)

# 按多个标签分组
sum by (method, status) (http_requests_total)

# 排除特定标签
sum without (instance) (http_requests_total)

# 计算总QPS
sum(rate(http_requests_total[5m]))

# 按服务分组计算QPS
sum by (service) (rate(http_requests_total[5m]))

# 平均值
avg(node_memory_MemAvailable_bytes)

# 按标签分组平均值
avg by (instance) (node_memory_MemAvailable_bytes)

# 计算平均延迟
avg(rate(http_request_duration_seconds_sum[5m]) / rate(http_request_duration_seconds_count[5m]))

# 按服务分组计算平均延迟
avg by (service) (rate(http_request_duration_seconds_sum[5m]) / rate(http_request_duration_seconds_count[5m]))

# 最小值
min(node_memory_MemAvailable_bytes)

# 最大值
max(node_memory_MemAvailable_bytes)

# 按标签分组
min by (instance) (node_memory_MemAvailable_bytes)
max by (instance) (node_memory_MemAvailable_bytes)

# 找出内存使用最高的实例
max by (instance) (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes)

# 找出延迟最高的请求
max by (endpoint) (rate(http_request_duration_seconds_sum[5m]) / rate(http_request_duration_seconds_count[5m]))

# 计数
count(up)

# 计算在线实例数
count(up == 1)

# 计算离线实例数
count(up == 0)

# 按标签分组计数
count by (job) (up)

# 计算错误数
count by (status) (http_requests_total{status=~"5.."})

# 标准差
stddev(node_memory_MemAvailable_bytes)

# 方差
stdvar(node_memory_MemAvailable_bytes)

# 按标签分组
stddev by (instance) (rate(http_request_duration_seconds[5m]))

# 计算延迟波动
stddev by (service) (rate(http_request_duration_seconds_sum[5m]) / rate(http_request_duration_seconds_count[5m]))

# 取前K个最大值
topk(5, http_requests_total)

# 取前K个最小值
bottomk(5, http_requests_total)

# 取QPS最高的5个服务
topk(5, sum by (service) (rate(http_requests_total[5m])))

# 取延迟最高的5个端点
topk(5, rate(http_request_duration_seconds_sum[5m]) / rate(http_request_duration_seconds_count[5m]))

# 取内存使用最高的5个实例
topk(5, node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes)

# 绝对值
abs(http_requests_total - 1000)

# 向上取整
ceil(1.2)  # 结果：2

# 向下取整
floor(1.8)  # 结果：1

# 四舍五入
round(1.5)  # 结果：2
round(1.567, 0.01)  # 结果：1.57

# 平方根
sqrt(http_requests_total)

# 自然对数
ln(http_requests_total)

# 以2为底的对数
log2(http_requests_total)

# 以10为底的对数
log10(http_requests_total)

# 正弦
sin(http_requests_total)

# 余弦
cos(http_requests_total)

# 正切
tan(http_requests_total)

# 反正弦
asin(http_requests_total)

# 反余弦
acos(http_requests_total)

# 反正切
atan(http_requests_total)

# 当前Unix时间戳
time()

# 指标过期时间
http_requests_total - timestamp(http_requests_total)

# 一天中的小时数（0-23）
hour()

# 一周中的星期几（0-6）
day_of_week()

# 一月中的日期（1-31）
day_of_month()

# 一年中的天数（1-365/366）
day_of_year()

# 一年中的周数（0-53）
week_of_year()

# 一年中的月数（1-12）
month()

# 年份
year()

# 查询工作时间段的请求
http_requests_total and hour() >= 9 and hour() < 18

# 查询工作日的请求
http_requests_total and day_of_week() >= 1 and day_of_week() <= 5

# 查询特定月份的数据
http_requests_total and month() == 12

# 查询特定年份的数据
http_requests_total and year() == 2024

# 计算P50延迟
histogram_quantile(0.5, rate(http_request_duration_seconds_bucket[5m]))

# 计算P90延迟
histogram_quantile(0.9, rate(http_request_duration_seconds_bucket[5m]))

# 计算P99延迟
histogram_quantile(0.99, rate(http_request_duration_seconds_bucket[5m]))

# 按服务分组计算P99延迟
histogram_quantile(0.99, sum by (le, service) (rate(http_request_duration_seconds_bucket[5m])))

# 按端点分组计算P99延迟
histogram_quantile(0.99, sum by (le, endpoint) (rate(http_request_duration_seconds_bucket[5m])))

# 替换标签值
label_replace(up{job="node-exporter"}, "host", "$1", "instance", "(.*):.*")

# 从instance中提取host
label_replace(up, "host", "$1", "instance", "([^:]+):.*")

# 添加新标签
label_replace(up, "env", "production", "", "")

# 修改现有标签
label_replace(up, "job", "node", "job", "node-exporter")

# 连接标签值
label_join(up{job="node-exporter"}, "new_label", "-", "job", "instance")

# 创建复合标签
label_join(up, "full_name", "_", "job", "instance")

# 连接多个标签
label_join(up, "combined", "-", "job", "instance", "environment")

# 计算变化次数
changes(up[1h])

# 计算重启次数
changes(process_start_time_seconds[1d])

# 计算配置变更次数
changes(prometheus_config_last_reload_success_timestamp_seconds[1d])

# 计算重置次数
resets(http_requests_total[1h])

# 计算计数器重置次数
resets(node_cpu_seconds_total[1d])

# 计算变化率（线性回归）
deriv(node_memory_MemAvailable_bytes[1h])

# 预测内存趋势
deriv(node_memory_MemAvailable_bytes[1h]) * 3600

# 预测1小时后的值
predict_linear(node_memory_MemAvailable_bytes[1h], 3600)

# 预测磁盘何时满
predict_linear(node_filesystem_avail_bytes{mountpoint="/"}[1h], 3600 * 24)

# 预测内存何时耗尽
predict_linear(node_memory_MemAvailable_bytes[1h], 3600 * 4)

# 范围内最大值
max_over_time(http_requests_total[1h])

# 范围内最小值
min_over_time(http_requests_total[1h])

# 范围内平均值
avg_over_time(http_requests_total[1h])

# 范围内总和
sum_over_time(http_requests_total[1h])

# 范围内计数
count_over_time(http_requests_total[1h])

# 范围内标准差
stddev_over_time(http_requests_total[1h])

# 范围内方差
stdvar_over_time(http_requests_total[1h])

# 范围内分位数
quantile_over_time(0.9, http_requests_total[1h])