Supported OS Linux Windows Mac OS

Versión de la integración3.2.0

Dashboard de información general de Weaviate

Información general

Weaviate es una base de datos vectorial de código abierto nativa de IA que ayuda a crear aplicaciones potenciadas por IA. Con la integración de Weaviate de Datadog, puedes:

  • Monitoriza las estadísticas de uso (como la duración de las operaciones de inserción, eliminación y mantenimiento) para identificar posibles problemas de almacenamiento, cuellos de botella y evaluar el impacto de las modificaciones de datos en la capacidad de respuesta del sistema.
  • Realiza un seguimiento de la latencia de las consultas, la velocidad y las solicitudes de lectura/escritura concurrentes para obtener información sobre la capacidad de respuesta general de la base de datos vectorial y las capacidades de gestión de la carga.
  • Optimiza las cargas de trabajo de escritura intensiva con estadísticas de objetos, como el tiempo medio que tardan las operaciones “put” (escritura).
  • Garantiza una ingesta de datos fluida y eficaz con métricas relacionadas con la importación que ofrecen información sobre operaciones como el proceso de carga de datos.

Este check monitoriza Weaviate a través del Datadog Agent. Para más información, consulta Monitorización de Weaviate. Para saber más sobre el conjunto de integraciones de IA de Datadog, consulta este blog.

Configuración

Sigue las instrucciones a continuación para instalar y configurar este check para un Agent que se ejecuta en un host. Para entornos en contenedores, consulta las plantillas de integración de Autodiscovery para obtener orientación sobre la aplicación de estas instrucciones.

Instalación

A partir de la versión 7.47.0 del Agent, el check de Weaviate se incluye en el paquete del Datadog Agent .

Nota: Este check requiere el Agent v7.47.0 o posterior.

Configuración

Weaviate puede configurarse para exponer métricas con formato Prometheus. El Datadog Agent puede recopilar estas métricas utilizando la integración descrita a continuación. Sigue las instrucciones para configurar la recopilación de datos para tus instancias de Weaviate. Para las configuraciones requeridas para exponer las métricas de Prometheus, ve la página Monitorización de la documentación de Weaviate.

Además, se puede recopilar un pequeño subconjunto de métricas comunicándose con diferentes endpoints de la API. En concreto:

  • /v1/meta: información sobre la versión
  • /v1/nodes: métricas específicas del nodo como objetos y fragmentos
  • /v1/.well-known/live: tiempo de respuesta HTTP y actividad del servicio

Nota: Este check utiliza OpenMetrics para la recopilación de métricas, que requiere Python 3.

Contenedores

Recopilación de métricas

Asegúrate de que las métricas con formato Prometheus estén expuestas en tu clúster de Weaviate. Puedes configurar y personalizarlas siguiendo las instrucciones de la página Monitorización de la documentación de Weaviate. Para que el Agent comience a recopilar métricas, los pods de Weaviate deben estar anotados. Para más información sobre anotaciones, consulta la guía plantillas de integración de Autodiscovery. Puedes encontrar opciones adicionales de configuración revisando el weaviate.d/conf.yaml de ejemplo

Nota: Las métricas mencionadas solo pueden recopilarse si están disponibles. Algunas métricas solo se generan cuando se realizan determinadas acciones. Por ejemplo, la métrica de eliminación de objetos solo se expone cuando se elimina un objeto.

Los dos parámetros más importantes para configurar el check de Weaviate son los siguientes:

  • openmetrics_endpoint: este parámetro debe establecerse en la localización en la que las métricas con formato Prometheus están expuestas. El puerto por defecto es 2112, pero puede configurarse utilizando la variable de entorno PROMETHEUS_MONITORING_PORT. En entornos en contenedores, %%host%% debe ser utilizado para la autodetección de hosts.
  • weaviate_api_endpoint: este parámetro es opcional. Por defecto, este parámetro se establece en <hostname>:8080 y especifica la configuración de la API de RESTful.

Si se requiere autenticación para los endpoints de la API de RESTful, el check puede configurarse para proporcionar una clave de API como parte del encabezado de solicitud.

apiVersion: v1
kind: Pod
# (...)
metadata:
  name: '<POD_NAME>'
  annotations:
    ad.datadoghq.com/weaviate.checks: |
      {
        "weaviate": {
          "init_config": {},
          "instances": [
            {
              "openmetrics_endpoint": "http://%%host%%:2112/metrics",
              "weaviate_api_endpoint": "http://%%host%%:8080",
              "headers": {'Authorization': 'Bearer if_needed_for_auth'}
            }
          ]
        }
      }
    # (...)
spec:
  containers:
    - name: 'weaviate'
# (...)

Nota: Puedes establecer estas anotaciones directamente en tu Helm chart de Weaviate usando la clave annotations.

Validación

Ejecuta el subcomando de estado del Agent y busca weaviate en la sección Checks.

Datos recopilados

Métricas

weaviate.async.operations.running
(gauge)
The number of currently running async operations. The operation itself is defined through the operation label
Shown as operation
weaviate.backup.restore.class.ms.count
(count)
The number of samples used to calculate the duration of restoring a class
Shown as operation
weaviate.backup.restore.class.ms.sum
(count)
The duration of restoring a class
Shown as millisecond
weaviate.backup.restore.data.transferred
(count)
The total number of bytes transferred during a backup restore
Shown as byte
weaviate.backup.restore.from.backend.ms.count
(count)
The number of samples used to calculate the duration of the file transfer stage of a backup restore
Shown as operation
weaviate.backup.restore.from.backend.ms.sum
(count)
The duration of the file transfer stage of a backup restore
Shown as millisecond
weaviate.backup.restore.init.ms.count
(count)
The number of samples used to calculate the duration of the startup phase of a backup restore
Shown as operation
weaviate.backup.restore.init.ms.sum
(count)
The duration of the startup phase of a backup restore
Shown as millisecond
weaviate.backup.restore.ms.count
(count)
The number of samples used to calculate the duration of backup restores
Shown as operation
weaviate.backup.restore.ms.sum
(count)
The duration of backup restores
Shown as millisecond
weaviate.backup.store.data.transferred
(count)
The total number of bytes transferred during a backup store
Shown as byte
weaviate.backup.store.to.backend.ms.count
(count)
The number of samples used to calculate the duration of the file transfer stage of a backup store
Shown as operation
weaviate.backup.store.to.backend.ms.sum
(count)
The duration of the file transfer stage of a backup store
Shown as millisecond
weaviate.batch.delete.durations_ms.bucket
(count)
The number of operations observed for the batch delete duration histogram by upper_bound buckets
Shown as operation
weaviate.batch.delete.durations_ms.count
(count)
The count of operations observed in the batch delete duration histogram
Shown as operation
weaviate.batch.delete.durations_ms.sum
(count)
The sum of the duration of a batch delete in ms. The operation label further defines what operation as part of the batch delete is being measured. Granularity is a shard of a class
Shown as millisecond
weaviate.batch.durations_ms.bucket
(count)
The number of operations observed for the batch operation duration histogram by upper_bound buckets
Shown as operation
weaviate.batch.durations_ms.count
(count)
The count of operations observed in the batch operation duration histogram
Shown as operation
weaviate.batch.durations_ms.sum
(count)
The sum of the duration of a single batch operation in ms. The operation label further defines what operation as part of the batch (e.g. object, inverted, vector) is being used. Granularity is a shard of a class
Shown as millisecond
weaviate.bucket.pause.durations.ms.count
(count)
The number of samples used to calculate the duration of bucket pauses
Shown as operation
weaviate.bucket.pause.durations.ms.sum
(count)
The duration of bucket pauses
Shown as millisecond
weaviate.concurrent.goroutines
(gauge)
The number of concurrently running goroutines
weaviate.concurrent.queries
(gauge)
The number of concurrently running query operations
Shown as operation
weaviate.go.gc.duration.seconds.count
(count)
The summary count of garbage collection cycles in the Weaviate instance
Shown as second
weaviate.go.gc.duration.seconds.quantile
(gauge)
A summary of the pause duration of garbage collection cycles in the Weaviate instance
Shown as second
weaviate.go.gc.duration.seconds.sum
(count)
The sum of the pause duration of garbage collection cycles in the Weaviate instance
Shown as second
weaviate.go.goroutines
(gauge)
The number of goroutines that currently exist in the Weaviate instance
weaviate.go.info
(gauge)
Metric containing the Go version as a tag
weaviate.go.memstats.alloc_bytes
(gauge)
The number of bytes allocated and still in use in the Weaviate instance
Shown as byte
weaviate.go.memstats.alloc_bytes.count
(count)
The monotonic count of bytes allocated and still in use in the Weaviate instance
Shown as byte
weaviate.go.memstats.buck_hash.sys_bytes
(gauge)
The number of bytes used by the profiling bucket hash table in the Weaviate instance
Shown as byte
weaviate.go.memstats.frees.count
(count)
The total number of frees in the Weaviate instance
weaviate.go.memstats.gc.cpu_fraction
(gauge)
The fraction of this program’s available CPU time used by the GC since the program started in the Weaviate instance
Shown as fraction
weaviate.go.memstats.gc.sys_bytes
(gauge)
The number of bytes used for garbage collection system metadata in the Weaviate instance
Shown as byte
weaviate.go.memstats.heap.alloc_bytes
(gauge)
The number of heap bytes allocated and still in use in the Weaviate instance
Shown as byte
weaviate.go.memstats.heap.idle_bytes
(gauge)
The number of heap bytes waiting to be used in the Weaviate instance
Shown as byte
weaviate.go.memstats.heap.inuse_bytes
(gauge)
The number of heap bytes that are in use in the Weaviate instance
Shown as byte
weaviate.go.memstats.heap.objects
(gauge)
The number of allocated objects in the Weaviate instance
Shown as object
weaviate.go.memstats.heap.released_bytes
(gauge)
The number of heap bytes released to the OS in the Weaviate instance
Shown as byte
weaviate.go.memstats.heap.sys_bytes
(gauge)
The number of heap bytes obtained from system in the Weaviate instance
Shown as byte
weaviate.go.memstats.lookups.count
(count)
The number of pointer lookups
weaviate.go.memstats.mallocs.count
(count)
The number of mallocs
weaviate.go.memstats.mcache.inuse_bytes
(gauge)
The number of bytes in use by mcache structures in the Weaviate instance
Shown as byte
weaviate.go.memstats.mcache.sys_bytes
(gauge)
The number of bytes used for mcache structures obtained from system in the Weaviate instance
Shown as byte
weaviate.go.memstats.mspan.inuse_bytes
(gauge)
The number of bytes in use by mspan structures in the Weaviate instance
Shown as byte
weaviate.go.memstats.mspan.sys_bytes
(gauge)
The number of bytes used for mspan structures obtained from system in the Weaviate instance
Shown as byte
weaviate.go.memstats.next.gc_bytes
(gauge)
The number of heap bytes when next garbage collection takes place in the Weaviate instance
Shown as byte
weaviate.go.memstats.other.sys_bytes
(gauge)
The number of bytes used for other system allocations in the Weaviate instance
Shown as byte
weaviate.go.memstats.stack.inuse_bytes
(gauge)
The number of bytes in use by the stack allocator in the Weaviate instance
Shown as byte
weaviate.go.memstats.stack.sys_bytes
(gauge)
The number of bytes obtained from system for stack allocator in the Weaviate instance
Shown as byte
weaviate.go.memstats.sys_bytes
(gauge)
The number of bytes obtained from system in the Weaviate instance
Shown as byte
weaviate.go.threads
(gauge)
The number of OS threads created in the Weaviate instance
Shown as thread
weaviate.http.latency_ms
(gauge)
The HTTP request response time latency in ms
Shown as millisecond
weaviate.lsm.active.segments
(gauge)
The number of currently present segments per shard. Granularity is shard of a class. Grouped by strategy
Shown as segment
weaviate.lsm.bloom.filters.duration_ms.count
(count)
The number of samples used to calculate the duration of a bloom operation
Shown as operation
weaviate.lsm.bloom.filters.duration_ms.sum
(count)
The duration of a bloom filter operation per shard in ms. Granularity is shard of a class. Grouped by strategy
Shown as millisecond
weaviate.lsm.memtable.durations_ms.count
(count)
The number of samples used to calculate the duration of a sync or async vector index maintenance operation
Shown as operation
weaviate.lsm.memtable.durations_ms.sum
(count)
The duration of a sync or async vector index maintenance operation. The operation itself is defined through the operation label
Shown as millisecond
weaviate.lsm.memtable.size
(gauge)
The size of memtable by path
weaviate.lsm.segment.objects
(gauge)
The number of entries per LSM segment by level. Granularity is shard of a class. Grouped by strategy and level
Shown as object
weaviate.lsm.segment.size
(gauge)
The size of LSM segment by level and unit
weaviate.lsm.segments
(gauge)
The number of segments by level
Shown as segment
weaviate.node.shard.objects
(gauge)
The number of objects inside a Weaviate shard
Shown as object
weaviate.node.stats.objects
(gauge)
The number of objects inside a Weaviate node
Shown as object
weaviate.node.stats.shards
(gauge)
The number of shard inside a Weaviate shard
Shown as shard
weaviate.node.status
(gauge)
The current status of a Weaviate Node. 0:HEALTHY, 1:UNHEALTHY, 2:UNAVAILABLE, and 3:UNKNOWN
weaviate.objects
(gauge)
The numbers of objects present. Granularity is a shard of a class
Shown as object
weaviate.objects.durations_ms.count
(count)
The number of samples used to calculate the duration of an individual object operation
Shown as operation
weaviate.objects.durations_ms.sum
(count)
The duration of an individual object operation, such as put, delete, etc. as indicated by the operation label, also as part of a batch. The step label adds additional precisions to each operation. Granularity is a shard of a class
Shown as millisecond
weaviate.process.cpu.seconds.count
(count)
The total user and system CPU time spent in seconds in the Weaviate instance
Shown as second
weaviate.process.max_fds
(gauge)
The maximum number of open file descriptors in the Weaviate instance
weaviate.process.open_fds
(gauge)
The number of open file descriptors in the Weaviate instance
weaviate.process.resident_memory.bytes
(gauge)
The resident memory size in bytes in the Weaviate instance
Shown as byte
weaviate.process.start_time.seconds
(gauge)
The start time of the process since unix epoch in seconds in the Weaviate instance
Shown as second
weaviate.process.virtual_memory.bytes
(gauge)
The virtual memory size in bytes in the Weaviate instance
Shown as byte
weaviate.process.virtual_memory.max_bytes
(gauge)
The maximum amount of virtual memory available in bytes in the Weaviate instance
Shown as byte
weaviate.promhttp.metric_handler.requests.count
(count)
The total number of scrapes by HTTP status code
Shown as request
weaviate.promhttp.metric_handler.requests_in_flight
(gauge)
The current number of scrapes being served
Shown as request
weaviate.queries.durations_ms.bucket
(count)
The number of operations observed in the query duration histogram by upper_bound buckets
Shown as operation
weaviate.queries.durations_ms.count
(count)
The count of operations observed in the query duration histogram
Shown as operation
weaviate.queries.durations_ms.sum
(count)
The sum of query durations in milliseconds
Shown as millisecond
weaviate.queries.filtered.vector.durations_ms.count
(count)
The count of the duration of queries summary
weaviate.queries.filtered.vector.durations_ms.sum
(count)
The duration of queries in milliseconds
Shown as millisecond
weaviate.query.dimensions.count
(count)
The vector dimensions used by any read-query that involves vectors
weaviate.requests
(gauge)
The number of requests tagged by a given status(ok, user_error, server_error). Available only on Weaviate version 1.20.0+
Shown as request
weaviate.startup.diskio.throughput.bucket
(count)
The number of operations observed for the the disk I/O throughput duration by upper_bound buckets
Shown as operation
weaviate.startup.diskio.throughput.count
(count)
The count of operations observed in the disk I/O throughput duration histogram
Shown as operation
weaviate.startup.diskio.throughput.sum
(count)
The sum of disk I/O throughput startup operations in bytes/s, such as reading back the HNSW index or recovering LSM segments. The operation itself is defined by the operation label
Shown as byte
weaviate.startup.durations_ms.count
(count)
The number of samples used to calculate the duration individual startup operation
Shown as operation
weaviate.startup.durations_ms.sum
(count)
The duration of individual startup operations in ms. The operation itself is defined through the operation label
Shown as millisecond
weaviate.startup.progress
(gauge)
The ratio (percentage) of startup progress for a particular component in a shard
weaviate.vector.dimensions.count
(count)
The total dimensions in a shard
weaviate.vector.index.durations_ms.count
(count)
The number of samples used to calculate the duration of a sync or async vector index operation
Shown as operation
weaviate.vector.index.durations_ms.sum
(count)
The duration of regular vector index operation, such as insert or delete. The operation itself is defined through the operation label. The step label adds more granularity to each operation
Shown as millisecond
weaviate.vector.index.maintenance.durations_ms.count
(count)
The number of samples used to calculate the duration of a sync or async vector index operation
Shown as operation
weaviate.vector.index.maintenance.durations_ms.sum
(count)
The duration of a sync or async vector index maintenance operation. The operation itself is defined through the operation label
Shown as millisecond
weaviate.vector.index.operations
(gauge)
The total number of mutating operations on the vector index. The operation itself is defined by the operation label
Shown as operation
weaviate.vector.index.size
(gauge)
The total capacity of the vector index. Typically larger than the number of vectors imported as it grows proactively
weaviate.vector.index.tombstone.cleaned.count
(count)
The total number of deleted and removed vectors after repair operations
weaviate.vector.index.tombstone.cleanup.threads
(gauge)
The number of currently active threads for repairing/cleaning up the vector index after deletes have occurred
weaviate.vector.index.tombstones
(gauge)
The number of active vector index tombstones

Eventos

La integración de Weaviate no incluye ningún evento.

Checks de servicio

weaviate.openmetrics.health

Returns CRITICAL if the Agent is unable to connect to the Weaviate OpenMetrics endpoint, otherwise returns OK.

Statuses: ok, critical

weaviate.node.status

Returns CRITICAL if the node is UNAVAILABLE, WARNING if UNHEALTHY and OK if HEALTHY.

Statuses: ok, warning, critical

weaviate.liveness.status

Returns OK if liveness endpoint returns a 200 response, otherwise returns CRITICAL.

Statuses: ok, critical

Solucionar problemas

¿Necesitas ayuda? Contacta con el equipo de asistencia de Datadog.

Referencias adicionales

Más enlaces, artículos y documentación útiles: