-
  task_name: "apinto_minute_request_request_v1"
  cron: "* * * * *"
  offset: "10s"
  flux: |
    request_request =
    from(bucket: "apinto")
        |> range(start: -1m)
        |> filter(fn: (r) => r._measurement == "request")
        |> filter(fn: (r) => r._field == "request")
        |> group(
            columns: [
                "api",
                "app",
                "upstream",
                "method",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
                "_measurement",
            ],
        )
    request_request
    |> sum()
    |> set(key: "_field", value: "request")
    |> to(
        bucket: "apinto/minute",
        timeColumn: "_start",
        tagColumns: [
          "api",
          "app",
          "method",
          "upstream",
          "node",
          "cluster",
          "provider",
          "api_kind",
          "status_code",
        ],
      )
      request_request
      |> max()
      |> set(key: "_field", value: "request_max")
      |> to(
          bucket: "apinto/minute",
          tagColumns: [
            "api",
            "app",
            "method",
            "upstream",
            "node",
            "cluster",
            "provider",
            "api_kind",
            "status_code",
          ],
          timeColumn: "_start",
      )
      request_request
      |> min()
      |> set(key: "_field", value: "request_min")
      |> to(
        bucket: "apinto/minute",
        timeColumn: "_start",
        tagColumns: [
          "api",
          "app",
          "method",
          "upstream",
          "node",
          "cluster",
          "provider",
          "api_kind",
          "status_code",
        ],
      )
      request_request
      |> mean()
      |> set(key: "_field", value: "request_avg")
      |> to(
        bucket: "apinto/minute",
        timeColumn: "_start",
        tagColumns: [
          "api",
          "app",
          "method",
          "upstream",
          "node",
          "cluster",
          "provider",
          "api_kind",
          "status_code",
        ],
      )
-
  task_name: "apinto_minute_request_response_v1"
  cron: "* * * * *"
  offset: "12s"
  flux: |
    
    request_response =
        from(bucket: "apinto")
            |> range(start: -1m)
            |> filter(fn: (r) => r._measurement == "request")
            |> filter(fn: (r) => r._field == "response")
            |> group(
                columns: [
                    "api",
                    "app",
                    "upstream",
                    "method",
                    "node",
                    "cluster",
                    "provider",
                    "api_kind",
                    "status_code",
                    "_measurement",
                ],
            )

    request_response
        |> sum()
        |> set(key: "_field", value: "response")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
    request_response
        |> max()
        |> set(key: "_field", value: "response_max")
        |> to(
            bucket: "apinto/minute",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
            timeColumn: "_start",
        )
    request_response
        |> min()
        |> set(key: "_field", value: "response_min")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
    request_response
        |> mean()
        |> set(key: "_field", value: "response_avg")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
-
  task_name: "apinto_minute_request_retry_v1"
  cron: "* * * * *"
  offset: "14s"
  flux: |
    
    request_retry =
        from(bucket: "apinto")
            |> range(start: -1m)
            |> filter(fn: (r) => r._measurement == "request")
            |> filter(fn: (r) => r._field == "retry")
            |> group(
                columns: [
                    "api",
                    "app",
                    "upstream",
                    "method",
                    "node",
                    "cluster",
                    "provider",
                    "api_kind",
                    "status_code",
                    "_measurement",
                ],
            )

    request_retry
        |> sum()
        |> set(key: "_field", value: "retry")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
    request_retry
        |> max()
        |> set(key: "_field", value: "retry_max")
        |> to(
            bucket: "apinto/minute",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
            timeColumn: "_start",
        )
    request_retry
        |> min()
        |> set(key: "_field", value: "retry_min")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
-
  task_name: "apinto_minute_request_status_v1"
  cron: "* * * * *"
  offset: "16s"
  flux: |
    
    request_status =
        from(bucket: "apinto")
            |> range(start: -1m)
            |> filter(fn: (r) => r._measurement == "request")
            |> filter(fn: (r) => r._field == "status")
            |> group(
                columns: [
                    "api",
                    "app",
                    "upstream",
                    "method",
                    "node",
                    "cluster",
                    "provider",
                    "api_kind",
                    "status_code",
                    "_measurement",
                ],
            )

    request_status
        |> count()
        |> set(key: "_field", value: "total")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
    request_status
        |> filter(fn: (r) => r._value < 400)
        |> count()
        |> set(key: "_field", value: "success")
        |> to(
            bucket: "apinto/minute",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
            timeColumn: "_start",
        )
    request_status
        |> filter(fn: (r) => r._value >= 200 and r._value < 300)
        |> count()
        |> set(key: "_field", value: "s2xx")
        |> to(
            bucket: "apinto/minute",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
            timeColumn: "_start",
        )
    request_status
        |> filter(fn: (r) => r._value >= 400 and r._value < 500)
        |> count()
        |> set(key: "_field", value: "s4xx")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
    request_status
        |> filter(fn: (r) => r._value >= 500)
        |> count()
        |> set(key: "_field", value: "s5xx")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
-
  task_name: "apinto_minute_request_timing_v1"
  cron: "* * * * *"
  offset: "18s"
  flux: |
    
    request_timing =
        from(bucket: "apinto")
            |> range(start: -1m)
            |> filter(fn: (r) => r._measurement == "request")
            |> filter(fn: (r) => r._field == "timing")
            |> group(
                columns: [
                    "api",
                    "app",
                    "upstream",
                    "method",
                    "node",
                    "cluster",
                    "provider",
                    "api_kind",
                    "status_code",
                    "_measurement",
                ],
            )

    request_timing
        |> sum()
        |> set(key: "_field", value: "timing")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
    request_timing
        |> max()
        |> set(key: "_field", value: "timing_max")
        |> to(
            bucket: "apinto/minute",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
            timeColumn: "_start",
        )
    request_timing
        |> min()
        |> set(key: "_field", value: "timing_min")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
    request_timing
        |> mean()
        |> set(key: "_field", value: "timing_avg")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
-
  task_name: "apinto_minute_proxy_timing_v1"
  cron: "* * * * *"
  offset: "20s"
  flux: |
    
    proxy_timing =
        from(bucket: "apinto")
            |> range(start: -1m)
            |> filter(fn: (r) => r._measurement == "proxy")
            |> filter(fn: (r) => r._field == "timing")
            |> group(
                columns: [
                    "api",
                    "app",
                    "upstream",
                    "addr",
                    "method",
                    "node",
                    "cluster",
                    "provider",
                    "api_kind",
                    "status_code",
                    "_measurement",
                ],
            )

    proxy_timing
        |> sum()
        |> set(key: "_field", value: "p_timing")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
    proxy_timing
        |> max()
        |> set(key: "_field", value: "p_timing_max")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
    proxy_timing
        |> min()
        |> set(key: "_field", value: "p_timing_min")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
    proxy_timing
        |> mean()
        |> set(key: "_field", value: "p_timing_avg")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
-
  task_name: "apinto_minute_proxy_status_v1"
  cron: "* * * * *"
  offset: "22s"
  flux: |
    
    proxy_status =
        from(bucket: "apinto")
            |> range(start: -1m)
            |> filter(fn: (r) => r._measurement == "proxy")
            |> filter(fn: (r) => r._field == "status")
            |> group(
                columns: [
                    "api",
                    "app",
                    "upstream",
                    "addr",
                    "method",
                    "node",
                    "cluster",
                    "provider",
                    "api_kind",
                    "status_code",
                    "_measurement",
                ],
            )

    proxy_status
        |> count()
        |> set(key: "_field", value: "p_total")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
    proxy_status
        |> filter(fn: (r) => r._value < 400)
        |> count()
        |> set(key: "_field", value: "p_success")
        |> to(
            bucket: "apinto/minute",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
            timeColumn: "_start",
        )
    proxy_status
        |> filter(fn: (r) => r._value >= 200 and r._value < 300)
        |> count()
        |> set(key: "_field", value: "p_s2xx")
        |> to(
            bucket: "apinto/minute",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
            timeColumn: "_start",
        )
    proxy_status
        |> filter(fn: (r) => r._value >= 400 and r._value < 500)
        |> count()
        |> set(key: "_field", value: "p_s4xx")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
    proxy_status
        |> filter(fn: (r) => r._value >= 500)
        |> count()
        |> set(key: "_field", value: "p_s5xx")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
-
  task_name: "apinto_minute_proxy_request_v1"
  cron: "* * * * *"
  offset: "24s"
  flux: |
    
    proxy_request =
        from(bucket: "apinto")
            |> range(start: -1m)
            |> filter(fn: (r) => r._measurement == "proxy")
            |> filter(fn: (r) => r._field == "request")
            |> group(
                columns: [
                    "api",
                    "app",
                    "upstream",
                    "addr",
                    "method",
                    "node",
                    "cluster",
                    "provider",
                    "api_kind",
                    "status_code",
                    "_measurement",
                ],
            )

    proxy_request
        |> sum()
        |> set(key: "_field", value: "p_request")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
    proxy_request
        |> max()
        |> set(key: "_field", value: "p_request_max")
        |> to(
            bucket: "apinto/minute",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
            timeColumn: "_start",
        )
    proxy_request
        |> min()
        |> set(key: "_field", value: "p_request_min")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
-
  task_name: "apinto_minute_proxy_response_v1"
  cron: "* * * * *"
  offset: "26s"
  flux: |
    
    proxy_response =
        from(bucket: "apinto")
            |> range(start: -1m)
            |> filter(fn: (r) => r._measurement == "proxy")
            |> filter(fn: (r) => r._field == "response")
            |> group(
                columns: [
                    "api",
                    "app",
                    "upstream",
                    "addr",
                    "method",
                    "node",
                    "cluster",
                    "provider",
                    "api_kind",
                    "status_code",
                    "_measurement",
                ],
            )
    proxy_response
        |> sum()
        |> set(key: "_field", value: "p_response")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
    proxy_response
        |> max()
        |> set(key: "_field", value: "p_response_max")
        |> to(
            bucket: "apinto/minute",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
            timeColumn: "_start",
        )
    proxy_response
        |> min()
        |> set(key: "_field", value: "p_response_min")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
-
  task_name: "apinto_minute_request_input_token_v1"
  cron: "* * * * *"
  offset: "28s"
  flux: |
    
    request_input_token =
        from(bucket: "apinto")
            |> range(start: -1m)
            |> filter(fn: (r) => r._measurement == "request")
            |> filter(fn: (r) => r._field == "input_token")
            |> group(
                columns: [
                    "api",
                    "app",
                    "upstream",
                    "addr",
                    "method",
                    "node",
                    "cluster",
                    "provider",
                    "api_kind",
                    "status_code",
                    "_measurement",
                ],
            )
    request_input_token
        |> sum()
        |> set(key: "_field", value: "input_token")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
    request_input_token
        |> max()
        |> set(key: "_field", value: "input_token_max")
        |> to(
            bucket: "apinto/minute",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
            timeColumn: "_start",
        )
    request_input_token
        |> min()
        |> set(key: "_field", value: "input_token_min")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
    request_input_token
        |> mean()
        |> set(key: "_field", value: "input_token_avg")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
-
  task_name: "apinto_minute_request_output_token_v1"
  cron: "* * * * *"
  offset: "30s"
  flux: |
    
    request_output_token =
        from(bucket: "apinto")
            |> range(start: -1m)
            |> filter(fn: (r) => r._measurement == "request")
            |> filter(fn: (r) => r._field == "output_token")
            |> group(
                columns: [
                    "api",
                    "app",
                    "upstream",
                    "addr",
                    "method",
                    "node",
                    "cluster",
                    "provider",
                    "api_kind",
                    "status_code",
                    "_measurement",
                ],
            )
    request_output_token
        |> sum()
        |> set(key: "_field", value: "output_token")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
    request_output_token
        |> max()
        |> set(key: "_field", value: "output_token_max")
        |> to(
            bucket: "apinto/minute",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
            timeColumn: "_start",
        )
    request_output_token
        |> min()
        |> set(key: "_field", value: "output_token_min")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
    request_output_token
        |> mean()
        |> set(key: "_field", value: "output_token_avg")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )

-
  task_name: "apinto_minute_request_total_token_v1"
  cron: "* * * * *"
  offset: "32s"
  flux: |
    request_total_token =
        from(bucket: "apinto")
            |> range(start: -1m)
            |> filter(fn: (r) => r._measurement == "request")
            |> filter(fn: (r) => r._field == "total_token")
            |> group(
                columns: [
                    "api",
                    "app",
                    "upstream",
                    "addr",
                    "method",
                    "node",
                    "cluster",
                    "provider",
                    "api_kind",
                    "status_code",
                    "_measurement",
                ],
            )
    request_total_token
        |> sum()
        |> set(key: "_field", value: "total_token")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
    request_total_token
        |> max()
        |> set(key: "_field", value: "total_token_max")
        |> to(
            bucket: "apinto/minute",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
            timeColumn: "_start",
        )
    request_total_token
        |> min()
        |> set(key: "_field", value: "total_token_min")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )
    request_total_token
        |> mean()
        |> set(key: "_field", value: "total_token_avg")
        |> to(
            bucket: "apinto/minute",
            timeColumn: "_start",
            tagColumns: [
                "api",
                "app",
                "method",
                "upstream",
                "addr",
                "node",
                "cluster",
                "provider",
                "api_kind",
                "status_code",
            ],
        )