November 19

VictoriaTraces: трассировка, наблюдаемость и OpenTelemetry

Это перевод оригинальной статьи VictoriaTraces: Tracing, Observability, and OpenTelemetry.

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

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

Давным-давно я делал нечто подобное с Jaeger — тем ещё монстром, и это так и осталось у меня в черновиках с 2019 или 2020 года. Поскольку сейчас весь наш стек построен на решениях VictoriaMetrics — сама VictoriaMetrics для метрик и VictoriaLogs для логов, — для трейсов мы тоже будем использовать решение команды VictoriaMetrics: VictoriaTraces.

Кроме того, VictoriaTraces гораздо менее требовательна к ресурсам и намного проще в настройке. Наверное, можно сравнить Loki с VictoriaLogs — и Jaeger с VictoriaTraces: та же история, гораздо более простая настройка, гораздо меньше CPU/RAM.

Эта статья планировалась как первая в серии о трейсах — поэтому первая половина здесь будет более теоретической, о наблюдаемости и OpenTelemetry. А во второй половине мы запустим VictoriaTraces в Kubernetes.

В предыдущей статье «OpenTelemetry: коллекторы OTel в Kubernetes и интеграция со стеком VictoriaMetrics» я описал стек для метрик и логов, полностью построенный на OpenTelemetry, и в этой статье буду на неё ссылаться.

А в следующей, третьей части, мы рассмотрим, как создавать трассировки из Python.

Мониторинг и наблюдаемость

«Мониторинг — это пассивное действие. Наблюдаемость — это активная практика» — из отличной книги «Изучаем OpenTelemetry: настройка и эксплуатация современной системы наблюдаемости».

Первое, что я хотел бы рассмотреть отдельно, — это разница между «мониторингом» и «наблюдаемостью».

Эти понятия часто путают или используют как взаимозаменяемые — но, хотя они и связаны, на самом деле речь идёт о разных концепциях.

Итак, мониторинг — это когда мы заранее знаем, что может сломаться, и настраиваем проверки специально для этого: «CPU выше 90% => алерт. Диск заполнен более чем на 85% => алерт. Ошибки 5xx на ALB => алерт».

Другими словами, мы отвечаем на вопросы, которые уже сформулировали заранее. По сути, это подход, основанный на дашбордах: мы смотрим на известные метрики и реагируем на известные проблемы.

Наблюдаемость — это когда система позволяет нам отвечать на вопросы, которые мы заранее не формулировали: происходит что-то «странное», и мы можем «докопаться» до причины — даже если никогда раньше с этим не сталкивались.

Ключевое слово здесь — исследуемость: возможность исследовать связи и причины проблем.

Например — выросло время отклика API бэкэнда. Мониторинг просто сообщит: «Высокое время отклика» (сработал алерт), но наблюдаемость позволяет углубиться — пройти по всей цепочке и найти первопричину: скачок времени отклика происходит на конкретном эндпоинте? У конкретного арендатора? В конкретном поде Kubernetes? Может быть, медленно работает один из вышестоящих сервисов? Другими словами, мы переходим от симптома — к причине с помощью данных, которые уже есть в системе.

Именно поэтому и говорят о «трёх столпах наблюдаемости» — метриках, логах и трейсах. На практике именно трейсы (распределённая трассировка) обычно отличают «просто мониторинг» от наблюдаемости, потому что именно трейсы позволяют исследовать неизвестную проблему — увидеть путь запроса через сервисы и найти узкое место, которое мы не предусмотрели.

При этом наблюдаемость — это не какие-то «волшебные динамические алерты»: в системе по-прежнему остаются обычные, заранее определённые алерты вроде «если доля 5xx превышает 1%, отправить сообщение в Slack».

Меняется то, что происходит после срабатывания алерта: мы не просто видим, что «этот домен возвращает ошибки», и идём вручную искать логи в VictoriaLogs с помощью grep — у нас есть возможность пройти весь путь: от алерта в Slack — через AWS ALB — через под Kubernetes — до компонента внутри этого пода и, в конечном счёте, до конкретного method() в коде, который возвращает ошибки, и до пользователя, чьи запросы заставляют этот метод генерировать ошибки.

Таким образом, оповещения по-прежнему относятся к «мониторингу»: наблюдаемость начинается в тот момент, когда срабатывает алерт и нужно понять почему.

Наблюдаемость — это не обнаружение проблем, а их исследование.

Что такое трассировка

Трассировка (или распределённая трассировка) — это способ проследить путь отдельного запроса через всю систему: с момента его поступления на ALB — через под Kubernetes — до базы данных, внешнего API или вызова LLM и обратно.

Далее мы будем говорить о VictoriaTraces, которая построена на VictoriaLogs, — потому что сама концепция трассировки такая же, как и у логов: сервис записывает каждый «чих» — каждый вызов, каждое действие, каждый запрос к внешним системам. Отличие от «просто логирования» состоит в том, что у трейсов есть ID, который связывает все относящиеся друг к другу вызовы в дерево, что позволяет построить полный путь запроса.

Один такой путь называется трейсом. Трейс состоит из спанов, где каждый спан — это одна операция: конкретный HTTP-запрос, SQL-запрос, вызов другого сервиса, этап обработки очереди. Спаны связываются в дерево через trace_id (общий для всего трейса) и parent_id (кто вызвал этот спан).

Выглядит это примерно так:

trace_id: abc123

[HTTP GET /api/orders]                                        # root span (120ms)
  ├─ [auth-service: validate token]                           # child span (8ms)
  ├─ [orders-service: get orders]                             # child span (95ms)
  │    ├─ [PostgreSQL: SELECT * FROM orders WHERE user_id=42] # (80ms)
  │    └─ [Redis: GET cache:user:42]                          # (2ms)
  └─ [response serialization]                                 # child span (12ms)

У каждого спана в этом трейсе есть поле trace_id, у каждого спана есть поля parent_id и span_id: у корневого спана parent_id будет пустым, у второго спана parent_id == span_id первого спана этого трейса и так далее.

Помимо времени выполнения, каждый спан может содержать атрибуты — пары «ключ — значение» с дополнительным контекстом: некоторые атрибуты добавляются автоматически (HTTP-метод, код состояния, SQL-выражение), некоторые разработчики добавляют вручную (tenant_id, row_count, cache_hit). Чем больше контекста в атрибутах — тем больше можно исследовать без добавления новых метрик или логов.

Например (это уже из следующей статьи, там разберём подробнее):

...
orders-api  |     "attributes": {
orders-api  |         "http.scheme": "http",
orders-api  |         "http.host": "172.25.0.3:8000",
orders-api  |         "net.host.port": 8000,
orders-api  |         "http.flavor": "1.1",
orders-api  |         "http.target": "/api/orders/by-customer/Vasya",
orders-api  |         "http.url": "http://172.25.0.3:8000/api/orders/by-customer/Vasya",
orders-api  |         "http.method": "GET",
orders-api  |         "http.server_name": "localhost:8000",
orders-api  |         "http.user_agent": "curl/8.20.0",
orders-api  |         "net.peer.ip": "172.25.0.1",
orders-api  |         "net.peer.port": 54900,
orders-api  |         "http.route": "/api/orders/by-customer/{name}",
orders-api  |         "customer.name": "Vasya",
orders-api  |         "customer.orders_count": 3,
orders-api  |         "http.status_code": 200
orders-api  |     },
...

По сути, атрибуты в трейсах — это метки метрик в формате Prometheus, которые мы впоследствии можем использовать для поиска трейсов и — что ещё важнее — для сопоставления связанных метрик, логов и трейсов.

Пример отладки с помощью трассировки

Вернёмся к примеру, который я описал выше: у нас есть алерт в Slack, сообщающий, что время отклика API бэкэнда на эндпоинте /coach подскочило до 20 секунд:

В алерте есть ссылка на дашборд Grafana с состоянием AWS Application Load Balancer, на дашборде — ссылка на VictoriaLogs с логами ALB и API бэкэнда, ссылка на дашборд с подами Kubernetes нашего API бэкэнда и его AWS RDS.

Метрики Grafana показывают скачок, в логах — ничего подозрительного. Без трейсов следующий шаг — гадание: идём смотреть CPU/RAM на рабочих узлах Kubernetes, нагрузку на связанные поды, дашборд Grafana для AWS RDS с PostgreSQL, пытаясь составить картину того, где находится проблема.

С трейсами мы открываем медленные трейсы для этого эндпоинта и сразу видим: из общих 120 мс на обработку всего запроса — 80 мс уходит на выполнение одного SQL-запроса. Смотрим на атрибуты этого спана — db.statement: SELECT * FROM orders WHERE user_id=42, индекс не используется: первопричина найдена за минуту.

Что такое OpenTelemetry?

OpenTelemetry (OTel) — это прежде всего набор общих «правил», определяющих, как нужно собирать данные и какие метаданные должны в них присутствовать.

Выше мы упоминали «три столпа наблюдаемости» — метрики, логи и трейсы: каждое действие сервиса и его компонентов — это событие, или сигнал в терминологии OTel.

OpenTelemetry и его протокол OpenTelemetry Protocol (см. спецификацию OTLP 1.10.0) описывают, как должны передаваться данные (HTTP/gRPC) и какие поля и заголовки они должны содержать, объединяя метрики, логи и трейсы в единый формат.

С помощью OTel мы собираем эти сигналы на уровне кода, из подов/узлов Kubernetes или из AWS API, обрабатываем их, добавляя атрибуты и объединяя в общий контекст, и передаём дальше в бэкэнд, где хранятся данные, — метрики в VictoriaMetrics, логи в VictoriaLogs, трейсы в VictoriaTraces.

OpenTelemetry против Prometheus

Когда мы работаем с VictoriaMetrics или Prometheus, то используем привычный подход к метрикам: экспортёр предоставляет эндпоинт /metrics, VictoriaMetrics с VMAgent обращается к этому эндпоинту и собирает метрики (модель PULL). Формат метрик — простой текстовый, например metric_name{label="value"} 123.45.

OpenTelemetry (OTel) использует другой подход, поскольку обычно работает по модели PUSH: сервис сам отправляет данные в OTel Collector, который затем направляет их куда нужно — в VictoriaMetrics, VictoriaLogs, VictoriaTraces или любой другой бэкэнд.

При этом приёмники OTel Collector также могут самостоятельно выполнять запросы к некоторым API, например — k8s_cluster выполняет запросы к Kubernetes API /apis/apps/v1/deployments, чтобы получить дополнительную информацию о подах Kubernetes.

Зачем нужен OpenTelemetry, если есть Prometheus

Для метрик формат Prometheus действительно отлично работает, но Prometheus — это только метрики: он не работает с трейсами, не работает со структурированными логами и, самое главное, — не связывает метрику, лог и трейс друг с другом: у нас уже есть VictoriaLogs для логов, VictoriaMetrics для метрик — но это отдельные системы со своими форматами, поэтому связать конкретную метрику с конкретным логом и конкретным трейсом сложно, поскольку у них нет общего контекста.

OTel решает именно эту проблему: когда метрики, логи и трейсы проходят через один SDK, они автоматически получают общий контекст — trace_id, service.name, deployment.environment, kubernetes.pod.name. В результате из алерта по metric_name мы можем перейти к трейсу конкретного запроса, а из трейса — к логам конкретного спана. Без OTel эти три системы существуют отдельно, и связывать их приходится вручную.

Компоненты OpenTelemetry

OpenTelemetry состоит из трёх основных частей:

  • OTel SDK: встраивается в код и генерирует телеметрию
    • для автоматического инструментирования достаточно нескольких строк при запуске сервиса — и мы сразу получаем спаны для HTTP, gRPC, SQL (см. раздел об инструментировании ниже)
  • OTel Collector: отдельный сервис (DaemonSet или Deployment в Kubernetes), который получает данные от SDK в сервисах, обрабатывает их и отправляет дальше в бэкэнды
    • тот же Collector в роли агента может самостоятельно собирать метрики и логи из Kubernetes или AWS — это также описано в предыдущей статье
  • OTLP (OpenTelemetry Protocol): формат и протокол передачи данных, который работает поверх gRPC или HTTP и поддерживается практически всеми современными бэкэндами — VictoriaMetrics, Grafana Tempo, Jaeger, Datadog.

Инструментирование OpenTelemetry

Сам термин инструментирование в контексте OpenTelemetry и трассировки означает процесс добавления в сервис или систему специального кода, который обеспечивает наблюдаемость этого кода.

См. «Инструментирование» и «Инструментирование без изменения кода».

В OpenTelemetry есть три способа инструментирования:

  • инструментирование без изменения кода: мы вообще ничего не меняем в коде — наш сервис вызывается через внешнюю обёртку, которая перехватывает вызовы нашего кода и сама добавляет нужные данные
    • быстро и удобно — но наименее гибко, поскольку не позволяет самостоятельно решать, что и куда добавлять
  • автоматическое инструментирование: OTel SDK может автоматически создавать спаны для HTTP-запросов, клиентов баз данных, вызовов gRPC и добавлять необходимые атрибуты
    • для автоматического инструментирования мы используем OTel SDK, добавляя в наш код библиотеки, которые через собственные методы и функции добавляют информацию к вызовам методов и функций нашего кода
  • ручное инструментирование: мы можем добавлять в код собственные спаны и атрибуты для бизнес-логики, которую автоматическое инструментирование не видит
    • например, создавать спан для обработки одного элемента в пакетном задании или атрибут order.total_items для SQL-вызова внутри спана обработки заказа

Обычно начинают с автоматического инструментирования (чтобы сразу получить базовую картину), а затем постепенно добавляют ручное инструментирование — там, где не хватает контекста для отладки конкретных проблем.

Что такое VictoriaTraces

Документация — VictoriaTraces и Ключевые концепции.

Репозиторий проекта — VictoriaTraces.

VictoriaTraces построена на VictoriaLogs: она получает данные от OTel Collector в виде JSON в формате OTLP и записывает их в собственном формате, преобразуя имена полей.

Проект всё ещё находится на стадии разработки, поэтому возможны изменения — но им уже вполне можно пользоваться.

Как и VictoriaLogs, VictoriaTraces формирует поля потока, которые используются для оптимизации хранения данных и поиска логов или трейсов.

В результате каждый записанный спан трейса хранится как часть определённого потока — аналогично тому, как каждая запись лога в VictoriaLogs является частью одного определённого потока логов.

В VictoriaTraces в качестве поля потока используется атрибут service.name, и каждое уникальное значение в поле потока влияет на объём данных, попадающих в хранилище VictoriaTraces и IndexDB, которая используется для поиска данных при выполнении sum by (label_name).

См. VictoriaMetrics: Churn Rate, высокая кардинальность, метрики и IndexDB — потому что подход к хранению данных в VictoriaMetrics, VictoriaLogs и VictoriaTraces одинаков.

Как и у VictoriaMetrics и VictoriaLogs, у VictoriaTraces есть собственный VM UI, где мы можем искать трейсы с помощью LogsQL:

Хотя для отображения дерева трейса лучше использовать Grafana — ниже мы этим и займёмся.

Также см. разделы документации VictoriaTraces по Мониторингу — мы можем собирать метрики, и «Срок хранения» — трейсы, как логи и метрики, тоже хранятся на диске, поэтому об использовании дискового пространства стоит помнить.

И очень интересная возможность — создание собственных метрик из трейсов, этим мы займёмся далее в этой статье.

Запуск VictoriaTraces в Kubernetes

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

Для запуска VictoriaTraces в Kubernetes есть отдельные Helm-чарты — victoria-traces-single и victoria-traces-cluster.

Документация чарта — VictoriaTraces Single.

Добавляем репозиторий:

$ helm repo add vm https://victoriametrics.github.io/helm-charts/
$ helm repo update

Находим последнюю доступную версию чарта:

$ helm search repo vm/victoria-traces-single
NAME                            CHART VERSION   APP VERSION     DESCRIPTION                                       
vm/victoria-traces-single       0.0.7           v0.8.0          The VictoriaTraces single Helm chart deploys Vi...

Создаём values.yaml, значения по умолчанию находятся в репозитории чарта, например:

victoria-traces-single:
  enabled: true
  server:
    mode: deployment
    ingress:
      enabled: true
      ingressClassName: alb
      annotations:
        alb.ingress.kubernetes.io/group.name: ops-1-33-internal-alb
        alb.ingress.kubernetes.io/target-type: ip
        alb.ingress.kubernetes.io/certificate-arn: arn:aws:acm:us-east-1:492***148:certificate/ad0ae28d-1843-412d-b3e1-05235186ea11
      hosts:
        - name: vmtraces.monitoring.1-33.ops.example.co
          path:
            - /
          port: http
    resources:
      requests:
        cpu: 100m
        memory: 256Mi
    persistentVolume:
      enabled: true
      storageClassName: gp3-retain
      size: 50Gi
    retentionPeriod: 30d
    vmServiceScrape:
      enabled: true

Здесь я задал тип развёртывания Deployment вместо StatefulSet и добавил Ingress через AWS ALB.

В persistentVolume создаём диск, в retentionPeriod меняем значение по умолчанию с 7 дней на месяц.

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

$ kk get deploy atlas-victoriametrics-vt-single-server
NAME                                     READY   UP-TO-DATE   AVAILABLE   AGE
atlas-victoriametrics-vt-single-server   1/1     1            1           44h

Проверяем Service Kubernetes:

$ kk get svc atlas-victoriametrics-vt-single-server
NAME                                     TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)     AGE
atlas-victoriametrics-vt-single-server   ClusterIP   None         <none>        10428/TCP   2d20h

VictoriaTraces принимает OTLP/HTTP на эндпоинте /insert/opentelemetry/v1/traces.

Для проверки можем отправить трейс с помощью curl — открываем порт:

$ kk port-forward svc/atlas-victoriametrics-vt-single-server 10428

Отправляем JSON с полями, которые впоследствии будет создавать наш OTel SDK:

$ curl -v -X POST "http://localhost:10428/insert/opentelemetry/v1/traces" -H "Content-Type: application/json" -d "{\"resourceSpans\":[{\"resource\":{\"attributes\":[{\"key\":\"service.name\",\"value\":{\"stringValue\":\"test-curl\"}}]},\"scopeSpans\":[{\"scope\":{\"name\":\"manual-test\"},\"spans\":[{\"traceId\":\"aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbb\",\"spanId\":\"cccccccccccccccc\",\"name\":\"test-span\",\"kind\":2,\"startTimeUnixNano\":\"$(date +%s)000000000\",\"endTimeUnixNano\":\"$(date +%s)000000000\",\"attributes\":[{\"key\":\"http.method\",\"value\":{\"stringValue\":\"GET\"}},{\"key\":\"http.route\",\"value\":{\"stringValue\":\"/api/test\"}}],\"status\":{\"code\":1}}]}]}]}"

Проверяем в VM UI — http://localhost:10428/select/vmui/:

Формат запроса — стандартный LogsQL:

{name="test-span"} trace_id:"aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbb"

И всё, VictoriaTraces готова к работе. Осталось только добавить инструментирование в наш код — подробнее об этом в следующей части, а здесь просто пример того, как это может выглядеть: это автоматическое инструментирование для FastAPI и asyncpg:

import os
from fastapi import FastAPI, HTTPException
from contextlib import asynccontextmanager
import asyncpg

from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
from opentelemetry.instrumentation.asyncpg import AsyncPGInstrumentor

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import ConsoleSpanExporter, SimpleSpanProcessor, BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter


pool = None


@asynccontextmanager
async def lifespan(app: FastAPI):
    global pool
    pool = await asyncpg.create_pool(
        host=os.getenv("DB_HOST", "postgres-test"),
        port=int(os.getenv("DB_PORT", "5432")),
        user=os.getenv("DB_USER", "postgres"),
        password=os.getenv("DB_PASSWORD", "testpass"),
        database=os.getenv("DB_NAME", "demo"),
        min_size=2,
        max_size=10,
    )
    yield
    await pool.close()


# Set up OTel tracer provider
provider = TracerProvider()

# Console exporter (for local debugging)
provider.add_span_processor(SimpleSpanProcessor(ConsoleSpanExporter()))
# OTLP exporter to VictoriaTraces
provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter()))

trace.set_tracer_provider(provider)

app = FastAPI(title="Orders API", lifespan=lifespan)

FastAPIInstrumentor.instrument_app(app)
AsyncPGInstrumentor().instrument()

@app.get("/healthz")
async def healthz():
    return {"status": "ok"}


@app.get("/api/orders")
async def list_orders():
    rows = await pool.fetch("SELECT * FROM orders ORDER BY id")
    return [dict(r) for r in rows]


@app.get("/api/orders/{order_id}")
async def get_order(order_id: int):
    row = await pool.fetchrow("SELECT * FROM orders WHERE id = $1", order_id)
    if not row:
        raise HTTPException(status_code=404, detail="Order not found")
    return dict(row)


@app.get("/api/orders/by-customer/{name}")
async def orders_by_customer(name: str):
    # get currently processing span
    current_span = trace.get_current_span()
    # add attribute to the current span: customer name
    current_span.set_attribute("customer.name", name)
    # fetch orders from the database
    rows = await pool.fetch(
        "SELECT * FROM orders WHERE customer_name = $1 ORDER BY id", name
    )
    # add attribute to the current span: number of orders fetched
    current_span.set_attribute("customer.orders_count", len(rows))
    return [dict(r) for r in rows]

VMAlert и правила записи с VictoriaTraces

Интересная возможность — мы можем создавать правила записи, использующие VictoriaTraces, см. «Оповещения на основе трейсов».

Логика та же, что и у правил записи и метрик из логов в VictoriaLogs: описываем правило с type="vlogs" — vmalert генерирует метрику, а затем эту метрику можно использовать в алертах или Grafana.

Единственный нюанс здесь — если у вас уже есть экземпляр vmalert для логов, понадобится второй экземпляр — потому что тип в правилах записи тот же (vlogs), а самому VMAlert нужен другой datasource.url.

Добавление VMAlert

vmalert можно установить из Helm-чарта victoria-metrics-alert или, как в моём случае, при использовании victoria-metrics-k8s-stack и VictoriaMetrics Kubernetes Operator — создать второй экземпляр через kind=VMAlert.

Документация по vmalert находится здесь>>>.

Пример с kind: VMAlert:

apiVersion: operator.victoriametrics.com/v1beta1
kind: VMAlert
metadata:
  name: vmalert-traces
spec:
  datasource:
    url: http://atlas-victoriametrics-vt-single-server:10428
  remoteWrite:
    url: http://vmsingle-vm-k8s-stack:8428
  notifiers:
    - url: http://vmalertmanager-vm-k8s-stack.ops-monitoring-ns.svc.cluster.local:9093
  ruleSelector: 
    matchLabels:
      app: vmalert-traces

Здесь:

  • datasource.url: эндпоинт VictoriaTraces — vmalert будет обращаться к нему для получения трейсов
  • remoteWrite: куда записывать сгенерированные метрики

remoteRead здесь необязателен — этот экземпляр только генерирует метрики.

Но notifiers обязателен — даже несмотря на то, что алерты генерироваться не будут.

В ruleSelector указываем, какие правила VMRules использовать, — иначе в ConfigMap этого экземпляра VMAlert попали бы все VMRule.

Добавление VMRule

Сначала в самой VictoriaTraces проверим какой-нибудь запрос, например:

{resource_attr:service.name="kraken-prod"} "span_attr:http.route":!""
| stats by ("resource_attr:service.name", "span_attr:http.route", "span_attr:http.status_code") quantile(0.95, duration) p95_duration

Здесь получаем все спаны с resource_attr:service.name="kraken-prod", выбираем только те, у которых есть span_attr:http.route, и вычисляем 95-й перцентиль по полю duration:

Описываем сам VMRule, в labels задаём app="vmalert-traces" — ruleSelector выберет по этой метке только этот VMRule:

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:

        # Target Status: metrics on events from Target Status logs
        - record: vmtraces:kraken:http:request_duration:p95
          expr: |
            {resource_attr:service.name=~"kraken-.*"} "span_attr:http.route":!""
            | stats by ("resource_attr:service.name", "span_attr:http.route", "span_attr:http.status_code") quantile(0.95, duration) p95_duration

Развёртываем и проверяем объекты vmalert:

$ kk get vmalert 
NAME             STATUS        REPLICACOUNT   AGE
vm-k8s-stack     operational   1              343d
vmalert-traces   operational                  42m

Здесь vm-k8s-stack — это vmalert по умолчанию из чарта victoria-metrics-k8s-stack — он обрабатывает алерты и содержит правила записи для логов (позже я, вероятно, разделю его на отдельные экземпляры — один для алертов, один для правил записи из логов, один для VictoriaTraces).

И, соответственно, получаем новый под Kubernetes:

$ kk get pod | grep vmalert 
vmalert-vm-k8s-stack-f6cdd77d9-mcnks                              2/2     Running     0               3d23h
vmalert-vmalert-traces-b8f77656c-jqzbp                            2/2     Running     0               4m29s

Для которого создаётся отдельный ConfigMap:

$ kk get pod vmalert-vmalert-traces-b8f77656c-jqzbp -o yaml | yq '.spec.volumes'
...
  {
    "configMap": {
      "defaultMode": 420,
      "name": "vm-vmalert-traces-rulefiles-0"
    },
    "name": "vm-vmalert-traces-rulefiles-0"
  },
...

Который содержит правила из VMRule recording-rules-vmalert-traces:

$ kk describe cm vm-vmalert-traces-rulefiles-0 
Name:         vm-vmalert-traces-rulefiles-0
...
Data
====
ops-monitoring-ns-recording-rules-vmalert-traces.yaml:
----
groups:
- name: Traces.VictoriaTraces.Logs.rules
  interval: 5m
  rules:
  - record: vmtraces:kraken:http:request_duration:p95
    expr: |
      {resource_attr:service.name=~"kraken-.*"} "span_attr:http.route":!""
      | stats by ("resource_attr:service.name", "span_attr:http.route", "span_attr:http.status_code") quantile(0.95, duration) p95_duration

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

VictoriaTraces и Grafana

Чтобы с трейсами было удобно работать, добавим источник данных в Grafana.

Для VictoriaTraces пока используется стандартный источник данных Jaeger, позже, вероятно, добавят собственный плагин — для VictoriaMetrics сначала тоже использовался обычный плагин Prometheus, для VictoriaLogs был плагин Loki, а затем команда добавила собственные.

Сервис мы уже нашли:

$ kk get svc | grep vt
atlas-victoriametrics-vt-single-server                   ClusterIP   None             <none>        10428/TCP                    24h

Проверяем плагин Jaeger:

Добавляем новый источник данных:

Задаём URL http://atlas-victoriametrics-vt-single-server:10428/select/jaeger:

Можно включить Trace to Logs и Metrics — тогда в Grafana Explore по trace_id будут генерироваться ссылки на связанные метрики и логи:

Сохраняем, проверяем:

Переходим в Explore и выполняем поиск по Trace ID:

VictoriaLogs, производные поля и VictoriaTraces

Плагин VictoriaLogs поддерживает производные поля: можно сформировать ссылку на VictoriaTraces прямо из логов VictoriaLogs.

Настраивается в Grafana Connections > VictoriaLogs: задаём имя, выбираем тип — в моём случае логи в формате JSON, поэтому через «Regex in log line»:

"trace_id":\s*"([a-f0-9]{32})"

В поле URL используем ${__value.raw} — сюда будет подставляться значение trace_id.

В Example log message можно проверить, правильно ли работает регулярное выражение:

После этого при открытии лога с полем trace_id справа появится блок «Links»:

Который откроет ссылку на этот трейс:

И на сегодня это, пожалуй, всё.

В следующей статье рассмотрим, как использовать инструментирование OpenTelemetry и создавать трейсы из приложения на Python.

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