docs: add specification for in-process flagd provider implementations

docs/other_resources/in-process-providers/evaluators/fractional_evaluation.md

@@ -0,0 +1,192 @@
+# Fractional Evaluation
+
+This evaluator allows to split the returned variants of a feature flag into different buckets,
+where each bucket can be assigned a percentage, representing how many requests will resolve to the corresponding
+variant. The sum of all weights must be 100, and the distribution must be performed by using the value of a referenced
+from the evaluation context to hash that value and map it to a value between [0, 100]. It is important to note
+that evaluations MUST be sticky, meaning that flag resolution requests containing the same value for the
+referenced property in their context MUST always resolve to the same variant. For calculating the hash value of the
+referenced evaluation context property, the [MurmurHash3](https://github.com/aappleby/smhasher/blob/master/src/MurmurHash3.cpp)
+hash function should be used. This is to ensure that flag resolution requests yield the same result,
+regardless of which implementation of the in-process flagd provider is being used.
+
+array containing at least two items, with the first item being an optional [json logic variable declaration](https://jsonlogic.com/operations.html#var)
+specifying the target property to base the distribution of values on. If not supplied, a concatination of the
+`flagKey` and `targetingKey` are used: `{"cat": [{"var":"$flagd.flag_key"}, {"var":"user.email"}]}`.
+The remaining items are `arrays`, each with two values, with the first being `string` item representing the name of the variant, and the
+second being a `float` item representing the percentage for that variant. The percentages of all items must add up to
+100.0, otherwise unexpected behavior can occur during the evaluation. The `data` object can be an arbitrary
+JSON object. Below is an example for a targetingRule containing a `fractionalEvaluation`:
+
+```json
+{
+ "flags": {
+ "headerColor": {
+ "variants": {
+ "red": "#FF0000",
+ "blue": "#0000FF",
+ "green": "#00FF00"
+ },
+ "defaultVariant": "red",
+ "state": "ENABLED",
+ "targeting": {
+ "fractionalEvaluation": [
+ {"var":"email"},
+ [
+ "red",
+ 50
+ ],
+ [
+ "blue",
+ 20
+ ],
+ [
+ "green",
+ 30
+ ]
+ ]
+ }
+ }
+ }
+}
+```
+
+Please note that the implementation of this evaluator can assume that instead of `{"var": "email"}`, it will receive
+the resolved value of that referenced property, as resolving the value will be taken care of by JsonLogic before
+applying the evaluator.
+
+The following flow chart depicts the logic of this evaluator:
+
+```mermaid
+flowchart TD
+A[Parse targetingRule] --> B{Is an array containing at least two items?};
+B -- Yes --> C{Is targetingRule at index 0 a string?};
+B -- No --> D[Return nil];
+C -- Yes --> E[targetPropertyValue := targetingRule at index 0];
+C -- No --> D;
+E -- Yes --> F[Iterate through the remaining elements of the targetingRule array and parse the variants and their percentages];
+F --> G{Parsing successful?};
+G -- No --> D;
+G -- Yes --> H{Does percentage of variants add up to 100?};
+H -- No --> D;
+H -- Yes --> I[hash := murmur3Hash of targetPropertyValue divided by Int64.MaxValue]
+I --> L[Iterate through the variant and increment the threshold by the percentage of each variant. Return the first variant where the bucket is smaller than the threshold.]
+```
+
+As a reference, below is a simplified version of the actual implementation of this evaluator in Go.
+
+```go
+
+type fractionalEvaluationDistribution struct {
+ variant string
+ percentage int
+}
+
+/*
+ values: contains the targeting rule object; e.g.:
+ [
+ {"var":"email"},
+ [
+ "red",
+ 50
+ ],
+ [
+ "blue",
+ 20
+ ],
+ [
+ "green",
+ 30
+ ]
+ ]
+
+ data: contains the evaluation context; e.g.:
+ {
+ "email": "test@faas.com"
+ }
+*/ 
+func FractionalEvaluation(values, data interface{}) interface{} {
+ // 1. Check if the values object contains at least two elements:
+ valuesArray, ok := values.([]interface{})
+ if !ok {
+ log.Error("fractional evaluation data is not an array")
+ return nil
+ }
+ if len(valuesArray) < 2 {
+ log.Error("fractional evaluation data has length under 2")
+ return nil
+ }
+
+ // 2. Get the target property value used for bucketing the values
+ valueToDistribute, ok := valuesArray[0].(string)
+ if !ok {
+ log.Error("first element of fractional evaluation data isn't of type string")
+ return nil
+ }
+
+ // 3. Parse the fractionalEvaluation values distribution
+ sumOfPercentages := 0
+ var feDistributions []fractionalEvaluationDistribution
+
+ // start at index 1, as the first item of the values array is the target property
+ for i := 1; i < len(valuesArray); i++ {
+ distributionArray, ok := values[i].([]interface{})
+ if !ok {
+ log.Error("distribution elements aren't of type []interface{}")
+ return nil
+ }
+
+ if len(distributionArray) != 2 {
+ log.Error("distribution element isn't length 2")
+ return nil
+ }
+
+ variant, ok := distributionArray[0].(string)
+ if !ok {
+ log.Error("first element of distribution element isn't a string")
+ return nil
+ }
+
+ percentage, ok := distributionArray[1].(float64)
+ if !ok {
+ log.Error("second element of distribution element isn't float")
+ return nil
+ }
+
+ sumOfPercentages += int(percentage)
+
+ feDistributions = append(feDistributions, fractionalEvaluationDistribution{
+ variant: variant,
+ percentage: int(percentage),
+ })
+ }
+
+ // check if the sum of percentages adds up to 100, otherwise log an error
+ if sumOfPercentages != 100 {
+ log.Error("percentages must sum to 100, got: %d", sumOfPercentages)
+ return nil
+ }
+
+ // 4. Calculate the hash of the target property and map it to a number between [0, 99]
+ hashValue := murmur3.HashString(value)
+
+ // divide the hash value by the largest possible value, integer 2^64
+ hashRatio := float64(hashValue) / math.Pow(2, 64)
+
+ // integer in range [0, 99]
+ bucket := int(hashRatio * 100)
+
+ // 5. Iterate through the variant and increment the threshold by the percentage of each variant.
+ // return the first variant where the bucket is smaller than the threshold. 
+ rangeEnd := 0
+ for _, dist := range feDistribution {
+ rangeEnd += dist.percentage
+ if bucket < rangeEnd {
+ // return the matching variant
+ return dist.variant
+ }
+ }
+
+ return ""
+}
+```

docs/other_resources/in-process-providers/evaluators/semver_evaluation.md

@@ -0,0 +1,45 @@
+# Semantic Versioning Evaluation
+
+This evaluator checks if the given property within the evaluation context matches a semantic versioning condition.
+It returns 'true', if the value of the given property meets the condition, 'false' if not.
+
+The implementation of this evaluator should accept the object containing the `sem_ver` evaluator
+configuration, and a `data` object containing the evaluation context.
+The 'sem_ver' evaluation rule contains exactly three items:
+
+1. Target property value: the resolved value of the target property referenced in the targeting rule
+2. Operator: One of the following: `=`, `!=`, `>`, `<`, `>=`, `<=`, `~` (match minor version), `^` (match major version)
+3. Target value: this needs to resolve to a semantic versioning string. If this condition is not met, the evaluator should
+log an appropriate error message and return `nil`
+
+The `sem_ver` evaluation returns a boolean, indicating whether the condition has been met.
+
+```js
+{
+ "if": [
+ {
+ "sem_ver": [{"var": "version"}, ">=", "1.0.0"]
+ },
+ "red", null
+ ]
+}
+```
+
+Please note that the implementation of this evaluator can assume that instead of `{"var": "version"}`, it will receive
+the resolved value of that referenced property, as resolving the value will be taken care of by JsonLogic before
+applying the evaluator.
+
+The following flow chart depicts the logic of this evaluator:
+
+```mermaid
+flowchart TD
+A[Parse targetingRule] --> B{Is an array containing exactly three items?};
+B -- Yes --> C{Is targetingRule at index 0 a semantic version string?};
+B -- No --> D[Return nil];
+C -- Yes --> E{Is targetingRule at index 1 a supported operator?};
+C -- No --> D;
+E -- Yes --> F{Is targetingRule at index 2 a semantic version string?};
+E -- No --> D;
+F -- No --> D;
+F --> G[Compare the two versions using the operator and return a boolean value indicating if they match];
+```

docs/other_resources/in-process-providers/evaluators/string_comparison_evaluation.md

@@ -0,0 +1,40 @@
+# StartsWith/EndsWith evaluation
+
+This evaluator selects a variant based on whether the specified property within the evaluation context
+starts/ends with a certain string.
+
+The implementation of this evaluator should accept the object containing the `starts_with` or `ends_with` evaluator
+configuration, and a `data` object containing the evaluation context.
+The `starts_with`/`ends_with` evaluation rule contains exactly two items:
+
+1. The resolved string value from the evaluation context
+2. The target string value
+
+The `starts_with`/`ends_with` evaluation returns a boolean, indicating whether the condition has been met.
+
+```js
+// starts_with property name used in a targeting rule
+"starts_with": [
+ // Evaluation context property the be evaluated
+ {"var": "email"},
+ // prefix that has to be present in the value of the referenced property 
+ "user@faas"
+]
+```
+
+Please note that the implementation of this evaluator can assume that instead of `{"var": "email"}`, it will receive
+the resolved value of that referenced property, as resolving the value will be taken care of by JsonLogic before
+applying the evaluator.
+
+The following flow chart depicts the logic of this evaluator:
+
+```mermaid
+flowchart TD
+A[Parse targetingRule] --> B{Is an array containing exactly two items?};
+B -- Yes --> C{Is targetingRule at index 0 a string?};
+B -- No --> D[Return nil];
+C -- Yes --> E{Is targetingRule at index 1 a string?};
+C -- No --> D;
+E -- No --> D;
+E --> F[Return a boolean value indicating if the first string starts/ends with the second string];
+```