Review funkt

node_modules/bullmq/dist/esm/interfaces/telemetry.d.ts

@@ -0,0 +1,254 @@
+import { SpanKind } from '../enums';
+/**
+ * Telemetry interface
+ *
+ * This interface allows third-party libraries to integrate their own telemetry
+ * system. The interface is heavily inspired by OpenTelemetry but it's not
+ * limited to it.
+ *
+ */
+export interface Telemetry<Context = any> {
+    /**
+     * Tracer instance
+     *
+     * The tracer is responsible for creating spans and propagating the context
+     * across the application.
+     */
+    tracer: Tracer<Context>;
+    /**
+     * Context manager instance
+     *
+     * The context manager is responsible for managing the context and propagating
+     * it across the application.
+     */
+    contextManager: ContextManager;
+    /**
+     * Meter instance (optional)
+     *
+     * The meter is responsible for creating and managing metrics instruments
+     * such as counters, histograms, etc.
+     */
+    meter?: Meter;
+}
+/**
+ * Meter interface
+ *
+ * The meter is responsible for creating metric instruments.
+ */
+export interface Meter {
+    /**
+     * Creates a new Counter metric instrument.
+     *
+     * @param name - the name of the counter
+     * @param options - optional configuration for the counter
+     * @returns a Counter instance
+     */
+    createCounter(name: string, options?: MetricOptions): Counter;
+    /**
+     * Creates a new Histogram metric instrument.
+     *
+     * @param name - the name of the histogram
+     * @param options - optional configuration for the histogram
+     * @returns a Histogram instance
+     */
+    createHistogram(name: string, options?: MetricOptions): Histogram;
+    /**
+     * Creates a new Gauge metric instrument.
+     *
+     * A gauge is a metric that represents a single numerical value that can
+     * arbitrarily go up and down. Gauges are typically used for measured values
+     * like queue sizes.
+     *
+     * @param name - the name of the gauge
+     * @param options - optional configuration for the gauge
+     * @returns a Gauge instance
+     */
+    createGauge(name: string, options?: MetricOptions): Gauge;
+}
+/**
+ * Options for creating metric instruments
+ */
+export interface MetricOptions {
+    /**
+     * Human-readable description of the metric
+     */
+    description?: string;
+    /**
+     * Unit of measurement for the metric (e.g., 'ms', 'bytes', '1')
+     */
+    unit?: string;
+}
+/**
+ * Counter metric interface
+ *
+ * A counter is a cumulative metric that represents a single monotonically
+ * increasing value. Counters are typically used to count requests, completed
+ * tasks, errors, etc.
+ */
+export interface Counter {
+    /**
+     * Adds a value to the counter.
+     *
+     * @param value - the value to add (must be non-negative)
+     * @param attributes - optional attributes to associate with this measurement
+     */
+    add(value: number, attributes?: Attributes): void;
+}
+/**
+ * Histogram metric interface
+ *
+ * A histogram is a metric that samples observations and counts them in
+ * configurable buckets. Typically used for measuring durations or sizes.
+ */
+export interface Histogram {
+    /**
+     * Records a value in the histogram.
+     *
+     * @param value - the value to record
+     * @param attributes - optional attributes to associate with this measurement
+     */
+    record(value: number, attributes?: Attributes): void;
+}
+/**
+ * Gauge metric interface
+ *
+ * A gauge is a synchronous instrument which can be used to record
+ * non-additive value(s) (e.g. the current queue size) when changes occur.
+ */
+export interface Gauge {
+    /**
+     * Records a value for the gauge.
+     *
+     * @param value - the value to record
+     * @param attributes - optional attributes to associate with this measurement
+     */
+    record(value: number, attributes?: Attributes): void;
+}
+/**
+ * Context manager interface
+ *
+ * The context manager is responsible for managing the context and propagating
+ * it across the application.
+ */
+export interface ContextManager<Context = any> {
+    /**
+     * Creates a new context and sets it as active for the fn passed as last argument
+     *
+     * @param context - the context to set as active
+     * @param fn - the function to execute with the context
+     */
+    with<A extends (...args: any[]) => any>(context: Context, fn: A): ReturnType<A>;
+    /**
+     * Returns the active context
+     */
+    active(): Context;
+    /**
+     * Returns a serialized version of the current context. The metadata
+     * is the mechanism used to propagate the context across a distributed
+     * application.
+     *
+     * @param context - the current context
+     */
+    getMetadata(context: Context): string;
+    /**
+     * Creates a new context from a serialized version effectively
+     * linking the new context to the parent context.
+     *
+     * @param activeContext - the current active context
+     * @param metadata - the serialized version of the context
+     */
+    fromMetadata(activeContext: Context, metadata: string): Context;
+}
+/**
+ * Tracer interface
+ *
+ */
+export interface Tracer<Context = any> {
+    /**
+     * startSpan creates a new Span with the given name and options on an optional
+     * context. If the context is not provided, the current active context should be
+     * used.
+     *
+     * @param name - span name
+     * @param options - span options
+     * @param context - optional context
+     * @returns - the created span
+     */
+    startSpan(name: string, options?: SpanOptions, context?: Context): Span;
+}
+export interface SpanOptions {
+    kind: SpanKind;
+}
+/**
+ * Span interface
+ */
+export interface Span<Context = any> {
+    /**
+     * setSpanOnContext sets the span on the context. This is useful when you want
+     * to propagate the span across the application.
+     *
+     * @param ctx - context to set the span on
+     * @returns - the context with the span set on it
+     */
+    setSpanOnContext(ctx: Context): Context;
+    /**
+     * setAttribute sets an attribute on the span.
+     *
+     * @param key - attribute key
+     * @param value - attribute value
+     */
+    setAttribute(key: string, value: AttributeValue): void;
+    /**
+     * setAttributes sets multiple attributes on the span.
+     *
+     * @param attributes - attributes to set
+     */
+    setAttributes(attributes: Attributes): void;
+    /**
+     * addEvent adds an event to the span.
+     *
+     * @param name - event name
+     * @param attributes - event attributes
+     */
+    addEvent(name: string, attributes?: Attributes): void;
+    /**
+     * recordException records an exception on the span.
+     *
+     * @param exception - exception to record
+     * @param time - time to record the exception
+     */
+    recordException(exception: Exception, time?: Time): void;
+    /**
+     * end ends the span.
+     *
+     * Note: spans must be ended so that they can be exported.
+     */
+    end(): void;
+}
+export interface Attributes {
+    [attribute: string]: AttributeValue | undefined;
+}
+export type AttributeValue = string | number | boolean | Array<null | undefined | string> | Array<null | undefined | number> | Array<null | undefined | boolean>;
+export type Exception = string | ExceptionType;
+export type ExceptionType = CodeException | MessageException | NameException;
+interface CodeException {
+    code: string | number;
+    name?: string;
+    message?: string;
+    stack?: string;
+}
+interface MessageException {
+    code?: string | number;
+    name?: string;
+    message: string;
+    stack?: string;
+}
+interface NameException {
+    code?: string | number;
+    name: string;
+    message?: string;
+    stack?: string;
+}
+export type Time = HighResolutionTime | number | Date;
+type HighResolutionTime = [number, number];
+export {};