November 19

VictoriaTraces: recording rules, метрики и алерты на основе спанов трейсов

Это перевод оригинальной статьи VictoriaTraces: Recording Rules, Metrics, and Alerts from Trace Spans.

Перевод сделан специально для телеграм-канала Мониторим ИТ. Подписывайтесь! Там еще больше полезных постов о мониторинге.

VictoriaTraces — как и VictoriaLogs — поддерживает recording rules (см. «VictoriaMetrics: правила записи для логов AWS Load Balancer») для трейсов, потому что трейсы — это, по сути, те же логи, просто с другой структурой.

А раз у нас есть правила записи — мы можем создавать метрики на основе логов для алертов и дашбордов Grafana.

Хотя на самом деле это не лучший вариант, особенно для какого-нибудь высоконагруженного проекта, потому что vmalert с правилом записи постоянно отправляет запросы к VictoriaTraces — и здесь лучше подошло бы что-то вроде otelcol.connector.spanmetrics, что можно добавить в pipeline.traces, — но если стека OTel нет или, как в моём случае, проект небольшой, то создание метрик с помощью правил записи — вполне работоспособный вариант.

Это уже третья часть об OpenTelemetry и VictoriaTraces, предыдущие здесь:

Метрики на основе трейсов: для чего?

Несколько примеров из моего собственного списка пожеланий к проекту — вот почему я начал разрабатывать это решение.

Время ответа AWS ALB

У нас есть метрика времени ответа AWS ALB: она вызывает срабатывание алерта, когда какой-нибудь эндпоинт начинает отвечать медленно. Метрика формируется на основе логов ALB с вычислениями по полям записи лога:

- record: vmlogs:alb:logs:alb_response_time:p95
  expr: |
    {namespace="ops-monitoring-ns"} app:="alb-logs-exporter" -"DEBUG" -"SQS" -"VMLOGS" -"PARSER"
    | filter not `{"date"`*
    | extract "<_> <_> <elb_id> <_> <_> <request_processing_time> <target_processing_time> <response_processing_time> <elb_status_code> <target_status_code> <received_bytes> <sent_bytes> <request_line> <user_agent> <_> <_> <_> <trace_id> <domain_name> <_> <_> <_> <_> <_> <error_reason> <_> <_> <_> <_> <conn_trace_id> <_> <_> <_>"
    | extract_regexp `.*:443(?P<uri_path>/[^/?]*).* HTTP` from request_line
    | filter target_processing_time :! "-1" and request_processing_time :! "-1" and response_processing_time :! "-1"
    | filter request_processing_time :! "" and target_processing_time :! "" and response_processing_time :! ""
    | math request_processing_time + target_processing_time + response_processing_time as total_response_time
    | rename domain_name as domain
    | stats by (domain, uri_path) quantile(0.95, total_response_time) as alb_response_time

И сразу возникает несколько проблем.

Первая: опять же — нагрузка на бэкэнд, VictoriaLogs: если логов много — то vmalert выполняет запрос каждую минуту (interval: 1m), к тому же в запросе есть регулярное выражение — которое само по себе довольно затратно по CPU/RAM.

Вторая: метка uri_path содержит в своём значении только первую часть URI. То есть, если пришёл запрос к /user/<name>/orders — то в метрике vmlogs:alb:logs:alb_response_time:p95 сохранится только uri_path="/user".

Это сделано из-за проблемы кардинальности — чтобы не создавать множество разных значений, поскольку это повлияет на хранилище и ресурсы (см. VictoriaMetrics: Churn Rate, High cardinality, metrics and IndexDB).

В результате, когда приходит алерт, мы видим только очень общую информацию — о самом эндпоинте, а не о конкретном пользователе.

И главная причина, по которой я начал разбираться в этой теме, — алерты никак не связаны с трейсами

Сейчас, если приходит вот такой алерт:

Всё, что мы можем сделать, — перейти на дашборд Grafana для подов Kubernetes и рабочих узлов и посмотреть там нагрузку на CPU/RAM. Если там всё в порядке — перейти на дашборд RDS и разбираться уже там.

Но, имея метрики на основе трейсов, я могу прямо в алерте сформировать ссылку на все связанные трейсы, а затем сразу увидеть в Grafana и VictoriaTraces, где проблема.

Длительность запросов AWS RDS

Другой пример — метрика на основе логов AWS RDS:

- record: vmlogs:aws:rds:cloudwatch_logs:explain:query_duration:sum:avg:5m
  expr: |
    logtype:="rds" "plan:"
      | extract_regexp `.*:(?P<connection>.*_kraken_user@.*kraken_db:\[\d+\])`
      | extract_regexp ".*duration: (?P<duration>.+) ms"
      | duration:~".+"
      | extract_regexp `.*Query Text: (?P<query>.+?)(?:\s+AS\s|\s+FROM\s)`
      | query:~".+"
      | stats by (environment, connection, query) avg(duration) avg_duration

Здесь тот же подход: AWS RDS записывает AUTO EXPLAIN в лог (см. «PostgreSQL: использование EXPLAIN и настройка “auto_explain” в AWS RDS»), а мы разбираем логи в VictoriaLogs и формируем метрику.

Данные в метках в целом интереснее, чем в примере с AWS ALB, поскольку здесь есть и часть SQL-запроса, и «ID подключения» в виде "<db_user>@<db_host>:<PID>" — но, опять же, разбираться с такими алертами сложнее, потому что нужно взять этот ID подключения, найти его в логах RDS, а затем как-то сопоставить эти логи с логами самого API бэкэнда.

Вместо этого можно получать аналогичную метрику на основе трейсов и формировать прямую ссылку на Grafana/VictoriaTraces.

Итак, вот что мы сделаем сегодня: рассмотрим метаданные, используемые в OTLP для спанов, определим несколько метрик на основе трейсов и напишем несколько алертов.

HTTP-метрики

В нашем API бэкэнда повсеместно используется автоинструментация OTel (надеюсь, я всё-таки закончу тот пост об OTel и Python).

Трейсы формируются для всех вызовов FastAPI и AWS — и на их основе мы можем написать себе несколько метрик и алертов.

В трейсах бэкэнда из FastAPI у нас есть поля (атрибуты) http.route, http.status_code, duration — поэтому мы можем создать удобные метрики, на основе которых впоследствии сможем создать удобные алерты.

Полезные атрибуты спанов и ресурсов

Сначала на примере HTTP-спана из FastAPI посмотрим в VictoriaTraces, что интересного у нас есть в атрибутах спана и ресурса.

[
  {
    ...
    "duration": "4464509750",
    ...
    "kind": "2",
    "name": "GET /morpheus/sleep-agent/status",
    ...
    "resource_attr:k8s.namespace.name": "prod-backend-api-ns",
    "resource_attr:k8s.node.name": "ip-10-0-42-22.ec2.internal",
    "resource_attr:k8s.pod.name": "backend-api-deployment-6966566f55-khb9v",
    "resource_attr:service.name": "kraken-prod",
    ...
    "span_attr:http.method": "GET",
    "span_attr:http.route": "/morpheus/sleep-agent/status",
    "span_attr:http.scheme": "http",
    "span_attr:http.status_code": "503",
    "span_attr:http.target": "/morpheus/sleep-agent/status",
    ...
    ...
    "status_code": "2",
    "status_message": "http 503",
    "trace_id": "6a0c64013a090e5462414f3e3fba1630"
  },

Что из этого может быть нам интересно и полезно:

  • duration: время выполнения запроса (в наносекундах) — полезно для метрик задержки HTTP и длительности запросов PostgreSQL
  • kind: определяет роль спана — обрабатывает ли наш сервис запрос от клиента (kind 2 — SERVER) или сервис отправляет запрос к внешнему ресурсу (kind 3 — CLIENT), см. Span Kind и сами значения в коде в trace.proto.

В примерах ниже для AWS будет span.kind=3, то есть "CLIENT" — наш сервис является клиентом, поскольку выполняет исходящий вызов AWS API

  • name: имя спана, формируемое SDK, — полезно, потому что оно включает сразу несколько других атрибутов — удобнее использовать в фильтрах Grafana (подробнее об этом позже, когда будем создавать алерт)
  • k8s.namespace.name, node.name, pod.name: атрибуты уровня ресурса, которые задаются либо коллектором OTel, либо, как в моём случае, через Downward API в Deployment Kubernetes для API бэкэнда (костыль, пока нет коллектора OTel)

Очень полезные атрибуты, потому что они позволяют выстраивать связи между метриками уровня пода, уровня узла и т. д. — они дают общий контекст для наблюдаемости

  • span_attr:http.method и http.route: полезны как для отображения в алерте, так и для фильтра в Grafana для VictoriaMetrics
  • span_attr:http.target: если http.route выше — это сам маршрут в FastAPI (с заполнителем вроде /chats/{chat_id}), то в http.target у нас уже есть конкретный URI, к которому обратились

В этом примере разница не очень очевидна, поскольку маршрут статический, но в других спанах они выглядят как route="/chats/{chat_id}" и target="/chats/john-789?limit=10"

  • span_attr:http.status_code: не путать с status_code ниже — здесь у нас именно код HTTP-ответа сервера клиенту
  • status_code: очень полезный атрибут — код статуса спана OTel (не HTTP-статус выше), который указывает результат операции — успех (1) или ошибка (2), см. Set Status

В этом примере хорошо видно, что HTTP-запрос завершился с кодом 503 — сервис недоступен, и, соответственно, статус этого спана == Error

  • status_message: описание для status_code — FastAPI/OTel при установке значения status_code=2 добавил текстовое описание ошибки
  • trace_id: ну и ID самого трейса, к которой относится этот конкретный спан

Теперь, имея список атрибутов, можем подумать о метрике.

Метрика «vmtraces:backend:http:request_5xx:rate»

Создаём новый VMRule с type: vlogs:

apiVersion: operator.victoriametrics.com/v1beta1
kind: VMRule
metadata:
  name: recording-rules-vmalert-traces
  labels:
    app: vmalert-traces
spec:
  groups:
    - name: Traces.VictoriaTraces.Logs.rules
      type: vlogs
      interval: 5m

      rules:

        - record: vmtraces:kraken:http:request_5xx:rate
          expr: |
            {resource_attr:service.name=~"kraken-.*"} "span_attr:http.route":!"" "span_attr:http.status_code":~"5.."
            | stats by ("resource_attr:k8s.namespace.name", "resource_attr:service.name", "span_attr:http.route", "span_attr:http.status_code") rate() requests_per_sec

Здесь мы выбираем все трейса из service.name=~"kraken-.*" (Kraken — название нашего бэкэнда), выбираем только те, которые относятся к HTTP — "span_attr:http.route":!"", выбираем только те, в которых есть ошибки 5xx.

Затем вычисляем частоту в секунду с агрегацией по пространству имён Kubernetes, имени сервиса OTel, HTTP-маршруту (URI) и коду ошибки.

Немного забегая вперёд: было бы здорово сразу формировать в алерте ссылку на конкретный трейс по её ID — но записывать здесь метку trace_id в метрику не лучшая идея, потому что это миллион разных значений — забьём базу данных VictoriaMetrics.

Развёртываем, проверяем, что метрика есть в VictoriaMetrics:

Алерт «Ошибки HTTP 5xx бэкэнда»

Чтобы не писать отдельные алерты для Dev/Staging/Prod — воспользуемся range Helm.

Добавляем в values.yaml чарта:

alerts:
  traces:
    backend:
      - env: dev
        namespace: dev-backend-api-ns
        severities: [warning]
      - env: staging
        namespace: staging-backend-api-ns
        severities: [warning]
      - env: prod
        namespace: prod-backend-api-ns
        severities: [warning, critical]

Описываем новый VMRule (для удобства я разделяю правила записи и алерты отдельно) — теперь уже с самим алертом:

apiVersion: operator.victoriametrics.com/v1beta1
kind: VMRule
metadata:
    name: alerts-kraken-traces-http
spec:

  groups:

    ##########################
    ### Kraken Traces HTTP ###
    ##########################

    - name:  Kraken.Traces.HTTP.rules

      rules:

      ##############################
      ### Kraken HTTP 5xx Errors ###
      ##############################

      {{- range .Values.alerts.traces.backend }}
      {{- $ns := . }}
      {{- range .severities }}
      {{- if not (eq . "critical") }}
      - alert: Kraken HTTP 5xx Errors
        expr: vmtraces:kraken:http:request_5xx:rate{"resource_attr:k8s.namespace.name"="{{ $ns.namespace }}",stats_result="requests_per_sec"} > 0
        for: 1s
        labels:
          severity: {{ . }}
          component: backend
          environment: {{ $ns.env }}
          ilert_routingkey: backend-{{ $ns.env }}-{{ . }}
        annotations:
          summary: "Kraken service is returning HTTP 5xx errors"
          description: |-
            HTTP 5xx error rate has been above 0 for more than `{{ "{{" }} $for }}`
            *Namespace*: `{{ "{{" }} index $labels "resource_attr:k8s.namespace.name" }}`
            *HTTP route*: `{{ "{{" }} index $labels "span_attr:http.route" }}`
            *HTTP status*: `{{ "{{" }} index $labels "span_attr:http.status_code" }}`
            *5xx rate*: `{{ "{{" }} printf "%.3f" $value }}` req/s
            <https://{{ $.Values.monitoring.root_url }}/explore?orgId=1&left=%7B%22datasource%22:%22{{ $.Values.monitoring.victoria_traces_uid }}%22,%22queries%22:%5B%7B%22refId%22:%22A%22,%22datasource%22:%7B%22type%22:%22jaeger%22,%22uid%22:%22{{ $.Values.monitoring.victoria_traces_uid }}%22%7D,%22queryType%22:%22search%22,%22service%22:%22{{ "{{" }} index $labels "resource_attr:service.name" }}%22,%22tags%22:%22http.route%3D{{ "{{" }} index $labels "span_attr:http.route" }}%22,%22limit%22:100%7D%5D,%22range%22:%7B%22from%22:%22now-1h%22,%22to%22:%22now%22%7D%7D|:grafana: VictoriaTraces>
      {{- end }}
      {{- end }}
      {{- end }}

Здесь с помощью {{- range .Values.alerts.traces.backend }} мы перебираем все значения из values и для каждого окружения создаём отдельный алерт.

С помощью {{- if not (eq . "critical") }} я не создаю алерты CRITICAL, потому что они сопровождаются @channel в Slack — пока это тестируется, хочу посмотреть, как оно работает.

Формат имён OTel и шаблонизация Helm

Здесь есть интересный момент, связанный с форматом имён метрик и меток OTel.

Если в формате Prometheus они задаются с помощью "_", то есть в виде "resource_attr_k8s_namespace_name", то OTel использует точки и двоеточия — и это ломает механизм шаблонизации Helm/Go.

Есть вариант использовать нормализацию меток — записывать метрики в VictoriaMetrics сразу в формате Prometheus, но для трейсов и логов этого (пока) сделать нельзя, и тогда у нас будут разные имена в разных бэкэндах.

Поэтому пока я решил не включать usePromCompatibleNaming и записывать данные как есть, а когда эту возможность добавят в VictoriaLogs и VictoriaTraces — алерты можно будет обновить.

Кстати, можете поставить лайк задаче на GitHub — OpenTelemetry: поддержка преобразований имён полей ;-)

Поэтому здесь мы делаем это с помощью index $labels и указываем имена меток в кавычках:

index $labels "resource_attr:k8s.namespace.name"

Значение в $labels имеет тип map(map[string]string), поэтому index проходит по вложенным ключам и получает нужную нам метку.

Ссылка из Grafana на VictoriaTraces

Последнее, что формируется в алерте, — прямая ссылка на Grafana, чтобы из алерта мы могли сразу открыть все подробности.

Как я уже писал выше, здесь было бы проще искать по trace_id — но мы не можем записывать его в метки, потому что, опять же, возникает проблема кардинальности.

Поэтому я сделал это через фильтр по тегам, которые подставляются из полученных атрибутов в $labels, — в данном случае по span_attr:http.route:

А само уведомление в Slack выглядит так:

Метрика “vmtraces:backend:http:request_duration:p95”

Здесь, по сути, всё то же самое — только вычисляем не rate(), а 95-й перцентиль по полю duration.

Почему 95-й перцентиль, а не какой-нибудь avg(): потому что среднее значение даст общую «размытую картину» по всем запросам — но может не показать проблемы, затрагивающие небольшое число пользователей.

Правило записи получилось таким:

- record: vmtraces:kraken:http:request_duration:p95
  expr: |
    {resource_attr:service.name=~"kraken-.*"} "span_attr:http.route":!"" kind:=2
    | stats by ("resource_attr:k8s.namespace.name", "resource_attr:service.name", "span_attr:http.route") quantile(0.95, duration) value

Здесь в фильтры добавляем kind=2, чтобы учитывать данные только из спанов с типом SERVER, — потому что нас интересует результат работы самого FastAPI в API бэкэнда.

Иначе в результаты могли бы попасть дочерние спаны этого трейса — например, спаны запросов от API бэкэнда к DynamoDB или RDS (хотя фильтр с "span_attr:http.route":!"" должен выбирать только HTTP).

Развёртываем, проверяем метрику:

Алерт «Высокая задержка HTTP p95 бэкэнда»

Здесь всё то же самое, что и в алерте для ошибок 5xx.

Только в выражении переводим наносекунды в секунды — делим результат на 1e9 (миллиард) и вызываем срабатывание алерта, если задержка p95 превышает 5 секунд:

{{- range .Values.alerts.traces.backend }}
{{- $ns := . }}
{{- range .severities }}
{{- if not (eq . "critical") }}
- alert: Kraken HTTP Latency p95 High
  expr: vmtraces:kraken:http:request_duration:p95{"resource_attr:k8s.namespace.name"="{{ $ns.namespace }}",stats_result="value"} / 1e9 > 5
  for: 5m
  labels:
    severity: {{ . }}
    component: backend
    environment: {{ $ns.env }}
    ilert_routingkey: backend-{{ $ns.env }}-{{ . }}
  annotations:
    summary: "Kraken HTTP p95 latency is high"
    description: |-
      HTTP p95 latency has been above 5s for more than `{{ "{{" }} $for }}`
      *Namespace*: `{{ "{{" }} index $labels "resource_attr:k8s.namespace.name" }}`
      *Service name*: `{{ "{{" }} index $labels "resource_attr:service.name" }}`
      *HTTP route*: `{{ "{{" }} index $labels "span_attr:http.route" }}`
      *P95 latency*: `{{ "{{" }} printf "%.2f" $value }}` seconds
      <https://{{ $.Values.monitoring.root_url }}/explore?orgId=1&left=%7B%22datasource%22:%22{{ $.Values.monitoring.victoria_traces_uid }}%22,%22queries%22:%5B%7B%22refId%22:%22A%22,%22datasource%22:%7B%22type%22:%22jaeger%22,%22uid%22:%22{{ $.Values.monitoring.victoria_traces_uid }}%22%7D,%22queryType%22:%22search%22,%22service%22:%22{{ "{{" }} index $labels "resource_attr:service.name" }}%22,%22tags%22:%22http.route%3D{{ "{{" }} index $labels "span_attr:http.route" }}%22,%22limit%22:100%7D%5D,%22range%22:%7B%22from%22:%22now-1h%22,%22to%22:%22now%22%7D%7D|:grafana: VictoriaTraces>
{{- end }}
{{- end }}
{{- end }}

На этом с HTTP пока всё — идём дальше.

Метрики API AWS

Чтобы выбрать спаны, связанные с AWS, можем использовать фильтр по атрибуту "span_attr:rpc.system".

Проверяем, что интересного у нас есть:

{resource_attr:service.name=~"kraken-.*"} "span_attr:rpc.system":"aws-api"

Здесь уже видим kind=3 — наш бэкэнд выступает в роли CLIENT по отношению к AWS API.

Метрика “vmtraces:backend:aws:client_error:rate”

Одна из полезных метрик, которые мы можем здесь создать, — частота ошибок при запросах к AWS.

Описываем новое правило записи:

# AWS client errors
- record: vmtraces:kraken:aws:client_error:rate
  expr: |
    {resource_attr:service.name=~"kraken-.*"} "span_attr:rpc.system":"aws-api" status_code:=2
    | stats by ("resource_attr:k8s.namespace.name", "resource_attr:service.name", "span_attr:rpc.service", name) rate() requests_per_sec

Здесь фильтр status_code:=2 выбирает только ошибки:

В атрибутах спана у нас есть и сам трейс стека, и status_message — но мы не записываем их в метки, это уже можно посмотреть в Grafana.

Развёртываем, проверяем метрику:

Алерт «Бэкэнд получает ошибки от сервисов AWS»

Описываем алерт — здесь всё то же самое, только в ссылке на Grafana фильтруем по name и его же выводим в тексте алерта в поле «Операция», потому что в нём есть и название сервиса AWS, и тип операции:

{{- range .Values.alerts.traces.backend }}
{{- $ns := . }}
{{- range .severities }}
{{- if not (eq . "critical") }}
- alert: Kraken AWS Client Errors
  expr: vmtraces:kraken:aws:client_error:rate{"resource_attr:k8s.namespace.name"="{{ $ns.namespace }}",stats_result="requests_per_sec"} > 0
  for: 1s
  labels:
    severity: {{ . }}
    component: backend
    environment: {{ $ns.env }}
    ilert_routingkey: backend-{{ $ns.env }}-{{ . }}
  annotations:
    summary: "Kraken is getting errors from AWS services"
    description: |-
      AWS client error rate has been above 0 for more than `{{ "{{" }} $for }}`
      *Namespace*: `{{ "{{" }} index $labels "resource_attr:k8s.namespace.name" }}`
      *Service name*: `{{ "{{" }} index $labels "resource_attr:service.name" }}`
      *Operation*: `{{ "{{" }} index $labels "name" }}`
      *Error rate*: `{{ "{{" }} printf "%.3f" $value }}` req/s
      <https://{{ $.Values.monitoring.root_url }}/explore?orgId=1&left=%7B%22datasource%22:%22{{ $.Values.monitoring.victoria_traces_uid }}%22,%22queries%22:%5B%7B%22refId%22:%22A%22,%22datasource%22:%7B%22type%22:%22jaeger%22,%22uid%22:%22{{ $.Values.monitoring.victoria_traces_uid }}%22%7D,%22queryType%22:%22search%22,%22service%22:%22{{ "{{" }} index $labels "resource_attr:service.name" }}%22,%22operation%22:%22{{ "{{" }} index $labels "name" }}%22,%22tags%22:%22rpc.service%3D{{ "{{" }} index $labels "span_attr:rpc.service" }}%22,%22limit%22:100%7D%5D,%22range%22:%7B%22from%22:%22now-1h%22,%22to%22:%22now%22%7D%7D|:grafana: VictoriaTraces>
{{- end }}
{{- end }}
{{- end }}

Развёртываем, ждём алерт в Slack:

И у нас есть ссылка на Grafana с фильтром по имени операции:

Метрики RDS

И последний пример — с запросами к RDS.

Метрика “vmtraces:backend:db:query_duration:p95”

Описываем правило записи, фильтруем по "scope_name":="opentelemetry.instrumentation.sqlalchemy":

# DB query p95 latency
- record: vmtraces:kraken:db:query_duration:p95
  expr: |
    {resource_attr:service.name=~"kraken-.*"} "scope_name":="opentelemetry.instrumentation.sqlalchemy"
    | stats by ("resource_attr:k8s.namespace.name", "resource_attr:service.name", "span_attr:db.name", name) quantile(0.95, duration) p95_duration

Как и для HTTP — вычисляем 95-й перцентиль.

Алерт «Высокая длительность запросов к БД Kraken по p95»

Как и в HTTP-алерте — переводим значение в секунды:

{{- range .Values.alerts.traces.backend }}
{{- $ns := . }}
{{- range .severities }}
{{- if not (eq . "critical") }}
- alert: "Kraken DB Query p95 Duration High"
  expr: vmtraces:kraken:db:query_duration:p95{"resource_attr:k8s.namespace.name"="{{ $ns.namespace }}",stats_result="p95_duration"} / 1e9 > 1
  for: 1m
  labels:
    severity: {{ . }}
    component: backend
    environment: {{ $ns.env }}
    ilert_routingkey: backend-{{ $ns.env }}-{{ . }}
  annotations:
    summary: "Kraken DB query p95 duration is high"
    description: |-
      DB query p95 duration has been above 1s for more than `{{ "{{" }} $for }}`
      *Namespace*: `{{ "{{" }} index $labels "resource_attr:k8s.namespace.name" }}`
      *Service name*: `{{ "{{" }} index $labels "resource_attr:service.name" }}`
      *DB name*: `{{ "{{" }} index $labels "span_attr:db.name" }}`
      *Query*: `{{ "{{" }} index $labels "name" }}`
      *P95 duration*: `{{ "{{" }} printf "%.2f" $value }}` seconds
      <https://{{ $.Values.monitoring.root_url }}/explore?schemaVersion=1&panes=%7B%22dlh%22:%7B%22datasource%22:%22dfl962zwff6yoa%22,%22queries%22:%5B%7B%22refId%22:%22A%22,%22datasource%22:%7B%22type%22:%22jaeger%22,%22uid%22:%22dfl962zwff6yoa%22%7D,%22queryType%22:%22search%22,%22service%22:%22{{ "{{" }} index $labels "resource_attr:service.name" }}%22,%22limit%22:100,%22tags%22:%22%22,%22operation%22:%22{{ "{{" }} index $labels "name" }}%22%7D%5D,%22range%22:%7B%22from%22:%22now-1h%22,%22to%22:%22now%22%7D,%22compact%22:false%7D%7D&orgId=1|:grafana: VictoriaTraces>
{{- end }}
{{- end }}
{{- end }}

В поле «Запрос» делаем то же самое, что и в алерте AWS, — выводим значение метки name, потому что оно содержит часть запроса.

В результате получаем такой алерт в Slack:

И ссылку в Grafana с фильтром по имени операции — “INSERT staging_kraken_db”:

И на этом всё.

Получилось намного лучше, чем старые алерты на основе логов.

А когда добавим ещё и коллекторы OTel — будет ещё лучше.

Подписывайтесь на телеграм-канал Мониторим ИТ, там еще больше полезной информации о мониторинге!