@spotify-confidence/openfeature-server-provider-local 0.10.1 → 0.11.0

package/dist/index.node.d.ts

@@ -82,6 +82,10 @@ declare enum ResolveReason {
   RESOLVE_REASON_UNRECOGNIZED_TARGETING_RULE = 7,
   /** RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED - The flag could not be resolved because a rule is using materialization */
   RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED = 8,
+  /** RESOLVE_REASON_TYPE_MISMATCH - The resolved value type does not match the type requested by the SDK */
+  RESOLVE_REASON_TYPE_MISMATCH = 9,
+  /** RESOLVE_REASON_FLAG_NOT_FOUND - The flag was not found in the resolve response */
+  RESOLVE_REASON_FLAG_NOT_FOUND = 10,
   UNRECOGNIZED = -1,
 }
 declare enum SdkId {
@@ -273,6 +277,10 @@ interface MaterializationRecord {
   rule: string;
   variant: string;
 }
+interface RegisterResolveRequest {
+  reason: ResolveReason;
+  latencyUs: number;
+}
 declare const ResolveProcessRequest: MessageFns$2<ResolveProcessRequest>;
 declare const ResolveProcessRequest_StaticMaterializations: MessageFns$2<ResolveProcessRequest_StaticMaterializations>;
 declare const ResolveProcessRequest_Resume: MessageFns$2<ResolveProcessRequest_Resume>;
@@ -280,6 +288,7 @@ declare const ResolveProcessResponse: MessageFns$2<ResolveProcessResponse>;
 declare const ResolveProcessResponse_Resolved: MessageFns$2<ResolveProcessResponse_Resolved>;
 declare const ResolveProcessResponse_Suspended: MessageFns$2<ResolveProcessResponse_Suspended>;
 declare const MaterializationRecord: MessageFns$2<MaterializationRecord>;
+declare const RegisterResolveRequest: MessageFns$2<RegisterResolveRequest>;
 type Builtin$2 = Date | Function | Uint8Array | string | number | boolean | undefined;
 type DeepPartial$2<T> = T extends Builtin$2 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$2<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$2<U>> : T extends {} ? { [K in keyof T]?: DeepPartial$2<T[K]> } : Partial<T>;
 type KeysOfUnion$2<T> = T extends T ? keyof T : never;
@@ -316,10 +325,12 @@ interface MessageFns$1<T> {
 //#region src/LocalResolver.d.ts
 interface LocalResolver {
   resolveProcess(request: ResolveProcessRequest): ResolveProcessResponse;
+  registerResolve(request: RegisterResolveRequest): void;
   setResolverState(request: SetResolverStateRequest): void;
   flushLogs(): Uint8Array;
   flushAssigned(): Uint8Array;
   applyFlags(request: ApplyFlagsRequest): void;
+  prometheusSnapshot(instance: string): string;
 }
 //#endregion
 //#region src/proto/confidence/flags/resolver/v1/internal_api.d.ts
@@ -429,7 +440,7 @@ interface MaterializationStore {
 }
 //#endregion
 //#region src/types.d.ts
-type ResolutionReason = "ERROR" | "FLAG_ARCHIVED" | "MATCH" | "NO_SEGMENT_MATCH" | "TARGETING_KEY_ERROR" | "NO_TREATMENT_MATCH" | "UNSPECIFIED";
+type ResolutionReason = "ERROR" | "FLAG_ARCHIVED" | "MATCH" | "NO_SEGMENT_MATCH" | "TARGETING_KEY_ERROR" | "NO_TREATMENT_MATCH" | "MATERIALIZATION_NOT_SUPPORTED" | "UNSPECIFIED";
 declare enum ErrorCode {
   PROVIDER_NOT_READY = "PROVIDER_NOT_READY",
   PROVIDER_FATAL = "PROVIDER_FATAL",
@@ -462,6 +473,12 @@ interface FlagBundle {
 //#endregion
 //#region src/ConfidenceServerProviderLocal.d.ts
 type FlagBundle$1 = FlagBundle;
+/**
+* Configuration for {@link ConfidenceServerProviderLocal.getPrometheusMetrics}.
+*
+* @experimental This API is subject to change.
+*/
+interface SnapshotConfig {}
 interface ProviderOptions {
   flagClientSecret: string;
   initializeTimeout?: number;
@@ -513,6 +530,12 @@ declare class ConfidenceServerProviderLocal implements Provider {
   /** Resolves with an evaluation of a String flag */
   resolveStringEvaluation(flagKey: string, defaultValue: string, context: EvaluationContext): Promise<ResolutionDetails<string>>;
   /**
+  * Returns a Prometheus metrics snapshot from the WASM resolver.
+  *
+  * @experimental This API is subject to change.
+  */
+  getPrometheusMetrics(_request?: SnapshotConfig): string;
+  /**
   * Applies a previously resolved flag, logging that it was used/exposed.
   * Call this when a flag value is actually rendered or used in the client.
   * @param resolveToken - Base64-encoded resolve token from the flag bundle
@@ -530,4 +553,4 @@ declare function createConfidenceServerProvider({
   ...options
 }: ProviderOptionsExt): ConfidenceServerProviderLocal;
 //#endregion
-export { type MaterializationStore, ProviderOptionsExt, createConfidenceServerProvider };
+export { type MaterializationStore, ProviderOptionsExt, type SnapshotConfig, createConfidenceServerProvider };

package/dist/index.node.js

@@ -777,6 +777,8 @@ let ResolveReason = /* @__PURE__ */ function(ResolveReason$1) {
 	ResolveReason$1[ResolveReason$1["RESOLVE_REASON_ERROR"] = 6] = "RESOLVE_REASON_ERROR";
 	ResolveReason$1[ResolveReason$1["RESOLVE_REASON_UNRECOGNIZED_TARGETING_RULE"] = 7] = "RESOLVE_REASON_UNRECOGNIZED_TARGETING_RULE";
 	ResolveReason$1[ResolveReason$1["RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED"] = 8] = "RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED";
+	ResolveReason$1[ResolveReason$1["RESOLVE_REASON_TYPE_MISMATCH"] = 9] = "RESOLVE_REASON_TYPE_MISMATCH";
+	ResolveReason$1[ResolveReason$1["RESOLVE_REASON_FLAG_NOT_FOUND"] = 10] = "RESOLVE_REASON_FLAG_NOT_FOUND";
 	ResolveReason$1[ResolveReason$1["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 	return ResolveReason$1;
 }({});
@@ -800,6 +802,10 @@ function resolveReasonFromJSON(object) {
 		case "RESOLVE_REASON_UNRECOGNIZED_TARGETING_RULE": return ResolveReason.RESOLVE_REASON_UNRECOGNIZED_TARGETING_RULE;
 		case 8:
 		case "RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED": return ResolveReason.RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED;
+		case 9:
+		case "RESOLVE_REASON_TYPE_MISMATCH": return ResolveReason.RESOLVE_REASON_TYPE_MISMATCH;
+		case 10:
+		case "RESOLVE_REASON_FLAG_NOT_FOUND": return ResolveReason.RESOLVE_REASON_FLAG_NOT_FOUND;
 		case -1:
 		case "UNRECOGNIZED":
 		default: return ResolveReason.UNRECOGNIZED;
@@ -816,6 +822,8 @@ function resolveReasonToJSON(object) {
 		case ResolveReason.RESOLVE_REASON_ERROR: return "RESOLVE_REASON_ERROR";
 		case ResolveReason.RESOLVE_REASON_UNRECOGNIZED_TARGETING_RULE: return "RESOLVE_REASON_UNRECOGNIZED_TARGETING_RULE";
 		case ResolveReason.RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED: return "RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED";
+		case ResolveReason.RESOLVE_REASON_TYPE_MISMATCH: return "RESOLVE_REASON_TYPE_MISMATCH";
+		case ResolveReason.RESOLVE_REASON_FLAG_NOT_FOUND: return "RESOLVE_REASON_FLAG_NOT_FOUND";
 		case ResolveReason.UNRECOGNIZED:
 		default: return "UNRECOGNIZED";
 	}
@@ -1413,7 +1421,7 @@ function isObject(value) {
 function isSet$3(value) {
 	return value !== null && value !== void 0;
 }
-const VERSION = "0.10.1";
+const VERSION = "0.11.0";
 const NOOP_LOG_FN = Object.assign(() => {}, { enabled: false });
 const debugBackend = loadDebug();
 const logger$2 = new class LoggerImpl {
@@ -2553,6 +2561,90 @@ const Response$1 = {
 		return message;
 	}
 };
+function createBasePrometheusSnapshotRequest() {
+	return { instance: "" };
+}
+const PrometheusSnapshotRequest = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.instance !== "") writer.uint32(10).string(message.instance);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBasePrometheusSnapshotRequest();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.instance = reader.string();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return { instance: isSet$1(object.instance) ? globalThis.String(object.instance) : "" };
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.instance !== "") obj.instance = message.instance;
+		return obj;
+	},
+	create(base) {
+		return PrometheusSnapshotRequest.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBasePrometheusSnapshotRequest();
+		message.instance = object.instance ?? "";
+		return message;
+	}
+};
+function createBasePrometheusSnapshotResponse() {
+	return { text: "" };
+}
+const PrometheusSnapshotResponse = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.text !== "") writer.uint32(10).string(message.text);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBasePrometheusSnapshotResponse();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.text = reader.string();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return { text: isSet$1(object.text) ? globalThis.String(object.text) : "" };
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.text !== "") obj.text = message.text;
+		return obj;
+	},
+	create(base) {
+		return PrometheusSnapshotResponse.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBasePrometheusSnapshotResponse();
+		message.text = object.text ?? "";
+		return message;
+	}
+};
 function bytesFromBase64$2(b64) {
 	if (globalThis.Buffer) return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
 	else {
@@ -2632,6 +2724,16 @@ function resolve(bundle, flagKey, defaultValue, logger$4) {
 			shouldApply: false
 		};
 	}
+	if (flag.reason === "MATERIALIZATION_NOT_SUPPORTED") {
+		logger$4?.warn("Flag '%s' requires materializations but no materialization store is configured. Pass a MaterializationStore implementation or: 'CONFIDENCE_REMOTE_STORE' to createConfidenceServerProvider()", flagName);
+		return {
+			reason: "ERROR",
+			errorCode: ErrorCode.GENERAL,
+			errorMessage: `Flag '${flagName}' requires materializations. Configure a materialization store.`,
+			value: defaultValue,
+			shouldApply: false
+		};
+	}
 	let value = flag.value;
 	for (let i = 0; i < path.length; i++) {
 		if (value === null || typeof value !== "object" || Array.isArray(value)) return {
@@ -2685,6 +2787,7 @@ function convertReason(reason) {
 		case ResolveReason.RESOLVE_REASON_TARGETING_KEY_ERROR: return "TARGETING_KEY_ERROR";
 		case ResolveReason.RESOLVE_REASON_NO_TREATMENT_MATCH: return "NO_TREATMENT_MATCH";
 		case ResolveReason.RESOLVE_REASON_UNRECOGNIZED_TARGETING_RULE: return "ERROR";
+		case ResolveReason.RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED: return "MATERIALIZATION_NOT_SUPPORTED";
 		default: return "UNSPECIFIED";
 	}
 }
@@ -2780,10 +2883,28 @@ var ConfidenceServerProviderLocal = class ConfidenceServerProviderLocal {
 		}
 	}
 	async evaluate(flagKey, defaultValue, context) {
+		const startMs = performance.now();
 		try {
 			const [flagName] = flagKey.split(".", 1);
 			const resolution = await this.resolve(context, [flagName], true);
-			return resolve(resolution, flagKey, defaultValue, logger$1);
+			const result = resolve(resolution, flagKey, defaultValue, logger$1);
+			const latencyUs = Math.round((performance.now() - startMs) * 1e3);
+			let reason;
+			if (resolution.errorCode) reason = ResolveReason.RESOLVE_REASON_ERROR;
+			else {
+				const [flagNameForTelemetry] = flagKey.split(".", 1);
+				if (resolution.flags[flagNameForTelemetry]?.reason === "MATERIALIZATION_NOT_SUPPORTED") reason = ResolveReason.RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED;
+				else if (result.errorCode === ErrorCode.FLAG_NOT_FOUND) reason = ResolveReason.RESOLVE_REASON_FLAG_NOT_FOUND;
+				else if (result.errorCode === ErrorCode.TYPE_MISMATCH) reason = ResolveReason.RESOLVE_REASON_TYPE_MISMATCH;
+				else reason = reasonStringToEnum(result.reason);
+			}
+			try {
+				this.resolver.registerResolve({
+					reason,
+					latencyUs
+				});
+			} catch {}
+			return result;
 		} finally {
 			this.flushAssigned();
 		}
@@ -2890,6 +3011,9 @@ var ConfidenceServerProviderLocal = class ConfidenceServerProviderLocal {
 	resolveStringEvaluation(flagKey, defaultValue, context) {
 		return Promise.resolve(this.evaluate(flagKey, defaultValue, context));
 	}
+	getPrometheusMetrics(_request) {
+		return this.resolver.prometheusSnapshot("0");
+	}
 	applyFlag(resolveToken, flagName) {
 		const request = {
 			flags: [{
@@ -2907,6 +3031,17 @@ var ConfidenceServerProviderLocal = class ConfidenceServerProviderLocal {
 		this.resolver.applyFlags(request);
 	}
 };
+function reasonStringToEnum(reason) {
+	switch (reason) {
+		case "MATCH": return ResolveReason.RESOLVE_REASON_MATCH;
+		case "NO_SEGMENT_MATCH": return ResolveReason.RESOLVE_REASON_NO_SEGMENT_MATCH;
+		case "NO_TREATMENT_MATCH": return ResolveReason.RESOLVE_REASON_NO_TREATMENT_MATCH;
+		case "FLAG_ARCHIVED": return ResolveReason.RESOLVE_REASON_FLAG_ARCHIVED;
+		case "TARGETING_KEY_ERROR": return ResolveReason.RESOLVE_REASON_TARGETING_KEY_ERROR;
+		case "ERROR": return ResolveReason.RESOLVE_REASON_ERROR;
+		default: return ResolveReason.RESOLVE_REASON_UNSPECIFIED;
+	}
+}
 function createBaseResolveProcessRequest() {
 	return {
 		deferredMaterializations: void 0,
@@ -3328,6 +3463,61 @@ const MaterializationRecord = {
 		return message;
 	}
 };
+function createBaseRegisterResolveRequest() {
+	return {
+		reason: 0,
+		latencyUs: 0
+	};
+}
+const RegisterResolveRequest = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.reason !== 0) writer.uint32(8).int32(message.reason);
+		if (message.latencyUs !== 0) writer.uint32(16).uint32(message.latencyUs);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseRegisterResolveRequest();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 8) break;
+					message.reason = reader.int32();
+					continue;
+				case 2:
+					if (tag !== 16) break;
+					message.latencyUs = reader.uint32();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			reason: isSet(object.reason) ? resolveReasonFromJSON(object.reason) : 0,
+			latencyUs: isSet(object.latencyUs) ? globalThis.Number(object.latencyUs) : 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.reason !== 0) obj.reason = resolveReasonToJSON(message.reason);
+		if (message.latencyUs !== 0) obj.latencyUs = Math.round(message.latencyUs);
+		return obj;
+	},
+	create(base) {
+		return RegisterResolveRequest.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseRegisterResolveRequest();
+		message.reason = object.reason ?? 0;
+		message.latencyUs = object.latencyUs ?? 0;
+		return message;
+	}
+};
 function bytesFromBase64(b64) {
 	if (globalThis.Buffer) return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
 	else {
@@ -3355,10 +3545,12 @@ const EXPORT_FN_NAMES = [
 	"wasm_msg_alloc",
 	"wasm_msg_free",
 	"wasm_msg_guest_resolve_flags",
+	"wasm_msg_guest_register_resolve",
 	"wasm_msg_guest_set_resolver_state",
 	"wasm_msg_guest_bounded_flush_logs",
 	"wasm_msg_guest_bounded_flush_assign",
-	"wasm_msg_guest_apply_flags"
+	"wasm_msg_guest_apply_flags",
+	"wasm_msg_guest_prometheus_snapshot"
 ];
 function verifyExports(exports) {
 	for (const fnName of EXPORT_FN_NAMES) if (typeof exports[fnName] !== "function") throw new Error(`Expected Function export "${fnName}" found ${exports[fnName]}`);
@@ -3385,6 +3577,11 @@ var UnsafeWasmResolver = class {
 		const resPtr = this.exports.wasm_msg_guest_resolve_flags(reqPtr);
 		return this.consumeResponse(resPtr, ResolveProcessResponse);
 	}
+	registerResolve(request) {
+		const reqPtr = this.transferRequest(request, RegisterResolveRequest);
+		const resPtr = this.exports.wasm_msg_guest_register_resolve(reqPtr);
+		this.consumeResponse(resPtr, Void);
+	}
 	setResolverState(request) {
 		const reqPtr = this.transferRequest(request, SetResolverStateRequest);
 		const resPtr = this.exports.wasm_msg_guest_set_resolver_state(reqPtr);
@@ -3407,6 +3604,11 @@ var UnsafeWasmResolver = class {
 		const resPtr = this.exports.wasm_msg_guest_apply_flags(reqPtr);
 		this.consumeResponse(resPtr, Void);
 	}
+	prometheusSnapshot(instance) {
+		const reqPtr = this.transferRequest({ instance }, PrometheusSnapshotRequest);
+		const resPtr = this.exports.wasm_msg_guest_prometheus_snapshot(reqPtr);
+		return this.consumeResponse(resPtr, PrometheusSnapshotResponse).text;
+	}
 	transferRequest(value, codec) {
 		const data = codec.encode(value).finish();
 		return this.transfer({ data }, Request);
@@ -3464,6 +3666,11 @@ var WasmResolver = class {
 			throw error$1;
 		}
 	}
+	registerResolve(request) {
+		try {
+			this.delegate.registerResolve(request);
+		} catch {}
+	}
 	setResolverState(request) {
 		this.currentState = request;
 		try {
@@ -3501,6 +3708,14 @@ var WasmResolver = class {
 			throw error$1;
 		}
 	}
+	prometheusSnapshot(instance) {
+		try {
+			return this.delegate.prometheusSnapshot(instance);
+		} catch (error$1) {
+			logger.error("prometheus snapshot failed:", error$1);
+			return "";
+		}
+	}
 };
 let resolver = null;
 function createConfidenceServerProvider({ wasmPath,...options }) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spotify-confidence/openfeature-server-provider-local",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "Spotify Confidence Open Feature provider",
   "type": "module",
   "files": [