Registry Management

/**
 * Container for all registered metrics
 */
class Registry<BoundRegistryContentType extends RegistryContentType = PrometheusContentType> {
  /**
   * Create a new Registry instance
   * @param regContentType Content type for metrics output (Prometheus or OpenMetrics)
   */
  constructor(regContentType?: BoundRegistryContentType);

  /**
   * Get string representation for all metrics
   */
  metrics(): Promise<string>;

  /**
   * Remove all metrics from the registry
   */
  clear(): void;

  /**
   * Reset all metrics in the registry
   */
  resetMetrics(): void;

  /**
   * Register metric to register
   * @param metric Metric to add to register
   */
  registerMetric<T extends string>(metric: Metric<T>): void;

  /**
   * Get all metrics as objects
   */
  getMetricsAsJSON(): Promise<MetricObjectWithValues<MetricValue<string>>[]>;

  /**
   * Get all metrics as objects
   */
  getMetricsAsArray(): MetricObject[];

  /**
   * Remove a single metric
   * @param name The name of the metric to remove
   */
  removeSingleMetric(name: string): void;

  /**
   * Get a single metric
   * @param name The name of the metric
   */
  getSingleMetric<T extends string>(name: string): Metric<T> | undefined;

  /**
   * Set static labels to every metric emitted by this registry
   * @param labels of name/value pairs:
   * { defaultLabel: "value", anotherLabel: "value 2" }
   */
  setDefaultLabels(labels: object): void;

  /**
   * Get a string representation of a single metric by name
   * @param name The name of the metric
   */
  getSingleMetricAsString(name: string): Promise<string>;

  /**
   * Gets the Content-Type of the metrics for use in the response headers.
   */
  readonly contentType: BoundRegistryContentType;

  /**
   * Set the content type of a registry. Used to change between Prometheus and
   * OpenMetrics versions.
   * @param contentType The type of the registry
   */
  setContentType(contentType: BoundRegistryContentType): void;

  /**
   * Merge registers
   * @param registers The registers you want to merge together
   */
  static merge(registers: Registry[]): Registry;

  /**
   * HTTP Prometheus Content-Type for metrics response headers.
   */
  static PROMETHEUS_CONTENT_TYPE: PrometheusContentType;

  /**
   * HTTP OpenMetrics Content-Type for metrics response headers.
   */
  static OPENMETRICS_CONTENT_TYPE: OpenMetricsContentType;
}

import { Registry, Counter, Gauge } from "prom-client";

// Create a custom registry
const customRegistry = new Registry();

// Create metrics and register them to custom registry
const requestsCounter = new Counter({
  name: "http_requests_total",
  help: "Total HTTP requests",
  registers: [customRegistry], // Register to custom registry
});

const memoryGauge = new Gauge({
  name: "memory_usage_bytes",
  help: "Memory usage in bytes",
  registers: [customRegistry],
});

// Get metrics as Prometheus format string
const prometheusMetrics = await customRegistry.metrics();
console.log(prometheusMetrics);

// Get metrics as JSON objects
const metricsJSON = await customRegistry.getMetricsAsJSON();
console.log(metricsJSON);

// Set default labels for all metrics in this registry
customRegistry.setDefaultLabels({
  service: "api-server",
  version: "1.0.0",
});

// Clear all metrics
customRegistry.clear();

/**
 * The register that contains all metrics
 */
const register: Registry;

/**
 * HTTP Content-Type for metrics response headers for the default registry,
 * defaults to Prometheus text format.
 */
const contentType: RegistryContentType;

/**
 * HTTP Prometheus Content-Type for metrics response headers.
 */
const prometheusContentType: PrometheusContentType;

/**
 * HTTP OpenMetrics Content-Type for metrics response headers.
 */
const openMetricsContentType: OpenMetricsContentType;

import { register, Counter } from "prom-client";

// Metrics are automatically registered to the global registry
const httpRequests = new Counter({
  name: "http_requests_total",
  help: "Total HTTP requests",
  // No need to specify registers - uses global registry by default
});

// Get all metrics from global registry
const metrics = await register.metrics();

// Set default labels on global registry
register.setDefaultLabels({
  application: "my-app",
  environment: "production",
});

// Get content type
console.log(register.contentType); // "text/plain; version=0.0.4; charset=utf-8"

type RegistryContentType = PrometheusContentType | OpenMetricsContentType;
type PrometheusContentType = 'text/plain; version=0.0.4; charset=utf-8';
type OpenMetricsContentType = 'application/openmetrics-text; version=1.0.0; charset=utf-8';

import { Registry } from "prom-client";

// Create registry with Prometheus format (default)
const prometheusRegistry = new Registry();

// Create registry with OpenMetrics format
const openMetricsRegistry = new Registry(Registry.OPENMETRICS_CONTENT_TYPE);

// Change content type after creation
prometheusRegistry.setContentType(Registry.OPENMETRICS_CONTENT_TYPE);

// Check current content type
console.log(openMetricsRegistry.contentType);

/**
 * Merge registers
 * @param registers The registers you want to merge together
 */
static merge(registers: Registry[]): Registry;

import { Registry, Counter } from "prom-client";

// Create separate registries
const registry1 = new Registry();
const registry2 = new Registry();

// Add metrics to each registry
new Counter({
  name: "requests_total",
  help: "Total requests",
  registers: [registry1],
});

new Counter({
  name: "errors_total", 
  help: "Total errors",
  registers: [registry2],
});

// Merge registries
const mergedRegistry = Registry.merge([registry1, registry2]);

// The merged registry now contains metrics from both registries
const allMetrics = await mergedRegistry.metrics();

/**
 * Remove a single metric
 * @param name The name of the metric to remove
 */
removeSingleMetric(name: string): void;

/**
 * Get a single metric
 * @param name The name of the metric
 */
getSingleMetric<T extends string>(name: string): Metric<T> | undefined;

/**
 * Remove all metrics from the registry
 */
clear(): void;

/**
 * Reset all metrics in the registry
 */
resetMetrics(): void;

import { register, Counter } from "prom-client";

const httpRequests = new Counter({
  name: "http_requests_total",
  help: "Total HTTP requests",
});

// Get a specific metric
const metric = register.getSingleMetric("http_requests_total");
console.log(metric?.help); // "Total HTTP requests"

// Remove a specific metric
register.removeSingleMetric("http_requests_total");

// Reset all metric values to zero (but keep the metrics registered)
register.resetMetrics();

// Remove all metrics from registry
register.clear();

interface MetricObject {
  name: string;
  help: string;
  type: MetricType;
  aggregator: Aggregator;
  collect: CollectFunction<any>;
}

interface MetricObjectWithValues<T extends MetricValue<string>> extends MetricObject {
  values: T[];
}

type Metric<T extends string = string> = Counter<T> | Gauge<T> | Summary<T> | Histogram<T>;

type Collector = () => void;