Skip to content

Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.

4.2 KB
Raw Blame
import { requestContext } from "@fastify/request-context";
import fp from "fastify-plugin";

import { RequestContextKey } from "@app/lib/request-context/request-context-keys";
import {
  coreHttpRequestCounter,
  highCardinalityMeter,
  isTelemetryEnabled,
  normalizeHttpMethod,
  shouldRecordHighCardinalityMetrics
} from "@app/lib/telemetry/metrics";

const apiMeter = highCardinalityMeter("API");

const latencyHistogram = apiMeter.createHistogram("API_latency", {
  unit: "ms"
});

const infisicalMeter = highCardinalityMeter("Infisical");

const requestCounter = infisicalMeter.createCounter("infisical.http.server.request.count", {
  description: "Total number of API requests to Infisical (covers both human users and machine identities)",
  unit: "{request}"
});

const requestDurationHistogram = infisicalMeter.createHistogram("infisical.http.server.request.duration", {
  description: "API request latency",
  unit: "s"
});

export const apiMetrics = fp(async (fastify) => {
  fastify.addHook("onResponse", async (request, reply) => {
    if (!isTelemetryEnabled()) return;

    // the line detects @fastify/static routes via config.rootPath and excludes frontend asset traffic
    // so http.route stays low-cardinality and metrics stay comparable across deployment modes.
    if ((request.routeOptions.config as { rootPath?: string } | undefined)?.rootPath) return;

    // Normalized only for the InfisicalCore instrument, we drop the per-actor meters there.
    const coreMethod = normalizeHttpMethod(request.method);
    const { method } = request;
    const route = request.routeOptions.url;
    const { statusCode } = reply;

    // Recorded ahead of the high-cardinality gate: these three labels are bounded (the route is Fastify's
    // template, never the raw path), and they are the denominator for coreHttpErrorCounter, so a deployment
    // that drops the per-actor meters must not lose them too.
    coreHttpRequestCounter.add(1, {
      "http.request.method": coreMethod,
      "http.route": route ?? "unknown",
      "http.response.status_code": statusCode
    });

    if (!shouldRecordHighCardinalityMetrics()) return;

    latencyHistogram.record(reply.elapsedTime, {
      route,
      method,
      statusCode
    });

    const orgId = requestContext.get(RequestContextKey.OrgId);
    const orgName = requestContext.get(RequestContextKey.OrgName);
    const userAuthInfo = requestContext.get(RequestContextKey.UserAuthInfo);
    const identityAuthInfo = requestContext.get(RequestContextKey.IdentityAuthInfo);
    const projectDetails = requestContext.get(RequestContextKey.ProjectDetails);
    const userAgent = requestContext.get(RequestContextKey.UserAgent);
    const ip = requestContext.get(RequestContextKey.Ip);

    const attributes: Record<string, string | number> = {
      "http.request.method": method,
      "http.route": route ?? "",
      "http.response.status_code": statusCode
    };

    if (orgId) {
      attributes["infisical.organization.id"] = orgId;
    }
    if (orgName) {
      attributes["infisical.organization.name"] = orgName;
    }

    if (userAuthInfo) {
      if (userAuthInfo.userId) {
        attributes["infisical.user.id"] = userAuthInfo.userId;
      }
      if (userAuthInfo.email) {
        attributes["infisical.user.email"] = userAuthInfo.email;
      }
    }

    if (identityAuthInfo) {
      if (identityAuthInfo.identityId) {
        attributes["infisical.identity.id"] = identityAuthInfo.identityId;
      }
      if (identityAuthInfo.identityName) {
        attributes["infisical.identity.name"] = identityAuthInfo.identityName;
      }
      if (identityAuthInfo.authMethod) {
        attributes["infisical.auth.method"] = identityAuthInfo.authMethod;
      }
    }

    if (projectDetails) {
      if (projectDetails.id) {
        attributes["infisical.project.id"] = projectDetails.id;
      }
      if (projectDetails.name) {
        attributes["infisical.project.name"] = projectDetails.name;
      }
    }

    if (userAgent) {
      attributes["user_agent.original"] = userAgent;
    }

    if (ip) {
      attributes["client.address"] = ip;
    }

    requestCounter.add(1, attributes);
    requestDurationHistogram.record(reply.elapsedTime / 1000, attributes);
  });
});