Skip to content
Draft
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -10,6 +10,9 @@
"~deprecated",
"~fractional-v1",
"~fractional-v2",
# the released testbed image has no "resolve" launchpad config, and its flagd
# does not support resolve yet
"~resolve",
]


Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -12,6 +12,9 @@
"~deprecated",
"~fractional-v1",
"~fractional-v2",
# the released testbed image has no "resolve" launchpad config, and its flagd
# does not support resolve yet
"~resolve",
]


Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -117,8 +117,7 @@ def resolve_details_empty_error_code(

@then(parsers.cfparse("the resolved metadata should contain"))
def metadata_contains(details: FlagEvaluationDetails[JsonPrimitive], datatable):
assert_equal(len(details.flag_metadata), len(datatable) - 1) # skip table header
for i in range(1, len(datatable)):
for i in range(1, len(datatable)): # skip table header
key, metadata_type, expected = datatable[i]
assert_equal(details.flag_metadata[key], type_cast[metadata_type](expected))

Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -33,6 +33,7 @@ class TestProviderType(Enum):
SSL = "ssl"
SOCKET = "socket"
METADATA = "metadata"
RESOLVE = "resolve"
SYNCPAYLOAD = "syncpayload"
FORBIDDEN = "forbidden"

Expand Down Expand Up @@ -79,6 +80,10 @@ def get_default_options_for_provider(
return options, wait
elif t == TestProviderType.METADATA:
launchpad = "metadata"
elif t == TestProviderType.RESOLVE and resolver_type != ResolverType.FILE:
# file mode reads the harness flag file directly, so it doesn't need the
# "resolve" launchpad config, which the released testbed image lacks
launchpad = "resolve"
elif t == TestProviderType.SYNCPAYLOAD:
launchpad = "sync-payload"

Expand Down
2 changes: 1 addition & 1 deletion tools/openfeature-flagd-core/README.md
Original file line number Diff line number Diff line change
@@ -1,6 +1,6 @@
# OpenFeature flagd Core

Reference implementation of the flagd evaluator -- flag parsing, targeting rules (JSON logic), and custom operators (fractional, sem_ver, starts_with, ends_with). Mirrors the Java `flagd-core` module.
Reference implementation of the flagd evaluator -- flag parsing, targeting rules (JSON logic), and custom operators (fractional, sem_ver, starts_with, ends_with, resolve). Mirrors the Java `flagd-core` module.

It is part of the [OpenFeature Python SDK contrib](https://github.com/open-feature/python-sdk-contrib) project.

Expand Down
Original file line number Diff line number Diff line change
@@ -1,4 +1,5 @@
import json
import logging
import threading
import typing
from collections.abc import Mapping, Sequence
Expand All @@ -15,9 +16,15 @@
from .model.flag import Flag
from .model.flag_store import FlagStore
from .targeting import targeting
from .targeting.custom_ops import ResolveResult

T = typing.TypeVar("T")

logger = logging.getLogger("openfeature.contrib")

# flag set metadata keys a resolve rule can't override; the schema only catches literal keys
RESERVED_METADATA_KEYS = frozenset({"flagSetId", "version"})

# Type map for each resolve method
_TYPE_MAP: dict[str, tuple[type | tuple[type, ...], str]] = {
"boolean": ((bool,), "bool"),
Expand All @@ -39,6 +46,36 @@ def _merge_metadata(
return metadata


def _merge_rule_metadata(
metadata: Mapping[str, float | int | str | bool],
rule_metadata: Mapping[str, float | int | str | bool],
) -> Mapping[str, float | int | str | bool]:
merged = dict(metadata)
for key, value in rule_metadata.items():
if key in RESERVED_METADATA_KEYS:
logger.debug(f"Ignoring reserved resolve metadata key {key}")
continue
merged[key] = value
return merged


def _targeting_match(
resolved: typing.Any, metadata: Mapping[str, float | int | str | bool]
) -> tuple[str, str, Mapping[str, float | int | str | bool]]:
"""Variant, reason and metadata of a non-null targeting result."""
if isinstance(resolved, ResolveResult):
reason = Reason.TARGETING_MATCH if resolved.reason is None else resolved.reason
return (
resolved.variant,
reason,
_merge_rule_metadata(metadata, resolved.metadata),
)
# convert to string to support shorthand
if isinstance(resolved, bool):
return str(resolved).lower(), Reason.TARGETING_MATCH, metadata
return str(resolved), Reason.TARGETING_MATCH, metadata


def _default_resolve(
flag: Flag,
default_value: T,
Expand Down Expand Up @@ -151,27 +188,21 @@ def _resolve(
return result

try:
variant = targeting(flag.key, flag.targeting, evaluation_context)
if variant is None:
result = _default_resolve(
flag, default_value, metadata, Reason.DEFAULT
)
self._check_type(result, flag_type)
return result

if isinstance(variant, bool):
variant = str(variant).lower()
elif not isinstance(variant, str):
variant = str(variant)

if variant not in flag.variants:
raise GeneralError(
f"Resolved variant {variant} not in variants config."
)

resolved = targeting(flag.key, flag.targeting, evaluation_context)
except ReferenceError as e:
raise ParseError(f"Invalid targeting {flag.targeting}") from e

if resolved is None:
result = _default_resolve(flag, default_value, metadata, Reason.DEFAULT)
self._check_type(result, flag_type)
return result

variant, reason, metadata = _targeting_match(resolved, metadata)
if variant not in flag.variants:
raise GeneralError(
f"Resolved variant {variant} not in variants config."
)

variant, value = flag.get_variant(variant)
if value is None:
raise GeneralError(
Expand All @@ -181,7 +212,7 @@ def _resolve(
result = FlagResolutionDetails(
value,
variant=variant,
reason=Reason.TARGETING_MATCH,
reason=reason,
flag_metadata=metadata,
)
self._check_type(result, flag_type)
Expand All @@ -195,11 +226,9 @@ def _check_type(
"""Validate the resolved value type matches the expected flag type."""
if flag_type is None:
return
# Skip type check when value is the caller's default (no variant resolved)
# This happens for DEFAULT reason with no variant, or DISABLED flags
if result.reason == Reason.DISABLED:
return
if result.reason == Reason.DEFAULT and result.variant is None:
# Skip type check when value is the caller's default (no variant resolved).
# Not by reason: a resolve rule may return any reason, DISABLED included.
if result.variant is None:
return

type_info = _TYPE_MAP.get(flag_type)
Expand Down
Original file line number Diff line number Diff line change
@@ -1,11 +1,13 @@
import logging
import math
import typing
from collections.abc import Sequence
from dataclasses import dataclass
from collections.abc import Mapping, Sequence
from dataclasses import dataclass, field

import cbor2
import mmh3
import semver
from json_logic.builtins import to_number

MAX_WEIGHT_SUM = 2_147_483_647 # MaxInt32

Expand All @@ -17,10 +19,25 @@

@dataclass
class Fraction:
variant: str | float | int | bool | None
# whatever the variant expression evaluated to, the resolver decides what to do with it
variant: typing.Any
weight: int = 1


@dataclass(frozen=True)
class ResolveResult:
"""Result of the terminal ``resolve`` operator.

No JSON input decodes to this type, so evaluation context data can't forge one.
"""

variant: str
# None keeps TARGETING_MATCH
reason: str | None = None
# merged over flag set and flag metadata
metadata: Mapping[str, str | bool | int | float] = field(default_factory=dict)


def _resolve_bucket_by(data: dict, args: tuple) -> tuple[typing.Any, tuple]:
if not isinstance(args[0], (list, tuple)):
return args[0], args[1:]
Expand Down Expand Up @@ -54,7 +71,7 @@ def normalize_numbers(data: typing.Any) -> typing.Any:
return data


def fractional(data: dict, *args: typing.Any) -> str | float | int | bool | None:
def fractional(data: dict, *args: typing.Any) -> typing.Any:
if not args:
logger.error("No arguments provided to fractional operator.")
return None
Expand Down Expand Up @@ -104,6 +121,24 @@ def fractional(data: dict, *args: typing.Any) -> str | float | int | bool | None
return None


def divide(
data: dict, a: typing.Any = None, b: typing.Any = None, *_: typing.Any
) -> float:
"""JsonLogic ``/`` that divides by zero like JavaScript, the JsonLogic reference.

The builtin raises ZeroDivisionError, which fails the whole evaluation; JavaScript,
and the Go and Java flagd cores, return Infinity or NaN.
"""
dividend: float = to_number(a)
divisor: float = to_number(b)
try:
return dividend / divisor
except ZeroDivisionError:
if dividend == 0 or math.isnan(dividend):
return math.nan
return math.copysign(math.inf, dividend) * math.copysign(1, divisor)


def _parse_fraction(arg: JsonLogicArg) -> Fraction:
if not isinstance(arg, (tuple, list)) or not arg or len(arg) > 2:
raise ValueError(
Expand Down Expand Up @@ -216,3 +251,70 @@ def normalize_version(arg: typing.Any) -> semver.Version:
version = numeric_part + ".0" * (2 - dot_count) + version[len(numeric_part) :]

return semver.Version.parse(version)


def resolve(data: dict, *args: typing.Any) -> ResolveResult | None:
"""Terminal ``resolve`` operator: ``["variant", "reason"?, [["key", value], ...]?]``.

Placement is enforced by the targeting schema. Malformed (computed) arguments return
None like the other custom operators, so the flag falls back to its default variant.
"""
if not 1 <= len(args) <= 3:
logger.debug("resolve takes 1 to 3 arguments")
return None

variant = _resolve_variant_key(args[0])
if variant is None:
logger.debug("resolve variant must be a string, boolean, or finite number")
return None

reason = args[1] if len(args) > 1 else None
if reason is not None and not isinstance(reason, str):
logger.debug("resolve reason must be a string or null")
return None

pairs = args[2] if len(args) > 2 else None
metadata = {} if pairs is None else _resolve_metadata(pairs)
if metadata is None:
return None

return ResolveResult(variant, reason, metadata)


def _resolve_variant_key(value: typing.Any) -> str | None:
# coerce like a plain targeting result
if isinstance(value, bool):
return str(value).lower()
if isinstance(value, str):
return value
if isinstance(value, int) or (isinstance(value, float) and math.isfinite(value)):
return str(value)
return None


def _resolve_metadata(
pairs: typing.Any,
) -> dict[str, str | bool | int | float] | None:
if not isinstance(pairs, (list, tuple)):
logger.debug("resolve metadata must be an array of [key, value] pairs")
return None
metadata: dict[str, str | bool | int | float] = {}
for pair in pairs:
if (
not isinstance(pair, (list, tuple))
or len(pair) != 2
or not isinstance(pair[0], str)
):
logger.debug("resolve metadata pair must be a [string, value] array")
return None
key, value = pair
# NaN and Infinity (e.g. a computed 1/0) can't be encoded as JSON
if not isinstance(value, (str, bool, int)) and not (
isinstance(value, float) and math.isfinite(value)
):
logger.debug(
"resolve metadata value must be a string, finite number, or boolean"
)
return None
metadata[key] = value
return metadata
Original file line number Diff line number Diff line change
Expand Up @@ -10,18 +10,22 @@
from openfeature.exception import ParseError

from .custom_ops import (
divide,
ends_with,
fractional,
resolve,
sem_ver,
starts_with,
)

OPERATORS = {
**builtins.BUILTINS,
"/": divide,
"fractional": fractional,
"starts_with": starts_with,
"ends_with": ends_with,
"sem_ver": sem_ver,
"resolve": resolve,
}


Expand Down
Loading
Loading