@valkey/valkey-glide 2.2.7 → 2.3.0-rc6

package/build-ts/OpenTelemetry.js

@@ -10,7 +10,7 @@ const _1 = require(".");
  * If you need to change configuration, restart the process with new settings.
  * ### OpenTelemetry
  *
- * - **openTelemetryConfig**: Use this object to configure OpenTelemetry exporters and options.
+ * - **openTelemetryConfig**: Use {@link GlideOpenTelemetryConfig} to configure OpenTelemetry exporters and options.
  *   - **traces**: (optional) Configure trace exporting.
  *     - **endpoint**: The collector endpoint for traces. Supported protocols:
  *       - `http://` or `https://` for HTTP/HTTPS
@@ -22,6 +22,7 @@ const _1 = require(".");
  *   - **metrics**: (optional) Configure metrics exporting.
  *     - **endpoint**: The collector endpoint for metrics. Same protocol rules as above.
  *   - **flushIntervalMs**: (optional) Interval in milliseconds for flushing data to the collector. Must be a positive integer. Defaults to 5000ms if not specified.
+ *   - **parentSpanContextProvider**: (optional) Callback returning the active parent span context. See {@link GlideOpenTelemetryConfig.parentSpanContextProvider}.
  *
  * #### File Exporter Details
  * - For `file://` endpoints:
@@ -40,6 +41,9 @@ const _1 = require(".");
 class OpenTelemetry {
     static _instance = null;
     static openTelemetryConfig = null;
+    static spanContextFn = null;
+    static TRACE_ID_REGEX = /^[0-9a-f]{32}$/;
+    static SPAN_ID_REGEX = /^[0-9a-f]{16}$/;
     /**
      * Singleton class for managing OpenTelemetry configuration and operations.
      * This class provides a centralized way to initialize OpenTelemetry and control
@@ -47,23 +51,26 @@ class OpenTelemetry {
      *
      * Example usage:
      * ```typescript
-     * import { OpenTelemetry, OpenTelemetryConfig, OpenTelemetryTracesConfig, OpenTelemetryMetricsConfig } from "@valkey/valkey-glide";
+     * import { OpenTelemetry, GlideOpenTelemetryConfig } from "@valkey/valkey-glide";
+     * import { trace } from "@opentelemetry/api";
      *
-     * let tracesConfig: OpenTelemetryTracesConfig = {
-     *  endpoint: "http://localhost:4318/v1/traces",
-     *  samplePercentage: 10, // Optional, defaults to 1. Can also be changed at runtime via setSamplePercentage().
-     * };
-     * let metricsConfig: OpenTelemetryMetricsConfig = {
-     *  endpoint: "http://localhost:4318/v1/metrics",
-     * };
-
-     * let config : OpenTelemetryConfig = {
-     *  traces: tracesConfig,
-     *  metrics: metricsConfig,
-     *  flushIntervalMs: 1000, // Optional, defaults to 5000
+     * const config: GlideOpenTelemetryConfig = {
+     *     traces: {
+     *         endpoint: "http://localhost:4318/v1/traces",
+     *         samplePercentage: 10,
+     *     },
+     *     metrics: {
+     *         endpoint: "http://localhost:4318/v1/metrics",
+     *     },
+     *     flushIntervalMs: 1000,
+     *     parentSpanContextProvider: () => {
+     *         const span = trace.getActiveSpan();
+     *         if (!span) return undefined;
+     *         const ctx = span.spanContext();
+     *         return { traceId: ctx.traceId, spanId: ctx.spanId, traceFlags: ctx.traceFlags };
+     *     },
      * };
      * OpenTelemetry.init(config);
-     *
      * ```
      *
      * @remarks
@@ -76,16 +83,23 @@ class OpenTelemetry {
      */
     static init(openTelemetryConfig) {
         if (!this._instance) {
-            this.internalInit(openTelemetryConfig);
+            const { parentSpanContextProvider, ...nativeConfig } = openTelemetryConfig;
+            this.internalInit(nativeConfig, parentSpanContextProvider);
             _1.Logger.log("info", "GlideOpenTelemetry", "OpenTelemetry initialized with config: " +
-                JSON.stringify(openTelemetryConfig));
+                JSON.stringify(nativeConfig) +
+                (parentSpanContextProvider
+                    ? " (parentSpanContextProvider: set)"
+                    : ""));
             return;
         }
         _1.Logger.log("warn", "GlideOpenTelemetry", "OpenTelemetry already initialized - ignoring new configuration");
     }
-    static internalInit(openTelemetryConfig) {
-        this.openTelemetryConfig = openTelemetryConfig;
-        (0, _1.InitOpenTelemetry)(openTelemetryConfig);
+    static internalInit(nativeConfig, parentSpanContextProvider) {
+        this.openTelemetryConfig = nativeConfig;
+        if (parentSpanContextProvider) {
+            this.spanContextFn = parentSpanContextProvider;
+        }
+        (0, _1.InitOpenTelemetry)(nativeConfig);
         this._instance = new OpenTelemetry();
     }
     /**
@@ -130,5 +144,143 @@ class OpenTelemetry {
         }
         this.openTelemetryConfig.traces.samplePercentage = percentage;
     }
+    /**
+     * Register or replace the callback that returns the active parent span context.
+     *
+     * This allows changing the provider at runtime (e.g., switching tracing contexts
+     * in a multi-tenant application). The initial provider can also be set via
+     * {@link GlideOpenTelemetryConfig.parentSpanContextProvider} in `init()`.
+     *
+     * @param fn - A function returning a `GlideSpanContext` or `undefined`, or `null` to clear.
+     *
+     * @example
+     * ```typescript
+     * import { trace } from "@opentelemetry/api";
+     *
+     * OpenTelemetry.setParentSpanContextProvider(() => {
+     *     const span = trace.getActiveSpan();
+     *     if (!span) return undefined;
+     *     const ctx = span.spanContext();
+     *     return {
+     *         traceId: ctx.traceId,
+     *         spanId: ctx.spanId,
+     *         traceFlags: ctx.traceFlags,
+     *         traceState: ctx.traceState?.toString(),
+     *     };
+     * });
+     * ```
+     */
+    static setParentSpanContextProvider(fn) {
+        this.spanContextFn = fn;
+    }
+    /**
+     * Retrieve the current parent span context by invoking the registered callback.
+     *
+     * @returns The `GlideSpanContext` from the registered callback, or `undefined` if no callback
+     *   is set or the callback returns `undefined`.
+     * @internal
+     */
+    static getParentSpanContext() {
+        let ctx;
+        try {
+            ctx = this.spanContextFn?.();
+        }
+        catch (e) {
+            _1.Logger.log("warn", "GlideOpenTelemetry", `parentSpanContextProvider threw: ${e}. Falling back to standalone span.`);
+            return undefined;
+        }
+        if (ctx === undefined) {
+            return undefined;
+        }
+        if (!this.TRACE_ID_REGEX.test(ctx.traceId)) {
+            _1.Logger.log("warn", "GlideOpenTelemetry", `Invalid traceId "${ctx.traceId}" — expected 32 lowercase hex chars. Falling back to standalone span.`);
+            return undefined;
+        }
+        if (!this.SPAN_ID_REGEX.test(ctx.spanId)) {
+            _1.Logger.log("warn", "GlideOpenTelemetry", `Invalid spanId "${ctx.spanId}" — expected 16 lowercase hex chars. Falling back to standalone span.`);
+            return undefined;
+        }
+        if (!Number.isInteger(ctx.traceFlags) ||
+            ctx.traceFlags < 0 ||
+            ctx.traceFlags > 255) {
+            _1.Logger.log("warn", "GlideOpenTelemetry", `Invalid traceFlags "${ctx.traceFlags}" — expected integer 0-255. Falling back to standalone span.`);
+            return undefined;
+        }
+        if (ctx.traceState !== undefined &&
+            !OpenTelemetry.validTraceState(ctx.traceState)) {
+            _1.Logger.log("warn", "GlideOpenTelemetry", `Invalid traceState "${ctx.traceState}" — expected W3C tracestate format. Falling back to standalone span.`);
+            return undefined;
+        }
+        return ctx;
+    }
+    /**
+     * Validate a W3C tracestate key.
+     * See https://www.w3.org/TR/trace-context/#key
+     * @internal
+     */
+    static validTraceStateKey(key) {
+        if (key.length === 0 || key.length > 256)
+            return false;
+        const ALLOWED_SPECIAL = new Set([
+            "_".charCodeAt(0),
+            "-".charCodeAt(0),
+            "*".charCodeAt(0),
+            "/".charCodeAt(0),
+        ]);
+        let vendorStart = null;
+        for (let i = 0; i < key.length; i++) {
+            const c = key.charCodeAt(i);
+            const isLower = c >= 0x61 && c <= 0x7a; // a-z
+            const isDigit = c >= 0x30 && c <= 0x39; // 0-9
+            const isAt = c === 0x40; // @
+            if (!(isLower || isDigit || ALLOWED_SPECIAL.has(c) || isAt)) {
+                return false;
+            }
+            if (i === 0 && !isLower && !isDigit)
+                return false;
+            if (isAt) {
+                if (vendorStart !== null || i + 14 < key.length)
+                    return false;
+                vendorStart = i;
+            }
+            else if (vendorStart !== null && i === vendorStart + 1) {
+                if (!isLower && !isDigit)
+                    return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Validate a W3C tracestate value.
+     * See https://www.w3.org/TR/trace-context/#value
+     * @internal
+     */
+    static validTraceStateValue(value) {
+        if (value.length > 256)
+            return false;
+        return !value.includes(",") && !value.includes("=");
+    }
+    /**
+     * Validate a W3C tracestate string (comma-separated key=value pairs).
+     * Mirrors the validation in opentelemetry-rust TraceState::from_str.
+     * @internal
+     */
+    static validTraceState(traceState) {
+        if (traceState === "")
+            return true;
+        const entries = traceState.split(",");
+        for (const entry of entries) {
+            const eqIndex = entry.indexOf("=");
+            if (eqIndex === -1)
+                return false;
+            const key = entry.substring(0, eqIndex);
+            const value = entry.substring(eqIndex + 1);
+            if (!OpenTelemetry.validTraceStateKey(key) ||
+                !OpenTelemetry.validTraceStateValue(value)) {
+                return false;
+            }
+        }
+        return true;
+    }
 }
 exports.OpenTelemetry = OpenTelemetry;

package/build-ts/ProtobufMessage.d.ts

@@ -504,6 +504,13 @@ export namespace command_request {
         Subscribe = 911,
         SUnsubscribe = 912,
         Unsubscribe = 913,
+        SubscribeBlocking = 914,
+        UnsubscribeBlocking = 915,
+        PSubscribeBlocking = 916,
+        PUnsubscribeBlocking = 917,
+        SSubscribeBlocking = 918,
+        SUnsubscribeBlocking = 919,
+        GetSubscriptions = 920,
         Eval = 1001,
         EvalReadOnly = 1002,
         EvalSha = 1003,
@@ -533,7 +540,7 @@ export namespace command_request {
         AclLoad = 1107,
         AclLog = 1108,
         AclSave = 1109,
-        AclSetSser = 1110,
+        AclSetUser = 1110,
         AclUsers = 1111,
         AclWhoami = 1112,
         BgRewriteAof = 1113,
@@ -1911,6 +1918,99 @@ export namespace connection_request {
         Sharded = 2
     }
 
+    /** CompressionBackend enum. */
+    enum CompressionBackend {
+        ZSTD = 0,
+        LZ4 = 1
+    }
+
+    /** Properties of a CompressionConfig. */
+    interface ICompressionConfig {
+
+        /** CompressionConfig enabled */
+        enabled?: (boolean|null);
+
+        /** CompressionConfig backend */
+        backend?: (connection_request.CompressionBackend|null);
+
+        /** CompressionConfig compressionLevel */
+        compressionLevel?: (number|null);
+
+        /** CompressionConfig minCompressionSize */
+        minCompressionSize?: (number|null);
+    }
+
+    /** Represents a CompressionConfig. */
+    class CompressionConfig implements ICompressionConfig {
+
+        /**
+         * Constructs a new CompressionConfig.
+         * @param [properties] Properties to set
+         */
+        constructor(properties?: connection_request.ICompressionConfig);
+
+        /** CompressionConfig enabled. */
+        public enabled: boolean;
+
+        /** CompressionConfig backend. */
+        public backend: connection_request.CompressionBackend;
+
+        /** CompressionConfig compressionLevel. */
+        public compressionLevel?: (number|null);
+
+        /** CompressionConfig minCompressionSize. */
+        public minCompressionSize: number;
+
+        /**
+         * Creates a new CompressionConfig instance using the specified properties.
+         * @param [properties] Properties to set
+         * @returns CompressionConfig instance
+         */
+        public static create(properties?: connection_request.ICompressionConfig): connection_request.CompressionConfig;
+
+        /**
+         * Encodes the specified CompressionConfig message. Does not implicitly {@link connection_request.CompressionConfig.verify|verify} messages.
+         * @param message CompressionConfig message or plain object to encode
+         * @param [writer] Writer to encode to
+         * @returns Writer
+         */
+        public static encode(message: connection_request.ICompressionConfig, writer?: $protobuf.Writer): $protobuf.Writer;
+
+        /**
+         * Encodes the specified CompressionConfig message, length delimited. Does not implicitly {@link connection_request.CompressionConfig.verify|verify} messages.
+         * @param message CompressionConfig message or plain object to encode
+         * @param [writer] Writer to encode to
+         * @returns Writer
+         */
+        public static encodeDelimited(message: connection_request.ICompressionConfig, writer?: $protobuf.Writer): $protobuf.Writer;
+
+        /**
+         * Decodes a CompressionConfig message from the specified reader or buffer.
+         * @param reader Reader or buffer to decode from
+         * @param [length] Message length if known beforehand
+         * @returns CompressionConfig
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): connection_request.CompressionConfig;
+
+        /**
+         * Decodes a CompressionConfig message from the specified reader or buffer, length delimited.
+         * @param reader Reader or buffer to decode from
+         * @returns CompressionConfig
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): connection_request.CompressionConfig;
+
+        /**
+         * Gets the default type url for CompressionConfig
+         * @param [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+         * @returns The default type url
+         */
+        public static getTypeUrl(typeUrlPrefix?: string): string;
+    }
+
     /** Properties of a PubSubChannelsOrPatterns. */
     interface IPubSubChannelsOrPatterns {
 
@@ -2112,8 +2212,23 @@ export namespace connection_request {
         /** ConnectionRequest rootCerts */
         rootCerts?: (Uint8Array[]|null);
 
+        /** ConnectionRequest compressionConfig */
+        compressionConfig?: (connection_request.ICompressionConfig|null);
+
+        /** ConnectionRequest clientCert */
+        clientCert?: (Uint8Array|null);
+
+        /** ConnectionRequest clientKey */
+        clientKey?: (Uint8Array|null);
+
         /** ConnectionRequest tcpNodelay */
         tcpNodelay?: (boolean|null);
+
+        /** ConnectionRequest pubsubReconciliationIntervalMs */
+        pubsubReconciliationIntervalMs?: (number|null);
+
+        /** ConnectionRequest readOnly */
+        readOnly?: (boolean|null);
     }
 
     /** Represents a ConnectionRequest. */
@@ -2185,9 +2300,24 @@ export namespace connection_request {
         /** ConnectionRequest rootCerts. */
         public rootCerts: Uint8Array[];
 
+        /** ConnectionRequest compressionConfig. */
+        public compressionConfig?: (connection_request.ICompressionConfig|null);
+
+        /** ConnectionRequest clientCert. */
+        public clientCert: Uint8Array;
+
+        /** ConnectionRequest clientKey. */
+        public clientKey: Uint8Array;
+
         /** ConnectionRequest tcpNodelay. */
         public tcpNodelay?: (boolean|null);
 
+        /** ConnectionRequest pubsubReconciliationIntervalMs. */
+        public pubsubReconciliationIntervalMs?: (number|null);
+
+        /** ConnectionRequest readOnly. */
+        public readOnly?: (boolean|null);
+
         /** ConnectionRequest periodicChecks. */
         public periodicChecks?: ("periodicChecksManualInterval"|"periodicChecksDisabled");