algolia-observability

name	algolia-observability
description	Set up observability for Algolia: Prometheus metrics for search latency/errors, OpenTelemetry tracing, structured logging, and Grafana dashboards. Trigger: "algolia monitoring", "algolia metrics", "algolia observability", "monitor algolia", "algolia alerts", "algolia tracing", "algolia dashboard".
allowed-tools	Read, Write, Edit
version	1.7.0
license	MIT
author	Jeremy Longshore <[e-mail]>
tags	["saas","search","algolia"]
compatibility	Designed for Claude Code

Algolia Observability

Overview

Algolia provides built-in analytics in the dashboard, but production systems need application-level observability: latency histograms, error rate counters, distributed traces, and alerts. This skill instruments the algoliasearch v5 client with Prometheus, OpenTelemetry, and structured logging.

Prerequisites

• Access to the application's metrics, tracing, and logging platform.
• A stable service name and index labels that distinguish production from test traffic.
• Permission to inspect Algolia request IDs and API responses without logging API keys or user PII.

Key Metrics to Track

Metric	Type	Why It Matters
Search latency (P50/P95/P99)	Histogram	User experience, SLA compliance
Search requests/sec	Counter	Capacity planning, cost tracking
Error rate by type	Counter	Detect API issues before users report
Index freshness (last updated)	Gauge	Data pipeline health
Record count	Gauge	Cost monitoring, data integrity

Instructions

Examples

The client wrapper, metrics endpoint, tracing, and alert examples below create a correlated view of search latency, errors, and index activity. Preserve request IDs and aggregate labels; never emit search credentials in telemetry.

Step 1: Instrumented Algolia Client Wrapper

// src/algolia/instrumented-client.ts
import { algoliasearch, ApiError } from 'algoliasearch';
import { Counter, Histogram, Gauge, Registry } from 'prom-client';

const registry = new Registry();

const searchLatency = new ({
  : ,
  : ,
  : [, ],
  : [, , , , , , , ],
  : [registry],
});

 searchTotal =  ({
  : ,
  : ,
  : [, ],
  : [registry],
});

 searchErrors =  ({
  : ,
  : ,
  : [, , ],
  : [registry],
});

 indexRecords =  ({
  : ,
  : ,
  : [],
  : [registry],
});

 client = (process..!, process..!);

   instrumentedSearch<T = >(
  : ,
  : <, >
) {
   timer = searchLatency.({ : indexName });

   {
     result =  client.<T>({ indexName, searchParams });
    ({ :  });
    searchTotal.({ : indexName, :  });
     result;
  }  (error) {
    ({ :  });
    searchTotal.({ : indexName, :  });

     (error  ) {
      searchErrors.({
        : indexName,
        : error. ===  ?  : ,
        : (error.),
      });
    }  {
      searchErrors.({
        : indexName,
        : ,
        : ,
      });
    }
     error;
  }
}


   () {
   { items } =  client.();
   ( idx  items) {
    indexRecords.({ : idx. }, idx. || );
  }
}

 { registry };