DQL¶

namespace[index]::datasource[:select-clause] [{where-clause}] [time-expr] [group-by-clause] [having-clause] [order-by-clause] [limit-clause] [sorder-by-clause] [slimit-clause] [soffset-clause]

M::cpu:(avg(usage) as avg_usage, max(usage) as max_usage) {host =~ 'web-.*', usage > 50} [1h::5m] BY host, env HAVING avg_usage > 60 ORDER BY time DESC LIMIT 100 SORDER BY avg_usage DESC SLIMIT 10

// デフォルトインデックスを使用（指定しない場合、自動的に default が使用される）
M::cpu           // M("default")::cpu と同等
L::nginx         // L("default")::nginx と同等

// 単一インデックスを指定
M("production")::cpu     // production インデックスの CPU メトリクスをクエリ
L("web-logs")::nginx     // web-logs インデックスの Nginx ログをクエリ

// 複数インデックスクエリ（複数のインデックスのデータを同時にクエリ）
M("production", "staging")::cpu     // 本番環境とステージング環境の CPU メトリクスをクエリ
L("web-logs", "api-logs")::nginx     // Web ログと API ログをクエリ

// 旧構文、非推奨
L::nginx { index = "web-logs" }
L::nginx { index IN ["web-logs", "api-logs"] }

// 本番環境の CPU 使用率をクエリ
M::cpu:(avg(usage)) [1h] BY host

// 本番環境とステージング環境の比較をクエリ
M("production", "staging")::cpu:(avg(usage)) [1h] BY index, host

// Web サーバーログを分析
L("web-logs")::nginx:(count(*)) {status >= 400} [1h] BY status

// Web サーバーと API サーバーのエラー率を比較
L("web-logs", "api-logs")::*:(count(*)) {status >= 500} [1h] BY index

M::cpu:(usage)                    // CPU メトリクスをクエリ
L::nginx:(count(*))                // Nginx ログをクエリ
T::user-service:(traces)           // ユーザーサービストレースをクエリ

M::*:(usage)                      // すべてのメトリクスをクエリ

M::re('cpu.*'):(usage)            // cpu で始まるメトリクスをクエリ
L::re('web.*'):(count(*))          // web で始まるログをクエリ
T::re('.*-service'):(traces)      // -service で終わるサービスをクエリ

namespace::(subquery):(projections)

L::(L::*:(count(*)) {level = 'error'} BY app_id):(count_distinct(app_id))

// エラーが発生したアプリケーションの数をカウント
L::(L::*:(count(*)) {level = 'error'} BY app_id):(count_distinct(app_id))

// CPU 使用率が高いサーバーを分析
M::(M::cpu:(avg(usage)) [1h] BY host {avg(usage) > 80}):(count(host))

// エラー率が 1% を超えるサービスエンドポイントを特定し、影響を受けるサービス数をカウント
M::(M::http_requests:(sum(request_count), sum(error_count)) [1h] BY service, endpoint
   {sum(error_count) / sum(request_count) > 0.01}
):(count(service))

// 単一フィールドを選択
M::cpu:(usage)

// 複数フィールドを選択
M::cpu:(usage, system, user)

// すべてのフィールドを選択
M::cpu:(*)

field-name@json-path
@json-path                    // デフォルトで message フィールドを使用

{
  "message": "User login attempt",
  "request": {
    "method": "POST",
    "path": "/api/login",
    "headers": {
      "user-agent": "Mozilla/5.0",
      "content-type": "application/json"
    },
    "body": {
      "username": "john.doe",
      "password": "***",
      "permissions": ["read", "write", "admin"]
    }
  },
  "response": {
    "status": 200,
    "time": 156,
    "data": [
      {"id": 1, "name": "user1"},
      {"id": 2, "name": "user2"}
    ]
  }
}

// リクエストメソッドを抽出
L::auth_logs:(message@request.method)

// リクエストパスを抽出
L::auth_logs:(message@request.path)

// ユーザー名を抽出
L::auth_logs:(message@request.body.username)

// レスポンスステータスを抽出
L::auth_logs:(message@response.status)

// User-Agent を抽出（ハイフンを含むため、角括弧が必要）
L::auth_logs:(message@request.headers["user-agent"])

// 権限配列の最初の要素を抽出
L::auth_logs:(message@request.body.permissions[0])

// レスポンスデータの最初のオブジェクトの name を抽出
L::auth_logs:(message@response.data[0].name)

// 異なるリクエストメソッドの数をカウント
L::auth_logs:(count(*)) [1h] BY message@request.method

// レスポンス時間の分布を分析
L::auth_logs:(avg(message@response.time), max(message@response.time)) [1h] BY message@request.method

// 複数フィールドを抽出
L::auth_logs:(
    message,
    message@request.method as method,
    message@request.path as path,
    message@response.status as status,
    message@response.time as response_time
) {message@response.status >= 400} [1h]

// 単位変換（ミリ秒から秒へ）
L::nginx:(response_time / 1000) as response_time_seconds

// パーセンテージ計算
M::memory:(used / total * 100) as usage_percentage

// 複合計算
M::network:((bytes_in + bytes_out) / 1024 / 1024) as total_traffic_mb

// 集計関数
M::cpu:(max(usage), min(usage), avg(usage)) [1h] BY host

// 変換関数
L::logs:(int(response_time) as response_time_seconds)
L::logs:(floor(response_time) as response_time_seconds)

CASE
  WHEN condition THEN value
  [WHEN condition THEN value ...]
  [ELSE default_value]
END

CASE field
  WHEN value1 THEN result1
  WHEN value2 THEN result2
  ELSE default_value
END

L::nginx_access:(
    sum(CASE WHEN status >= 500 THEN bytes ELSE 0 END) as error_bytes
) [1h] BY host

L::nginx_access:(
    count(CASE WHEN status >= 500 THEN 1 ELSE nil END) as error_count
) [1h] BY service

L::nginx_access:(
    max(CASE
        WHEN status >= 500 THEN 3
        WHEN status >= 400 THEN 2
        WHEN status >= 300 THEN 1
        ELSE 0
    END) as status_level
) [1h] BY service

L::app_logs:(
    sum(CASE WHEN lower(level) = "error" THEN 1 ELSE 0 END) as error_count
) [1h] BY service

L::nginx_access:(
    sum(CASE WHEN status >= 500 THEN int(bytes) ELSE 0 END) as error_bytes
) [1h] BY host

// 推奨：各行で CASE を計算してから集計
L::nginx_access:(
    sum(CASE WHEN status >= 500 THEN bytes ELSE 0 END) as error_bytes
) [1h] BY host

// 非サポート：CASE 内での集計関数の使用
L::nginx_access:(
    CASE WHEN sum(bytes) > 0 THEN "has_bytes" ELSE "empty" END
) [1h] BY host

expression as alias_name

// 単純なエイリアス
M::cpu:(avg(usage) as avg_usage, max(usage) as max_usage) [1h] BY host

// 式のエイリアス
M::memory:((used / total) * 100 as usage_percent) [1h] BY host

// 関数のエイリアス
L::logs:(count(*) as error_count) {level = 'error'} [1h] BY service

// JSON 抽出のエイリアス
L::api_logs:(
    message@request.method as http_method,
    message@response.status as http_status,
    message@response.time as response_time_ms
) [1h]

M::cpu:(max(usage)) [1h] BY host

// 結果には max(usage) 列が含まれ、後続で直接 usage 列名を使用してサブクエリ結果の `max(usage)` 列を取得できます。
M::(M::cpu:(max(usage)) [1h] BY host):(max(usage)) { usage > 80 }

// エイリアスが必要な場合
M::cpu:(max(usage) as max_usage, min(usage) as min_usage) [1h] BY host

[start_time:end_time:interval:rollup]

[1672502400000:1672588800000]     // ミリ秒単位のタイムスタンプ
[1672502400:1672588800]           // 秒単位のタイムスタンプ

[1h]                             // 過去1時間から現在まで
[1h:5m]                          // 過去1時間から過去5分まで
[1h30m]                          // 過去1時間30分
[2h15m30s]                       // 過去2時間15分30秒

O::HOST:(count(*)){ `last_update_time` > (now()-10m) } // 10m は 600,000 の整数として計算に参加
L::*:( count(*) / 1i ) [::1m] // 時間ウィンドウサイズ (1m) の秒数で割り、ログ書き込みの QPS を計算

[TODAY]                          // 今日のデータ
[YESTERDAY]                      // 昨日のデータ
[THIS WEEK]                      // 今週のデータ
[LAST WEEK]                      // 先週のデータ
[THIS MONTH]                     // 今月のデータ
[LAST MONTH]                     // 先月のデータ

M::cpu:(max(usage_total)) [1h]

{
  "columns": ["time", "max(usage_total)"],
  "values": [
    [1721059200000, 37.46]
  ]
}

M::cpu:(max(usage_total)) [1h::10m]

{
  "columns": ["time", "max(usage_total)"],
  "values": [
    [1721059200000, 37.46],
    [1721058600000, 34.12],
    [1721058000000, 33.81],
    [1721057400000, 30.92],
    [1721058000000, 34.53],
    [1721057400000, 36.11]
  ]
}

生データ → WHERE フィルタ → **Rollup 前処理** → グループ集計 → HAVING フィルタ → 最終結果

// 推奨：各時系列で rate を計算し、次に service で合計
M::http_requests:(sum(request_count)) [1h::5m:rate] BY service

// 非推奨：Counter の生の累積値を直接集計すると、QPS にならない
M::http_requests:(sum(request_count)) [1h::5m] BY service

// Rollup 関数呼び出し：各時系列で EWMA を計算し、次に host で平均を計算
M::cpu:(avg(usage)) [1h::1m:ewma(0.3)] BY host

// エラー：ewma には alpha が必要なため、関数名のみを記述できない
M::cpu:(avg(usage)) [1h::1m:ewma] BY host

// エラー：時間句の Rollup パラメータはアルゴリズムパラメータのみを記述し、フィールド名は記述しない
M::cpu:(avg(usage)) [1h::1m:ewma(usage, 0.3)] BY host

// 明示的な集計呼び出し：Select 集計フェーズで usage に対して EWMA を計算
M::cpu:(ewma(usage, 0.3)) [1h::1m] BY host

// 各時系列で5点移動平均を計算し、次に host で平均を計算
M::cpu:(avg(usage)) [1h::1m:moving_average(5)] BY host

// 各時系列で P95 を取得し、次に service で平均を計算
M::response_time:(avg(duration)) [1h::5m:percentile(95)] BY service

// 正しい：Select 句で2つのフィールドを明示的に指定
M::service_metric:(corr(cpu_usage, request_count)) [1h::5m] BY service

// エラー：時間句の Rollup では2つの入力フィールドを表現できない
M::service_metric:(avg(cpu_usage)) [1h::5m:corr] BY service

// Rollup 短縮形：各元の時系列で zscore を計算してからグループ集計
M::cpu:(max(usage)) [1h::5m:zscore] BY host

// 明示的な集計呼び出し：Select 集計フェーズで usage に対して zscore を計算
M::cpu:(zscore(usage)) [1h::5m] BY host

{
  "host": "web-server-01",
  "data": [
    {"time": "2024-07-15 08:25:00", "request_count": 150},
    {"time": "2024-07-15 08:20:00", "request_count": 140},
    {"time": "2024-07-15 08:15:00", "request_count": 130},
    {"time": "2024-07-15 08:10:00", "request_count": 120},
    {"time": "2024-07-15 08:05:00", "request_count": 110},
    {"time": "2024-07-15 08:00:00", "request_count": 100}
  ]
}

{
  "host": "web-server-02",
  "data": [
    {"time": "2024-07-15 08:25:00", "request_count": 250},
    {"time": "2024-07-15 08:20:00", "request_count": 240},
    {"time": "2024-07-15 08:15:00", "request_count": 230},
    {"time": "2024-07-15 08:10:00", "request_count": 220},
    {"time": "2024-07-15 08:05:00", "request_count": 210},
    {"time": "2024-07-15 08:00:00", "request_count": 200}
  ]
}

M::http:(sum(request_count)) [rate]

// すべてのサーバーの合計リクエストレートを計算
M::http_requests:(sum(request_count)) [rate]

// エラー率を計算
M::http_requests:(
    sum(error_count) as errors,
    sum(request_count) as requests
) [rate] BY service

[1h]                             // 時間範囲のみ指定
[1h::5m]                         // 時間範囲 + 集計ステップ
[1h:5m]                          // 開始時間 + 終了時間
[1h:5m:1m]                       // 開始 + 終了 + ステップ
[1h:5m:1m:avg]                   // 完全な形式
[::5m]                           // 集計ステップのみ指定
[:::sum]                         // rollup 関数のみ指定
[sum]                            // rollup 関数のみ指定（最も簡潔な形式）

<select-query> SHIFT <duration>

L::logs:(service, count(*) AS requests)[1d:1h] SHIFT 7d BY service

{condition1, condition2, condition3}

// 単一条件
M::cpu:(usage) {host = 'web-01'} [1h]

// 複数の AND 条件
M::cpu:(usage) {host = 'web-01', usage > 80} [1h]

// AND キーワードを使用
M::cpu:(usage) {host = 'web-01' AND usage > 80} [1h]

// 論理演算子の混合使用
M::cpu:(usage) {(host = 'web-01' OR host = 'web-02') AND usage > 80} [1h]

// エラーログのマッチング
L::logs:(message) {message =~ 'ERROR.*\\d{4}'} [1h]

// 特定の形式のログをマッチング
L::logs:(message) {message =~ '\\[(ERROR|WARN)\\].*'} [1h]

// デバッグ情報を除外
L::logs:(message) {message !~ 'DEBUG.*'} [1h]

// ホスト名のパターンマッチング
M::cpu:(usage) {host =~ 'web-.*\\.prod\\.com'} [1h]

// ステータスコードフィルタリング
L::nginx:(count(*)) {status IN [200, 201, 202, 204]} [1h]

// 特定のステータスコードを除外
L::nginx:(count(*)) {status NOT IN [404, 500, 502]} [1h]

// ログレベルフィルタリング
L::app_logs:(count(*)) {level IN ['ERROR', 'WARN', 'CRITICAL']} [1h]

// 配列が特定の値を含むかどうかをチェック
{tags IN ['web']}           // true、tags が 'web' を含むため
{tags IN ['mobile']}        // false、tags が 'mobile' を含まないため

// 配列が特定の値を含まないかどうかをチェック
{tags NOT IN ['mobile']}    // true、tags が 'mobile' を含まないため
{tags NOT IN ['web']}       // false、tags が 'web' を含むため

// 配列が指定されたすべての値を含むかどうかをチェック
{tags IN ['web', 'api']}           // true、'web' と 'api' を含むため
{tags IN ['web', 'api', 'mobile']} // false、'mobile' を含まないため

// 歴史的構文：単一値の包含チェック（等価演算子のオーバーロードセマンティクス）
{tags = 'web'}           // true、tags が 'web' を含むため
{tags = 'mobile'}        // false、tags が 'mobile' を含まないため

// 歴史的構文：単一値の非包含チェック（不等価演算子のオーバーロードセマンティクス）
{tags != 'mobile'}       // true、tags が 'mobile' を含まないため
{tags != 'web'}          // false、tags が 'web' を含むため

// 文字列マッチング
L::logs:(message) { match(message, 'error') }
L::logs:(message) { wildcard(message, 'error*') }

// レスポンス時間が異常なリクエストをクエリ
L::access_logs:(*) {
    response_time > 1000 AND
    match(message, 'timeout')
}

// メモリ使用率が異常なホストをクエリ
M::memory:(usage) {
    (usage > 90 OR usage < 10) AND
    host =~ 'prod-.*' AND
    tags IN ['critical', 'important']
}

M::cpu:(avg(usage)) { host IN (O::HOST:(hostname) {provider = 'cloud-a'}) } [1h] BY host

// 特定のクラウドプロバイダーのサーバーを監視
M::cpu:(avg(usage)) { host IN (O::HOST:(hostname) {provider = 'cloud-a'}) } [1h] BY host


// 異なるクラウドプロバイダーのパフォーマンスを比較
M::memory:(avg(used / total * 100)) { host IN (O::HOST:(hostname) {provider IN ['cloud-a', 'cloud-b']}) } [1h] BY host


// 特定のビジネスのログを分析
L::app_logs:(count(*)) { service IN (T::services:(service_name) {business_unit = 'ecommerce'}) } [1h] BY level


// 重要なビジネスのアプリケーションパフォーマンスを監視
M::response_time:(avg(response_time)) { service IN (T::services:(service_name) {criticality = 'high'}) } [1h] BY service

BY expression1, expression2, ...

// 単一フィールドによるグループ化
M::cpu:(avg(usage)) [1h] BY host

// 複数フィールドによるグループ化
M::cpu:(avg(usage)) [1h] BY host, env

// ネストされたグループ化
M::cpu:(avg(usage)) [1h] BY datacenter, rack, host

// 複合数式
M::memory:(avg(used)) [1h] BY ((used / total) * 100) as
usage_percent

// 複数フィールドの算術演算
M::performance:(avg(response_time)) [1h] BY
(response_time / 1000) as response_seconds

// Drain クラスタリングアルゴリズム
L::logs:(count(*)) BY drain(message, 0.7) as sample

// 正規表現抽出によるグループ化
L::logs:(count(*)) [1h] BY regexp_extract(message, 'error_code: (\\d+)', 1)

{
  "series": [
    {
      "columns": ["time", "max(usage_total)"],
      "name": "cpu",
      "tags": {"host": "web-server-01"},
      "values": [
        [1721059200000, 78.5],
        [1721058600000, 82.3],
        [1721058000000, 75.8],
        [1721057400000, 88.2]
      ]
    },
    {
      "columns": ["time", "max(usage_total)"],
      "name": "cpu",
      "tags": {"host": "web-server-02"},
      "values": [
        [1721059200000, 45.2],
        [1721058600000, 52.8],
        [1721058000000, 48.5],
        [1721057400000, 61.3]
      ]
    },
    {
      "columns": ["time", "max(usage_total)"],
      "name": "cpu",
      "tags": {"host": "web-server-03"},
      "values": [
        [1721059200000, 92.1],
        [1721058600000, 95.7],
        [1721058000000, 89.4],
        [1721057400000, 97.6]
      ]
    }
  ]
}

HAVING condition

生データ → WHERE フィルタ → グループ集計 → HAVING フィルタ → 最終結果

// 集計関数の値に基づくフィルタリング
M::cpu:(avg(usage) as avg_usage) [1h] BY host HAVING avg_usage > 80

// 複数の集計条件に基づくフィルタリング
M::http_requests:(
    sum(request_count) as total,
    sum(error_count) as errors
) [1h] BY service, endpoint
HAVING errors / total > 0.01 AND total > 1000

// グループ統計に基づくフィルタリング
L::logs:(count(*) as count) [1h] BY service HAVING count > 100

// 複合集計条件に基づくフィルタリング
M::response_time:(
    avg(response_time) as avg_time,
    max(response_time) as max_time,
    min(response_time) as min_time
) [1h] BY endpoint
HAVING avg_time > 1000 AND max_time > 5000 AND (max_time - min_time) > 2000

ORDER BY expression [ASC|DESC]
LIMIT row_count
OFFSET row_offset

// 時間降順で並べ替え、各ホストの最新データを表示
M::cpu:(max(usage_total)) [1h::10m] BY host ORDER BY time DESC

// 時間昇順で並べ替え、履歴トレンドを表示
M::cpu:(max(usage_total)) [1h::10m] BY host ORDER BY time ASC

{
  "series": [
    {
      "columns": ["time", "max(usage_total)"],
      "name": "cpu",
      "tags": {"host": "web-server-01"},
      "values": [
        [1721059200000, 78.5],  // 12:00:00
        [1721058600000, 82.3],  // 11:50:00
        [1721058000000, 75.8],  // 11:40:00
        [1721057400000, 88.2],  // 11:30:00
        [1721056800000, 72.1],  // 11:20:00
        [1721056200000, 69.4]   // 11:10:00
      ]
    },
    {
      "columns": ["time", "max(usage_total)"],
      "name": "cpu",
      "tags": {"host": "web-server-02"},
      "values": [
        [1721059200000, 45.2],  // 12:00:00
        [1721058600000, 52.8],  // 11:50:00
        [1721058000000, 48.5],  // 11:40:00
        [1721057400000, 61.3],  // 11:30:00
        [1721056800000, 55.7],  // 11:20:00
        [1721056200000, 58.9]   // 11:10:00
      ]
    }
  ]
}

// CPU 使用率降順で並べ替え、各ホストのピーク時間帯を特定
M::cpu:(max(usage_total) as max_usage_total) [1h::10m] BY host ORDER BY max_usage_total DESC

// レスポンス時間昇順で並べ替え、パフォーマンスが最も良い時間帯を特定
M::response_time:(avg(response_time) as avg_response_time) [1h::5m] BY endpoint ORDER BY avg_response_time ASC

// 各ホストの最新3データポイントのみを表示
M::cpu:(max(usage_total)) [1h::10m] BY host ORDER BY time DESC LIMIT 3

// 最新の2データポイントをスキップし、次の3データポイントを表示
M::cpu:(max(usage_total)) [1h::10m] BY host ORDER BY time DESC LIMIT 3 OFFSET 2

{
  "series": [
    {
      "columns": ["time", "max(usage_total)"],
      "name": "cpu",
      "tags": {"host": "web-server-01"},
      "values": [
        [1721059200000, 78.5],  // 12:00:00 - 最新
        [1721058600000, 82.3],  // 11:50:00
        [1721058000000, 75.8]   // 11:40:00
        // 最初の3件のみを返す
      ]
    },
    {
      "columns": ["time", "max(usage_total)"],
      "name": "cpu",
      "tags": {"host": "web-server-02"},
      "values": [
        [1721059200000, 45.2],  // 12:00:00 - 最新
        [1721058600000, 52.8],  // 11:50:00
        [1721058000000, 48.5]   // 11:40:00
        // 最初の3件のみを返す
      ]
    }
  ]
}

SORDER BY aggregate_function(expression) [ASC|DESC]
SLIMIT group_count
SOFFSET group_offset

// 平均 CPU 使用率降順で並べ替え、負荷が最も高いホストを特定
M::cpu:(avg(usage)) [1h::10m] BY host SORDER BY avg(usage) DESC SLIMIT 5

// 平均レスポンス時間昇順で並べ替え、パフォーマンスが最も良いサービスを特定
M::response_time:(avg(response_time)) [1h] BY service SORDER BY avg(response_time) ASC SLIMIT 10

{
  "series": [
    {
      "columns": ["time", "avg(usage)"],
      "name": "cpu",
      "tags": {"host": "web-server-03"},  // 平均使用率: 90.9 - 1位
      "values": [
        [1721059200000, 92.1],
        [1721058600000, 95.7],
        [1721058000000, 89.4]
      ]
    },
    {
      "columns": ["time", "avg(usage)"],
      "name": "cpu",
      "tags": {"host": "web-server-01"},  // 平均使用率: 77.7 - 2位
      "values": [
        [1721059200000, 78.5],
        [1721058600000, 82.3],
        [1721058000000, 75.8]
      ]
    }
    // web-server-02 (avg: 53.7) は SLIMIT 2 により除外
  ]
}

// 最大 CPU 使用率でソートし、異常なピークがあるホストを特定
M::cpu:(max(usage_total)) [1h::10m] BY host SORDER BY max(usage_total) DESC SLIMIT 10

// 最小メモリ使用率でソートし、リソース利用率が最も低いホストを特定
M::memory:(min(usage_percent)) [24h::1h] BY host SORDER BY min(usage_percent) ASC SLIMIT 5

// 最新の CPU 使用率でソートし、現在の負荷が最も高いホストを特定
M::cpu:(usage) [1h::10m] BY host SORDER BY last(usage) DESC SLIMIT 10

// 最新のエラー率でソートし、現在問題が最も多いサービスを特定
L::logs:(count(*) as error_count) {level = 'error'} [1h] BY service SORDER BY error_count DESC SLIMIT 5

// CPU 使用率が最も高い10台のサーバーを特定し、各サーバーの最新5データポイントを表示
M::cpu:(avg(usage)) [1h::10m] BY host
SORDER BY avg(usage) DESC SLIMIT 10    // グループ間ソート：使用率が最も高い10台を特定
ORDER BY time DESC LIMIT 5             // グループ内ソート：各サーバーの最新5ポイントを表示

{
  "series": [
    {
      "columns": ["time", "avg(usage)"],
      "name": "cpu",
      "tags": {"host": "web-server-03"},  // 平均使用率: 90.9 - 1位
      "values": [
        [1721059200000, 92.1],  // 12:00:00 - 最新
        [1721058600000, 95.7],  // 11:50:00
        [1721058000000, 89.4],  // 11:40:00
        [1721057400000, 97.6],  // 11:30:00
        [1721056800000, 87.3]   // 11:20:00
        // 最新5データポイントのみを返す（LIMIT 5）
      ]
    },
    {
      "columns": ["time", "avg(usage)"],
      "name": "cpu",
      "tags": {"host": "web-server-01"},  // 平均使用率: 77.7 - 2位
      "values": [
        [1721059200000, 78.5],  // 12:00:00 - 最新
        [1721058600000, 82.3],  // 11:50:00
        [1721058000000, 75.8],  // 11:40:00
        [1721057400000, 88.2],  // 11:30:00
        [1721056800000, 72.1]   // 11:20:00
        // 最新5データポイントのみを返す（LIMIT 5）
      ]
    }
    // 他のホストは SLIMIT 10 により除外され、使用率が最も高い10台のみが返される
  ]
}