chore: fix CODEOWNERS

Signed-off-by: Todd Baert <todd.baert@dynatrace.com>

.github/workflows/build.yaml

@@ -15,9 +15,6 @@ on:
       - "README.md"
       - "docs/**"
 
-env:
-  GO_VERSION: '1.20'
-
 jobs:
   lint:
     runs-on: ubuntu-latest
@@ -28,9 +25,9 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4
       - name: Setup go
-        uses: actions/setup-go@93397bea11091df50f3d7e59dc26a7711a8bcfbe # v4
+        uses: actions/setup-go@0c52d547c9bc32b1aa3301fd7a9cb496313a4491 # v5
         with:
-          go-version: ${{ env.GO_VERSION }}
+          go-version-file: 'flagd/go.mod'
       - run: make workspace-init
       - run: make lint
 
@@ -40,9 +37,9 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4
       - name: Setup go
-        uses: actions/setup-go@93397bea11091df50f3d7e59dc26a7711a8bcfbe # v4
+        uses: actions/setup-go@0c52d547c9bc32b1aa3301fd7a9cb496313a4491 # v5
         with:
-          go-version: ${{ env.GO_VERSION }}
+          go-version-file: 'flagd/go.mod'
       - run: make workspace-init
       - run: make generate-docs
       - name: Check no diff
@@ -58,13 +55,13 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4
       - name: Setup go
-        uses: actions/setup-go@93397bea11091df50f3d7e59dc26a7711a8bcfbe # v4
+        uses: actions/setup-go@0c52d547c9bc32b1aa3301fd7a9cb496313a4491 # v5
         with:
-          go-version: ${{ env.GO_VERSION }}
+          go-version-file: 'flagd/go.mod'
       - run: make workspace-init
       - run: make test
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@eaaf4bedf32dbdc6b720b63067d99c4d77d6047d # v3
+        uses: codecov/codecov-action@e0b68c6749509c5f83f984dd99a76a1c1a231044 # v4
 
   docker-local:
     runs-on: ubuntu-latest
@@ -76,9 +73,9 @@ jobs:
           submodules: recursive
 
       - name: Setup go
-        uses: actions/setup-go@93397bea11091df50f3d7e59dc26a7711a8bcfbe # v4
+        uses: actions/setup-go@0c52d547c9bc32b1aa3301fd7a9cb496313a4491 # v5
         with:
-          go-version: ${{ env.GO_VERSION }}
+          go-version-file: 'flagd/go.mod'
 
       - name: Set up QEMU
         uses: docker/setup-qemu-action@master
@@ -98,16 +95,18 @@ jobs:
           tags: flagd-local:test
 
       - name: Run Trivy vulnerability scanner
-        uses: aquasecurity/trivy-action@master
+        uses: aquasecurity/trivy-action@0.28.0
         with:
-          input: /github/workspace/flagd-local.tar
-          format: "template"
-          template: "@/contrib/sarif.tpl"
+          input: ${{ github.workspace }}/flagd-local.tar
+          format: "sarif"
           output: "trivy-results.sarif"
           severity: "CRITICAL,HIGH"
+        env:
+          # use an alternative trivvy db to avoid rate limits
+          TRIVY_DB_REPOSITORY: public.ecr.aws/aquasecurity/trivy-db:2,ghcr.io/aquasecurity/trivy-db:2
 
       - name: Upload Trivy scan results to GitHub Security tab
-        uses: github/codeql-action/upload-sarif@407ffafae6a767df3e0230c3df91b6443ae8df75 # v2
+        uses: github/codeql-action/upload-sarif@e8893c57a1f3a2b659b6b55564fdfdbbd2982911 # v3
         with:
           sarif_file: "trivy-results.sarif"
 
@@ -121,9 +120,17 @@ jobs:
           submodules: recursive
 
       - name: Setup go
-        uses: actions/setup-go@93397bea11091df50f3d7e59dc26a7711a8bcfbe # v4
+        uses: actions/setup-go@0c52d547c9bc32b1aa3301fd7a9cb496313a4491 # v5
         with:
-          go-version: ${{ env.GO_VERSION }}
+          go-version-file: 'flagd/go.mod'
+
+      - name: Install envoy
+        run: |
+          wget -O- https://apt.envoyproxy.io/signing.key | sudo gpg --dearmor -o /etc/apt/keyrings/envoy-keyring.gpg
+          echo "deb [signed-by=/etc/apt/keyrings/envoy-keyring.gpg] https://apt.envoyproxy.io jammy main" | sudo tee /etc/apt/sources.list.d/envoy.list
+          sudo apt-get update
+          sudo apt-get install envoy
+          envoy --version
 
       - name: Workspace init
         run: make workspace-init
@@ -137,7 +144,12 @@ jobs:
           -f file:${{ github.workspace }}/test-harness/flags/testing-flags.json \
           -f file:${{ github.workspace }}/test-harness/flags/custom-ops.json \
           -f file:${{ github.workspace }}/test-harness/flags/evaluator-refs.json \
-          -f file:${{ github.workspace }}/test-harness/flags/zero-flags.json &
+          -f file:${{ github.workspace }}/test-harness/flags/zero-flags.json \
+          -f file:${{ github.workspace }}/test-harness/flags/edge-case-flags.json &
+
+      - name: Run envoy proxy in background
+        run: |
+          envoy -c ./test/integration/config/envoy.yaml &
 
       - name: Run evaluation test suite
         run: go clean -testcache && go test -cover ./test/integration

.github/workflows/dev-benches-page.yml

@@ -35,9 +35,9 @@ jobs:
       - name: Setup Pages
         uses: actions/configure-pages@1f0c5cde4bc74cd7e1254d0cb4de8d49e9068c7d # v4
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@a753861a5debcf57bf8b404356158c8e1e33150c # v2
+        uses: actions/upload-pages-artifact@0252fc4ba7626f0298f0cf00902a25c6afc77fa8 # v3
         with:
           path: './dev/bench'
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@77d7344265e1f960dab5c00dbff52287a70b0d4f # v3
+        uses: actions/deploy-pages@87c3283f01cd6fe19a0ab93a23b2f6fcba5a8e42 # v4

.github/workflows/lint-pr.yaml

@@ -12,12 +12,12 @@ jobs:
     name: Validate PR title
     runs-on: ubuntu-latest
     steps:
-      - uses: amannn/action-semantic-pull-request@c3cd5d1ea3580753008872425915e343e351ab54 # v5
+      - uses: amannn/action-semantic-pull-request@e9fabac35e210fea40ca5b14c0da95a099eff26f # v5
         id: lint_pr_title
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-      - uses: marocchino/sticky-pull-request-comment@efaaab3fd41a9c3de579aba759d2552635e590fd # v2
+      - uses: marocchino/sticky-pull-request-comment@331f8f5b4215f0445d3c07b4967662a32a2d3e31 # v2
         # When the previous steps fails, the workflow would stop. By adding this
         # condition you can continue the execution with the populated error message.
         if: always() && (steps.lint_pr_title.outputs.error_message != null)
@@ -34,7 +34,7 @@ jobs:
             ```
       # Delete a previous comment when the issue has been resolved
       - if: ${{ steps.lint_pr_title.outputs.error_message == null }}
-        uses: marocchino/sticky-pull-request-comment@efaaab3fd41a9c3de579aba759d2552635e590fd # v2
+        uses: marocchino/sticky-pull-request-comment@331f8f5b4215f0445d3c07b4967662a32a2d3e31 # v2
         with:   
           header: pr-title-lint-error
           delete: true

.github/workflows/publish-benchmark.yaml

@@ -1,41 +0,0 @@
-name: "Trigger Site Rebuild on a CRON Schedule"
-
-on:
-  schedule:
-    # runs at 02:00 every day, UTC
-    - cron: "0 2 * * *"
-
-env:
-  GO_VERSION: '1.20'
-
-jobs:
-  benchmark-publish:
-    name: Run Benchmark
-    if: github.repository == 'open-feature/flagd'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4
-
-      - name: Setup go
-        uses: actions/setup-go@93397bea11091df50f3d7e59dc26a7711a8bcfbe # v4
-        with:
-          go-version: ${{ env.GO_VERSION }}
-
-      - name: Workspace init
-        run: make workspace-init
-
-      - name: Run benchmark
-        run: set -o pipefail; go test -bench=Bench -short -benchtime=5s -benchmem ./core/... | tee output.txt
-
-      - name: Store benchmark result
-        uses: benchmark-action/github-action-benchmark@v1
-        with:
-          name: Go Benchmark
-          tool: "go"
-          output-file-path: output.txt
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          auto-push: true
-          # Show alert with commit comment on detecting possible performance regression
-          alert-threshold: "130%"
-          comment-on-alert: true
-          fail-on-alert: false

.github/workflows/release-please.yaml

@@ -8,7 +8,7 @@ env:
   PUBLISHABLE_ITEMS: '["flagd","flagd-proxy"]'
   REGISTRY: ghcr.io
   REPO_OWNER: ${{ github.repository_owner }}
-  DEFAULT_GO_VERSION: '1.20'
+  DEFAULT_GO_VERSION: '~1.21'
   PUBLIC_KEY_FILE: publicKey.pub
   GOPRIVATE: buf.build/gen/go
 
@@ -22,12 +22,13 @@ jobs:
       - name: Get current date
         id: date
         run: echo "::set-output name=date::$(date +'%Y-%m-%d')"
-      - uses: google-github-actions/release-please-action@a6d1fd9854c8c40688a72f7e4b072a1e965860a0 # v4
+      - uses: google-github-actions/release-please-action@v3
         id: release
         with:
+          command: manifest
           token: ${{secrets.GITHUB_TOKEN}}
           default-branch: main
-
+          signoff: "OpenFeature Bot <109696520+openfeaturebot@users.noreply.github.com>"
       - name: Dump Release Please Output
         env:
           RELEASE_PLEASE_OUTPUT: ${{ toJson(steps.release.outputs) }}
@@ -62,6 +63,7 @@ jobs:
   container-release:
     name: Build and push containers to GHCR
     needs: release-please
+    environment: publish
     runs-on: ubuntu-latest
     if: ${{ needs.release-please.outputs.items_to_publish != '' && toJson(fromJson(needs.release-please.outputs.items_to_publish)) != '[]' }}
     strategy:
@@ -86,7 +88,7 @@ jobs:
 
       - name: Extract metadata (tags, labels) for Docker
         id: meta
-        uses: docker/metadata-action@31cebacef4805868f9ce9a0cb03ee36c32df2ac4
+        uses: docker/metadata-action@8e5442c4ef9f78752691e2d8f8d19755c6f78e81
         with:
           images: ${{ env.REGISTRY }}/${{ matrix.path }}
 
@@ -107,6 +109,8 @@ jobs:
           context: .
           file: ./${{ matrix.path }}/build.Dockerfile
           platforms: linux/amd64,linux/arm64
+          provenance: mode=max
+          sbom: true
           push: true
           tags: |
             ${{ env.REGISTRY }}/${{ env.REPO_OWNER }}/${{ matrix.path }}:latest
@@ -117,7 +121,7 @@ jobs:
             COMMIT=${{ github.sha }}
             DATE=${{ needs.release-please.outputs.date }}
       - name: Install Cosign
-        uses: sigstore/cosign-installer@1fc5bd396d372bee37d608f955b336615edf79c8
+        uses: sigstore/cosign-installer@e1523de7571e31dbe865fd2e80c5c7c23ae71eb4
 
       - name: Sign the image
         run: |
@@ -127,24 +131,12 @@ jobs:
           COSIGN_PRIVATE_KEY: ${{secrets.COSIGN_PRIVATE_KEY}}
           COSIGN_PASSWORD: ${{secrets.COSIGN_PASSWORD}}
 
-      - name: Generate image SBOM file name
-        id: image-sbom-file-gen
-        run: echo "IMG_SBOM_FILE=${{ format('{0}-{1}-sbom.spdx', matrix.path, env.VERSION) }}" >> $GITHUB_OUTPUT
-
-      - name: SBOM for latest image
-        uses: anchore/sbom-action@5ecf649a417b8ae17dc8383dc32d46c03f2312df # v0
-        with:
-          image: ${{ env.REGISTRY }}/${{ env.REPO_OWNER }}/${{ matrix.path }}:${{ env.VERSION }}
-          artifact-name: ${{ steps.image-sbom-file-gen.outputs.IMG_SBOM_FILE }}
-          output-file: ${{ steps.image-sbom-file-gen.outputs.IMG_SBOM_FILE }}
-
       - name: Bundle release assets
         uses: softprops/action-gh-release@de2c0eb89ae2a093876385947365aca7b0e5f844 # v1
         with:
           tag_name: ${{ env.TAG }}
           files: |
             ${{ env.PUBLIC_KEY_FILE }}
-            ${{ steps.image-sbom-file-gen.outputs.IMG_SBOM_FILE }}
 
   release-go-binaries:
     name: Create and publish binaries to GitHub
@@ -168,7 +160,7 @@ jobs:
         with:
           ref: ${{ env.TAG }}
       - name: Set up Go
-        uses: actions/setup-go@93397bea11091df50f3d7e59dc26a7711a8bcfbe # v4
+        uses: actions/setup-go@0c52d547c9bc32b1aa3301fd7a9cb496313a4491 # v5
         with:
           go-version: ${{ env.DEFAULT_GO_VERSION }}
       - name: Download cyclonedx-gomod
@@ -183,46 +175,33 @@ jobs:
           cd ${{ matrix.path }} && cyclonedx-gomod app > ../sbom.xml
       - name: build darwin arm64
         run: |
-          env GOOS=darwin GOARCH=arm64 go build ${{ env.BUILD_ARGS }} -o ./${{ matrix.path }}_darwin_arm64 ./${{ matrix.path }}/main.go
+          env CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build ${{ env.BUILD_ARGS }} -o ./${{ matrix.path }}_darwin_arm64 ./${{ matrix.path }}/main.go
           tar -cvzf ${{ matrix.path }}_${{ env.VERSION_NO_PREFIX }}_Darwin_arm64.tar.gz ./${{ matrix.path }}_darwin_arm64 ./LICENSE ./CHANGELOG.md ./README.md ./sbom.xml
       - name: build darwin x86_64
         run: |
-          env GOOS=darwin GOARCH=amd64 go build ${{ env.BUILD_ARGS }} -o ./${{ matrix.path }}_darwin_x86_64 ./${{ matrix.path }}/main.go
+          env CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 go build ${{ env.BUILD_ARGS }} -o ./${{ matrix.path }}_darwin_x86_64 ./${{ matrix.path }}/main.go
           tar -cvzf ${{ matrix.path }}_${{ env.VERSION_NO_PREFIX }}_Darwin_x86_64.tar.gz ./${{ matrix.path }}_darwin_x86_64 ./LICENSE ./CHANGELOG.md ./README.md ./sbom.xml
       - name: build linux arm64
         run: |
-          env GOOS=linux GOARCH=arm64 go build ${{ env.BUILD_ARGS }} -o ./${{ matrix.path }}_linux_arm64 ./${{ matrix.path }}/main.go
+          env CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build ${{ env.BUILD_ARGS }} -o ./${{ matrix.path }}_linux_arm64 ./${{ matrix.path }}/main.go
           tar -cvzf ${{ matrix.path }}_${{ env.VERSION_NO_PREFIX }}_Linux_arm64.tar.gz ./${{ matrix.path }}_linux_arm64 ./LICENSE ./CHANGELOG.md ./README.md ./sbom.xml
       - name: build linux x86_64
         run: |
-          env GOOS=linux GOARCH=amd64 go build ${{ env.BUILD_ARGS }} -o ./${{ matrix.path }}_linux_x86_64 ./${{ matrix.path }}/main.go
+          env CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build ${{ env.BUILD_ARGS }} -o ./${{ matrix.path }}_linux_x86_64 ./${{ matrix.path }}/main.go
           tar -cvzf ${{ matrix.path }}_${{ env.VERSION_NO_PREFIX }}_Linux_x86_64.tar.gz ./${{ matrix.path }}_linux_x86_64 ./LICENSE ./CHANGELOG.md ./README.md ./sbom.xml
       - name: build linux i386
         run: |
-          env GOOS=linux GOARCH=386 go build ${{ env.BUILD_ARGS }} -o ./${{ matrix.path }}_linux_i386 ./${{ matrix.path }}/main.go
+          env CGO_ENABLED=0 GOOS=linux GOARCH=386 go build ${{ env.BUILD_ARGS }} -o ./${{ matrix.path }}_linux_i386 ./${{ matrix.path }}/main.go
           tar -cvzf ${{ matrix.path }}_${{ env.VERSION_NO_PREFIX }}_Linux_i386.tar.gz ./${{ matrix.path }}_linux_i386 ./LICENSE ./CHANGELOG.md ./README.md ./sbom.xml
       # Windows artifacts use .zip archive
       - name: build windows x86_64
         run: |
-          env GOOS=windows GOARCH=amd64 go build ${{ env.BUILD_ARGS }} -o ./${{ matrix.path }}_windows_x86_64 ./${{ matrix.path }}/main.go
+          env CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build ${{ env.BUILD_ARGS }} -o ./${{ matrix.path }}_windows_x86_64 ./${{ matrix.path }}/main.go
           zip -r ${{ matrix.path }}_${{ env.VERSION_NO_PREFIX }}_Windows_x86_64.zip ./${{ matrix.path }}_windows_x86_64 ./LICENSE ./CHANGELOG.md ./README.md ./sbom.xml
       - name: build windows i386
         run: |
-          env GOOS=windows GOARCH=386 go build ${{ env.BUILD_ARGS }} -o ./${{ matrix.path }}_windows_i386 ./${{ matrix.path }}/main.go
+          env CGO_ENABLED=0 GOOS=windows GOARCH=386 go build ${{ env.BUILD_ARGS }} -o ./${{ matrix.path }}_windows_i386 ./${{ matrix.path }}/main.go
           zip -r ${{ matrix.path }}_${{ env.VERSION_NO_PREFIX }}_Windows_i386.zip ./${{ matrix.path }}_windows_i386 ./LICENSE ./CHANGELOG.md ./README.md ./sbom.xml
-      # Bundle licenses
-      - name: Install go-licenses
-        run: go install github.com/google/go-licenses@latest
-      - name: Build license extraction locations
-        id: license-files
-        run: |
-          echo "LICENSE_FOLDER=${{ format('{0}-third-party-license', matrix.path) }}" >> $GITHUB_OUTPUT
-          echo "LICENSE_ERROR_FILE=${{ format('{0}-license-errors.txt', matrix.path) }}" >> $GITHUB_OUTPUT
-      - name: Run go-licenses for module ${{ matrix.path }}
-        run: go-licenses save ./${{ matrix.path }} --save_path=./${{ steps.license-files.outputs.LICENSE_FOLDER }} --force --logtostderr=false 2> ./${{ steps.license-files.outputs.LICENSE_ERROR_FILE }}
-        continue-on-error: true # tool set stderr which can be ignored and referred through error artefact
-      - name: Bundle license extracts
-        run: tar czf ./${{ steps.license-files.outputs.LICENSE_FOLDER }}.tar.gz ./${{ steps.license-files.outputs.LICENSE_FOLDER }}
       # Bundle release artifacts
       - name: Bundle release assets
         uses: softprops/action-gh-release@de2c0eb89ae2a093876385947365aca7b0e5f844 # v1
@@ -232,7 +211,6 @@ jobs:
             ./sbom.xml
             ./*.tar.gz
             ./*.zip
-            ./${{ steps.license-files.outputs.LICENSE_ERROR_FILE }}
   homebrew:
     name: Bump homebrew-core formula
     needs: release-please

.gitignore

@@ -12,7 +12,15 @@ core-coverage.out
 go.work
 go.work.sum
 bin/
+node_modules/
+.venv
 
 # built documentation
 site
-.cache/
+.cache/
+
+# coverage results
+*coverage.out
+
+# benchmark results
+benchmark.txt

.gitmodules

@@ -6,4 +6,4 @@
 	url = https://github.com/open-feature/spec.git
 [submodule "schemas"]
 	path = schemas
-	url = https://github.com/open-feature/schemas.git
+	url = https://github.com/open-feature/flagd-schemas.git

.golangci.bck.yml

@@ -0,0 +1,30 @@
+run:
+  timeout: 3m
+linters-settings:
+  funlen:
+    statements: 50
+  golint:
+    min-confidence: 0.6
+  enable-all: true
+issues:
+  exclude:
+    - pkg/generated
+  exclude-rules:
+    - path: _test.go
+      linters:
+        - funlen
+        - maligned
+        - noctx
+        - scopelint
+        - bodyclose
+        - lll
+        - goconst
+        - gocognit
+        - gocyclo
+        - dupl
+        - staticcheck
+  exclude-dirs:
+    - (^|/)bin($|/)
+    - (^|/)examples($|/)
+    - (^|/)schemas($|/)
+    - (^|/)test-harness($|/)

.golangci.yml

@@ -1,67 +1,43 @@
-run:
-  skip-dirs:
-    - (^|/)bin($|/)
-    - (^|/)examples($|/)
-    - (^|/)schemas($|/)
-    - (^|/)test-harness($|/)
+version: "2"
 linters:
-  enable:
-    - asciicheck
-    - asasalint
-    - bidichk
-    - bodyclose
-    - contextcheck
-    - dogsled
-    - dupl
-    - dupword
-    - durationcheck
-    - errchkjson
-    - exhaustive
-    - funlen
-    - gci
-    - goconst
-    - gocritic
-    - gocyclo
-    - interfacebloat
-    - gosec
-    - lll
-    - misspell
-    - nakedret
-    - nilerr
-    - nilnil
-    - noctx
-    - nosprintfhostport
-    - prealloc
-    - promlinter
-    - revive
-    - rowserrcheck
-    - exportloopref
-    - stylecheck
-    - unconvert
-    - unparam
-    - whitespace
-    - wrapcheck
-    - gofumpt
-    - tenv
-linters-settings:
-  funlen:
-    statements: 50
-  golint:
-    min-confidence: 0.6
-issues:
-  exclude:
-    - pkg/generated
-  exclude-rules:
-    - path: _test.go
-      linters:
-        - funlen
-        - maligned
-        - noctx
-        - scopelint
-        - bodyclose
-        - lll
-        - goconst
-        - gocognit
-        - gocyclo
-        - dupl
-        - staticcheck
+  settings:
+    funlen:
+      statements: 50
+  exclusions:
+    generated: lax
+    presets:
+      - comments
+      - common-false-positives
+      - legacy
+      - std-error-handling
+    rules:
+      - linters:
+          - bodyclose
+          - dupl
+          - funlen
+          - gocognit
+          - goconst
+          - gocyclo
+          - lll
+          - maligned
+          - noctx
+          - scopelint
+          - staticcheck
+        path: _test.go
+      - path: (.+)\.go$
+        text: pkg/generated
+    paths:
+      - (^|/)bin($|/)
+      - (^|/)examples($|/)
+      - (^|/)schemas($|/)
+      - (^|/)test-harness($|/)
+      - third_party$
+      - builtin$
+      - examples$
+formatters:
+  exclusions:
+    generated: lax
+    paths:
+      - third_party$
+      - builtin$
+      - examples$

.markdownlint-cli2.yaml

@@ -13,12 +13,19 @@ config:
   max-one-sentence-per-line: true
   code-block-style: false         # not compatible with mkdocs "details" panes
   no-alt-text: false
+  descriptive-link-text: false
+  MD007:
+    indent: 4
 
 ignores:
   - "**/CHANGELOG.md"
+  - ".venv"
   - "node_modules"
+  - "playground-app/node_modules"
   - "tmp"
-  - "**/protos.md"  # auto-generated
-  - "schemas"       # submodule
-  - "spec"          # submodule
-  - "test-harness"  # submodule
+  - "**/protos.md"           # auto-generated
+  - "docs/playground"        # auto-generated
+  - "docs/providers/*.md"    # auto-generated
+  - "schemas"                # submodule
+  - "spec"                   # submodule
+  - "test-harness"           # submodule

.nvmrc

@@ -0,0 +1 @@
+20

.release-please-manifest.json

@@ -1,5 +1,5 @@
 {
-  "flagd": "0.7.2",
-  "flagd-proxy": "0.3.2",
-  "core": "0.7.2"
+  "flagd": "0.12.9",
+  "flagd-proxy": "0.8.0",
+  "core": "0.12.1"
 }

CODEOWNERS

@@ -3,4 +3,4 @@
 #
 # Managed by Peribolos: https://github.com/open-feature/community/blob/main/config/open-feature/cloud-native/workgroup.yaml
 #
-* @open-feature/cloud-native-maintainers
+* @open-feature/flagd-maintainers @open-feature/maintainers

CONTRIBUTING.md

@@ -8,6 +8,24 @@ TLDR: be respectful.
 Any contributions are expected to include unit tests.
 These can be validated with `make test` or the automated github workflow will run them on PR creation.
 
+## Development
+
+### Prerequisites
+
+You'll need:
+
+- Go
+- make
+- docker
+
+You'll want:
+
+- curl (for calling HTTP endpoints)
+- [grpcurl](https://github.com/fullstorydev/grpcurl) (for making gRPC calls)
+- jq (for pretty printing responses)
+
+### Workspace Initialization
+
 This project uses a go workspace, to setup the project run
 
 ```shell
@@ -22,6 +40,70 @@ The project uses remote buf packages, changing the remote generation source will
 export GOPRIVATE=buf.build/gen/go
 ```
 
+### Manual testing
+
+flagd has a number of interfaces (you can read more about them at [flagd.dev](https://flagd.dev/)) which can be used to evaluate flags, or deliver flag configurations so that they can be evaluated by _in-process_ providers.
+
+You can manually test this functionality by starting flagd (from the flagd/ directory) with `go run main.go start -f file:../config/samples/example_flags.flagd.json`.
+
+NOTE: you will need `go, curl`
+
+#### Remote single flag evaluation via HTTP1.1/Connect
+
+```sh
+# evaluates a single boolean flag
+curl -X POST -d '{"flagKey":"myBoolFlag","context":{}}' -H "Content-Type: application/json" "http://localhost:8013/flagd.evaluation.v1.Service/ResolveBoolean" | jq
+```
+
+#### Remote single flag evaluation via HTTP1.1/OFREP
+
+```sh
+# evaluates a single boolean flag
+curl -X POST  -d '{"context":{}}' 'http://localhost:8016/ofrep/v1/evaluate/flags/myBoolFlag' | jq
+```
+
+#### Remote single flag evaluation via gRPC
+
+```sh
+# evaluates a single boolean flag
+grpcurl -import-path schemas/protobuf/flagd/evaluation/v1/ -proto evaluation.proto -plaintext -d '{"flagKey":"myBoolFlag"}' localhost:8013 flagd.evaluation.v1.Service/ResolveBoolean | jq
+```
+
+#### Remote bulk evaluation via HTTP1.1/OFREP
+
+```sh
+# evaluates flags in bulk
+curl -X POST  -d '{"context":{}}' 'http://localhost:8016/ofrep/v1/evaluate/flags' | jq
+```
+
+#### Remote bulk evaluation via gRPC
+
+```sh
+# evaluates flags in bulk
+grpcurl -import-path schemas/protobuf/flagd/evaluation/v1/ -proto evaluation.proto -plaintext -d '{}' localhost:8013 flagd.evaluation.v1.Service/ResolveAll | jq
+```
+
+#### Remote event streaming via gRPC
+
+```sh
+# notifies of flag changes (but does not evaluate)
+grpcurl -import-path schemas/protobuf/flagd/evaluation/v1/ -proto evaluation.proto -plaintext -d '{}' localhost:8013 flagd.evaluation.v1.Service/EventStream
+```
+
+#### Flag configuration fetch via gRPC
+
+```sh
+# sends back a representation of all flags
+grpcurl -import-path schemas/protobuf/flagd/sync/v1/ -proto sync.proto -plaintext localhost:8015 flagd.sync.v1.FlagSyncService/FetchAllFlags | jq
+```
+
+#### Flag synchronization stream via gRPC
+
+```sh
+# will open a persistent stream which sends flag changes when the watched source is modified
+grpcurl -import-path schemas/protobuf/flagd/sync/v1/ -proto sync.proto -plaintext localhost:8015 flagd.sync.v1.FlagSyncService/SyncFlags | jq
+```
+
 ## DCO Sign-Off
 
 A DCO (Developer Certificate of Origin) sign-off is a line placed at the end of

Dockerfile

@@ -0,0 +1,2 @@
+FROM squidfunk/mkdocs-material:9.5
+RUN pip install mkdocs-include-markdown-plugin

Makefile

@@ -1,5 +1,6 @@
 PHONY: .docker-build .build .run .mockgen
 PREFIX=/usr/local
+PUBLIC_JSON_SCHEMA_DIR=docs/schema/v0/
 ALL_GO_MOD_DIRS := $(shell find . -type f -name 'go.mod' -exec dirname {} \; | sort)
 
 FLAGD_DEV_NAMESPACE ?= flagd-dev
@@ -39,16 +40,26 @@ build: workspace-init # default to flagd
 build-flagd:
 	go build -ldflags "-X main.version=dev -X main.commit=$$(git rev-parse --short HEAD) -X main.date=$$(date +%FT%TZ)" -o ./bin/flagd ./flagd
 .PHONY: test
-test: # default to core
-	make test-core
+test: test-core test-flagd test-flagd-proxy
 test-core:
 	go test -race -covermode=atomic -cover -short ./core/pkg/... -coverprofile=core-coverage.out
-flagd-integration-test: # dependent on ./bin/flagd start -f file:test-harness/flags/testing-flags.json -f file:test-harness/flags/custom-ops.json -f file:test-harness/flags/evaluator-refs.json -f file:test-harness/flags/zero-flags.json
-	go test -cover ./test/integration $(ARGS)
+test-flagd:
+	go test -race -covermode=atomic -cover -short ./flagd/pkg/... -coverprofile=flagd-coverage.out
+test-flagd-proxy:
+	go test -race -covermode=atomic -cover -short ./flagd-proxy/pkg/... -coverprofile=flagd-proxy-coverage.out
+flagd-benchmark-test:
+	go test -bench=Bench -short -benchtime=5s -benchmem ./core/... | tee benchmark.txt
+flagd-integration-test-harness:
+# target used to start a locally built flagd with the e2e flags
+	cd flagd; go run main.go start -f file:../test-harness/flags/testing-flags.json -f file:../test-harness/flags/custom-ops.json -f file:../test-harness/flags/evaluator-refs.json -f file:../test-harness/flags/zero-flags.json -f file:../test-harness/flags/edge-case-flags.json
+flagd-integration-test: # dependent on flagd-e2e-test-harness if not running in github actions
+	go test -count=1 -cover ./test/integration $(ARGS)
 run: # default to flagd
 	make run-flagd
 run-flagd:
-	cd flagd; go run main.go start -f file:../config/samples/example_flags.flagd.json
+	cd flagd; go run main.go start -f file:../config/samples/example_flags.flagd.json 
+run-flagd-selector-demo:
+	cd flagd; go run main.go start -f file:../config/samples/example_flags.flagd.json -f file:../config/samples/example_flags.flagd.2.json
 install:
 	cp systemd/flagd.service /etc/systemd/system/flagd.service
 	mkdir -p /etc/flagd
@@ -62,16 +73,20 @@ uninstall:
 	rm /etc/systemd/system/flagd.service
 	rm -f $(DESTDIR)$(PREFIX)/bin/flagd
 lint:
-	go install -v github.com/golangci/golangci-lint/cmd/golangci-lint@latest
-	$(foreach module, $(ALL_GO_MOD_DIRS), ${GOPATH}/bin/golangci-lint run --deadline=5m --timeout=5m $(module)/... || exit;)
+	go install -v github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.2.1
+	$(foreach module, $(ALL_GO_MOD_DIRS), ${GOPATH}/bin/golangci-lint run $(module)/...;)
+lint-fix:
+	go install -v github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.2.1
+	$(foreach module, $(ALL_GO_MOD_DIRS), ${GOPATH}/bin/golangci-lint run --fix $(module)/...;)
 install-mockgen:
-	go install github.com/golang/mock/mockgen@v1.6.0
+	go install go.uber.org/mock/mockgen@v0.4.0
 mockgen: install-mockgen
 	cd core; mockgen -source=pkg/sync/http/http_sync.go -destination=pkg/sync/http/mock/http.go -package=syncmock
 	cd core; mockgen -source=pkg/sync/grpc/grpc_sync.go -destination=pkg/sync/grpc/mock/grpc.go -package=grpcmock
 	cd core; mockgen -source=pkg/sync/grpc/credentials/builder.go -destination=pkg/sync/grpc/credentials/mock/builder.go -package=credendialsmock
-	cd core; mockgen -source=pkg/eval/ievaluator.go -destination=pkg/eval/mock/ievaluator.go -package=evalmock
-	cd core; mockgen -source=pkg/service/middleware/interface.go -destination=pkg/service/middleware/mock/interface.go -package=middlewaremock
+	cd core; mockgen -source=pkg/evaluator/ievaluator.go -destination=pkg/evaluator/mock/ievaluator.go -package=evalmock
+	cd core; mockgen -source=pkg/sync/builder/syncbuilder.go -destination=pkg/sync/builder/mock/syncbuilder.go -package=middlewaremocksyncbuildermock
+	cd flagd; mockgen -source=pkg/service/middleware/interface.go -destination=pkg/service/middleware/mock/interface.go -package=middlewaremock
 generate-docs:
 	cd flagd; go run ./cmd/doc/main.go
 
@@ -115,11 +130,37 @@ pull-schemas-submodule:
 
 .PHONY: generate-proto-docs
 generate-proto-docs: pull-schemas-submodule
-	docker run --rm -v ${PWD}/$(DOCS_DIR)/reference/specifications:/out -v ${PWD}/schemas/protobuf:/protos pseudomuto/protoc-gen-doc --doc_opt=markdown,protos-with-toc.md schema/v1/schema.proto sync/v1/sync_service.proto \
+	docker run --rm -v ${PWD}/$(DOCS_DIR)/reference/specifications:/out -v ${PWD}/schemas/protobuf:/protos pseudomuto/protoc-gen-doc --doc_opt=markdown,protos-with-toc.md flagd/evaluation/v1/evaluation.proto flagd/sync/v1/sync.proto \
 	&& echo '<!-- WARNING: THIS DOC IS AUTO-GENERATED. DO NOT EDIT! -->' > ${PWD}/$(DOCS_DIR)/reference/specifications/protos.md \
 	&& sed '/^## Table of Contents/,/#top/d' ${PWD}/$(DOCS_DIR)/reference/specifications/protos-with-toc.md >> ${PWD}/$(DOCS_DIR)/reference/specifications/protos.md \
 	&& rm -f ${PWD}/$(DOCS_DIR)/reference/specifications/protos-with-toc.md
 
+# Update the schema at flagd.dev
+# PUBLIC_JSON_SCHEMA_DIR above controls the dir (and therefore major version)
+.PHONY: update-public-schema
+update-public-schema: pull-schemas-submodule
+	rm -f $(PUBLIC_JSON_SCHEMA_DIR)*.json
+	cp schemas/json/*.json $(PUBLIC_JSON_SCHEMA_DIR)
+
 .PHONY: run-web-docs
 run-web-docs: generate-docs generate-proto-docs
-	docker run --rm -it -p 8000:8000 -v ${PWD}:/docs squidfunk/mkdocs-material
+	docker build -t flag-docs:latest .  --load \
+	&& docker run --rm -it -p 8000:8000 -v ${PWD}:/docs flag-docs:latest
+
+# Run the playground app in dev mode
+# See the readme in the playground-app folder for more details
+.PHONY: playground-dev
+playground-dev:
+	cd playground-app && npm ci && npm run dev
+
+# Build the playground app
+# See the readme in the playground-app folder for more details
+.PHONY: playground-build
+playground-build:
+	cd playground-app && npm ci && npm run build
+
+# Publish the playground app to the docs folder
+# See the readme in the playground-app folder for more details
+.PHONY: playground-publish
+playground-publish: playground-build
+	cp playground-app/dist/assets/index-*.js docs/playground/playground.js

README.md

@@ -21,11 +21,11 @@
 
 ## What's flagd?
 
-Flagd is a feature flag daemon with a Unix philosophy. Think of it as a ready-made, open source, OpenFeature-compliant feature flag backend system.
+flagd is a feature flag daemon with a Unix philosophy. Think of it as a ready-made, open source, OpenFeature-compliant feature flag backend system.
 
 ## Features
 
-- 🌐 OpenFeature compliant and [speaks your language](https://openfeature.dev/ecosystem?instant_search%5BrefinementList%5D%5Bvendor%5D%5B0%5D=FlagD).
+- 🌐 OpenFeature compliant and [speaks your language](https://openfeature.dev/ecosystem?instant_search%5BrefinementList%5D%5Bvendor%5D%5B0%5D=flagd).
 - 🆕 Easy to [extend to new languages](https://flagd.dev/reference/providers/).
 - 🔄 Supports multiple data sources simultaneously.
 - 🕒 Feature Flag updates occur in near real-time.
@@ -96,7 +96,7 @@ Experiment with flagd in your browser using [the Killercoda tutorial](https://ki
     Retrieve a `String` value:
 
     ```sh
-    curl -X POST "http://localhost:8013/schema.v1.Service/ResolveString" \
+    curl -X POST "http://localhost:8013/flagd.evaluation.v1.Service/ResolveString" \
       -d '{"flagKey":"myStringFlag","context":{}}' -H "Content-Type: application/json"
     ```
 
@@ -105,7 +105,7 @@ Experiment with flagd in your browser using [the Killercoda tutorial](https://ki
 
     ```sh
     set json={"flagKey":"myStringFlag","context":{}}
-    curl -i -X POST -H "Content-Type: application/json" -d %json:"=\"% "localhost:8013/schema.v1.Service/ResolveString"
+    curl -i -X POST -H "Content-Type: application/json" -d %json:"=\"% "localhost:8013/flagd.evaluation.v1.Service/ResolveString"
     ```
 
     Result:

benchmark.txt

@@ -0,0 +1,72 @@
+PASS
+ok  	github.com/open-feature/flagd/core/pkg/certreloader	15.986s
+goos: linux
+goarch: amd64
+pkg: github.com/open-feature/flagd/core/pkg/evaluator
+cpu: 11th Gen Intel(R) Core(TM) i9-11950H @ 2.60GHz
+BenchmarkFractionalEvaluation/test_a@faas.com-16         	  423930	     13316 ns/op	    7229 B/op	     135 allocs/op
+BenchmarkFractionalEvaluation/test_b@faas.com-16         	  469594	     13677 ns/op	    7229 B/op	     135 allocs/op
+BenchmarkFractionalEvaluation/test_c@faas.com-16         	  569103	     13286 ns/op	    7229 B/op	     135 allocs/op
+BenchmarkFractionalEvaluation/test_d@faas.com-16         	  412386	     13023 ns/op	    7229 B/op	     135 allocs/op
+BenchmarkResolveBooleanValue/test_staticBoolFlag-16      	 3106903	      1792 ns/op	    1008 B/op	      11 allocs/op
+BenchmarkResolveBooleanValue/test_targetingBoolFlag-16   	  448164	     11250 ns/op	    6065 B/op	      87 allocs/op
+BenchmarkResolveBooleanValue/test_staticObjectFlag-16    	 3958750	      1476 ns/op	    1008 B/op	      11 allocs/op
+BenchmarkResolveBooleanValue/test_missingFlag-16         	 5331808	      1353 ns/op	     784 B/op	      12 allocs/op
+BenchmarkResolveBooleanValue/test_disabledFlag-16        	 4530751	      1301 ns/op	    1072 B/op	      13 allocs/op
+BenchmarkResolveStringValue/test_staticStringFlag-16     	 4583056	      1525 ns/op	    1040 B/op	      13 allocs/op
+BenchmarkResolveStringValue/test_targetingStringFlag-16  	  839954	     10388 ns/op	    6097 B/op	      89 allocs/op
+BenchmarkResolveStringValue/test_staticObjectFlag-16     	 4252830	      1677 ns/op	    1008 B/op	      11 allocs/op
+BenchmarkResolveStringValue/test_missingFlag-16          	 3743324	      1495 ns/op	     784 B/op	      12 allocs/op
+BenchmarkResolveStringValue/test_disabledFlag-16         	 3495699	      1709 ns/op	    1072 B/op	      13 allocs/op
+BenchmarkResolveFloatValue/test:_staticFloatFlag-16      	 4382868	      1511 ns/op	    1024 B/op	      13 allocs/op
+BenchmarkResolveFloatValue/test:_targetingFloatFlag-16   	  867987	     10344 ns/op	    6081 B/op	      89 allocs/op
+BenchmarkResolveFloatValue/test:_staticObjectFlag-16     	 3913120	      1695 ns/op	    1008 B/op	      11 allocs/op
+BenchmarkResolveFloatValue/test:_missingFlag-16          	 3910468	      1349 ns/op	     784 B/op	      12 allocs/op
+BenchmarkResolveFloatValue/test:_disabledFlag-16         	 3642919	      1666 ns/op	    1072 B/op	      13 allocs/op
+BenchmarkResolveIntValue/test_staticIntFlag-16           	 4077288	      1349 ns/op	    1008 B/op	      11 allocs/op
+BenchmarkResolveIntValue/test_targetingNumberFlag-16     	  922383	      7601 ns/op	    6065 B/op	      87 allocs/op
+BenchmarkResolveIntValue/test_staticObjectFlag-16        	 4995128	      1229 ns/op	    1008 B/op	      11 allocs/op
+BenchmarkResolveIntValue/test_missingFlag-16             	 5574153	      1274 ns/op	     768 B/op	      12 allocs/op
+BenchmarkResolveIntValue/test_disabledFlag-16            	 3633708	      1734 ns/op	    1072 B/op	      13 allocs/op
+BenchmarkResolveObjectValue/test_staticObjectFlag-16     	 1624102	      4559 ns/op	    2243 B/op	      37 allocs/op
+BenchmarkResolveObjectValue/test_targetingObjectFlag-16  	  443880	     11995 ns/op	    7283 B/op	     109 allocs/op
+BenchmarkResolveObjectValue/test_staticBoolFlag-16       	 3462445	      1665 ns/op	    1008 B/op	      11 allocs/op
+BenchmarkResolveObjectValue/test_missingFlag-16          	 4207567	      1458 ns/op	     784 B/op	      12 allocs/op
+BenchmarkResolveObjectValue/test_disabledFlag-16         	 3407262	      1848 ns/op	    1072 B/op	      13 allocs/op
+PASS
+ok  	github.com/open-feature/flagd/core/pkg/evaluator	239.506s
+?   	github.com/open-feature/flagd/core/pkg/evaluator/mock	[no test files]
+PASS
+ok  	github.com/open-feature/flagd/core/pkg/logger	0.003s
+?   	github.com/open-feature/flagd/core/pkg/model	[no test files]
+?   	github.com/open-feature/flagd/core/pkg/service	[no test files]
+PASS
+ok  	github.com/open-feature/flagd/core/pkg/service/ofrep	0.002s
+PASS
+ok  	github.com/open-feature/flagd/core/pkg/store	0.003s
+?   	github.com/open-feature/flagd/core/pkg/sync	[no test files]
+PASS
+ok  	github.com/open-feature/flagd/core/pkg/sync/blob	0.016s
+PASS
+ok  	github.com/open-feature/flagd/core/pkg/sync/builder	0.018s
+?   	github.com/open-feature/flagd/core/pkg/sync/builder/mock	[no test files]
+PASS
+ok  	github.com/open-feature/flagd/core/pkg/sync/file	1.007s
+PASS
+ok  	github.com/open-feature/flagd/core/pkg/sync/grpc	8.011s
+PASS
+ok  	github.com/open-feature/flagd/core/pkg/sync/grpc/credentials	0.008s
+?   	github.com/open-feature/flagd/core/pkg/sync/grpc/credentials/mock	[no test files]
+?   	github.com/open-feature/flagd/core/pkg/sync/grpc/mock	[no test files]
+PASS
+ok  	github.com/open-feature/flagd/core/pkg/sync/grpc/nameresolvers	0.002s
+PASS
+ok  	github.com/open-feature/flagd/core/pkg/sync/http	4.006s
+?   	github.com/open-feature/flagd/core/pkg/sync/http/mock	[no test files]
+PASS
+ok  	github.com/open-feature/flagd/core/pkg/sync/kubernetes	0.016s
+?   	github.com/open-feature/flagd/core/pkg/sync/testing	[no test files]
+PASS
+ok  	github.com/open-feature/flagd/core/pkg/telemetry	0.016s
+PASS
+ok  	github.com/open-feature/flagd/core/pkg/utils	0.002s

config/deployments/flagd/deployment.yaml

@@ -61,6 +61,7 @@ metadata:
 data:
   flags: |
     {
+      "$schema": "https://flagd.dev/schema/v0/flags.json",
       "flags": {
         "myStringFlag": {
           "state": "ENABLED",

config/samples/example_flags.flagd.2.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "https://flagd.dev/schema/v0/flags.json",
+  "metadata": {
+    "flagSetId": "other",
+    "version": "v1"
+  },
+  "flags": {
+    "myStringFlag": {
+      "state": "ENABLED",
+      "variants": {
+        "dupe1": "dupe1",
+        "dupe2": "dupe2"
+      },
+      "defaultVariant": "dupe1"
+    }
+  }
+}

config/samples/example_flags.flagd.json

@@ -1,4 +1,9 @@
 {
+  "$schema": "https://flagd.dev/schema/v0/flags.json",
+  "metadata": {
+    "flagSetId": "example",
+    "version": "v1"
+  },
   "flags": {
     "myBoolFlag": {
       "state": "ENABLED",
@@ -6,7 +11,10 @@
         "on": true,
         "off": false
       },
-      "defaultVariant": "on"
+      "defaultVariant": "on",
+      "metadata": {
+        "version": "v2"
+      }
     },
     "myStringFlag": {
       "state": "ENABLED",
@@ -100,8 +108,10 @@
             "$ref": "emailWithFaas"
           },
           {
-            "fractionalEvaluation": [
-              "email",
+            "fractional": [
+              {
+                "var": "email"
+              },
               [
                 "red",
                 25
@@ -132,17 +142,17 @@
       "defaultVariant": "first",
       "state": "ENABLED",
       "targeting": {
-        "if": [{
-            "in": ["@openfeature.dev", {
-              "var": "email"
-            }]
-          }, "second",
+        "if": [
           {
-            "in": ["Chrome", {
-              "var": "userAgent"
-            }]
-          }, "third",
-          null
+            "in": [
+              "@openfeature.dev",
+              {
+                "var": "email"
+              }
+            ]
+          },
+          "second",
+          "first"
         ]
       }
     }

config/samples/example_flags.flagd.yaml

@@ -1,3 +1,4 @@
+# yaml-language-server: $schema=https://flagd.dev/schema/v0/flags.json
 flags:
   myBoolFlag:
     state: ENABLED
@@ -69,8 +70,8 @@ flags:
     targeting:
       if:
       - "$ref": emailWithFaas
-      - fractionalEvaluation:
-        - email
+      - fractional:
+        - var: email
         - - red
           - 25
         - - blue
@@ -88,16 +89,13 @@ flags:
     defaultVariant: first
     state: ENABLED
     targeting:
-if:
-- in:
-  - "@openfeature.dev"
-  - var: email
-- second
-- in:
-  - Chrome
-  - var: userAgent
-- third
--
+      if:
+      - in:
+        - "@openfeature.dev"
+        - var: email
+      - second
+      - first
+
 "$evaluators":
   emailWithFaas:
     in:

config/samples/example_flags.json

@@ -1,4 +1,5 @@
 {
+  "$schema": "https://flagd.dev/schema/v0/flags.json",
   "flags": {
     "myBoolFlag": {
       "state": "ENABLED",
@@ -101,7 +102,9 @@
           },
           {
             "fractionalEvaluation": [
-              "email",
+              {
+                "var": "email"
+              },
               [
                 "red",
                 25

config/samples/example_flags.yaml

@@ -1,3 +1,4 @@
+# yaml-language-server: $schema=https://flagd.dev/schema/v0/flags.json
 flags:
   myBoolFlag:
     state: ENABLED
@@ -70,7 +71,7 @@ flags:
       if:
       - "$ref": emailWithFaas
       - fractionalEvaluation:
-        - email
+        - var: email
         - - red
           - 25
         - - blue

config/samples/example_flags_secondary.flagd.json

@@ -1,4 +1,8 @@
 {
+  "$schema": "https://flagd.dev/schema/v0/flags.json",
+  "metadata": {
+    "version": "v2"
+  },
   "flags": {
     "myBoolFlag": {
       "state": "ENABLED",

config/samples/example_flags_secondary.json

@@ -1,4 +1,5 @@
 {
+  "$schema": "https://flagd.dev/schema/v0/flags.json",
   "flags": {
     "myBoolFlag": {
       "state": "ENABLED",

core/CHANGELOG.md

@@ -1,5 +1,491 @@
 # Changelog
 
+## [0.12.1](https://github.com/open-feature/flagd/compare/core/v0.12.0...core/v0.12.1) (2025-07-28)
+
+
+### 🧹 Chore
+
+* add back file-delete test ([#1694](https://github.com/open-feature/flagd/issues/1694)) ([750aa17](https://github.com/open-feature/flagd/commit/750aa176b5a8dd24a9daaff985ff6efeb084c758))
+* fix benchmark ([#1698](https://github.com/open-feature/flagd/issues/1698)) ([5e2d7d7](https://github.com/open-feature/flagd/commit/5e2d7d7176ba05e667cd92acd7decb531a8de2f6))
+
+## [0.12.0](https://github.com/open-feature/flagd/compare/core/v0.11.8...core/v0.12.0) (2025-07-21)
+
+
+### ⚠ BREAKING CHANGES
+
+* remove sync.Type ([#1691](https://github.com/open-feature/flagd/issues/1691))
+
+### 🐛 Bug Fixes
+
+* update to latest otel semconv ([#1668](https://github.com/open-feature/flagd/issues/1668)) ([81855d7](https://github.com/open-feature/flagd/commit/81855d76f94a09251a19a05f830cc1d11ab6b566))
+
+
+### ✨ New Features
+
+* Add support for HTTP eTag header and 304 no change response ([#1645](https://github.com/open-feature/flagd/issues/1645)) ([ea3be4f](https://github.com/open-feature/flagd/commit/ea3be4f9010644132795bb60b36fb7705f901b62))
+* remove sync.Type ([#1691](https://github.com/open-feature/flagd/issues/1691)) ([ac647e0](https://github.com/open-feature/flagd/commit/ac647e065636071f5bc065a9a084461cea692166))
+
+## [0.11.8](https://github.com/open-feature/flagd/compare/core/v0.11.7...core/v0.11.8) (2025-07-15)
+
+
+### 🧹 Chore
+
+* **deps:** update github.com/open-feature/flagd-schemas digest to 08b4c52 ([#1682](https://github.com/open-feature/flagd/issues/1682)) ([68d04e2](https://github.com/open-feature/flagd/commit/68d04e21e63c63d6054fcd6aebfb864e8b3a597e))
+
+## [0.11.7](https://github.com/open-feature/flagd/compare/core/v0.11.6...core/v0.11.7) (2025-07-15)
+
+
+### 🐛 Bug Fixes
+
+* general err if targeting variant not in variants ([#1680](https://github.com/open-feature/flagd/issues/1680)) ([6cabfc8](https://github.com/open-feature/flagd/commit/6cabfc8ff3bd4ad69699a72724495e84cdec0cc3))
+
+## [0.11.6](https://github.com/open-feature/flagd/compare/core/v0.11.5...core/v0.11.6) (2025-07-10)
+
+
+### ✨ New Features
+
+* add sync_context to SyncFlags ([#1642](https://github.com/open-feature/flagd/issues/1642)) ([07a45d9](https://github.com/open-feature/flagd/commit/07a45d9b2275584fa92ff33cbe5e5c7d7864db38))
+* allowing null/missing defaultValue ([#1659](https://github.com/open-feature/flagd/issues/1659)) ([3f6b78c](https://github.com/open-feature/flagd/commit/3f6b78c8ccab75e9c07d26741c4b206fd0b722ee))
+
+## [0.11.5](https://github.com/open-feature/flagd/compare/core/v0.11.4...core/v0.11.5) (2025-06-13)
+
+
+### ✨ New Features
+
+* add server-side deadline to sync service ([#1638](https://github.com/open-feature/flagd/issues/1638)) ([b70fa06](https://github.com/open-feature/flagd/commit/b70fa06b66e1fe8a28728441a7ccd28c6fe6a0c6))
+* updating context using headers ([#1641](https://github.com/open-feature/flagd/issues/1641)) ([ba34815](https://github.com/open-feature/flagd/commit/ba348152b6e7b6bd7473bb11846aac7db316c88e))
+
+## [0.11.4](https://github.com/open-feature/flagd/compare/core/v0.11.3...core/v0.11.4) (2025-05-28)
+
+
+### 🐛 Bug Fixes
+
+* incorrect comparison used for time ([#1608](https://github.com/open-feature/flagd/issues/1608)) ([8c5ac2f](https://github.com/open-feature/flagd/commit/8c5ac2f2c31e092cbe6ddb4d3c1adeeeb04e9ef9))
+
+
+### 🧹 Chore
+
+* **deps:** update dependency go to v1.24.1 ([#1559](https://github.com/open-feature/flagd/issues/1559)) ([cd46044](https://github.com/open-feature/flagd/commit/cd4604471bba0a1df67bf87653a38df3caf9d20f))
+* **security:** upgrade dependency versions ([#1632](https://github.com/open-feature/flagd/issues/1632)) ([761d870](https://github.com/open-feature/flagd/commit/761d870a3c563b8eb1b83ee543b41316c98a1d48))
+
+
+### 🔄 Refactoring
+
+* Refactor the cron function in http sync ([#1600](https://github.com/open-feature/flagd/issues/1600)) ([babcacf](https://github.com/open-feature/flagd/commit/babcacfe4dd1244dda954823d8a3ed2019c8752b))
+* removed hardcoded metric export interval and use otel default ([#1621](https://github.com/open-feature/flagd/issues/1621)) ([81c66eb](https://github.com/open-feature/flagd/commit/81c66ebf2b82fc6874ab325569f52801d5ab8e5e))
+
+## [0.11.3](https://github.com/open-feature/flagd/compare/core/v0.11.2...core/v0.11.3) (2025-03-25)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update github.com/open-feature/flagd-schemas digest to 9b0ee43 ([#1598](https://github.com/open-feature/flagd/issues/1598)) ([0587ce4](https://github.com/open-feature/flagd/commit/0587ce44e60b643ff6960c1eaf4461f933ea95b7))
+* **deps:** update github.com/open-feature/flagd-schemas digest to e840a03 ([#1587](https://github.com/open-feature/flagd/issues/1587)) ([9ee0c57](https://github.com/open-feature/flagd/commit/9ee0c573d6dbfa0c4e9b18c9da7313094ea56916))
+* **deps:** update module connectrpc.com/otelconnect to v0.7.2 ([#1574](https://github.com/open-feature/flagd/issues/1574)) ([6094dce](https://github.com/open-feature/flagd/commit/6094dce5c0472f593b79d6d40e080f9b8d6503e5))
+* **deps:** update module github.com/google/go-cmp to v0.7.0 ([#1569](https://github.com/open-feature/flagd/issues/1569)) ([6e9dbd2](https://github.com/open-feature/flagd/commit/6e9dbd2dbf8365f839e353f53cb638847a1f05d6))
+* **deps:** update module github.com/prometheus/client_golang to v1.21.1 ([#1576](https://github.com/open-feature/flagd/issues/1576)) ([cd95193](https://github.com/open-feature/flagd/commit/cd95193f71fd465ffd1b177fa492aa84d8414a87))
+* **deps:** update module google.golang.org/grpc to v1.71.0 ([#1578](https://github.com/open-feature/flagd/issues/1578)) ([5c2c64f](https://github.com/open-feature/flagd/commit/5c2c64f878b8603dd37cbfd79b0e1588e4b5a3c6))
+* incorrect metadata returned per source ([#1599](https://github.com/open-feature/flagd/issues/1599)) ([b333e11](https://github.com/open-feature/flagd/commit/b333e11ecfe54f72c44ee61b3dcb1f2a487c94d4))
+
+
+### ✨ New Features
+
+* accept version numbers which are not strings ([#1589](https://github.com/open-feature/flagd/issues/1589)) ([6a13796](https://github.com/open-feature/flagd/commit/6a137967a258e799cbac9e3bb3927a07412c2a7b))
+
+## [0.11.2](https://github.com/open-feature/flagd/compare/core/v0.11.1...core/v0.11.2) (2025-02-21)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update golang.org/x/exp digest to 939b2ce ([#1555](https://github.com/open-feature/flagd/issues/1555)) ([23afa9c](https://github.com/open-feature/flagd/commit/23afa9c18c27885bdae0f5c4ebdc30e780e9da71))
+* **deps:** update golang.org/x/exp digest to f9890c6 ([#1551](https://github.com/open-feature/flagd/issues/1551)) ([02c4b42](https://github.com/open-feature/flagd/commit/02c4b4250131ca819c85dcf10c2d78e0c218469f))
+* **deps:** update module buf.build/gen/go/open-feature/flagd/protocolbuffers/go to v1.36.5-20250127221518-be6d1143b690.1 ([#1549](https://github.com/open-feature/flagd/issues/1549)) ([d3eb44e](https://github.com/open-feature/flagd/commit/d3eb44ed45a54bd9152b7477cce17be90016683c))
+* **deps:** update module github.com/diegoholiveira/jsonlogic/v3 to v3.7.4 ([#1556](https://github.com/open-feature/flagd/issues/1556)) ([0dfa799](https://github.com/open-feature/flagd/commit/0dfa79956695849f3a703554525759093931a01d))
+* **deps:** update module github.com/prometheus/client_golang to v1.21.0 ([#1568](https://github.com/open-feature/flagd/issues/1568)) ([a3d4162](https://github.com/open-feature/flagd/commit/a3d41625a2b79452c0732af29d0b4f320e74fe8b))
+* **deps:** update module golang.org/x/crypto to v0.33.0 ([#1552](https://github.com/open-feature/flagd/issues/1552)) ([7cef153](https://github.com/open-feature/flagd/commit/7cef153a275a4fac5099f5a52013dcd227a79bb3))
+* **deps:** update module golang.org/x/mod to v0.23.0 ([#1544](https://github.com/open-feature/flagd/issues/1544)) ([6fe7bd2](https://github.com/open-feature/flagd/commit/6fe7bd2a3e82dfc81068d9d95d8c3a4acc16456c))
+
+
+### ✨ New Features
+
+* Adding gRPC dial option override to grpc_sync.go ([#1563](https://github.com/open-feature/flagd/issues/1563)) ([1a97ca5](https://github.com/open-feature/flagd/commit/1a97ca5f81582e6d1f139a61e0e49007ad173d3f))
+
+## [0.11.1](https://github.com/open-feature/flagd/compare/core/v0.11.0...core/v0.11.1) (2025-02-04)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update module golang.org/x/sync to v0.11.0 ([#1543](https://github.com/open-feature/flagd/issues/1543)) ([7d6c0dc](https://github.com/open-feature/flagd/commit/7d6c0dc6e6e6955af1e5225807deeb2b6797900b))
+
+## [0.11.0](https://github.com/open-feature/flagd/compare/core/v0.10.8...core/v0.11.0) (2025-01-31)
+
+
+### ⚠ BREAKING CHANGES
+
+* flagSetMetadata in OFREP/ResolveAll, core refactors ([#1540](https://github.com/open-feature/flagd/issues/1540))
+
+### 🐛 Bug Fixes
+
+* **deps:** update github.com/open-feature/flagd-schemas digest to bb76343 ([#1534](https://github.com/open-feature/flagd/issues/1534)) ([8303353](https://github.com/open-feature/flagd/commit/8303353a1b503ef34b8e46d9bf77ce53c067ef3b))
+* **deps:** update golang.org/x/exp digest to 3edf0e9 ([#1538](https://github.com/open-feature/flagd/issues/1538)) ([7a06567](https://github.com/open-feature/flagd/commit/7a0656713a8c2ac3d456a3a300fe137debee0edd))
+* **deps:** update golang.org/x/exp digest to e0ece0d ([#1539](https://github.com/open-feature/flagd/issues/1539)) ([4281c6e](https://github.com/open-feature/flagd/commit/4281c6e80b233a162436fea3640bf5d061d40b96))
+* **deps:** update module buf.build/gen/go/open-feature/flagd/grpc/go to v1.5.1-20250127221518-be6d1143b690.2 ([#1536](https://github.com/open-feature/flagd/issues/1536)) ([e23060f](https://github.com/open-feature/flagd/commit/e23060f24b2a714ae748e6b37d0d06b7caa1c95c))
+* **deps:** update module buf.build/gen/go/open-feature/flagd/protocolbuffers/go to v1.36.4-20241220192239-696330adaff0.1 ([#1529](https://github.com/open-feature/flagd/issues/1529)) ([8881a80](https://github.com/open-feature/flagd/commit/8881a804b4055da0127a16b8fc57022d24906e1b))
+* **deps:** update module buf.build/gen/go/open-feature/flagd/protocolbuffers/go to v1.36.4-20250127221518-be6d1143b690.1 ([#1537](https://github.com/open-feature/flagd/issues/1537)) ([f74207b](https://github.com/open-feature/flagd/commit/f74207bc13b75bae4275bc486df51e2da569dd41))
+* **deps:** update module google.golang.org/grpc to v1.70.0 ([#1528](https://github.com/open-feature/flagd/issues/1528)) ([79b2b0a](https://github.com/open-feature/flagd/commit/79b2b0a6bbd48676dcbdd2393feb8247529bf29c))
+
+
+### ✨ New Features
+
+* flagSetMetadata in OFREP/ResolveAll, core refactors ([#1540](https://github.com/open-feature/flagd/issues/1540)) ([b49abf9](https://github.com/open-feature/flagd/commit/b49abf95069da93bdf8369c8aa0ae40e698df760))
+* support yaml in blob, file, and http syncs ([#1522](https://github.com/open-feature/flagd/issues/1522)) ([76d673a](https://github.com/open-feature/flagd/commit/76d673ae8f765512270e6498569c0ce3d54a60bf))
+
+## [0.10.8](https://github.com/open-feature/flagd/compare/core/v0.10.7...core/v0.10.8) (2025-01-19)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update module github.com/diegoholiveira/jsonlogic/v3 to v3.7.3 ([#1520](https://github.com/open-feature/flagd/issues/1520)) ([db2f990](https://github.com/open-feature/flagd/commit/db2f99021dfd676d2fd0c6af6af7e77783ee31ce))
+* **deps:** update opentelemetry-go monorepo ([#1524](https://github.com/open-feature/flagd/issues/1524)) ([eeae9a6](https://github.com/open-feature/flagd/commit/eeae9a64caf93356fd663cc735cc422edcf9e132))
+
+## [0.10.7](https://github.com/open-feature/flagd/compare/core/v0.10.6...core/v0.10.7) (2025-01-16)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update module buf.build/gen/go/open-feature/flagd/protocolbuffers/go to v1.36.3-20241220192239-696330adaff0.1 ([#1513](https://github.com/open-feature/flagd/issues/1513)) ([64c5787](https://github.com/open-feature/flagd/commit/64c57875b032edcef2e2d230e7735990e01b72b8))
+
+## [0.10.6](https://github.com/open-feature/flagd/compare/core/v0.10.5...core/v0.10.6) (2025-01-15)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update github.com/open-feature/flagd-schemas digest to 37baa2c ([#1499](https://github.com/open-feature/flagd/issues/1499)) ([1a853f7](https://github.com/open-feature/flagd/commit/1a853f79dc41523fd6dcb1ae6ca9745947955cbc))
+* **deps:** update github.com/open-feature/flagd-schemas digest to b81a56e ([#1391](https://github.com/open-feature/flagd/issues/1391)) ([6a3d8ac](https://github.com/open-feature/flagd/commit/6a3d8ac2511c32bd0dc77bba0169679aa9bf6ca6))
+* **deps:** update golang.org/x/exp digest to 7588d65 ([#1495](https://github.com/open-feature/flagd/issues/1495)) ([242e594](https://github.com/open-feature/flagd/commit/242e59450c71c682b56e554830ea3003bdbf9622))
+* **deps:** update golang.org/x/exp digest to b2144cd ([#1320](https://github.com/open-feature/flagd/issues/1320)) ([a692b00](https://github.com/open-feature/flagd/commit/a692b009ae8e7dc928d0fd65236b404192c99562))
+* **deps:** update module buf.build/gen/go/open-feature/flagd/grpc/go to v1.5.1-20241220192239-696330adaff0.1 ([#1489](https://github.com/open-feature/flagd/issues/1489)) ([53add83](https://github.com/open-feature/flagd/commit/53add83a491c6e00e0d9b1b64a9461e5973edca7))
+* **deps:** update module buf.build/gen/go/open-feature/flagd/grpc/go to v1.5.1-20241220192239-696330adaff0.2 ([#1492](https://github.com/open-feature/flagd/issues/1492)) ([9f1d94a](https://github.com/open-feature/flagd/commit/9f1d94a42ac00ecf5fc58c07a76c350e2e4ec2f6))
+* **deps:** update module buf.build/gen/go/open-feature/flagd/protocolbuffers/go to v1.36.0-20241220192239-696330adaff0.1 ([#1490](https://github.com/open-feature/flagd/issues/1490)) ([6edce72](https://github.com/open-feature/flagd/commit/6edce72e8cff01ea13cbd15d604b35ccc8337f50))
+* **deps:** update module buf.build/gen/go/open-feature/flagd/protocolbuffers/go to v1.36.2-20241220192239-696330adaff0.1 ([#1502](https://github.com/open-feature/flagd/issues/1502)) ([426c36e](https://github.com/open-feature/flagd/commit/426c36e838b9ded3a23f933e66e963c8110c0ddb))
+* **deps:** update module connectrpc.com/connect to v1.18.1 ([#1507](https://github.com/open-feature/flagd/issues/1507)) ([89d3259](https://github.com/open-feature/flagd/commit/89d32591db784458ce9b4cca36662ea502418bc5))
+* **deps:** update module github.com/diegoholiveira/jsonlogic/v3 to v3.7.0 ([#1496](https://github.com/open-feature/flagd/issues/1496)) ([e1fe149](https://github.com/open-feature/flagd/commit/e1fe1490fd1c26b9c566ff5ddef666c0fa74b2d5))
+* **deps:** update module github.com/diegoholiveira/jsonlogic/v3 to v3.7.1 ([#1509](https://github.com/open-feature/flagd/issues/1509)) ([9d06812](https://github.com/open-feature/flagd/commit/9d0681270f26bb91777fa2b8a792a4b0ccd07304))
+* **deps:** update module golang.org/x/crypto to v0.32.0 ([#1497](https://github.com/open-feature/flagd/issues/1497)) ([63a34d2](https://github.com/open-feature/flagd/commit/63a34d23aedcd798ff9f4cd47cdaddca35416423))
+* **deps:** update module google.golang.org/grpc to v1.69.2 ([#1484](https://github.com/open-feature/flagd/issues/1484)) ([6b40ad3](https://github.com/open-feature/flagd/commit/6b40ad34c83da4a3116e7cad4139a63a6c918097))
+* **deps:** update module google.golang.org/grpc to v1.69.4 ([#1510](https://github.com/open-feature/flagd/issues/1510)) ([76d6353](https://github.com/open-feature/flagd/commit/76d6353840ab8e7c93bdb0802eb1c49fc6fe1dc0))
+* **deps:** update opentelemetry-go monorepo ([#1470](https://github.com/open-feature/flagd/issues/1470)) ([26b0b1a](https://github.com/open-feature/flagd/commit/26b0b1af8bc4b3a393c3453784b50f167f13f743))
+
+
+### ✨ New Features
+
+* add ssl support to sync service ([#1479](https://github.com/open-feature/flagd/issues/1479)) ([#1501](https://github.com/open-feature/flagd/issues/1501)) ([d50fcc8](https://github.com/open-feature/flagd/commit/d50fcc821c1ae043cb8cf77e464f7b738e2ff755))
+* support flag metadata ([#1476](https://github.com/open-feature/flagd/issues/1476)) ([13fbbad](https://github.com/open-feature/flagd/commit/13fbbad4d849b35884f429c0e74a71ece9cce2c9))
+
+## [0.10.5](https://github.com/open-feature/flagd/compare/core/v0.10.4...core/v0.10.5) (2024-12-17)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update kubernetes packages to v0.31.2 ([#1430](https://github.com/open-feature/flagd/issues/1430)) ([0df8622](https://github.com/open-feature/flagd/commit/0df862215563545c33f518ab7a5ad42a19bf6adb))
+* **deps:** update kubernetes packages to v0.31.3 ([#1454](https://github.com/open-feature/flagd/issues/1454)) ([f56d7b0](https://github.com/open-feature/flagd/commit/f56d7b043c2d80ae4fe27e996c05a7cc1c2c1b28))
+* **deps:** update kubernetes packages to v0.31.4 ([#1461](https://github.com/open-feature/flagd/issues/1461)) ([431fbb4](https://github.com/open-feature/flagd/commit/431fbb49513bcdb21b09845f47c26e51e7e9f21b))
+* **deps:** update module buf.build/gen/go/open-feature/flagd/protocolbuffers/go to v1.35.2-20240906125204-0a6a901b42e8.1 ([#1451](https://github.com/open-feature/flagd/issues/1451)) ([8c6d91d](https://github.com/open-feature/flagd/commit/8c6d91d538d226b10cb954c23409902e9d245cda))
+* **deps:** update module buf.build/gen/go/open-feature/flagd/protocolbuffers/go to v1.36.0-20240906125204-0a6a901b42e8.1 ([#1475](https://github.com/open-feature/flagd/issues/1475)) ([0b11c6c](https://github.com/open-feature/flagd/commit/0b11c6cf612b244bda6bab119814647f3ce8de2e))
+* **deps:** update module github.com/diegoholiveira/jsonlogic/v3 to v3.6.0 ([#1460](https://github.com/open-feature/flagd/issues/1460)) ([dbc1da4](https://github.com/open-feature/flagd/commit/dbc1da4ba984c06972b57cf990d1d31c4b8323df))
+* **deps:** update module github.com/diegoholiveira/jsonlogic/v3 to v3.6.1 ([#1473](https://github.com/open-feature/flagd/issues/1473)) ([a3d899c](https://github.com/open-feature/flagd/commit/a3d899c5f8952181a6a987436e2255c2ab9176c5))
+* **deps:** update module github.com/fsnotify/fsnotify to v1.8.0 ([#1438](https://github.com/open-feature/flagd/issues/1438)) ([949c73b](https://github.com/open-feature/flagd/commit/949c73bd6ebadb30cfa3b7573b43d722f8d2a93d))
+* **deps:** update module github.com/stretchr/testify to v1.10.0 ([#1455](https://github.com/open-feature/flagd/issues/1455)) ([8c843df](https://github.com/open-feature/flagd/commit/8c843df7714b1f2d120c5cac8e40c7220cc0c05b))
+* **deps:** update module golang.org/x/crypto to v0.29.0 ([#1443](https://github.com/open-feature/flagd/issues/1443)) ([db96dd5](https://github.com/open-feature/flagd/commit/db96dd57b9de032fc4d15931bf907a7ed962f81b))
+* **deps:** update module golang.org/x/crypto to v0.30.0 ([#1457](https://github.com/open-feature/flagd/issues/1457)) ([dbdaa19](https://github.com/open-feature/flagd/commit/dbdaa199f0667f16d2a3b91867535ce93e63373c))
+* **deps:** update module golang.org/x/crypto to v0.31.0 ([#1463](https://github.com/open-feature/flagd/issues/1463)) ([b2245d7](https://github.com/open-feature/flagd/commit/b2245d7f73f1bde859b9627d337dd09ecd2f1a31))
+* **deps:** update module golang.org/x/mod to v0.22.0 ([#1444](https://github.com/open-feature/flagd/issues/1444)) ([ed064e1](https://github.com/open-feature/flagd/commit/ed064e134fb3a5edb0ec2d976f136af7e94d7f6d))
+* **deps:** update module google.golang.org/grpc to v1.68.0 ([#1442](https://github.com/open-feature/flagd/issues/1442)) ([cd27d09](https://github.com/open-feature/flagd/commit/cd27d098e6d8d8b0f681ef42d26dba1ebac67d12))
+* **deps:** update module google.golang.org/grpc to v1.68.1 ([#1456](https://github.com/open-feature/flagd/issues/1456)) ([0b6e2a1](https://github.com/open-feature/flagd/commit/0b6e2a1cd64910226d348c921b08a6de8013ac90))
+* **deps:** update module google.golang.org/grpc to v1.69.0 ([#1469](https://github.com/open-feature/flagd/issues/1469)) ([dd4869f](https://github.com/open-feature/flagd/commit/dd4869f5e095066f80c9d82d1be83155e7504d88))
+* **deps:** update opentelemetry-go monorepo ([#1447](https://github.com/open-feature/flagd/issues/1447)) ([68b5794](https://github.com/open-feature/flagd/commit/68b5794180da84af9adc1f2cd80f929489969c1c))
+
+
+### ✨ New Features
+
+* add context-value flag ([#1448](https://github.com/open-feature/flagd/issues/1448)) ([7ca092e](https://github.com/open-feature/flagd/commit/7ca092e478c937eca0c91357394499763545dc1c))
+* s3 support for the blob sync ([#1449](https://github.com/open-feature/flagd/issues/1449)) ([a9f7261](https://github.com/open-feature/flagd/commit/a9f7261e75bc064947ae14900e5c4edc4b49bec4))
+
+## [0.10.4](https://github.com/open-feature/flagd/compare/core/v0.10.3...core/v0.10.4) (2024-10-28)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update module buf.build/gen/go/open-feature/flagd/protocolbuffers/go to v1.35.1-20240906125204-0a6a901b42e8.1 ([#1420](https://github.com/open-feature/flagd/issues/1420)) ([1f06d5a](https://github.com/open-feature/flagd/commit/1f06d5a1837ea2b753974e96c2a1154d6cb3e582))
+* **deps:** update module github.com/prometheus/client_golang to v1.20.5 ([#1425](https://github.com/open-feature/flagd/issues/1425)) ([583ba89](https://github.com/open-feature/flagd/commit/583ba894f2de794b36b6a1cc3bfceb9c46dc9d96))
+* **deps:** update module go.uber.org/mock to v0.5.0 ([#1427](https://github.com/open-feature/flagd/issues/1427)) ([0c6fd7f](https://github.com/open-feature/flagd/commit/0c6fd7fa688db992d4e58a202889cbfea07eebf6))
+* **deps:** update module gocloud.dev to v0.40.0 ([#1422](https://github.com/open-feature/flagd/issues/1422)) ([e0e4709](https://github.com/open-feature/flagd/commit/e0e4709243d8301bcbb0aaaa309be66944c1d9ed))
+* **deps:** update module golang.org/x/crypto to v0.28.0 ([#1416](https://github.com/open-feature/flagd/issues/1416)) ([fb272da](https://github.com/open-feature/flagd/commit/fb272da56e0eba12245309899888c18920b9a200))
+* **deps:** update module google.golang.org/grpc to v1.67.1 ([#1415](https://github.com/open-feature/flagd/issues/1415)) ([85a3a6b](https://github.com/open-feature/flagd/commit/85a3a6b46233fcc7cf71a0292b46c82ac8e66d7b))
+
+
+### ✨ New Features
+
+* added custom grpc resolver ([#1424](https://github.com/open-feature/flagd/issues/1424)) ([e5007e2](https://github.com/open-feature/flagd/commit/e5007e2bcb6f049a3c54e09331065bb9abe215be))
+* support azure blob sync ([#1428](https://github.com/open-feature/flagd/issues/1428)) ([5c39cfe](https://github.com/open-feature/flagd/commit/5c39cfe30a3dead4f6db2c6f9ee4c12193cd479b))
+
+## [0.10.3](https://github.com/open-feature/flagd/compare/core/v0.10.2...core/v0.10.3) (2024-09-23)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update kubernetes package and controller runtime, fix proto lint ([#1290](https://github.com/open-feature/flagd/issues/1290)) ([94860d6](https://github.com/open-feature/flagd/commit/94860d6ceabe9eb7c1e5dd8ea139a796710d6d8b))
+* **deps:** update module buf.build/gen/go/open-feature/flagd/grpc/go to v1.5.1-20240906125204-0a6a901b42e8.1 ([#1400](https://github.com/open-feature/flagd/issues/1400)) ([954d972](https://github.com/open-feature/flagd/commit/954d97238210f90b650493ae76277d4a8d80788a))
+* **deps:** update module connectrpc.com/connect to v1.17.0 ([#1408](https://github.com/open-feature/flagd/issues/1408)) ([e7eb691](https://github.com/open-feature/flagd/commit/e7eb691094dfbf02e37d79c41f60f556415e7640))
+* **deps:** update module github.com/prometheus/client_golang to v1.20.3 ([#1384](https://github.com/open-feature/flagd/issues/1384)) ([8fd16b2](https://github.com/open-feature/flagd/commit/8fd16b23b1fa8517128af36b3068ca18ebbad6c3))
+* **deps:** update module github.com/prometheus/client_golang to v1.20.4 ([#1406](https://github.com/open-feature/flagd/issues/1406)) ([a0a6426](https://github.com/open-feature/flagd/commit/a0a64269b08251317676075fdea7bc65bea8a8dc))
+* **deps:** update module gocloud.dev to v0.39.0 ([#1404](https://github.com/open-feature/flagd/issues/1404)) ([a3184d6](https://github.com/open-feature/flagd/commit/a3184d68413749808709baac47df3bf7400f9cdc))
+* **deps:** update module golang.org/x/crypto to v0.27.0 ([#1396](https://github.com/open-feature/flagd/issues/1396)) ([f9a7d10](https://github.com/open-feature/flagd/commit/f9a7d10590d3191ea8eba0dbb340fa94d07026a4))
+* **deps:** update module golang.org/x/mod to v0.21.0 ([#1397](https://github.com/open-feature/flagd/issues/1397)) ([1507e19](https://github.com/open-feature/flagd/commit/1507e19e9304bcebfbbe4376f45e9f2e82135fd2))
+* **deps:** update module google.golang.org/grpc to v1.66.0 ([#1393](https://github.com/open-feature/flagd/issues/1393)) ([c96e9d7](https://github.com/open-feature/flagd/commit/c96e9d764aa51caf00fbde07cdc7d2de55b98b9e))
+* **deps:** update module google.golang.org/grpc to v1.66.1 ([#1402](https://github.com/open-feature/flagd/issues/1402)) ([50c9cd3](https://github.com/open-feature/flagd/commit/50c9cd3ada2f470a22374392a5a152a487636645))
+* **deps:** update module google.golang.org/grpc to v1.66.2 ([#1405](https://github.com/open-feature/flagd/issues/1405)) ([69ec28f](https://github.com/open-feature/flagd/commit/69ec28fceb597bdaad63b184943b66ccdb4af0b7))
+* **deps:** update module google.golang.org/grpc to v1.67.0 ([#1407](https://github.com/open-feature/flagd/issues/1407)) ([1ad6480](https://github.com/open-feature/flagd/commit/1ad6480a0f37c4677e53065ef455f615b26b1f17))
+* **deps:** update opentelemetry-go monorepo ([#1387](https://github.com/open-feature/flagd/issues/1387)) ([22aef5b](https://github.com/open-feature/flagd/commit/22aef5bbf030c619e48fbe22a16d83e071b11902))
+* **deps:** update opentelemetry-go monorepo ([#1403](https://github.com/open-feature/flagd/issues/1403)) ([fc4cd3e](https://github.com/open-feature/flagd/commit/fc4cd3e547f4826ea0bb8cc1bb2304807932b4e6))
+* remove dep cycle with certreloader ([#1410](https://github.com/open-feature/flagd/issues/1410)) ([5244f6f](https://github.com/open-feature/flagd/commit/5244f6f6c94f310fd80c7ab84942103cc8c18a39))
+
+
+### ✨ New Features
+
+* add mTLS support to otel exporter ([#1389](https://github.com/open-feature/flagd/issues/1389)) ([8737f53](https://github.com/open-feature/flagd/commit/8737f53444016b114ee4ae52eead0b835af0e200))
+
+## [0.10.2](https://github.com/open-feature/flagd/compare/core/v0.10.1...core/v0.10.2) (2024-08-22)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update module buf.build/gen/go/open-feature/flagd/grpc/go to v1.5.1-20240215170432-1e611e2999cc.1 ([#1372](https://github.com/open-feature/flagd/issues/1372)) ([ae24595](https://github.com/open-feature/flagd/commit/ae2459504f7eccafebccec83fa1f72b08f41a978))
+* **deps:** update module connectrpc.com/otelconnect to v0.7.1 ([#1367](https://github.com/open-feature/flagd/issues/1367)) ([184915b](https://github.com/open-feature/flagd/commit/184915b31726729e8ed2f7999f338bf4ed684809))
+* **deps:** update module github.com/open-feature/open-feature-operator/apis to v0.2.44 ([#1368](https://github.com/open-feature/flagd/issues/1368)) ([0c68726](https://github.com/open-feature/flagd/commit/0c68726bed1cdae07f1b90447818ebbc9dc45caf))
+* **deps:** update module golang.org/x/crypto to v0.26.0 ([#1379](https://github.com/open-feature/flagd/issues/1379)) ([05f6658](https://github.com/open-feature/flagd/commit/05f6658e3dc72182adbff9197c8980641af8c53f))
+* **deps:** update module golang.org/x/mod to v0.20.0 ([#1377](https://github.com/open-feature/flagd/issues/1377)) ([797d7a4](https://github.com/open-feature/flagd/commit/797d7a4bbafc73e6882e5998df500ae4fe98fbbc))
+* **deps:** update module golang.org/x/sync to v0.8.0 ([#1378](https://github.com/open-feature/flagd/issues/1378)) ([4804c17](https://github.com/open-feature/flagd/commit/4804c17a67ea9761079ecade34ccb3446643050b))
+
+
+### ✨ New Features
+
+* add 'watcher' interface to file sync ([#1365](https://github.com/open-feature/flagd/issues/1365)) ([61fff43](https://github.com/open-feature/flagd/commit/61fff43e288daac88efb127ada20276c01ed5928))
+* added new grpc sync config option to allow setting max receive message size. ([#1358](https://github.com/open-feature/flagd/issues/1358)) ([bed077b](https://github.com/open-feature/flagd/commit/bed077bac9da3b6e3bd45ca54046e40a595fcba6))
+* Support blob type sources and GCS as an example of such source. ([#1366](https://github.com/open-feature/flagd/issues/1366)) ([21f2c9a](https://github.com/open-feature/flagd/commit/21f2c9a5d64cbfe2fc841080850a2c582e8f4ba6))
+
+
+### 🧹 Chore
+
+* **deps:** update dependency go to v1.22.6 ([#1297](https://github.com/open-feature/flagd/issues/1297)) ([50b92c1](https://github.com/open-feature/flagd/commit/50b92c17cfd872d3e6b95fef3b3d96444e563715))
+
+## [0.10.1](https://github.com/open-feature/flagd/compare/core/v0.10.0...core/v0.10.1) (2024-07-08)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update module buf.build/gen/go/open-feature/flagd/grpc/go to v1.4.0-20240215170432-1e611e2999cc.2 ([#1342](https://github.com/open-feature/flagd/issues/1342)) ([efdd921](https://github.com/open-feature/flagd/commit/efdd92139903b89ac986a62ff2cf4f5cfef91cde))
+* **deps:** update module golang.org/x/crypto to v0.25.0 ([#1351](https://github.com/open-feature/flagd/issues/1351)) ([450cbc8](https://github.com/open-feature/flagd/commit/450cbc84ca55eef3fccc768003e358a8e589668e))
+* **deps:** update module golang.org/x/mod to v0.19.0 ([#1349](https://github.com/open-feature/flagd/issues/1349)) ([6ee89b4](https://github.com/open-feature/flagd/commit/6ee89b44ca4aca8f6236603fc3f969e814907bd6))
+* **deps:** update module google.golang.org/grpc to v1.65.0 ([#1346](https://github.com/open-feature/flagd/issues/1346)) ([72a6b87](https://github.com/open-feature/flagd/commit/72a6b876e880ff0b43440d9b63710c7a87536988))
+* **deps:** update opentelemetry-go monorepo ([#1347](https://github.com/open-feature/flagd/issues/1347)) ([37fb3cd](https://github.com/open-feature/flagd/commit/37fb3cd81d5436e9d8cd3ea490a3951ae5794130))
+
+## [0.10.0](https://github.com/open-feature/flagd/compare/core/v0.9.3...core/v0.10.0) (2024-06-27)
+
+
+### ⚠ BREAKING CHANGES
+
+* support emitting errors from the bulk evaluator ([#1338](https://github.com/open-feature/flagd/issues/1338))
+
+### 🐛 Bug Fixes
+
+* **deps:** update module buf.build/gen/go/open-feature/flagd/grpc/go to v1.4.0-20240215170432-1e611e2999cc.1 ([#1333](https://github.com/open-feature/flagd/issues/1333)) ([494062f](https://github.com/open-feature/flagd/commit/494062fed891fab0fb659352142dbbc97c8f1492))
+* **deps:** update module buf.build/gen/go/open-feature/flagd/protocolbuffers/go to v1.34.2-20240215170432-1e611e2999cc.2 ([#1330](https://github.com/open-feature/flagd/issues/1330)) ([32291ad](https://github.com/open-feature/flagd/commit/32291ad93d25d79299a7a02381df70e2719c4fbc))
+* **deps:** update module connectrpc.com/connect to v1.16.2 ([#1289](https://github.com/open-feature/flagd/issues/1289)) ([8bacb7c](https://github.com/open-feature/flagd/commit/8bacb7c59c17956dda3cf9d2a7bc6f139885a656))
+* **deps:** update module github.com/open-feature/open-feature-operator/apis to v0.2.43 ([#1331](https://github.com/open-feature/flagd/issues/1331)) ([fecd769](https://github.com/open-feature/flagd/commit/fecd769e5f2c4aa7bf1a0fb13f0543e7b8045af8))
+* **deps:** update module golang.org/x/crypto to v0.24.0 ([#1335](https://github.com/open-feature/flagd/issues/1335)) ([2a31a17](https://github.com/open-feature/flagd/commit/2a31a1740303991412e0169e50a064823cce0560))
+* **deps:** update module golang.org/x/mod to v0.18.0 ([#1336](https://github.com/open-feature/flagd/issues/1336)) ([5fa83f7](https://github.com/open-feature/flagd/commit/5fa83f7ab266320d8d8f1388a6c2f2cac922275a))
+* **deps:** update opentelemetry-go monorepo ([#1314](https://github.com/open-feature/flagd/issues/1314)) ([e9f1a7a](https://github.com/open-feature/flagd/commit/e9f1a7a04828f36691e694375b3c665140bc7dee))
+* readable error messages  ([#1325](https://github.com/open-feature/flagd/issues/1325)) ([7ff33ef](https://github.com/open-feature/flagd/commit/7ff33effcc47e31c5b7fdc33385d8128db2163fc))
+
+
+### ✨ New Features
+
+* add mandatory flags property in bulk response ([#1339](https://github.com/open-feature/flagd/issues/1339)) ([b20266e](https://github.com/open-feature/flagd/commit/b20266ed5e0c16bf14769f300297f7f2b0ab2dcd))
+* support emitting errors from the bulk evaluator ([#1338](https://github.com/open-feature/flagd/issues/1338)) ([b9c099c](https://github.com/open-feature/flagd/commit/b9c099cb7fa002a509a82c81b467f5e784c27e82))
+* support relative weighting for fractional evaluation ([#1313](https://github.com/open-feature/flagd/issues/1313)) ([f82c094](https://github.com/open-feature/flagd/commit/f82c094f5c47f99ef37b7392bfd39cec3ec7ba51))
+
+## [0.9.3](https://github.com/open-feature/flagd/compare/core/v0.9.2...core/v0.9.3) (2024-06-06)
+
+
+### 🐛 Bug Fixes
+
+* fixes store merge when selector is used ([#1322](https://github.com/open-feature/flagd/issues/1322)) ([ed5025d](https://github.com/open-feature/flagd/commit/ed5025d8f28fdf92a5c7dceaec7fd6df7f979e3b))
+
+
+### 🧹 Chore
+
+* adapt telemetry setup error handling ([#1315](https://github.com/open-feature/flagd/issues/1315)) ([20bcb78](https://github.com/open-feature/flagd/commit/20bcb78d11dbb16aab2b14d5869bb990a0f7bca5))
+
+## [0.9.2](https://github.com/open-feature/flagd/compare/core/v0.9.1...core/v0.9.2) (2024-05-10)
+
+
+### ✨ New Features
+
+* improve error log and add flag disabled handling for ofrep ([#1306](https://github.com/open-feature/flagd/issues/1306)) ([39ae4fe](https://github.com/open-feature/flagd/commit/39ae4fe11380af5c6e23c4aaae45b5ec17cf32d6))
+
+
+### 🧹 Chore
+
+* bump go deps to latest ([#1307](https://github.com/open-feature/flagd/issues/1307)) ([004ad08](https://github.com/open-feature/flagd/commit/004ad083dc01538791148d6233e453d2a3009fcd))
+
+## [0.9.1](https://github.com/open-feature/flagd/compare/core/v0.9.0...core/v0.9.1) (2024-04-19)
+
+
+### 🐛 Bug Fixes
+
+* missing/nil custom variables in fractional operator ([#1295](https://github.com/open-feature/flagd/issues/1295)) ([418c5cd](https://github.com/open-feature/flagd/commit/418c5cd7c07fad61674a751872a1256b5062799c))
+
+
+### ✨ New Features
+
+* move json logic operator registration to resolver ([#1291](https://github.com/open-feature/flagd/issues/1291)) ([b473457](https://github.com/open-feature/flagd/commit/b473457ddff28789fee1eeb6704491b6aa3525e3))
+
+## [0.9.0](https://github.com/open-feature/flagd/compare/core/v0.8.2...core/v0.9.0) (2024-04-10)
+
+
+### ⚠ BREAKING CHANGES
+
+* allow custom seed when using targetingKey override for fractional op ([#1266](https://github.com/open-feature/flagd/issues/1266))
+  * This is a breaking change only to the extent that it changes the assignment of evaluated flag values.
+      Previously, flagd's `fractional` op would internally concatenate any specified bucketing property with the `flag-key`.
+      This improved apparent "randomness" by reducing the chances that users were assigned a bucket of the same ordinality across multiple flags.
+      However, sometimes it's desireable to have such predictibility, so now **flagd will use the bucketing value as is**.
+      If you are specifying a bucketing value in a `fractional` rule, and want to maintain the previous assignments, you can do this concatenation manually:
+      `{ "var": "user.name" }` => `{"cat": [{ "var": "$flagd.flagKey" }, { "var": "user.name" }]}`.
+      This will result in the same assignment as before.
+      Please note, that if you do not specify a bucketing key at all (the shorthand version of the `fractional` op), flagd still uses a concatentation of the `flag-key` and `targetingKey` as before; this behavior has not changed.
+
+### ✨ New Features
+
+* allow custom seed when using targetingKey override for fractional op ([#1266](https://github.com/open-feature/flagd/issues/1266)) ([f62bc72](https://github.com/open-feature/flagd/commit/f62bc721e8ebc07e27fbe7b9ca085a8771295d65))
+
+
+### 🧹 Chore
+
+* refactor evaluation core ([#1259](https://github.com/open-feature/flagd/issues/1259)) ([0e6604c](https://github.com/open-feature/flagd/commit/0e6604cd038dc13d7d40e622523320bf03efbcd0))
+* update go deps ([#1279](https://github.com/open-feature/flagd/issues/1279)) ([219789f](https://github.com/open-feature/flagd/commit/219789fca8a929d552e4e8d1f6b6d5cd44505f43))
+* wire evaluation ctx to store methods ([#1273](https://github.com/open-feature/flagd/issues/1273)) ([0075932](https://github.com/open-feature/flagd/commit/00759322594f309ca9236156f296805a09f5f9fe))
+
+## [0.8.2](https://github.com/open-feature/flagd/compare/core/v0.8.1...core/v0.8.2) (2024-03-27)
+
+
+### ✨ New Features
+
+* OFREP support for flagd  ([#1247](https://github.com/open-feature/flagd/issues/1247)) ([9d12fc2](https://github.com/open-feature/flagd/commit/9d12fc20702a86e8385564659be88f07ad36d9e5))
+
+## [0.8.1](https://github.com/open-feature/flagd/compare/core/v0.8.0...core/v0.8.1) (2024-03-15)
+
+
+### 🐛 Bug Fixes
+
+* occasional panic when watched YAML files change ([#1246](https://github.com/open-feature/flagd/issues/1246)) ([6249d12](https://github.com/open-feature/flagd/commit/6249d12ec452073ed881b6e5faf716332c7f132a))
+* update protobuff CVE-2024-24786 ([#1249](https://github.com/open-feature/flagd/issues/1249)) ([fd81c23](https://github.com/open-feature/flagd/commit/fd81c235fb4a09dfc42289ac316ac3a1d7eff58c))
+
+
+### 🧹 Chore
+
+* move packaging & isolate service implementations  ([#1234](https://github.com/open-feature/flagd/issues/1234)) ([b58fab3](https://github.com/open-feature/flagd/commit/b58fab3df030ef7e9e10eafa7a0141c05aa05bbd))
+
+## [0.8.0](https://github.com/open-feature/flagd/compare/core/v0.7.5...core/v0.8.0) (2024-02-20)
+
+
+### ⚠ BREAKING CHANGES
+
+* new proto (flagd.sync.v1) for sync sources ([#1214](https://github.com/open-feature/flagd/issues/1214))
+
+### 🐛 Bug Fixes
+
+* **deps:** update github.com/open-feature/flagd-schemas digest to 8c72c14 ([#1212](https://github.com/open-feature/flagd/issues/1212)) ([4add9fd](https://github.com/open-feature/flagd/commit/4add9fd1c47e3e3dea818a6b262273fadb7edb81))
+* **deps:** update kubernetes packages to v0.29.2 ([#1213](https://github.com/open-feature/flagd/issues/1213)) ([b0c805f](https://github.com/open-feature/flagd/commit/b0c805f7f58979f927e60c22c94c0448af459c7d))
+* **deps:** update module buf.build/gen/go/open-feature/flagd/connectrpc/go to v1.15.0-20240215170432-1e611e2999cc.1 ([#1219](https://github.com/open-feature/flagd/issues/1219)) ([4c4f08a](https://github.com/open-feature/flagd/commit/4c4f08afabf7d646973768500db028ab0b4c7d68))
+* **deps:** update module golang.org/x/crypto to v0.19.0 ([#1203](https://github.com/open-feature/flagd/issues/1203)) ([f0ff317](https://github.com/open-feature/flagd/commit/f0ff3177f67c832d62694cdf44b766344da5483f))
+* **deps:** update module golang.org/x/mod to v0.15.0 ([#1202](https://github.com/open-feature/flagd/issues/1202)) ([6ca8e6d](https://github.com/open-feature/flagd/commit/6ca8e6d33f6646698605fb4b5b99f8a3ee1ddbed))
+* **deps:** update module golang.org/x/net to v0.21.0 ([#1204](https://github.com/open-feature/flagd/issues/1204)) ([bccf365](https://github.com/open-feature/flagd/commit/bccf365fa2e5f443208ec70b1244bdb4f07ced04))
+* **deps:** update module google.golang.org/grpc to v1.61.1 ([#1210](https://github.com/open-feature/flagd/issues/1210)) ([10cc63e](https://github.com/open-feature/flagd/commit/10cc63e7992b4ae8d861f5296afcc78417e645cb))
+* **deps:** update opentelemetry-go monorepo ([#1199](https://github.com/open-feature/flagd/issues/1199)) ([422ebaa](https://github.com/open-feature/flagd/commit/422ebaa30b8bb0246bcdf8c0cc2be0a5870eb9e9))
+
+
+### ✨ New Features
+
+* new proto (flagd.sync.v1) for sync sources ([#1214](https://github.com/open-feature/flagd/issues/1214)) ([544234e](https://github.com/open-feature/flagd/commit/544234ebd9f9be5f54c2865a866575a7869a56c0))
+
+## [0.7.5](https://github.com/open-feature/flagd/compare/core/v0.7.4...core/v0.7.5) (2024-02-05)
+
+
+### 🐛 Bug Fixes
+
+* add signal handling to SyncFlags grpc ([#1176](https://github.com/open-feature/flagd/issues/1176)) ([5c8ed7c](https://github.com/open-feature/flagd/commit/5c8ed7c6dd29ffe43c1f1f0e2843683570873443))
+* **deps:** update kubernetes packages to v0.29.1 ([#1156](https://github.com/open-feature/flagd/issues/1156)) ([899e6b5](https://github.com/open-feature/flagd/commit/899e6b505abe63b7b599858a0d55e6a69be08993))
+* **deps:** update module buf.build/gen/go/open-feature/flagd/connectrpc/go to v1.14.0-20231031123731-ac2ec0f39838.1 ([#1170](https://github.com/open-feature/flagd/issues/1170)) ([8b3c8d6](https://github.com/open-feature/flagd/commit/8b3c8d6c87cbebd6f324771cb8aa1f6990a74cf4))
+* **deps:** update module golang.org/x/crypto to v0.18.0 ([#1138](https://github.com/open-feature/flagd/issues/1138)) ([53569d9](https://github.com/open-feature/flagd/commit/53569d9cd88de1073a7e49b1a835adee4b0e8ef2))
+* **deps:** update module golang.org/x/net to v0.20.0 ([#1139](https://github.com/open-feature/flagd/issues/1139)) ([fdb1d0c](https://github.com/open-feature/flagd/commit/fdb1d0c909373e23a8c8fca435ef77205526f730))
+* **deps:** update module google.golang.org/grpc to v1.61.0 ([#1164](https://github.com/open-feature/flagd/issues/1164)) ([11ccecd](https://github.com/open-feature/flagd/commit/11ccecd5ac2e23991ac76ee079630f527559db1d))
+* **deps:** update opentelemetry-go monorepo ([#1155](https://github.com/open-feature/flagd/issues/1155)) ([436fefe](https://github.com/open-feature/flagd/commit/436fefedf67afda1cbf97ff12f7c3071cb833d9a))
+
+
+### ✨ New Features
+
+* add targeting validation ([#1146](https://github.com/open-feature/flagd/issues/1146)) ([b727dd0](https://github.com/open-feature/flagd/commit/b727dd00c561c27e54dbe4bafff0ca2d82487a42))
+* **core:** support any auth scheme in HTTP-sync auth header ([#1152](https://github.com/open-feature/flagd/issues/1152)) ([df65966](https://github.com/open-feature/flagd/commit/df6596634e1ca960592d5e4825985aeee781a25d))
+
+
+### 🧹 Chore
+
+* update test dependencies, fix for otel api change and update renovate configuration ([#1188](https://github.com/open-feature/flagd/issues/1188)) ([3270346](https://github.com/open-feature/flagd/commit/32703464d5c637dbb06c2c857070e9f038977c01))
+
+
+### 📚 Documentation
+
+* update schemas ([#1158](https://github.com/open-feature/flagd/issues/1158)) ([396c618](https://github.com/open-feature/flagd/commit/396c618bac13c5c8eb2aadc29bb126a83fec1b56))
+
+## [0.7.4](https://github.com/open-feature/flagd/compare/core/v0.7.3...core/v0.7.4) (2024-01-04)
+
+
+### 🐛 Bug Fixes
+
+* add custom marshalling options ([#1117](https://github.com/open-feature/flagd/issues/1117)) ([e8e49de](https://github.com/open-feature/flagd/commit/e8e49de909fba6791a26e73a59d5b7ab54284499))
+* **deps:** update kubernetes packages to v0.29.0 ([#1082](https://github.com/open-feature/flagd/issues/1082)) ([751a79a](https://github.com/open-feature/flagd/commit/751a79a16571bea943aa1297c9828d1149d0c319))
+* **deps:** update module connectrpc.com/connect to v1.14.0 ([#1108](https://github.com/open-feature/flagd/issues/1108)) ([0a41aca](https://github.com/open-feature/flagd/commit/0a41acae082e65b2f0b1e1f36304556f77eba72a))
+* **deps:** update module github.com/prometheus/client_golang to v1.18.0 ([#1110](https://github.com/open-feature/flagd/issues/1110)) ([745bbb0](https://github.com/open-feature/flagd/commit/745bbb079af50f8fdb870e2234edd70c7a7a52f9))
+* **deps:** update module golang.org/x/crypto to v0.17.0 [security] ([#1090](https://github.com/open-feature/flagd/issues/1090)) ([26681de](https://github.com/open-feature/flagd/commit/26681ded7389ca4ecb3d9612aedad8c700796dc9))
+* **deps:** update module google.golang.org/protobuf to v1.32.0 ([#1106](https://github.com/open-feature/flagd/issues/1106)) ([e0d3b34](https://github.com/open-feature/flagd/commit/e0d3b34aa2fad5435a296dda896c9d430563b6ea))
+
+## [0.7.3](https://github.com/open-feature/flagd/compare/core/v0.7.2...core/v0.7.3) (2023-12-22)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update golang.org/x/exp digest to 6522937 ([#1032](https://github.com/open-feature/flagd/issues/1032)) ([78b23d2](https://github.com/open-feature/flagd/commit/78b23d25fcd2ea49675fc96963565afbdf0acf25))
+* **deps:** update module connectrpc.com/connect to v1.13.0 ([#1070](https://github.com/open-feature/flagd/issues/1070)) ([63f86ea](https://github.com/open-feature/flagd/commit/63f86ea699ff1f25639101a36e4fc25c76c94c1e))
+* **deps:** update module github.com/diegoholiveira/jsonlogic/v3 to v3.4.0 ([#1068](https://github.com/open-feature/flagd/issues/1068)) ([5c5d5ab](https://github.com/open-feature/flagd/commit/5c5d5abc38540277deb4e11f41f79ff49273d659))
+* **deps:** update module github.com/open-feature/open-feature-operator to v0.5.2 ([#1059](https://github.com/open-feature/flagd/issues/1059)) ([cefea3e](https://github.com/open-feature/flagd/commit/cefea3ee035726940ee5ac51e8f7fc92cc0eeac3))
+* **deps:** update module google.golang.org/grpc to v1.60.0 ([#1074](https://github.com/open-feature/flagd/issues/1074)) ([bf3e9d8](https://github.com/open-feature/flagd/commit/bf3e9d82b40afdc89edc519f40bc0f67af48f1bf))
+* **deps:** update module google.golang.org/grpc to v1.60.1 ([#1092](https://github.com/open-feature/flagd/issues/1092)) ([5bf1368](https://github.com/open-feature/flagd/commit/5bf1368e68012937b57bf27168646e784524ae9b))
+* make sure sync builder is initialized to avoid nil pointer access ([#1076](https://github.com/open-feature/flagd/issues/1076)) ([ebcd616](https://github.com/open-feature/flagd/commit/ebcd616e0df1ab56fd11bcf4f53fa7cf13f5e1d6))
+
+
+### ✨ New Features
+
+* support new flagd.evaluation and flagd.sync schemas ([#1083](https://github.com/open-feature/flagd/issues/1083)) ([e9728aa](https://github.com/open-feature/flagd/commit/e9728aae8352e77e6564a88e37d13f87021526ef))
+
+
+### 🧹 Chore
+
+* refactoring component structure ([#1044](https://github.com/open-feature/flagd/issues/1044)) ([0c7f78a](https://github.com/open-feature/flagd/commit/0c7f78a95fa4ad2a8b2afe2f6023b9c6d4fd48ed))
+* renaming of evaluation components ([#1064](https://github.com/open-feature/flagd/issues/1064)) ([d39f31d](https://github.com/open-feature/flagd/commit/d39f31d65b57a9b033a4976e5cea8fdab716769d))
+* use client-go library for retrieving FeatureFlag CRs ([#1077](https://github.com/open-feature/flagd/issues/1077)) ([c86dff0](https://github.com/open-feature/flagd/commit/c86dff0bd058ca65f4ccd34c0bc5c0a4ad5b11a6))
+
 ## [0.7.2](https://github.com/open-feature/flagd/compare/core/v0.7.1...core/v0.7.2) (2023-12-05)
 
 

core/go.mod

@@ -1,110 +1,167 @@
 module github.com/open-feature/flagd/core
 
-go 1.20
+go 1.24.0
+
+toolchain go1.24.4
 
 require (
-	buf.build/gen/go/open-feature/flagd/connectrpc/go v1.12.0-20231031123731-ac2ec0f39838.1
-	buf.build/gen/go/open-feature/flagd/grpc/go v1.3.0-20230710190440-2333a9579c1a.1
-	buf.build/gen/go/open-feature/flagd/protocolbuffers/go v1.31.0-20231031123731-ac2ec0f39838.2
-	connectrpc.com/connect v1.12.0
-	connectrpc.com/otelconnect v0.6.0
-	github.com/diegoholiveira/jsonlogic/v3 v3.3.2
-	github.com/fsnotify/fsnotify v1.7.0
-	github.com/golang/mock v1.6.0
-	github.com/open-feature/open-feature-operator v0.5.1
-	github.com/open-feature/open-feature-operator/apis v0.2.38-0.20231117101310-726a7f714906
-	github.com/open-feature/schemas v0.2.8
-	github.com/prometheus/client_golang v1.17.0
+	buf.build/gen/go/open-feature/flagd/grpc/go v1.5.1-20250529171031-ebdc14163473.2
+	buf.build/gen/go/open-feature/flagd/protocolbuffers/go v1.36.6-20250529171031-ebdc14163473.1
+	connectrpc.com/connect v1.18.1
+	connectrpc.com/otelconnect v0.7.2
+	github.com/diegoholiveira/jsonlogic/v3 v3.8.4
+	github.com/fsnotify/fsnotify v1.9.0
+	github.com/google/go-cmp v0.7.0
+	github.com/open-feature/flagd-schemas v0.2.9-0.20250707123415-08b4c52d3b86
+	github.com/open-feature/open-feature-operator/apis v0.2.45
+	github.com/prometheus/client_golang v1.22.0
 	github.com/robfig/cron v1.2.0
-	github.com/rs/cors v1.10.1
-	github.com/rs/xid v1.5.0
-	github.com/stretchr/testify v1.8.4
+	github.com/stretchr/testify v1.10.0
 	github.com/twmb/murmur3 v1.1.8
 	github.com/xeipuuv/gojsonschema v1.2.0
 	github.com/zeebo/xxh3 v1.0.2
-	go.opentelemetry.io/otel v1.21.0
-	go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v0.44.0
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.21.0
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.21.0
-	go.opentelemetry.io/otel/exporters/prometheus v0.44.0
-	go.opentelemetry.io/otel/metric v1.21.0
-	go.opentelemetry.io/otel/sdk v1.21.0
-	go.opentelemetry.io/otel/sdk/metric v1.21.0
-	go.opentelemetry.io/otel/trace v1.21.0
-	go.uber.org/zap v1.26.0
-	golang.org/x/crypto v0.16.0
-	golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa
-	golang.org/x/mod v0.14.0
-	golang.org/x/net v0.19.0
-	golang.org/x/sync v0.5.0
-	google.golang.org/grpc v1.59.0
-	google.golang.org/protobuf v1.31.0
+	go.opentelemetry.io/otel v1.37.0
+	go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.37.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.37.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.37.0
+	go.opentelemetry.io/otel/exporters/prometheus v0.59.0
+	go.opentelemetry.io/otel/metric v1.37.0
+	go.opentelemetry.io/otel/sdk v1.37.0
+	go.opentelemetry.io/otel/sdk/metric v1.37.0
+	go.opentelemetry.io/otel/trace v1.37.0
+	go.uber.org/mock v0.5.2
+	go.uber.org/zap v1.27.0
+	gocloud.dev v0.42.0
+	golang.org/x/crypto v0.39.0
+	golang.org/x/exp v0.0.0-20250210185358-939b2ce775ac
+	golang.org/x/mod v0.25.0
+	golang.org/x/sync v0.15.0
+	google.golang.org/grpc v1.73.0
+	google.golang.org/protobuf v1.36.6
 	gopkg.in/yaml.v3 v3.0.1
-	k8s.io/apimachinery v0.28.4
-	k8s.io/client-go v0.28.4
-	sigs.k8s.io/controller-runtime v0.16.3
+	k8s.io/apimachinery v0.33.2
+	k8s.io/client-go v0.33.2
 )
 
 require (
-	github.com/Masterminds/goutils v1.1.1 // indirect
-	github.com/Masterminds/semver v1.5.0 // indirect
+	cel.dev/expr v0.23.0 // indirect
+	cloud.google.com/go v0.121.1 // indirect
+	cloud.google.com/go/auth v0.16.1 // indirect
+	cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect
+	cloud.google.com/go/compute/metadata v0.7.0 // indirect
+	cloud.google.com/go/iam v1.5.2 // indirect
+	cloud.google.com/go/monitoring v1.24.2 // indirect
+	cloud.google.com/go/storage v1.55.0 // indirect
+	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.17.1 // indirect
+	github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.8.2 // indirect
+	github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0 // indirect
+	github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.6.0 // indirect
+	github.com/Azure/go-autorest v14.2.0+incompatible // indirect
+	github.com/Azure/go-autorest/autorest/to v0.4.1 // indirect
+	github.com/AzureAD/microsoft-authentication-library-for-go v1.4.2 // indirect
+	github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.27.0 // indirect
+	github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.51.0 // indirect
+	github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.51.0 // indirect
+	github.com/aws/aws-sdk-go v1.55.6 // indirect
+	github.com/aws/aws-sdk-go-v2 v1.36.3 // indirect
+	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.10 // indirect
+	github.com/aws/aws-sdk-go-v2/config v1.29.12 // indirect
+	github.com/aws/aws-sdk-go-v2/credentials v1.17.65 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.30 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.69 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.34 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.34 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.34 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.3 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.7.0 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.15 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.18.15 // indirect
+	github.com/aws/aws-sdk-go-v2/service/s3 v1.78.2 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sso v1.25.2 // indirect
+	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.30.0 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sts v1.33.17 // indirect
+	github.com/aws/smithy-go v1.22.3 // indirect
+	github.com/barkimedes/go-deepcopy v0.0.0-20220514131651-17c30cfc62df // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/cenkalti/backoff/v4 v4.2.1 // indirect
-	github.com/cespare/xxhash/v2 v2.2.0 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/emicklei/go-restful/v3 v3.11.0 // indirect
-	github.com/evanphx/json-patch v5.6.0+incompatible // indirect
-	github.com/evanphx/json-patch/v5 v5.6.0 // indirect
-	github.com/go-logr/logr v1.3.0 // indirect
+	github.com/cenkalti/backoff/v5 v5.0.2 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/cncf/xds/go v0.0.0-20250326154945-ae57f3c0d45f // indirect
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
+	github.com/emicklei/go-restful/v3 v3.12.0 // indirect
+	github.com/envoyproxy/go-control-plane/envoy v1.32.4 // indirect
+	github.com/envoyproxy/protoc-gen-validate v1.2.1 // indirect
+	github.com/evanphx/json-patch/v5 v5.9.0 // indirect
+	github.com/felixge/httpsnoop v1.0.4 // indirect
+	github.com/fxamacker/cbor/v2 v2.7.0 // indirect
+	github.com/go-jose/go-jose/v4 v4.0.5 // indirect
+	github.com/go-logr/logr v1.4.3 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/go-openapi/jsonpointer v0.19.6 // indirect
-	github.com/go-openapi/jsonreference v0.20.2 // indirect
-	github.com/go-openapi/swag v0.22.3 // indirect
-	github.com/go-task/slim-sprig v2.20.0+incompatible // indirect
+	github.com/go-openapi/jsonpointer v0.21.0 // indirect
+	github.com/go-openapi/jsonreference v0.21.0 // indirect
+	github.com/go-openapi/swag v0.23.0 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/golang/protobuf v1.5.3 // indirect
-	github.com/google/gnostic-models v0.6.8 // indirect
-	github.com/google/go-cmp v0.6.0 // indirect
-	github.com/google/gofuzz v1.2.0 // indirect
-	github.com/google/uuid v1.3.1 // indirect
-	github.com/grpc-ecosystem/grpc-gateway/v2 v2.16.0 // indirect
-	github.com/huandu/xstrings v1.4.0 // indirect
-	github.com/imdario/mergo v0.3.13 // indirect
+	github.com/golang-jwt/jwt/v5 v5.2.2 // indirect
+	github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
+	github.com/google/gnostic-models v0.6.9 // indirect
+	github.com/google/s2a-go v0.1.9 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/google/wire v0.6.0 // indirect
+	github.com/googleapis/enterprise-certificate-proxy v0.3.6 // indirect
+	github.com/googleapis/gax-go/v2 v2.14.2 // indirect
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.1 // indirect
+	github.com/jmespath/go-jmespath v0.4.0 // indirect
 	github.com/josharian/intern v1.0.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.4 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
+	github.com/kylelemons/godebug v1.1.0 // indirect
 	github.com/mailru/easyjson v0.7.7 // indirect
-	github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect
-	github.com/mitchellh/copystructure v1.2.0 // indirect
-	github.com/mitchellh/reflectwalk v1.0.2 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
+	github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect
 	github.com/pkg/errors v0.9.1 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/prometheus/client_model v0.5.0 // indirect
-	github.com/prometheus/common v0.44.0 // indirect
-	github.com/prometheus/procfs v0.11.1 // indirect
+	github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect
+	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
+	github.com/prometheus/client_model v0.6.2 // indirect
+	github.com/prometheus/common v0.65.0 // indirect
+	github.com/prometheus/procfs v0.16.1 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/spiffe/go-spiffe/v2 v2.5.0 // indirect
+	github.com/x448/float16 v0.8.4 // indirect
 	github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb // indirect
 	github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect
-	go.opentelemetry.io/proto/otlp v1.0.0 // indirect
+	github.com/zeebo/errs v1.4.0 // indirect
+	go.opencensus.io v0.24.0 // indirect
+	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
+	go.opentelemetry.io/contrib/detectors/gcp v1.36.0 // indirect
+	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.60.0 // indirect
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.60.0 // indirect
+	go.opentelemetry.io/proto/otlp v1.7.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
-	golang.org/x/oauth2 v0.11.0 // indirect
-	golang.org/x/sys v0.15.0 // indirect
-	golang.org/x/term v0.15.0 // indirect
-	golang.org/x/text v0.14.0 // indirect
-	golang.org/x/time v0.3.0 // indirect
-	google.golang.org/appengine v1.6.7 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20230822172742-b8732ec3820d // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d // indirect
+	golang.org/x/net v0.41.0 // indirect
+	golang.org/x/oauth2 v0.30.0 // indirect
+	golang.org/x/sys v0.33.0 // indirect
+	golang.org/x/term v0.32.0 // indirect
+	golang.org/x/text v0.26.0 // indirect
+	golang.org/x/time v0.11.0 // indirect
+	golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da // indirect
+	gomodules.xyz/jsonpatch/v2 v2.4.0 // indirect
+	google.golang.org/api v0.235.0 // indirect
+	google.golang.org/genproto v0.0.0-20250603155806-513f23925822 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20250603155806-513f23925822 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20250603155806-513f23925822 // indirect
+	gopkg.in/evanphx/json-patch.v4 v4.12.0 // indirect
 	gopkg.in/inf.v0 v0.9.1 // indirect
-	gopkg.in/yaml.v2 v2.4.0 // indirect
-	k8s.io/api v0.28.4 // indirect
-	k8s.io/klog/v2 v2.100.1 // indirect
-	k8s.io/kube-openapi v0.0.0-20230717233707-2695361300d9 // indirect
-	k8s.io/utils v0.0.0-20230406110748-d93618cff8a2 // indirect
-	sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd // indirect
-	sigs.k8s.io/structured-merge-diff/v4 v4.2.3 // indirect
-	sigs.k8s.io/yaml v1.3.0 // indirect
+	k8s.io/api v0.33.2 // indirect
+	k8s.io/apiextensions-apiserver v0.31.1 // indirect
+	k8s.io/klog/v2 v2.130.1 // indirect
+	k8s.io/kube-openapi v0.0.0-20250318190949-c8a335a9a2ff // indirect
+	k8s.io/utils v0.0.0-20241104100929-3ea5e8cea738 // indirect
+	sigs.k8s.io/controller-runtime v0.19.3 // indirect
+	sigs.k8s.io/gateway-api v1.2.1 // indirect
+	sigs.k8s.io/json v0.0.0-20241010143419-9aa6b5e7a4b3 // indirect
+	sigs.k8s.io/randfill v1.0.0 // indirect
+	sigs.k8s.io/structured-merge-diff/v4 v4.6.0 // indirect
+	sigs.k8s.io/yaml v1.4.0 // indirect
 )

core/pkg/certreloader/certreloader.go

@@ -0,0 +1,69 @@
+package certreloader
+
+import (
+	"crypto/tls"
+	"fmt"
+	"sync"
+	"time"
+)
+
+type Config struct {
+	KeyPath        string
+	CertPath       string
+	ReloadInterval time.Duration
+}
+
+type CertReloader struct {
+	cert       *tls.Certificate
+	mu         sync.RWMutex
+	nextReload time.Time
+	Config
+}
+
+func NewCertReloader(config Config) (*CertReloader, error) {
+	reloader := CertReloader{
+		Config: config,
+	}
+
+	reloader.mu.Lock()
+	defer reloader.mu.Unlock()
+	cert, err := reloader.loadCertificate()
+	if err != nil {
+		return nil, fmt.Errorf("failed to load initial certificate: %w", err)
+	}
+	reloader.cert = &cert
+
+	return &reloader, nil
+}
+
+func (r *CertReloader) GetCertificate() (*tls.Certificate, error) {
+	now := time.Now()
+	// Read locking here before we do the time comparison
+	// If a reload is in progress this will block and we will skip reloading in the current
+	// call once we can continue
+	r.mu.RLock()
+	shouldReload := r.ReloadInterval != 0 && r.nextReload.Before(now)
+	r.mu.RUnlock()
+	if shouldReload {
+		// Need to release the read lock, otherwise we deadlock
+		r.mu.Lock()
+		defer r.mu.Unlock()
+		cert, err := r.loadCertificate()
+		if err != nil {
+			return nil, fmt.Errorf("failed to load TLS cert and key: %w", err)
+		}
+		r.cert = &cert
+		r.nextReload = now.Add(r.ReloadInterval)
+		return r.cert, nil
+	}
+	return r.cert, nil
+}
+
+func (r *CertReloader) loadCertificate() (tls.Certificate, error) {
+	newCert, err := tls.LoadX509KeyPair(r.CertPath, r.KeyPath)
+	if err != nil {
+		return tls.Certificate{}, fmt.Errorf("failed to load key pair: %w", err)
+	}
+
+	return newCert, nil
+}

core/pkg/certreloader/certreloader_test.go

@@ -0,0 +1,306 @@
+package certreloader
+
+import (
+	"bytes"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/tls"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/pem"
+	"fmt"
+	"io"
+	"math/big"
+	"net"
+	"os"
+	"testing"
+	"time"
+)
+
+func TestNewCertReloader(t *testing.T) {
+	cert1, key1, cleanup := generateValidCertificateFiles(t)
+	defer cleanup()
+	_, key2, cleanup := generateValidCertificateFiles(t)
+	defer cleanup()
+
+	tcs := []struct {
+		name   string
+		config Config
+		err    error
+	}{
+		{
+			name:   "no config set",
+			config: Config{},
+			err:    fmt.Errorf("failed to load initial certificate: failed to load key pair: open : no such file or directory"),
+		},
+		{
+			name:   "invalid certs",
+			config: Config{CertPath: cert1, KeyPath: key2},
+			err:    fmt.Errorf("failed to load initial certificate: failed to load key pair: tls: private key does not match public key"),
+		},
+
+		{
+			name:   "valid certs",
+			config: Config{CertPath: cert1, KeyPath: key1},
+			err:    nil,
+		},
+	}
+
+	for _, tc := range tcs {
+		t.Run(tc.name, func(t *testing.T) {
+			reloader, err := NewCertReloader(tc.config)
+			if err != nil {
+				if tc.err == nil {
+					t.Fatalf("NewCertReloader returned error when no error was expected: %s", err)
+				} else if tc.err.Error() != err.Error() {
+					t.Fatalf("expected error did not matched received error. expected: %v, received: %v", tc.err, err)
+				}
+			} else {
+				if reloader == nil {
+					t.Fatal("expected reloader to not be nil")
+				}
+			}
+		})
+	}
+}
+
+func TestCertificateReload(t *testing.T) {
+	newCert, newKey, cleanup := generateValidCertificateFiles(t)
+	defer cleanup()
+
+	tcs := []struct {
+		name           string
+		waitInterval   time.Duration
+		reloadInterval time.Duration
+		newCert        string
+		newKey         string
+		shouldRotate   bool
+		err            error
+	}{
+		{
+			name:           "reloads after interval",
+			waitInterval:   time.Microsecond * 200,
+			reloadInterval: time.Microsecond * 100,
+			newCert:        newCert,
+			newKey:         newKey,
+			shouldRotate:   true,
+			err:            nil,
+		},
+		{
+			name:           "doesnt reload before  interval",
+			waitInterval:   time.Microsecond * 50,
+			reloadInterval: time.Microsecond * 100,
+			newCert:        newCert,
+			newKey:         newKey,
+			shouldRotate:   false,
+			err:            nil,
+		},
+	}
+
+	for _, tc := range tcs {
+		t.Run(tc.name, func(t *testing.T) {
+			cert, key, cleanup := generateValidCertificateFiles(t)
+			defer cleanup()
+			reloader, err := NewCertReloader(Config{
+				CertPath:       cert,
+				KeyPath:        key,
+				ReloadInterval: tc.reloadInterval,
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if err := copyFile(tc.newCert, cert); err != nil {
+				t.Fatalf("failed to move %s -> %s: %s", newCert, cert, err)
+			}
+			if err := copyFile(tc.newKey, key); err != nil {
+				t.Fatalf("failed to move %s -> %s: %s", newKey, key, err)
+			}
+			time.Sleep(tc.waitInterval)
+
+			actualCert, err := reloader.GetCertificate()
+			if err != nil {
+				t.Fatal(err)
+			}
+			actualCertParsed, err := x509.ParseCertificate(actualCert.Certificate[0])
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			var expectedCert tls.Certificate
+			if tc.shouldRotate {
+				expectedCert, err = tls.LoadX509KeyPair(tc.newCert, tc.newKey)
+				if err != nil {
+					t.Fatal(err)
+				}
+			} else {
+				expectedCert, err = tls.LoadX509KeyPair(cert, key)
+				if err != nil {
+					t.Fatal(err)
+				}
+			}
+			expectedCertParsed, err := x509.ParseCertificate(expectedCert.Certificate[0])
+			if err != nil {
+				t.Fatal(err)
+			}
+			if expectedCertParsed.DNSNames[0] != actualCertParsed.DNSNames[0] {
+				t.Fatalf("expected certificate was not returned by GetCertificate. expectedCert: %v, actualCert: %v", expectedCertParsed.DNSNames[0], actualCertParsed.DNSNames[0])
+			}
+		})
+	}
+}
+
+func generateValidCertificate(t *testing.T) (*bytes.Buffer, *bytes.Buffer) {
+	t.Helper()
+
+	// set up our CA certificate
+	ca := &x509.Certificate{
+		SerialNumber: big.NewInt(2019),
+		Subject: pkix.Name{
+			Organization:  []string{"Company, INC."},
+			Country:       []string{"US"},
+			Province:      []string{""},
+			Locality:      []string{"San Francisco"},
+			StreetAddress: []string{"Golden Gate Bridge"},
+			PostalCode:    []string{"94016"},
+		},
+		NotBefore:             time.Now(),
+		NotAfter:              time.Now().AddDate(10, 0, 0),
+		IsCA:                  true,
+		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth},
+		KeyUsage:              x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
+		BasicConstraintsValid: true,
+	}
+
+	// create our private and public key
+	caPrivKey, err := rsa.GenerateKey(rand.Reader, 4096)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// create the CA
+	caBytes, err := x509.CreateCertificate(rand.Reader, ca, ca, &caPrivKey.PublicKey, caPrivKey)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// pem encode
+	caPEM := new(bytes.Buffer)
+	err = pem.Encode(caPEM, &pem.Block{
+		Type:  "CERTIFICATE",
+		Bytes: caBytes,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	caPrivKeyPEM := new(bytes.Buffer)
+	err = pem.Encode(caPrivKeyPEM, &pem.Block{
+		Type:  "RSA PRIVATE KEY",
+		Bytes: x509.MarshalPKCS1PrivateKey(caPrivKey),
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// set up our server certificate
+	cert := &x509.Certificate{
+		SerialNumber: big.NewInt(2019),
+		Subject: pkix.Name{
+			Organization:  []string{"Company, INC."},
+			Country:       []string{"US"},
+			Province:      []string{""},
+			Locality:      []string{"San Francisco"},
+			StreetAddress: []string{"Golden Gate Bridge"},
+			PostalCode:    []string{"94016"},
+		},
+		DNSNames:     []string{randString(8)},
+		IPAddresses:  []net.IP{net.IPv4(127, 0, 0, 1), net.IPv6loopback},
+		NotBefore:    time.Now(),
+		NotAfter:     time.Now().AddDate(10, 0, 0),
+		SubjectKeyId: []byte{1, 2, 3, 4, 6},
+		ExtKeyUsage:  []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth},
+		KeyUsage:     x509.KeyUsageDigitalSignature,
+	}
+
+	certPrivKey, err := rsa.GenerateKey(rand.Reader, 4096)
+	if err != nil {
+		t.Fatalf("failed to create private key: %s", err)
+	}
+
+	certBytes, err := x509.CreateCertificate(rand.Reader, cert, ca, &certPrivKey.PublicKey, caPrivKey)
+	if err != nil {
+		t.Fatalf("failed to create certificate: %s", err)
+	}
+
+	certPEM := new(bytes.Buffer)
+	err = pem.Encode(certPEM, &pem.Block{
+		Type:  "CERTIFICATE",
+		Bytes: certBytes,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	certPrivKeyPEM := new(bytes.Buffer)
+	err = pem.Encode(certPrivKeyPEM, &pem.Block{
+		Type:  "RSA PRIVATE KEY",
+		Bytes: x509.MarshalPKCS1PrivateKey(certPrivKey),
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	return certPEM, certPrivKeyPEM
+}
+
+func generateValidCertificateFiles(t *testing.T) (string, string, func()) {
+	t.Helper()
+	certFile, err := os.CreateTemp("", "certreloader_cert")
+	if err != nil {
+		t.Fatalf("failed to create certFile: %s", err)
+	}
+	defer certFile.Close()
+	keyFile, err := os.CreateTemp("", "certreloader_key")
+	if err != nil {
+		t.Fatalf("failed to create keyFile: %s", err)
+	}
+	defer keyFile.Close()
+
+	certBytes, keyBytes := generateValidCertificate(t)
+	if _, err := io.Copy(certFile, certBytes); err != nil {
+		t.Fatalf("failed to copy certBytes into %s: %s", certFile.Name(), err)
+	}
+	if _, err := io.Copy(keyFile, keyBytes); err != nil {
+		t.Fatalf("failed to copy keyBytes into %s: %s", keyFile.Name(), err)
+	}
+
+	return certFile.Name(), keyFile.Name(), func() {
+		os.Remove(certFile.Name())
+		os.Remove(keyFile.Name())
+	}
+}
+
+func copyFile(src, dst string) error {
+	data, err := os.ReadFile(src)
+	if err != nil {
+		return fmt.Errorf("failed to load key pair: %w", err)
+	}
+
+	err = os.WriteFile(dst, data, 0o0600)
+	if err != nil {
+		return fmt.Errorf("failed to load key pair: %w", err)
+	}
+	return nil
+}
+
+func randString(n int) string {
+	const alphanum = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+	bytes := make([]byte, n)
+	//nolint:errcheck
+	rand.Read(bytes)
+	for i, b := range bytes {
+		bytes[i] = alphanum[b%byte(len(alphanum))]
+	}
+	return string(bytes)
+}

core/pkg/eval/fractional_evaluation.go

@@ -1,126 +0,0 @@
-package eval
-
-import (
-	"errors"
-	"fmt"
-	"math"
-
-	"github.com/open-feature/flagd/core/pkg/logger"
-	"github.com/twmb/murmur3"
-)
-
-const FractionEvaluationName = "fractional"
-
-type FractionalEvaluator struct {
-	Logger *logger.Logger
-}
-
-type fractionalEvaluationDistribution struct {
-	variant    string
-	percentage int
-}
-
-func NewFractionalEvaluator(logger *logger.Logger) *FractionalEvaluator {
-	return &FractionalEvaluator{Logger: logger}
-}
-
-func (fe *FractionalEvaluator) FractionalEvaluation(values, data any) any {
-	valueToDistribute, feDistributions, err := parseFractionalEvaluationData(values, data)
-	if err != nil {
-		fe.Logger.Error(fmt.Sprintf("parse fractional evaluation data: %v", err))
-		return nil
-	}
-
-	return distributeValue(valueToDistribute, feDistributions)
-}
-
-func parseFractionalEvaluationData(values, data any) (string, []fractionalEvaluationDistribution, error) {
-	valuesArray, ok := values.([]any)
-	if !ok {
-		return "", nil, errors.New("fractional evaluation data is not an array")
-	}
-	if len(valuesArray) < 2 {
-		return "", nil, errors.New("fractional evaluation data has length under 2")
-	}
-
-	dataMap, ok := data.(map[string]any)
-	if !ok {
-		return "", nil, errors.New("data isn't of type map[string]any")
-	}
-
-	// Ignore the error as we can't really do anything if the properties are
-	// somehow missing.
-	properties, _ := getFlagdProperties(dataMap)
-
-	bucketBy, ok := valuesArray[0].(string)
-	if ok {
-		valuesArray = valuesArray[1:]
-	} else {
-		bucketBy, ok = dataMap[targetingKeyKey].(string)
-		if !ok {
-			return "", nil, errors.New("bucketing value not supplied and no targetingKey in context")
-		}
-	}
-
-	feDistributions, err := parseFractionalEvaluationDistributions(valuesArray)
-	if err != nil {
-		return "", nil, err
-	}
-
-	return fmt.Sprintf("%s%s", properties.FlagKey, bucketBy), feDistributions, nil
-}
-
-func parseFractionalEvaluationDistributions(values []any) ([]fractionalEvaluationDistribution, error) {
-	sumOfPercentages := 0
-	var feDistributions []fractionalEvaluationDistribution
-	for i := 0; i < len(values); i++ {
-		distributionArray, ok := values[i].([]any)
-		if !ok {
-			return nil, errors.New("distribution elements aren't of type []any")
-		}
-
-		if len(distributionArray) != 2 {
-			return nil, errors.New("distribution element isn't length 2")
-		}
-
-		variant, ok := distributionArray[0].(string)
-		if !ok {
-			return nil, errors.New("first element of distribution element isn't string")
-		}
-
-		percentage, ok := distributionArray[1].(float64)
-		if !ok {
-			return nil, errors.New("second element of distribution element isn't float")
-		}
-
-		sumOfPercentages += int(percentage)
-
-		feDistributions = append(feDistributions, fractionalEvaluationDistribution{
-			variant:    variant,
-			percentage: int(percentage),
-		})
-	}
-
-	if sumOfPercentages != 100 {
-		return nil, fmt.Errorf("percentages must sum to 100, got: %d", sumOfPercentages)
-	}
-
-	return feDistributions, nil
-}
-
-// distributeValue calculate hash for given hash key and find the bucket distributions belongs to
-func distributeValue(value string, feDistribution []fractionalEvaluationDistribution) string {
-	hashValue := int32(murmur3.StringSum32(value))
-	hashRatio := math.Abs(float64(hashValue)) / math.MaxInt32
-	bucket := int(hashRatio * 100) // in range [0, 100]
-
-	rangeEnd := 0
-	for _, dist := range feDistribution {
-		rangeEnd += dist.percentage
-		if bucket < rangeEnd {
-			return dist.variant
-		}
-	}
-
-	return ""
-}

core/pkg/eval/legacy_fractional_evaluation.go

@@ -1,145 +0,0 @@
-// This evaluation type is deprecated and will be removed before v1.
-// Do not enhance it or use it for reference.
-
-package eval
-
-import (
-	"errors"
-	"fmt"
-	"math"
-
-	"github.com/open-feature/flagd/core/pkg/logger"
-	"github.com/zeebo/xxh3"
-)
-
-const (
-	LegacyFractionEvaluationName = "fractionalEvaluation"
-	LegacyFractionEvaluationLink = "https://flagd.dev/concepts/#migrating-from-legacy-fractionalevaluation"
-)
-
-// Deprecated: LegacyFractionalEvaluator is deprecated. This will be removed prior to v1 release.
-type LegacyFractionalEvaluator struct {
-	Logger *logger.Logger
-}
-
-type legacyFractionalEvaluationDistribution struct {
-	variant    string
-	percentage int
-}
-
-func NewLegacyFractionalEvaluator(logger *logger.Logger) *LegacyFractionalEvaluator {
-	return &LegacyFractionalEvaluator{Logger: logger}
-}
-
-func (fe *LegacyFractionalEvaluator) LegacyFractionalEvaluation(values, data interface{}) interface{} {
-	fe.Logger.Warn(
-		fmt.Sprintf("%s is deprecated, please use %s, see: %s",
-			LegacyFractionEvaluationName,
-			FractionEvaluationName,
-			LegacyFractionEvaluationLink))
-
-	valueToDistribute, feDistributions, err := parseLegacyFractionalEvaluationData(values, data)
-	if err != nil {
-		fe.Logger.Error(fmt.Sprintf("parse fractional evaluation data: %v", err))
-		return nil
-	}
-
-	return distributeLegacyValue(valueToDistribute, feDistributions)
-}
-
-func parseLegacyFractionalEvaluationData(values, data interface{}) (string,
-	[]legacyFractionalEvaluationDistribution, error,
-) {
-	valuesArray, ok := values.([]interface{})
-	if !ok {
-		return "", nil, errors.New("fractional evaluation data is not an array")
-	}
-	if len(valuesArray) < 2 {
-		return "", nil, errors.New("fractional evaluation data has length under 2")
-	}
-
-	bucketBy, ok := valuesArray[0].(string)
-	if !ok {
-		return "", nil, errors.New("first element of fractional evaluation data isn't of type string")
-	}
-
-	dataMap, ok := data.(map[string]interface{})
-	if !ok {
-		return "", nil, errors.New("data isn't of type map[string]interface{}")
-	}
-
-	v, ok := dataMap[bucketBy]
-	if !ok {
-		return "", nil, nil
-	}
-
-	valueToDistribute, ok := v.(string)
-	if !ok {
-		return "", nil, fmt.Errorf("var: %s isn't of type string", bucketBy)
-	}
-
-	feDistributions, err := parseLegacyFractionalEvaluationDistributions(valuesArray)
-	if err != nil {
-		return "", nil, err
-	}
-
-	return valueToDistribute, feDistributions, nil
-}
-
-func parseLegacyFractionalEvaluationDistributions(values []interface{}) (
-	[]legacyFractionalEvaluationDistribution, error,
-) {
-	sumOfPercentages := 0
-	var feDistributions []legacyFractionalEvaluationDistribution
-	for i := 1; i < len(values); i++ {
-		distributionArray, ok := values[i].([]interface{})
-		if !ok {
-			return nil, errors.New("distribution elements aren't of type []interface{}")
-		}
-
-		if len(distributionArray) != 2 {
-			return nil, errors.New("distribution element isn't length 2")
-		}
-
-		variant, ok := distributionArray[0].(string)
-		if !ok {
-			return nil, errors.New("first element of distribution element isn't string")
-		}
-
-		percentage, ok := distributionArray[1].(float64)
-		if !ok {
-			return nil, errors.New("second element of distribution element isn't float")
-		}
-
-		sumOfPercentages += int(percentage)
-
-		feDistributions = append(feDistributions, legacyFractionalEvaluationDistribution{
-			variant:    variant,
-			percentage: int(percentage),
-		})
-	}
-
-	if sumOfPercentages != 100 {
-		return nil, fmt.Errorf("percentages must sum to 100, got: %d", sumOfPercentages)
-	}
-
-	return feDistributions, nil
-}
-
-func distributeLegacyValue(value string, feDistribution []legacyFractionalEvaluationDistribution) string {
-	hashValue := xxh3.HashString(value)
-
-	hashRatio := float64(hashValue) / math.Pow(2, 64) // divide the hash value by the largest possible value, integer 2^64
-
-	bucket := int(hashRatio * 100) // integer in range [0, 99]
-
-	rangeEnd := 0
-	for _, dist := range feDistribution {
-		rangeEnd += dist.percentage
-		if bucket < rangeEnd {
-			return dist.variant
-		}
-	}
-
-	return ""
-}

core/pkg/eval/legacy_fractional_evaluation_test.go

@@ -1,304 +0,0 @@
-package eval
-
-import (
-	"testing"
-
-	"github.com/open-feature/flagd/core/pkg/logger"
-	"github.com/open-feature/flagd/core/pkg/model"
-	"github.com/open-feature/flagd/core/pkg/store"
-)
-
-func TestLegacyFractionalEvaluation(t *testing.T) {
-	flags := Flags{
-		Flags: map[string]model.Flag{
-			"headerColor": {
-				State:          "ENABLED",
-				DefaultVariant: "red",
-				Variants: map[string]any{
-					"red":    "#FF0000",
-					"blue":   "#0000FF",
-					"green":  "#00FF00",
-					"yellow": "#FFFF00",
-				},
-				Targeting: []byte(`{
-											"if": [
-											  {
-												"in": ["@faas.com", {
-														"var": ["email"]
-													  }]
-											  },
-											  {
-												"fractionalEvaluation": [
-												  "email",
-												  [
-													"red",
-													25
-												  ],
-												  [
-													"blue",
-													25
-												  ],
-												  [
-													"green",
-													25
-												  ],
-												  [
-													"yellow",
-													25
-												  ]
-												]
-											  }, null
-											]
-										  }`),
-			},
-		},
-	}
-
-	tests := map[string]struct {
-		flags             Flags
-		flagKey           string
-		context           map[string]any
-		expectedValue     string
-		expectedVariant   string
-		expectedReason    string
-		expectedErrorCode string
-	}{
-		"test@faas.com": {
-			flags:   flags,
-			flagKey: "headerColor",
-			context: map[string]any{
-				"email": "test@faas.com",
-			},
-			expectedVariant: "red",
-			expectedValue:   "#FF0000",
-			expectedReason:  model.TargetingMatchReason,
-		},
-		"test2@faas.com": {
-			flags:   flags,
-			flagKey: "headerColor",
-			context: map[string]any{
-				"email": "test2@faas.com",
-			},
-			expectedVariant: "yellow",
-			expectedValue:   "#FFFF00",
-			expectedReason:  model.TargetingMatchReason,
-		},
-		"test3@faas.com": {
-			flags:   flags,
-			flagKey: "headerColor",
-			context: map[string]any{
-				"email": "test3@faas.com",
-			},
-			expectedVariant: "red",
-			expectedValue:   "#FF0000",
-			expectedReason:  model.TargetingMatchReason,
-		},
-		"test4@faas.com": {
-			flags:   flags,
-			flagKey: "headerColor",
-			context: map[string]any{
-				"email": "test4@faas.com",
-			},
-			expectedVariant: "blue",
-			expectedValue:   "#0000FF",
-			expectedReason:  model.TargetingMatchReason,
-		},
-		"non even split": {
-			flags: Flags{
-				Flags: map[string]model.Flag{
-					"headerColor": {
-						State:          "ENABLED",
-						DefaultVariant: "red",
-						Variants: map[string]any{
-							"red":    "#FF0000",
-							"blue":   "#0000FF",
-							"green":  "#00FF00",
-							"yellow": "#FFFF00",
-						},
-						Targeting: []byte(`{
-											"if": [
-											  {
-												"in": ["@faas.com", {
-														"var": ["email"]
-													  }]
-											  },
-											  {
-												"fractionalEvaluation": [
-												  "email",
-												  [
-													"red",
-													50
-												  ],
-												  [
-													"blue",
-													25
-												  ],
-												  [
-													"green",
-													25
-												  ]
-												]
-											  }, null
-											]
-										  }`),
-					},
-				},
-			},
-			flagKey: "headerColor",
-			context: map[string]any{
-				"email": "test4@faas.com",
-			},
-			expectedVariant: "red",
-			expectedValue:   "#FF0000",
-			expectedReason:  model.TargetingMatchReason,
-		},
-		"fallback to default variant if no email provided": {
-			flags: Flags{
-				Flags: map[string]model.Flag{
-					"headerColor": {
-						State:          "ENABLED",
-						DefaultVariant: "red",
-						Variants: map[string]any{
-							"red":    "#FF0000",
-							"blue":   "#0000FF",
-							"green":  "#00FF00",
-							"yellow": "#FFFF00",
-						},
-						Targeting: []byte(`{
-							"fractionalEvaluation": [
-								"email",
-								[
-								"red",
-								25
-								],
-								[
-								"blue",
-								25
-								],
-								[
-								"green",
-								25
-								],
-								[
-								"yellow",
-								25
-								]
-							]
-							}`),
-					},
-				},
-			},
-			flagKey:           "headerColor",
-			context:           map[string]any{},
-			expectedVariant:   "",
-			expectedValue:     "",
-			expectedReason:    model.ErrorReason,
-			expectedErrorCode: model.ParseErrorCode,
-		},
-		"fallback to default variant if invalid variant as result of fractional evaluation": {
-			flags: Flags{
-				Flags: map[string]model.Flag{
-					"headerColor": {
-						State:          "ENABLED",
-						DefaultVariant: "red",
-						Variants: map[string]any{
-							"red":    "#FF0000",
-							"blue":   "#0000FF",
-							"green":  "#00FF00",
-							"yellow": "#FFFF00",
-						},
-						Targeting: []byte(`{
-							"fractionalEvaluation": [
-								"email",
-								[
-								"black",
-								100
-								]
-							]
-							}`),
-					},
-				},
-			},
-			flagKey: "headerColor",
-			context: map[string]any{
-				"email": "foo@foo.com",
-			},
-			expectedVariant:   "",
-			expectedValue:     "",
-			expectedReason:    model.ErrorReason,
-			expectedErrorCode: model.ParseErrorCode,
-		},
-		"fallback to default variant if percentages don't sum to 100": {
-			flags: Flags{
-				Flags: map[string]model.Flag{
-					"headerColor": {
-						State:          "ENABLED",
-						DefaultVariant: "red",
-						Variants: map[string]any{
-							"red":    "#FF0000",
-							"blue":   "#0000FF",
-							"green":  "#00FF00",
-							"yellow": "#FFFF00",
-						},
-						Targeting: []byte(`{
-							"fractionalEvaluation": [
-								"email",
-								[
-								"red",
-								25
-								],
-								[
-								"blue",
-								25
-								]
-							]
-							}`),
-					},
-				},
-			},
-			flagKey: "headerColor",
-			context: map[string]any{
-				"email": "foo@foo.com",
-			},
-			expectedVariant: "red",
-			expectedValue:   "#FF0000",
-			expectedReason:  model.DefaultReason,
-		},
-	}
-	const reqID = "default"
-	for name, tt := range tests {
-		t.Run(name, func(t *testing.T) {
-			log := logger.NewLogger(nil, false)
-			je := NewJSONEvaluator(
-				log,
-				store.NewFlags(),
-				WithEvaluator(
-					"fractionalEvaluation",
-					NewLegacyFractionalEvaluator(log).LegacyFractionalEvaluation,
-				),
-			)
-			je.store.Flags = tt.flags.Flags
-
-			value, variant, reason, _, err := resolve[string](reqID, tt.flagKey, tt.context, je.evaluateVariant)
-
-			if value != tt.expectedValue {
-				t.Errorf("expected value '%s', got '%s'", tt.expectedValue, value)
-			}
-
-			if variant != tt.expectedVariant {
-				t.Errorf("expected variant '%s', got '%s'", tt.expectedVariant, variant)
-			}
-
-			if reason != tt.expectedReason {
-				t.Errorf("expected reason '%s', got '%s'", tt.expectedReason, reason)
-			}
-
-			if err != nil {
-				errorCode := err.Error()
-				if errorCode != tt.expectedErrorCode {
-					t.Errorf("expected err '%v', got '%v'", tt.expectedErrorCode, err)
-				}
-			}
-		})
-	}
-}

core/pkg/eval/mock/ievaluator.go

@@ -1,172 +0,0 @@
-// Code generated by MockGen. DO NOT EDIT.
-// Source: pkg/eval/ievaluator.go
-
-// Package evalmock is a generated GoMock package.
-package evalmock
-
-import (
-	context "context"
-	reflect "reflect"
-
-	gomock "github.com/golang/mock/gomock"
-	eval "github.com/open-feature/flagd/core/pkg/eval"
-	sync "github.com/open-feature/flagd/core/pkg/sync"
-)
-
-// MockIEvaluator is a mock of IEvaluator interface.
-type MockIEvaluator struct {
-	ctrl     *gomock.Controller
-	recorder *MockIEvaluatorMockRecorder
-}
-
-// MockIEvaluatorMockRecorder is the mock recorder for MockIEvaluator.
-type MockIEvaluatorMockRecorder struct {
-	mock *MockIEvaluator
-}
-
-// NewMockIEvaluator creates a new mock instance.
-func NewMockIEvaluator(ctrl *gomock.Controller) *MockIEvaluator {
-	mock := &MockIEvaluator{ctrl: ctrl}
-	mock.recorder = &MockIEvaluatorMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockIEvaluator) EXPECT() *MockIEvaluatorMockRecorder {
-	return m.recorder
-}
-
-// GetState mocks base method.
-func (m *MockIEvaluator) GetState() (string, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetState")
-	ret0, _ := ret[0].(string)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetState indicates an expected call of GetState.
-func (mr *MockIEvaluatorMockRecorder) GetState() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetState", reflect.TypeOf((*MockIEvaluator)(nil).GetState))
-}
-
-// ResolveAllValues mocks base method.
-func (m *MockIEvaluator) ResolveAllValues(ctx context.Context, reqID string, context map[string]any) []eval.AnyValue {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResolveAllValues", ctx, reqID, context)
-	ret0, _ := ret[0].([]eval.AnyValue)
-	return ret0
-}
-
-// ResolveAllValues indicates an expected call of ResolveAllValues.
-func (mr *MockIEvaluatorMockRecorder) ResolveAllValues(ctx, reqID, context interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveAllValues", reflect.TypeOf((*MockIEvaluator)(nil).ResolveAllValues), ctx, reqID, context)
-}
-
-// ResolveBooleanValue mocks base method.
-func (m *MockIEvaluator) ResolveBooleanValue(ctx context.Context, reqID, flagKey string, context map[string]any) (bool, string, string, map[string]interface{}, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResolveBooleanValue", ctx, reqID, flagKey, context)
-	ret0, _ := ret[0].(bool)
-	ret1, _ := ret[1].(string)
-	ret2, _ := ret[2].(string)
-	ret3, _ := ret[3].(map[string]interface{})
-	ret4, _ := ret[4].(error)
-	return ret0, ret1, ret2, ret3, ret4
-}
-
-// ResolveBooleanValue indicates an expected call of ResolveBooleanValue.
-func (mr *MockIEvaluatorMockRecorder) ResolveBooleanValue(ctx, reqID, flagKey, context interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveBooleanValue", reflect.TypeOf((*MockIEvaluator)(nil).ResolveBooleanValue), ctx, reqID, flagKey, context)
-}
-
-// ResolveFloatValue mocks base method.
-func (m *MockIEvaluator) ResolveFloatValue(ctx context.Context, reqID, flagKey string, context map[string]any) (float64, string, string, map[string]interface{}, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResolveFloatValue", ctx, reqID, flagKey, context)
-	ret0, _ := ret[0].(float64)
-	ret1, _ := ret[1].(string)
-	ret2, _ := ret[2].(string)
-	ret3, _ := ret[3].(map[string]interface{})
-	ret4, _ := ret[4].(error)
-	return ret0, ret1, ret2, ret3, ret4
-}
-
-// ResolveFloatValue indicates an expected call of ResolveFloatValue.
-func (mr *MockIEvaluatorMockRecorder) ResolveFloatValue(ctx, reqID, flagKey, context interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveFloatValue", reflect.TypeOf((*MockIEvaluator)(nil).ResolveFloatValue), ctx, reqID, flagKey, context)
-}
-
-// ResolveIntValue mocks base method.
-func (m *MockIEvaluator) ResolveIntValue(ctx context.Context, reqID, flagKey string, context map[string]any) (int64, string, string, map[string]interface{}, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResolveIntValue", ctx, reqID, flagKey, context)
-	ret0, _ := ret[0].(int64)
-	ret1, _ := ret[1].(string)
-	ret2, _ := ret[2].(string)
-	ret3, _ := ret[3].(map[string]interface{})
-	ret4, _ := ret[4].(error)
-	return ret0, ret1, ret2, ret3, ret4
-}
-
-// ResolveIntValue indicates an expected call of ResolveIntValue.
-func (mr *MockIEvaluatorMockRecorder) ResolveIntValue(ctx, reqID, flagKey, context interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveIntValue", reflect.TypeOf((*MockIEvaluator)(nil).ResolveIntValue), ctx, reqID, flagKey, context)
-}
-
-// ResolveObjectValue mocks base method.
-func (m *MockIEvaluator) ResolveObjectValue(ctx context.Context, reqID, flagKey string, context map[string]any) (map[string]any, string, string, map[string]interface{}, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResolveObjectValue", ctx, reqID, flagKey, context)
-	ret0, _ := ret[0].(map[string]any)
-	ret1, _ := ret[1].(string)
-	ret2, _ := ret[2].(string)
-	ret3, _ := ret[3].(map[string]interface{})
-	ret4, _ := ret[4].(error)
-	return ret0, ret1, ret2, ret3, ret4
-}
-
-// ResolveObjectValue indicates an expected call of ResolveObjectValue.
-func (mr *MockIEvaluatorMockRecorder) ResolveObjectValue(ctx, reqID, flagKey, context interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveObjectValue", reflect.TypeOf((*MockIEvaluator)(nil).ResolveObjectValue), ctx, reqID, flagKey, context)
-}
-
-// ResolveStringValue mocks base method.
-func (m *MockIEvaluator) ResolveStringValue(ctx context.Context, reqID, flagKey string, context map[string]any) (string, string, string, map[string]interface{}, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResolveStringValue", ctx, reqID, flagKey, context)
-	ret0, _ := ret[0].(string)
-	ret1, _ := ret[1].(string)
-	ret2, _ := ret[2].(string)
-	ret3, _ := ret[3].(map[string]interface{})
-	ret4, _ := ret[4].(error)
-	return ret0, ret1, ret2, ret3, ret4
-}
-
-// ResolveStringValue indicates an expected call of ResolveStringValue.
-func (mr *MockIEvaluatorMockRecorder) ResolveStringValue(ctx, reqID, flagKey, context interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveStringValue", reflect.TypeOf((*MockIEvaluator)(nil).ResolveStringValue), ctx, reqID, flagKey, context)
-}
-
-// SetState mocks base method.
-func (m *MockIEvaluator) SetState(payload sync.DataSync) (map[string]interface{}, bool, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetState", payload)
-	ret0, _ := ret[0].(map[string]interface{})
-	ret1, _ := ret[1].(bool)
-	ret2, _ := ret[2].(error)
-	return ret0, ret1, ret2
-}
-
-// SetState indicates an expected call of SetState.
-func (mr *MockIEvaluatorMockRecorder) SetState(payload interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetState", reflect.TypeOf((*MockIEvaluator)(nil).SetState), payload)
-}

core/pkg/evaluator/fractional.go

@@ -0,0 +1,148 @@
+package evaluator
+
+import (
+	"errors"
+	"fmt"
+	"math"
+
+	"github.com/open-feature/flagd/core/pkg/logger"
+	"github.com/twmb/murmur3"
+)
+
+const FractionEvaluationName = "fractional"
+
+type Fractional struct {
+	Logger *logger.Logger
+}
+
+type fractionalEvaluationDistribution struct {
+	totalWeight      int
+	weightedVariants []fractionalEvaluationVariant
+}
+
+type fractionalEvaluationVariant struct {
+	variant string
+	weight  int
+}
+
+func (v fractionalEvaluationVariant) getPercentage(totalWeight int) float64 {
+	if totalWeight == 0 {
+		return 0
+	}
+
+	return 100 * float64(v.weight) / float64(totalWeight)
+}
+
+func NewFractional(logger *logger.Logger) *Fractional {
+	return &Fractional{Logger: logger}
+}
+
+func (fe *Fractional) Evaluate(values, data any) any {
+	valueToDistribute, feDistributions, err := parseFractionalEvaluationData(values, data)
+	if err != nil {
+		fe.Logger.Warn(fmt.Sprintf("parse fractional evaluation data: %v", err))
+		return nil
+	}
+
+	return distributeValue(valueToDistribute, feDistributions)
+}
+
+func parseFractionalEvaluationData(values, data any) (string, *fractionalEvaluationDistribution, error) {
+	valuesArray, ok := values.([]any)
+	if !ok {
+		return "", nil, errors.New("fractional evaluation data is not an array")
+	}
+	if len(valuesArray) < 2 {
+		return "", nil, errors.New("fractional evaluation data has length under 2")
+	}
+
+	dataMap, ok := data.(map[string]any)
+	if !ok {
+		return "", nil, errors.New("data isn't of type map[string]any")
+	}
+
+	// Ignore the error as we can't really do anything if the properties are
+	// somehow missing.
+	properties, _ := getFlagdProperties(dataMap)
+
+	bucketBy, ok := valuesArray[0].(string)
+	if ok {
+		valuesArray = valuesArray[1:]
+	} else {
+		// check for nil here as custom property could be nil/missing
+		if valuesArray[0] == nil {
+			valuesArray = valuesArray[1:]
+		}
+
+		targetingKey, ok := dataMap[targetingKeyKey].(string)
+		if !ok {
+			return "", nil, errors.New("bucketing value not supplied and no targetingKey in context")
+		}
+
+		bucketBy = fmt.Sprintf("%s%s", properties.FlagKey, targetingKey)
+	}
+
+	feDistributions, err := parseFractionalEvaluationDistributions(valuesArray)
+	if err != nil {
+		return "", nil, err
+	}
+
+	return bucketBy, feDistributions, nil
+}
+
+func parseFractionalEvaluationDistributions(values []any) (*fractionalEvaluationDistribution, error) {
+	feDistributions := &fractionalEvaluationDistribution{
+		totalWeight:      0,
+		weightedVariants: make([]fractionalEvaluationVariant, len(values)),
+	}
+	for i := 0; i < len(values); i++ {
+		distributionArray, ok := values[i].([]any)
+		if !ok {
+			return nil, errors.New("distribution elements aren't of type []any. " +
+				"please check your rule in flag definition")
+		}
+
+		if len(distributionArray) == 0 {
+			return nil, errors.New("distribution element needs at least one element")
+		}
+
+		variant, ok := distributionArray[0].(string)
+		if !ok {
+			return nil, errors.New("first element of distribution element isn't string")
+		}
+
+		weight := 1.0
+		if len(distributionArray) >= 2 {
+			distributionWeight, ok := distributionArray[1].(float64)
+			if ok {
+				// default the weight to 1 if not specified explicitly
+				weight = distributionWeight
+			}
+		}
+
+		feDistributions.totalWeight += int(weight)
+		feDistributions.weightedVariants[i] = fractionalEvaluationVariant{
+			variant: variant,
+			weight:  int(weight),
+		}
+	}
+
+	return feDistributions, nil
+}
+
+// distributeValue calculate hash for given hash key and find the bucket distributions belongs to
+func distributeValue(value string, feDistribution *fractionalEvaluationDistribution) string {
+	hashValue := int32(murmur3.StringSum32(value))
+	hashRatio := math.Abs(float64(hashValue)) / math.MaxInt32
+	bucket := hashRatio * 100 // in range [0, 100]
+
+	rangeEnd := float64(0)
+	for _, weightedVariant := range feDistribution.weightedVariants {
+		rangeEnd += weightedVariant.getPercentage(feDistribution.totalWeight)
+		if bucket < rangeEnd {
+			return weightedVariant.variant
+		}
+	}
+
+	return ""
+}

core/pkg/evaluator/fractional_test.go

@@ -1,15 +1,21 @@
-package eval
+package evaluator
 
 import (
+	"context"
 	"testing"
 
 	"github.com/open-feature/flagd/core/pkg/logger"
 	"github.com/open-feature/flagd/core/pkg/model"
 	"github.com/open-feature/flagd/core/pkg/store"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestFractionalEvaluation(t *testing.T) {
-	flags := Flags{
+	const source = "testSource"
+	var sources = []string{source}
+	ctx := context.Background()
+
+	commonFlags := Flags{
 		Flags: map[string]model.Flag{
 			"headerColor": {
 				State:          "ENABLED",
@@ -29,7 +35,7 @@ func TestFractionalEvaluation(t *testing.T) {
 											  },
 											  {
 												"fractional": [
-												  {"var": "email"},
+												  {"cat": [{"var": "$flagd.flagKey"}, {"var": "email"}]},
 												  [
 												  "red",
 												  25
@@ -51,6 +57,34 @@ func TestFractionalEvaluation(t *testing.T) {
 											]
 										  }`),
 			},
+			"customSeededHeaderColor": {
+				State:          "ENABLED",
+				DefaultVariant: "red",
+				Variants: map[string]any{
+					"red":    "#FF0000",
+					"blue":   "#0000FF",
+					"green":  "#00FF00",
+					"yellow": "#FFFF00",
+				},
+				Targeting: []byte(`{
+					"if": [
+						{
+						"in": ["@faas.com", {
+								"var": ["email"]
+								}]
+						},
+						{
+						"fractional": [
+							{"cat": ["my-seed", {"var": "email"}]},
+							["red",25],
+							["blue",25],
+							["green",25],
+							["yellow",25]
+						]
+						}, null
+					]				  
+				}`),
+			},
 		},
 	}
 
@@ -64,7 +98,7 @@ func TestFractionalEvaluation(t *testing.T) {
 		expectedErrorCode string
 	}{
 		"rachel@faas.com": {
-			flags:   flags,
+			flags:   commonFlags,
 			flagKey: "headerColor",
 			context: map[string]any{
 				"email": "rachel@faas.com",
@@ -74,7 +108,7 @@ func TestFractionalEvaluation(t *testing.T) {
 			expectedReason:  model.TargetingMatchReason,
 		},
 		"monica@faas.com": {
-			flags:   flags,
+			flags:   commonFlags,
 			flagKey: "headerColor",
 			context: map[string]any{
 				"email": "monica@faas.com",
@@ -84,7 +118,7 @@ func TestFractionalEvaluation(t *testing.T) {
 			expectedReason:  model.TargetingMatchReason,
 		},
 		"joey@faas.com": {
-			flags:   flags,
+			flags:   commonFlags,
 			flagKey: "headerColor",
 			context: map[string]any{
 				"email": "joey@faas.com",
@@ -94,7 +128,7 @@ func TestFractionalEvaluation(t *testing.T) {
 			expectedReason:  model.TargetingMatchReason,
 		},
 		"ross@faas.com": {
-			flags:   flags,
+			flags:   commonFlags,
 			flagKey: "headerColor",
 			context: map[string]any{
 				"email": "ross@faas.com",
@@ -103,6 +137,46 @@ func TestFractionalEvaluation(t *testing.T) {
 			expectedValue:   "#00FF00",
 			expectedReason:  model.TargetingMatchReason,
 		},
+		"rachel@faas.com with custom seed": {
+			flags:   commonFlags,
+			flagKey: "customSeededHeaderColor",
+			context: map[string]any{
+				"email": "rachel@faas.com",
+			},
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"monica@faas.com with custom seed": {
+			flags:   commonFlags,
+			flagKey: "customSeededHeaderColor",
+			context: map[string]any{
+				"email": "monica@faas.com",
+			},
+			expectedVariant: "red",
+			expectedValue:   "#FF0000",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"joey@faas.com with custom seed": {
+			flags:   commonFlags,
+			flagKey: "customSeededHeaderColor",
+			context: map[string]any{
+				"email": "joey@faas.com",
+			},
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"ross@faas.com with custom seed": {
+			flags:   commonFlags,
+			flagKey: "customSeededHeaderColor",
+			context: map[string]any{
+				"email": "ross@faas.com",
+			},
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
 		"ross@faas.com with different flag key": {
 			flags: Flags{
 				Flags: map[string]model.Flag{
@@ -247,7 +321,7 @@ func TestFractionalEvaluation(t *testing.T) {
 			expectedValue:   "#FF0000",
 			expectedReason:  model.DefaultReason,
 		},
-		"fallback to default variant if percentages don't sum to 100": {
+		"get variant for non-percentage weight values": {
 			flags: Flags{
 				Flags: map[string]model.Flag{
 					"headerColor": {
@@ -281,7 +355,41 @@ func TestFractionalEvaluation(t *testing.T) {
 			},
 			expectedVariant: "red",
 			expectedValue:   "#FF0000",
-			expectedReason:  model.DefaultReason,
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"get variant for non-specified weight values": {
+			flags: Flags{
+				Flags: map[string]model.Flag{
+					"headerColor": {
+						State:          "ENABLED",
+						DefaultVariant: "red",
+						Variants: map[string]any{
+							"red":    "#FF0000",
+							"blue":   "#0000FF",
+							"green":  "#00FF00",
+							"yellow": "#FFFF00",
+						},
+						Targeting: []byte(`{
+							"fractional": [
+								{"var": "email"},
+								[
+								"red"
+								],
+								[
+								"blue"
+								]
+							]
+							}`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "foo@foo.com",
+			},
+			expectedVariant: "red",
+			expectedValue:   "#FF0000",
+			expectedReason:  model.TargetingMatchReason,
 		},
 		"default to targetingKey if no bucket key provided": {
 			flags: Flags{
@@ -318,22 +426,49 @@ func TestFractionalEvaluation(t *testing.T) {
 			expectedValue:   "#0000FF",
 			expectedReason:  model.TargetingMatchReason,
 		},
+		"missing email - parser should ignore nil/missing custom variables and continue": {
+			flags: Flags{
+				Flags: map[string]model.Flag{
+					"headerColor": {
+						State:          "ENABLED",
+						DefaultVariant: "red",
+						Variants: map[string]any{
+							"red":  "#FF0000",
+							"blue": "#0000FF",
+						},
+						Targeting: []byte(
+							`{
+								"fractional": [
+									{"var": "email"},
+									["red",50],
+									["blue",50]
+								]
+							}`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"targetingKey": "foo@foo.com",
+			},
+			expectedVariant: "red",
+			expectedValue:   "#FF0000",
+			expectedReason:  model.TargetingMatchReason,
+		},
 	}
 	const reqID = "default"
 	for name, tt := range tests {
 		t.Run(name, func(t *testing.T) {
 			log := logger.NewLogger(nil, false)
-			je := NewJSONEvaluator(
-				log,
-				store.NewFlags(),
-				WithEvaluator(
-					FractionEvaluationName,
-					NewFractionalEvaluator(log).FractionalEvaluation,
-				),
-			)
-			je.store.Flags = tt.flags.Flags
+			s, err := store.NewStore(log, sources)
+			if err != nil {
+				t.Fatalf("NewStore failed: %v", err)
+			}
 
-			value, variant, reason, _, err := resolve[string](reqID, tt.flagKey, tt.context, je.evaluateVariant)
+			je := NewJSON(log, s)
+			je.store.Update(source, tt.flags.Flags, model.Metadata{})
+
+			value, variant, reason, _, err := resolve[string](ctx, reqID, tt.flagKey, tt.context, je.evaluateVariant)
 
 			if value != tt.expectedValue {
 				t.Errorf("expected value '%s', got '%s'", tt.expectedValue, value)
@@ -358,6 +493,10 @@ func TestFractionalEvaluation(t *testing.T) {
 }
 
 func BenchmarkFractionalEvaluation(b *testing.B) {
+	const source = "testSource"
+	var sources = []string{source}
+	ctx := context.Background()
+
 	flags := Flags{
 		Flags: map[string]model.Flag{
 			"headerColor": {
@@ -378,7 +517,7 @@ func BenchmarkFractionalEvaluation(b *testing.B) {
 						},
 						{
 						"fractional": [
-							"email",
+							{"var": "email"},
 							[
 							"red",
 							25
@@ -412,41 +551,41 @@ func BenchmarkFractionalEvaluation(b *testing.B) {
 		expectedReason    string
 		expectedErrorCode string
 	}{
-		"test@faas.com": {
+		"test_a@faas.com": {
 			flags:   flags,
 			flagKey: "headerColor",
 			context: map[string]any{
-				"email": "test@faas.com",
+				"email": "test_a@faas.com",
+			},
+			expectedVariant: "blue",
+			expectedValue:   "#0000FF",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"test_b@faas.com": {
+			flags:   flags,
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "test_b@faas.com",
 			},
 			expectedVariant: "red",
 			expectedValue:   "#FF0000",
 			expectedReason:  model.TargetingMatchReason,
 		},
-		"test2@faas.com": {
+		"test_c@faas.com": {
 			flags:   flags,
 			flagKey: "headerColor",
 			context: map[string]any{
-				"email": "test2@faas.com",
+				"email": "test_c@faas.com",
 			},
-			expectedVariant: "yellow",
-			expectedValue:   "#FFFF00",
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
 			expectedReason:  model.TargetingMatchReason,
 		},
-		"test3@faas.com": {
+		"test_d@faas.com": {
 			flags:   flags,
 			flagKey: "headerColor",
 			context: map[string]any{
-				"email": "test3@faas.com",
-			},
-			expectedVariant: "red",
-			expectedValue:   "#FF0000",
-			expectedReason:  model.TargetingMatchReason,
-		},
-		"test4@faas.com": {
-			flags:   flags,
-			flagKey: "headerColor",
-			context: map[string]any{
-				"email": "test4@faas.com",
+				"email": "test_d@faas.com",
 			},
 			expectedVariant: "blue",
 			expectedValue:   "#0000FF",
@@ -457,16 +596,16 @@ func BenchmarkFractionalEvaluation(b *testing.B) {
 	for name, tt := range tests {
 		b.Run(name, func(b *testing.B) {
 			log := logger.NewLogger(nil, false)
-			je := NewJSONEvaluator(
-				log,
-				&store.Flags{Flags: tt.flags.Flags},
-				WithEvaluator(
-					FractionEvaluationName,
-					NewFractionalEvaluator(log).FractionalEvaluation,
-				),
-			)
+			s, err := store.NewStore(log, sources)
+			if err != nil {
+				b.Fatalf("NewStore failed: %v", err)
+			}
+			je := NewJSON(log, s)
+			je.store.Update(source, tt.flags.Flags, model.Metadata{})
+
 			for i := 0; i < b.N; i++ {
-				value, variant, reason, _, err := resolve[string](reqID, tt.flagKey, tt.context, je.evaluateVariant)
+				value, variant, reason, _, err := resolve[string](
+					ctx, reqID, tt.flagKey, tt.context, je.evaluateVariant)
 
 				if value != tt.expectedValue {
 					b.Errorf("expected value '%s', got '%s'", tt.expectedValue, value)
@@ -490,3 +629,49 @@ func BenchmarkFractionalEvaluation(b *testing.B) {
 		})
 	}
 }
+
+func Test_fractionalEvaluationVariant_getPercentage(t *testing.T) {
+	type fields struct {
+		variant string
+		weight  int
+	}
+	type args struct {
+		totalWeight int
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   float64
+	}{
+		{
+			name: "get percentage",
+			fields: fields{
+				weight: 10,
+			},
+			args: args{
+				totalWeight: 20,
+			},
+			want: 50,
+		},
+		{
+			name: "total weight 0",
+			fields: fields{
+				weight: 10,
+			},
+			args: args{
+				totalWeight: 0,
+			},
+			want: 0,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			v := fractionalEvaluationVariant{
+				variant: tt.fields.variant,
+				weight:  tt.fields.weight,
+			}
+			assert.Equalf(t, tt.want, v.getPercentage(tt.args.totalWeight), "getPercentage(%v)", tt.args.totalWeight)
+		})
+	}
+}

core/pkg/evaluator/ievaluator.go

@@ -1,8 +1,9 @@
-package eval
+package evaluator
 
 import (
 	"context"
 
+	"github.com/open-feature/flagd/core/pkg/model"
 	"github.com/open-feature/flagd/core/pkg/sync"
 )
 
@@ -11,12 +12,12 @@ type AnyValue struct {
 	Variant  string
 	Reason   string
 	FlagKey  string
-	Metadata map[string]interface{}
+	Metadata model.Metadata
 	Error    error
 }
 
 func NewAnyValue(
-	value interface{}, variant string, reason string, flagKey string, metadata map[string]interface{},
+	value interface{}, variant string, reason string, flagKey string, metadata model.Metadata,
 	err error,
 ) AnyValue {
 	return AnyValue{
@@ -30,44 +31,52 @@ func NewAnyValue(
 }
 
 /*
-IEvaluator implementations store the state of the flags,
-do parsing and validation of the flag state and evaluate flags in response to handlers.
+IEvaluator is an extension of IResolver, allowing storage updates and retrievals
 */
 type IEvaluator interface {
 	GetState() (string, error)
 	SetState(payload sync.DataSync) (map[string]interface{}, bool, error)
+	IResolver
+}
 
+// IResolver focuses on resolving of the known flags
+type IResolver interface {
 	ResolveBooleanValue(
 		ctx context.Context,
 		reqID string,
 		flagKey string,
-		context map[string]any) (value bool, variant string, reason string, metadata map[string]interface{}, err error)
+		context map[string]any) (value bool, variant string, reason string, metadata model.Metadata, err error)
 	ResolveStringValue(
 		ctx context.Context,
 		reqID string,
 		flagKey string,
 		context map[string]any) (
-		value string, variant string, reason string, metadata map[string]interface{}, err error)
+		value string, variant string, reason string, metadata model.Metadata, err error)
 	ResolveIntValue(
 		ctx context.Context,
 		reqID string,
 		flagKey string,
 		context map[string]any) (
-		value int64, variant string, reason string, metadata map[string]interface{}, err error)
+		value int64, variant string, reason string, metadata model.Metadata, err error)
 	ResolveFloatValue(
 		ctx context.Context,
 		reqID string,
 		flagKey string,
 		context map[string]any) (
-		value float64, variant string, reason string, metadata map[string]interface{}, err error)
+		value float64, variant string, reason string, metadata model.Metadata, err error)
 	ResolveObjectValue(
 		ctx context.Context,
 		reqID string,
 		flagKey string,
 		context map[string]any) (
-		value map[string]any, variant string, reason string, metadata map[string]interface{}, err error)
+		value map[string]any, variant string, reason string, metadata model.Metadata, err error)
+	ResolveAsAnyValue(
+		ctx context.Context,
+		reqID string,
+		flagKey string,
+		context map[string]any) AnyValue
 	ResolveAllValues(
 		ctx context.Context,
 		reqID string,
-		context map[string]any) (values []AnyValue)
+		context map[string]any) (resolutions []AnyValue, metadata model.Metadata, err error)
 }

core/pkg/evaluator/ievaluator_test.go

@@ -1,4 +1,4 @@
-package eval
+package evaluator
 
 import (
 	"fmt"

core/pkg/evaluator/json.go

@@ -1,4 +1,4 @@
-package eval
+package evaluator
 
 import (
 	"bytes"
@@ -12,11 +12,11 @@ import (
 	"time"
 
 	"github.com/diegoholiveira/jsonlogic/v3"
+	schema "github.com/open-feature/flagd-schemas/json"
 	"github.com/open-feature/flagd/core/pkg/logger"
 	"github.com/open-feature/flagd/core/pkg/model"
 	"github.com/open-feature/flagd/core/pkg/store"
 	"github.com/open-feature/flagd/core/pkg/sync"
-	schema "github.com/open-feature/schemas/json"
 	"github.com/xeipuuv/gojsonschema"
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/attribute"
@@ -28,58 +28,60 @@ import (
 
 const (
 	SelectorMetadataKey = "scope"
-
-	flagdPropertiesKey = "$flagd"
-
+	flagdPropertiesKey  = "$flagd"
 	// targetingKeyKey is used to extract the targetingKey to bucket on in fractional
 	// evaluation if the user did not supply the optional bucketing property.
 	targetingKeyKey = "targetingKey"
+	Disabled        = "DISABLED"
 )
 
 var regBrace *regexp.Regexp
 
+func init() {
+	regBrace = regexp.MustCompile("^[^{]*{|}[^}]*$")
+}
+
+type constraints interface {
+	bool | string | map[string]any | float64 | interface{}
+}
+
+type JSONEvaluatorOption func(je *JSON)
+
 type flagdProperties struct {
 	FlagKey   string `json:"flagKey"`
 	Timestamp int64  `json:"timestamp"`
 }
 
-func init() {
-	regBrace = regexp.MustCompile("^[^{]*{|}[^}]*$")
-}
-
-type variantEvaluator func(string, string, map[string]any) (
+type variantEvaluator func(context.Context, string, string, map[string]any) (
 	variant string, variants map[string]interface{}, reason string, metadata map[string]interface{}, error error)
 
-type JSONEvaluator struct {
-	store          *store.Flags
-	Logger         *logger.Logger
-	jsonEvalTracer trace.Tracer
-}
-
-type constraints interface {
-	bool | string | map[string]any | float64
-}
-
-const (
-	Disabled = "DISABLED"
-)
-
-type JSONEvaluatorOption func(je *JSONEvaluator)
-
+// Deprecated - this will be remove in the next release
 func WithEvaluator(name string, evalFunc func(interface{}, interface{}) interface{}) JSONEvaluatorOption {
-	return func(_ *JSONEvaluator) {
+	return func(_ *JSON) {
 		jsonlogic.AddOperator(name, evalFunc)
 	}
 }
 
-func NewJSONEvaluator(logger *logger.Logger, s *store.Flags, opts ...JSONEvaluatorOption) *JSONEvaluator {
-	ev := JSONEvaluator{
-		Logger: logger.WithFields(
-			zap.String("component", "evaluator"),
-			zap.String("evaluator", "json"),
-		),
+// JSON evaluator
+type JSON struct {
+	store          *store.Store
+	Logger         *logger.Logger
+	jsonEvalTracer trace.Tracer
+	Resolver
+}
+
+func NewJSON(logger *logger.Logger, s *store.Store, opts ...JSONEvaluatorOption) *JSON {
+	logger = logger.WithFields(
+		zap.String("component", "evaluator"),
+		zap.String("evaluator", "json"),
+	)
+	tracer := otel.Tracer("jsonEvaluator")
+
+	ev := JSON{
 		store:          s,
-		jsonEvalTracer: otel.Tracer("jsonEvaluator"),
+		Logger:         logger,
+		jsonEvalTracer: tracer,
+		Resolver:       NewResolver(s, logger, tracer),
 	}
 
 	for _, o := range opts {
@@ -89,7 +91,7 @@ func NewJSONEvaluator(logger *logger.Logger, s *store.Flags, opts ...JSONEvaluat
 	return &ev
 }
 
-func (je *JSONEvaluator) GetState() (string, error) {
+func (je *JSON) GetState() (string, error) {
 	s, err := je.store.String()
 	if err != nil {
 		return "", fmt.Errorf("unable to fetch evaluator state: %w", err)
@@ -97,17 +99,16 @@ func (je *JSONEvaluator) GetState() (string, error) {
 	return s, nil
 }
 
-func (je *JSONEvaluator) SetState(payload sync.DataSync) (map[string]interface{}, bool, error) {
+func (je *JSON) SetState(payload sync.DataSync) (map[string]interface{}, bool, error) {
 	_, span := je.jsonEvalTracer.Start(
 		context.Background(),
 		"flagSync",
-		trace.WithAttributes(attribute.String("feature_flag.source", payload.Source)),
-		trace.WithAttributes(attribute.String("feature_flag.sync_type", payload.Type.String())))
+		trace.WithAttributes(attribute.String("feature_flag.source", payload.Source)))
 	defer span.End()
 
-	var newFlags Flags
+	var definition Definition
 
-	err := je.configToFlags(payload.FlagData, &newFlags)
+	err := configToFlagDefinition(je.Logger, payload.FlagData, &definition)
 	if err != nil {
 		span.SetStatus(codes.Error, "flagSync error")
 		span.RecordError(err)
@@ -117,18 +118,7 @@ func (je *JSONEvaluator) SetState(payload sync.DataSync) (map[string]interface{}
 	var events map[string]interface{}
 	var reSync bool
 
-	switch payload.Type {
-	case sync.ALL:
-		events, reSync = je.store.Merge(je.Logger, payload.Source, newFlags.Flags)
-	case sync.ADD:
-		events = je.store.Add(je.Logger, payload.Source, newFlags.Flags)
-	case sync.UPDATE:
-		events = je.store.Update(je.Logger, payload.Source, newFlags.Flags)
-	case sync.DELETE:
-		events = je.store.DeleteFlags(je.Logger, payload.Source, newFlags.Flags)
-	default:
-		return nil, false, fmt.Errorf("unsupported sync type: %d", payload.Type)
-	}
+	events, reSync = je.store.Update(payload.Source, definition.Flags, definition.Metadata)
 
 	// Number of events correlates to the number of flags changed through this sync, record it
 	span.SetAttributes(attribute.Int("feature_flag.change_count", len(events)))
@@ -136,17 +126,45 @@ func (je *JSONEvaluator) SetState(payload sync.DataSync) (map[string]interface{}
 	return events, reSync, nil
 }
 
-func (je *JSONEvaluator) ResolveAllValues(ctx context.Context, reqID string, context map[string]any) []AnyValue {
-	_, span := je.jsonEvalTracer.Start(ctx, "resolveAll")
+// Resolver implementation for flagd flags. This resolver should be kept reusable, hence must interact with interfaces.
+type Resolver struct {
+	store  store.IStore
+	Logger *logger.Logger
+	tracer trace.Tracer
+}
+
+func NewResolver(store store.IStore, logger *logger.Logger, jsonEvalTracer trace.Tracer) Resolver {
+	// register supported json logic custom operator implementations
+	jsonlogic.AddOperator(FractionEvaluationName, NewFractional(logger).Evaluate)
+	jsonlogic.AddOperator(StartsWithEvaluationName, NewStringComparisonEvaluator(logger).StartsWithEvaluation)
+	jsonlogic.AddOperator(EndsWithEvaluationName, NewStringComparisonEvaluator(logger).EndsWithEvaluation)
+	jsonlogic.AddOperator(SemVerEvaluationName, NewSemVerComparison(logger).SemVerEvaluation)
+
+	return Resolver{store: store, Logger: logger, tracer: jsonEvalTracer}
+}
+
+func (je *Resolver) ResolveAllValues(ctx context.Context, reqID string, context map[string]any) ([]AnyValue,
+	model.Metadata, error,
+) {
+	_, span := je.tracer.Start(ctx, "resolveAll")
 	defer span.End()
 
+	var selector store.Selector
+	s := ctx.Value(store.SelectorContextKey{})
+	if s != nil {
+		selector = s.(store.Selector)
+	}
+	allFlags, flagSetMetadata, err := je.store.GetAll(ctx, &selector)
+	if err != nil {
+		return nil, flagSetMetadata, fmt.Errorf("error retreiving flags from the store: %w", err)
+	}
+
 	values := []AnyValue{}
 	var value interface{}
 	var variant string
 	var reason string
 	var metadata map[string]interface{}
-	var err error
-	allFlags := je.store.GetAll()
+
 	for flagKey, flag := range allFlags {
 		if flag.State == Disabled {
 			// ignore evaluation of disabled flag
@@ -156,43 +174,24 @@ func (je *JSONEvaluator) ResolveAllValues(ctx context.Context, reqID string, con
 		defaultValue := flag.Variants[flag.DefaultVariant]
 		switch defaultValue.(type) {
 		case bool:
-			value, variant, reason, metadata, err = resolve[bool](
-				reqID,
-				flagKey,
-				context,
-				je.evaluateVariant,
-			)
+			value, variant, reason, metadata, err = resolve[bool](ctx, reqID, flagKey, context, je.evaluateVariant)
 		case string:
-			value, variant, reason, metadata, err = resolve[string](
-				reqID,
-				flagKey,
-				context,
-				je.evaluateVariant,
-			)
+			value, variant, reason, metadata, err = resolve[string](ctx, reqID, flagKey, context, je.evaluateVariant)
 		case float64:
-			value, variant, reason, metadata, err = resolve[float64](
-				reqID,
-				flagKey,
-				context,
-				je.evaluateVariant,
-			)
+			value, variant, reason, metadata, err = resolve[float64](ctx, reqID, flagKey, context, je.evaluateVariant)
 		case map[string]any:
-			value, variant, reason, metadata, err = resolve[map[string]any](
-				reqID,
-				flagKey,
-				context,
-				je.evaluateVariant,
-			)
+			value, variant, reason, metadata, err = resolve[map[string]any](ctx, reqID, flagKey, context, je.evaluateVariant)
 		}
 		if err != nil {
 			je.Logger.ErrorWithID(reqID, fmt.Sprintf("bulk evaluation: key: %s returned error: %s", flagKey, err.Error()))
 		}
 		values = append(values, NewAnyValue(value, variant, reason, flagKey, metadata, err))
 	}
-	return values
+
+	return values, flagSetMetadata, nil
 }
 
-func (je *JSONEvaluator) ResolveBooleanValue(
+func (je *Resolver) ResolveBooleanValue(
 	ctx context.Context, reqID string, flagKey string, context map[string]any) (
 	value bool,
 	variant string,
@@ -200,14 +199,14 @@ func (je *JSONEvaluator) ResolveBooleanValue(
 	metadata map[string]interface{},
 	err error,
 ) {
-	_, span := je.jsonEvalTracer.Start(ctx, "resolveBoolean")
+	_, span := je.tracer.Start(ctx, "resolveBoolean")
 	defer span.End()
 
 	je.Logger.DebugWithID(reqID, fmt.Sprintf("evaluating boolean flag: %s", flagKey))
-	return resolve[bool](reqID, flagKey, context, je.evaluateVariant)
+	return resolve[bool](ctx, reqID, flagKey, context, je.evaluateVariant)
 }
 
-func (je *JSONEvaluator) ResolveStringValue(
+func (je *Resolver) ResolveStringValue(
 	ctx context.Context, reqID string, flagKey string, context map[string]any) (
 	value string,
 	variant string,
@@ -215,14 +214,14 @@ func (je *JSONEvaluator) ResolveStringValue(
 	metadata map[string]interface{},
 	err error,
 ) {
-	_, span := je.jsonEvalTracer.Start(ctx, "resolveString")
+	_, span := je.tracer.Start(ctx, "resolveString")
 	defer span.End()
 
 	je.Logger.DebugWithID(reqID, fmt.Sprintf("evaluating string flag: %s", flagKey))
-	return resolve[string](reqID, flagKey, context, je.evaluateVariant)
+	return resolve[string](ctx, reqID, flagKey, context, je.evaluateVariant)
 }
 
-func (je *JSONEvaluator) ResolveFloatValue(
+func (je *Resolver) ResolveFloatValue(
 	ctx context.Context, reqID string, flagKey string, context map[string]any) (
 	value float64,
 	variant string,
@@ -230,32 +229,32 @@ func (je *JSONEvaluator) ResolveFloatValue(
 	metadata map[string]interface{},
 	err error,
 ) {
-	_, span := je.jsonEvalTracer.Start(ctx, "resolveFloat")
+	_, span := je.tracer.Start(ctx, "resolveFloat")
 	defer span.End()
 
 	je.Logger.DebugWithID(reqID, fmt.Sprintf("evaluating float flag: %s", flagKey))
-	value, variant, reason, metadata, err = resolve[float64](reqID, flagKey, context, je.evaluateVariant)
+	value, variant, reason, metadata, err = resolve[float64](ctx, reqID, flagKey, context, je.evaluateVariant)
 	return
 }
 
-func (je *JSONEvaluator) ResolveIntValue(ctx context.Context, reqID string, flagKey string, context map[string]any) (
+func (je *Resolver) ResolveIntValue(ctx context.Context, reqID string, flagKey string, context map[string]any) (
 	value int64,
 	variant string,
 	reason string,
 	metadata map[string]interface{},
 	err error,
 ) {
-	_, span := je.jsonEvalTracer.Start(ctx, "resolveInt")
+	_, span := je.tracer.Start(ctx, "resolveInt")
 	defer span.End()
 
 	je.Logger.DebugWithID(reqID, fmt.Sprintf("evaluating int flag: %s", flagKey))
 	var val float64
-	val, variant, reason, metadata, err = resolve[float64](reqID, flagKey, context, je.evaluateVariant)
+	val, variant, reason, metadata, err = resolve[float64](ctx, reqID, flagKey, context, je.evaluateVariant)
 	value = int64(val)
 	return
 }
 
-func (je *JSONEvaluator) ResolveObjectValue(
+func (je *Resolver) ResolveObjectValue(
 	ctx context.Context, reqID string, flagKey string, context map[string]any) (
 	value map[string]any,
 	variant string,
@@ -263,17 +262,32 @@ func (je *JSONEvaluator) ResolveObjectValue(
 	metadata map[string]interface{},
 	err error,
 ) {
-	_, span := je.jsonEvalTracer.Start(ctx, "resolveObject")
+	_, span := je.tracer.Start(ctx, "resolveObject")
 	defer span.End()
 
 	je.Logger.DebugWithID(reqID, fmt.Sprintf("evaluating object flag: %s", flagKey))
-	return resolve[map[string]any](reqID, flagKey, context, je.evaluateVariant)
+	return resolve[map[string]any](ctx, reqID, flagKey, context, je.evaluateVariant)
 }
 
-func resolve[T constraints](reqID string, key string, context map[string]any, variantEval variantEvaluator) (
-	value T, variant string, reason string, metadata map[string]interface{}, err error,
+func (je *Resolver) ResolveAsAnyValue(
+	ctx context.Context,
+	reqID string,
+	flagKey string,
+	context map[string]any,
+) AnyValue {
+	_, span := je.tracer.Start(ctx, "resolveAnyValue")
+	defer span.End()
+
+	je.Logger.DebugWithID(reqID, fmt.Sprintf("evaluating flag `%s` as a generic flag", flagKey))
+	value, variant, reason, meta, err := resolve[interface{}](ctx, reqID, flagKey, context, je.evaluateVariant)
+	return NewAnyValue(value, variant, reason, flagKey, meta, err)
+}
+
+// resolve is a helper for generic flag resolving
+func resolve[T constraints](ctx context.Context, reqID string, key string, context map[string]any,
+	variantEval variantEvaluator) (value T, variant string, reason string, metadata map[string]interface{}, err error,
 ) {
-	variant, variants, reason, metadata, err := variantEval(reqID, key, context)
+	variant, variants, reason, metadata, err := variantEval(ctx, reqID, key, context)
 	if err != nil {
 		return value, variant, reason, metadata, err
 	}
@@ -287,24 +301,28 @@ func resolve[T constraints](reqID string, key string, context map[string]any, va
 	return value, variant, reason, metadata, nil
 }
 
-// runs the rules (if defined) to determine the variant, otherwise falling through to the default
 // nolint: funlen
-func (je *JSONEvaluator) evaluateVariant(reqID string, flagKey string, context map[string]any) (
+func (je *Resolver) evaluateVariant(ctx context.Context, reqID string, flagKey string, evalCtx map[string]any) (
 	variant string, variants map[string]interface{}, reason string, metadata map[string]interface{}, err error,
 ) {
-	metadata = map[string]interface{}{}
 
-	flag, ok := je.store.Get(flagKey)
-	if !ok {
+	var selector store.Selector
+	s := ctx.Value(store.SelectorContextKey{})
+	if s != nil {
+		selector = s.(store.Selector)
+	}
+	flag, metadata, err := je.store.Get(ctx, flagKey, &selector)
+	if err != nil {
 		// flag not found
 		je.Logger.DebugWithID(reqID, fmt.Sprintf("requested flag could not be found: %s", flagKey))
 		return "", map[string]interface{}{}, model.ErrorReason, metadata, errors.New(model.FlagNotFoundErrorCode)
 	}
 
-	// add selector to evaluation metadata
-	selector := je.store.SelectorForFlag(flag)
-	if selector != "" {
-		metadata[SelectorMetadataKey] = selector
+	for key, value := range flag.Metadata {
+		// If value is not nil or empty, copy to metadata
+		if value != nil {
+			metadata[key] = value
+		}
 	}
 
 	if flag.State == Disabled {
@@ -322,14 +340,14 @@ func (je *JSONEvaluator) evaluateVariant(reqID string, flagKey string, context m
 			return "", flag.Variants, model.ErrorReason, metadata, errors.New(model.ParseErrorCode)
 		}
 
-		context = je.setFlagdProperties(context, flagdProperties{
+		evalCtx = setFlagdProperties(je.Logger, evalCtx, flagdProperties{
 			FlagKey:   flagKey,
 			Timestamp: time.Now().Unix(),
 		})
 
-		b, err := json.Marshal(context)
+		b, err := json.Marshal(evalCtx)
 		if err != nil {
-			je.Logger.ErrorWithID(reqID, fmt.Sprintf("error parsing context for flag: %s, %s, %v", flagKey, err, context))
+			je.Logger.ErrorWithID(reqID, fmt.Sprintf("error parsing context for flag: %s, %s, %v", flagKey, err, evalCtx))
 
 			return "", flag.Variants, model.ErrorReason, metadata, errors.New(model.ErrorReason)
 		}
@@ -338,13 +356,18 @@ func (je *JSONEvaluator) evaluateVariant(reqID string, flagKey string, context m
 		// evaluate JsonLogic rules to determine the variant
 		err = jsonlogic.Apply(bytes.NewReader(targetingBytes), bytes.NewReader(b), &result)
 		if err != nil {
-			je.Logger.ErrorWithID(reqID, fmt.Sprintf("error applying rules: %s", err))
+			je.Logger.ErrorWithID(reqID, fmt.Sprintf("error applying targeting rules: %s", err))
 			return "", flag.Variants, model.ErrorReason, metadata, errors.New(model.ParseErrorCode)
 		}
 
 		// check if string is "null" before we strip quotes, so we can differentiate between JSON null and "null"
 		trimmed := strings.TrimSpace(result.String())
+
 		if trimmed == "null" {
+			if flag.DefaultVariant == "" {
+				return "", flag.Variants, model.ErrorReason, metadata, errors.New(model.FlagNotFoundErrorCode)
+			}
+
 			return flag.DefaultVariant, flag.Variants, model.DefaultReason, metadata, nil
 		}
 
@@ -357,12 +380,18 @@ func (je *JSONEvaluator) evaluateVariant(reqID string, flagKey string, context m
 		}
 		je.Logger.ErrorWithID(reqID,
 			fmt.Sprintf("invalid or missing variant: %s for flagKey: %s, variant is not valid", variant, flagKey))
-		return "", flag.Variants, model.ErrorReason, metadata, errors.New(model.ParseErrorCode)
+		return "", flag.Variants, model.ErrorReason, metadata, errors.New(model.GeneralErrorCode)
 	}
+
+	if flag.DefaultVariant == "" {
+		return "", flag.Variants, model.ErrorReason, metadata, errors.New(model.FlagNotFoundErrorCode)
+	}
+
 	return flag.DefaultVariant, flag.Variants, model.StaticReason, metadata, nil
 }
 
-func (je *JSONEvaluator) setFlagdProperties(
+func setFlagdProperties(
+	log *logger.Logger,
 	context map[string]any,
 	properties flagdProperties,
 ) map[string]any {
@@ -373,7 +402,7 @@ func (je *JSONEvaluator) setFlagdProperties(
 	newContext := maps.Clone(context)
 
 	if _, ok := newContext[flagdPropertiesKey]; ok {
-		je.Logger.Warn("overwriting $flagd properties in the context")
+		log.Warn("overwriting $flagd properties in the context")
 	}
 
 	newContext[flagdPropertiesKey] = properties
@@ -400,34 +429,61 @@ func getFlagdProperties(context map[string]any) (flagdProperties, bool) {
 	return p, true
 }
 
-// configToFlags convert string configurations to flags and store them to pointer newFlags
-func (je *JSONEvaluator) configToFlags(config string, newFlags *Flags) error {
-	schemaLoader := gojsonschema.NewStringLoader(schema.FlagdDefinitions)
-	flagStringLoader := gojsonschema.NewStringLoader(config)
+func loadAndCompileSchema(log *logger.Logger) *gojsonschema.Schema {
+	schemaLoader := gojsonschema.NewSchemaLoader()
 
-	result, err := gojsonschema.Validate(schemaLoader, flagStringLoader)
-	if err != nil {
-		return fmt.Errorf("error validating json schema: %w", err)
-	} else if !result.Valid() {
-		return fmt.Errorf("JSON schema validation failed: %s", buildErrorString(result.Errors()))
+	// compile dependency schema
+	targetingSchemaLoader := gojsonschema.NewStringLoader(schema.TargetingSchema)
+	if err := schemaLoader.AddSchemas(targetingSchemaLoader); err != nil {
+		log.Warn(fmt.Sprintf("error adding Targeting schema: %s", err))
 	}
 
-	transposedConfig, err := je.transposeEvaluators(config)
+	// compile root schema
+	flagdDefinitionsLoader := gojsonschema.NewStringLoader(schema.FlagSchema)
+	compiledSchema, err := schemaLoader.Compile(flagdDefinitionsLoader)
+	if err != nil {
+		log.Warn(fmt.Sprintf("error compiling FlagdDefinitions schema: %s", err))
+	}
+
+	return compiledSchema
+}
+
+// configToFlagDefinition convert string configurations to flags and store them to pointer newFlags
+func configToFlagDefinition(log *logger.Logger, config string, definition *Definition) error {
+	compiledSchema := loadAndCompileSchema(log)
+
+	flagStringLoader := gojsonschema.NewStringLoader(config)
+
+	result, err := compiledSchema.Validate(flagStringLoader)
+	if err != nil {
+		log.Logger.Warn(fmt.Sprintf("failed to execute JSON schema validation: %s", err))
+	} else if !result.Valid() {
+		log.Logger.Warn(fmt.Sprintf(
+			"flag definition does not conform to the schema; validation errors: %s", buildErrorString(result.Errors()),
+		))
+	}
+
+	transposedConfig, err := transposeEvaluators(config)
 	if err != nil {
 		return fmt.Errorf("transposing evaluators: %w", err)
 	}
 
-	err = json.Unmarshal([]byte(transposedConfig), &newFlags)
+	err = json.Unmarshal([]byte(transposedConfig), &definition)
 	if err != nil {
 		return fmt.Errorf("unmarshalling provided configurations: %w", err)
 	}
 
-	return validateDefaultVariants(newFlags)
+	return validateDefaultVariants(definition)
 }
 
 // validateDefaultVariants returns an error if any of the default variants aren't valid
-func validateDefaultVariants(flags *Flags) error {
+func validateDefaultVariants(flags *Definition) error {
 	for name, flag := range flags.Flags {
+		// Default Variant is not provided in the config
+		if flag.DefaultVariant == "" {
+			continue
+		}
+
 		if _, ok := flag.Variants[flag.DefaultVariant]; !ok {
 			return fmt.Errorf(
 				"default variant: '%s' isn't a valid variant of flag: '%s'", flag.DefaultVariant, name,
@@ -438,7 +494,7 @@ func validateDefaultVariants(flags *Flags) error {
 	return nil
 }
 
-func (je *JSONEvaluator) transposeEvaluators(state string) (string, error) {
+func transposeEvaluators(state string) (string, error) {
 	var evaluators Evaluators
 	if err := json.Unmarshal([]byte(state), &evaluators); err != nil {
 		return "", fmt.Errorf("unmarshal: %w", err)

core/pkg/evaluator/json_model.go

@@ -1,4 +1,4 @@
-package eval
+package evaluator
 
 import (
 	"encoding/json"
@@ -10,6 +10,11 @@ type Evaluators struct {
 	Evaluators map[string]json.RawMessage `json:"$evaluators"`
 }
 
+type Definition struct {
+	Flags    map[string]model.Flag  `json:"flags"`
+	Metadata map[string]interface{} `json:"metadata"`
+}
+
 type Flags struct {
 	Flags map[string]model.Flag `json:"flags"`
 }

core/pkg/evaluator/json_test.go

@@ -1,5 +1,5 @@
 //nolint:wrapcheck
-package eval_test
+package evaluator_test
 
 import (
 	"context"
@@ -10,7 +10,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/open-feature/flagd/core/pkg/eval"
+	"github.com/open-feature/flagd/core/pkg/evaluator"
 	"github.com/open-feature/flagd/core/pkg/logger"
 	"github.com/open-feature/flagd/core/pkg/model"
 	"github.com/open-feature/flagd/core/pkg/store"
@@ -44,7 +44,90 @@ const ValidFlags = `{
   }
 }`
 
+const NullDefault = `{
+  "flags": {
+    "validFlag": {
+      "state": "ENABLED",
+      "variants": {
+        "on": true,
+        "off": false
+      },
+      "defaultVariant": null
+    }
+  }
+}`
+
+const UndefinedDefault = `{
+  "flags": {
+    "validFlag": {
+      "state": "ENABLED",
+      "variants": {
+        "on": true,
+        "off": false
+      }
+    }
+  }
+}`
+
+const NullDefaultWithTargetting = `{
+  "flags": {
+    "validFlag": {
+      "state": "ENABLED",
+      "variants": {
+        "on": true,
+        "off": false
+      },
+      "defaultVariant": null,
+	  "targeting": {
+        "if": [
+          {
+            "==": [
+              {
+                "var": [
+                  "key"
+                ]
+              },
+              "value"
+            ]
+          },
+          "on"
+        ]
+      }
+    }
+  }
+}`
+
+const UndefinedDefaultWithTargetting = `{
+  "flags": {
+    "validFlag": {
+      "state": "ENABLED",
+      "variants": {
+        "on": true,
+        "off": false
+      },
+	  "targeting": {
+        "if": [
+          {
+            "==": [
+              {
+                "var": [
+                  "key"
+                ]
+              },
+              "value"
+            ]
+          },
+          "on"
+        ]
+      }
+    }
+  }
+}`
+
 const (
+	FlagSetID                  = "testSetId"
+	Version                    = "v33"
+	ValidFlag                  = "validFlag"
 	MissingFlag                = "missingFlag"
 	StaticBoolFlag             = "staticBoolFlag"
 	StaticBoolValue            = true
@@ -69,9 +152,15 @@ const (
 	ColorProp                  = "color"
 	ColorValue                 = "yellow"
 	DisabledFlag               = "disabledFlag"
+	MetadataFlag               = "metadataFlag"
+	VersionOverride            = "v66"
 )
 
 var Flags = fmt.Sprintf(`{
+	"metadata": {
+		"flagSetId": "%s",
+		"version": "%s"
+	},
   "flags": {
     "%s": {
       "state": "ENABLED",
@@ -242,9 +331,22 @@ var Flags = fmt.Sprintf(`{
         "off": false
       },
       "defaultVariant": "on"
+    },
+	"%s": {
+      "state": "ENABLED",
+      "variants": {
+        "on": true,
+        "off": false
+      },
+      "defaultVariant": "on",
+			"metadata": {
+				"version": "%s"
+			}
     }
   }
 }`,
+	FlagSetID,
+	Version,
 	StaticBoolFlag,
 	StaticBoolValue,
 	StaticStringFlag,
@@ -275,11 +377,13 @@ var Flags = fmt.Sprintf(`{
 	DynamicObjectValue,
 	ColorProp,
 	ColorValue,
-	DisabledFlag)
+	DisabledFlag,
+	MetadataFlag,
+	VersionOverride)
 
 func TestGetState_Valid_ContainsFlag(t *testing.T) {
-	evaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
-	_, _, err := evaluator.SetState(sync.DataSync{FlagData: ValidFlags})
+	evaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
+	_, _, err := evaluator.SetState(sync.DataSync{FlagData: ValidFlags, Source: "testSource"})
 	if err != nil {
 		t.Fatalf("Expected no error")
 	}
@@ -298,28 +402,28 @@ func TestGetState_Valid_ContainsFlag(t *testing.T) {
 }
 
 func TestSetState_Invalid_Error(t *testing.T) {
-	evaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
+	evaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
 
 	// set state with an invalid flag definition
-	_, _, err := evaluator.SetState(sync.DataSync{FlagData: InvalidFlags})
-	if err == nil {
-		t.Fatalf("expected error")
+	_, _, err := evaluator.SetState(sync.DataSync{FlagData: InvalidFlags, Source: "testSource"})
+	if err != nil {
+		t.Fatalf("unexpected error")
 	}
 }
 
 func TestSetState_Valid_NoError(t *testing.T) {
-	evaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
+	evaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
 
 	// set state with a valid flag definition
-	_, _, err := evaluator.SetState(sync.DataSync{FlagData: ValidFlags})
+	_, _, err := evaluator.SetState(sync.DataSync{FlagData: ValidFlags, Source: "testSource"})
 	if err != nil {
 		t.Fatalf("expected no error")
 	}
 }
 
 func TestResolveAllValues(t *testing.T) {
-	evaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
-	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags})
+	evaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
+	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags, Source: "testSource"})
 	if err != nil {
 		t.Fatalf("expected no error")
 	}
@@ -335,7 +439,11 @@ func TestResolveAllValues(t *testing.T) {
 	}
 	const reqID = "default"
 	for _, test := range tests {
-		vals := evaluator.ResolveAllValues(context.TODO(), reqID, test.context)
+		vals, _, err := evaluator.ResolveAllValues(context.TODO(), reqID, test.context)
+		if err != nil {
+			t.Error("error from resolver", err)
+		}
+
 		for _, val := range vals {
 			// disabled flag must be ignored from bulk evaluation
 			if val.FlagKey == DisabledFlag {
@@ -383,8 +491,8 @@ func TestResolveBooleanValue(t *testing.T) {
 		{DisabledFlag, nil, StaticBoolValue, model.ErrorReason, model.FlagDisabledErrorCode},
 	}
 	const reqID = "default"
-	evaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
-	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags})
+	evaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
+	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags, Source: "testSource"})
 	if err != nil {
 		t.Fatalf("expected no error")
 	}
@@ -418,8 +526,8 @@ func BenchmarkResolveBooleanValue(b *testing.B) {
 		{DisabledFlag, nil, StaticBoolValue, model.ErrorReason, model.FlagDisabledErrorCode},
 	}
 
-	evaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
-	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags})
+	evaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
+	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags, Source: "testSource"})
 	if err != nil {
 		b.Fatalf("expected no error")
 	}
@@ -458,8 +566,8 @@ func TestResolveStringValue(t *testing.T) {
 		{DisabledFlag, nil, "", model.ErrorReason, model.FlagDisabledErrorCode},
 	}
 	const reqID = "default"
-	evaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
-	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags})
+	evaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
+	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags, Source: "testSource"})
 	if err != nil {
 		t.Fatalf("expected no error")
 	}
@@ -494,8 +602,8 @@ func BenchmarkResolveStringValue(b *testing.B) {
 		{DisabledFlag, nil, "", model.ErrorReason, model.FlagDisabledErrorCode},
 	}
 
-	evaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
-	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags})
+	evaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
+	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags, Source: "testSource"})
 	if err != nil {
 		b.Fatalf("expected no error")
 	}
@@ -534,8 +642,8 @@ func TestResolveFloatValue(t *testing.T) {
 		{DisabledFlag, nil, 0, model.ErrorReason, model.FlagDisabledErrorCode},
 	}
 	const reqID = "default"
-	evaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
-	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags})
+	evaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
+	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags, Source: "testSource"})
 	if err != nil {
 		t.Fatalf("expected no error")
 	}
@@ -570,8 +678,8 @@ func BenchmarkResolveFloatValue(b *testing.B) {
 		{DisabledFlag, nil, 0, model.ErrorReason, model.FlagDisabledErrorCode},
 	}
 
-	evaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
-	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags})
+	evaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
+	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags, Source: "testSource"})
 	if err != nil {
 		b.Fatalf("expected no error")
 	}
@@ -610,8 +718,8 @@ func TestResolveIntValue(t *testing.T) {
 		{DisabledFlag, nil, 0, model.ErrorReason, model.FlagDisabledErrorCode},
 	}
 	const reqID = "default"
-	evaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
-	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags})
+	evaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
+	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags, Source: "testSource"})
 	if err != nil {
 		t.Fatalf("expected no error")
 	}
@@ -646,8 +754,8 @@ func BenchmarkResolveIntValue(b *testing.B) {
 		{DisabledFlag, nil, 0, model.ErrorReason, model.FlagDisabledErrorCode},
 	}
 
-	evaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
-	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags})
+	evaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
+	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags, Source: "testSource"})
 	if err != nil {
 		b.Fatalf("expected no error")
 	}
@@ -686,8 +794,8 @@ func TestResolveObjectValue(t *testing.T) {
 		{DisabledFlag, nil, "{}", model.ErrorReason, model.FlagDisabledErrorCode},
 	}
 	const reqID = "default"
-	evaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
-	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags})
+	evaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
+	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags, Source: "testSource"})
 	if err != nil {
 		t.Fatalf("expected no error")
 	}
@@ -725,8 +833,8 @@ func BenchmarkResolveObjectValue(b *testing.B) {
 		{DisabledFlag, nil, "{}", model.ErrorReason, model.FlagDisabledErrorCode},
 	}
 
-	evaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
-	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags})
+	evaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
+	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags, Source: "testSource"})
 	if err != nil {
 		b.Fatalf("expected no error")
 	}
@@ -753,6 +861,74 @@ func BenchmarkResolveObjectValue(b *testing.B) {
 	}
 }
 
+func TestResolveAsAnyValue(t *testing.T) {
+	tests := []struct {
+		flagKey   string
+		context   map[string]interface{}
+		val       string
+		reason    string
+		errorCode string
+	}{
+		// success
+		{StaticBoolFlag, nil, "{}", model.StaticReason, ""},
+		{StaticObjectFlag, nil, StaticObjectValue, model.StaticReason, ""},
+		{DynamicObjectFlag, map[string]interface{}{ColorProp: ColorValue}, DynamicObjectValue, model.TargetingMatchReason, ""},
+		// errors
+		{MissingFlag, nil, "{}", model.ErrorReason, model.FlagNotFoundErrorCode},
+		{DisabledFlag, nil, "{}", model.ErrorReason, model.FlagDisabledErrorCode},
+	}
+
+	evaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
+	_, _, err := evaluator.SetState(sync.DataSync{FlagData: Flags, Source: "testSource"})
+	if err != nil {
+		t.Fatalf("expected no error")
+	}
+
+	for _, test := range tests {
+		t.Run(fmt.Sprintf("evaluating flag: %s", test.flagKey), func(t *testing.T) {
+			anyResult := evaluator.ResolveAsAnyValue(context.TODO(), "", test.flagKey, test.context)
+
+			if test.errorCode == "" {
+				assert.NoError(t, anyResult.Error)
+			} else {
+				assert.Equal(t, model.ErrorReason, anyResult.Reason)
+				assert.EqualError(t, anyResult.Error, test.errorCode)
+			}
+		})
+	}
+}
+
+func TestResolve_DefaultVariant(t *testing.T) {
+	tests := []struct {
+		flags     string
+		flagKey   string
+		context   map[string]interface{}
+		reason    string
+		errorCode string
+	}{
+		{NullDefault, ValidFlag, nil, model.ErrorReason, model.FlagNotFoundErrorCode},
+		{UndefinedDefault, ValidFlag, nil, model.ErrorReason, model.FlagNotFoundErrorCode},
+		{NullDefaultWithTargetting, ValidFlag, nil, model.ErrorReason, model.FlagNotFoundErrorCode},
+		{UndefinedDefaultWithTargetting, ValidFlag, nil, model.ErrorReason, model.FlagNotFoundErrorCode},
+	}
+
+	for _, test := range tests {
+		t.Run("", func(t *testing.T) {
+			evaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
+			_, _, err := evaluator.SetState(sync.DataSync{FlagData: test.flags, Source: "testSource"})
+
+			if err != nil {
+				t.Fatalf("expected no error")
+			}
+
+			anyResult := evaluator.ResolveAsAnyValue(context.TODO(), "", test.flagKey, test.context)
+
+			assert.Equal(t, model.ErrorReason, anyResult.Reason)
+			assert.EqualError(t, anyResult.Error, test.errorCode)
+		})
+	}
+}
+
 func TestSetState_DefaultVariantValidation(t *testing.T) {
 	tests := map[string]struct {
 		jsonFlags string
@@ -804,9 +980,9 @@ func TestSetState_DefaultVariantValidation(t *testing.T) {
 
 	for name, tt := range tests {
 		t.Run(name, func(t *testing.T) {
-			jsonEvaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
+			jsonEvaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
 
-			_, _, err := jsonEvaluator.SetState(sync.DataSync{FlagData: tt.jsonFlags})
+			_, _, err := jsonEvaluator.SetState(sync.DataSync{FlagData: tt.jsonFlags, Source: "testSource"})
 
 			if tt.valid && err != nil {
 				t.Error(err)
@@ -818,7 +994,6 @@ func TestSetState_DefaultVariantValidation(t *testing.T) {
 func TestState_Evaluator(t *testing.T) {
 	tests := map[string]struct {
 		inputState          string
-		inputSyncType       sync.Type
 		expectedOutputState string
 		expectedError       bool
 		expectedResync      bool
@@ -854,7 +1029,6 @@ func TestState_Evaluator(t *testing.T) {
   					}
 				}
 			`,
-			inputSyncType: sync.ALL,
 			expectedOutputState: `
 				{
   					"flags": {
@@ -867,7 +1041,8 @@ func TestState_Evaluator(t *testing.T) {
 						  },
 						  "defaultVariant": "recursive",
 						  "state": "ENABLED",
-						  "source":"",
+						  "source":"testSource",
+						  "selector":"",
 						  "targeting": {
 							"if": [
 							  {
@@ -914,7 +1089,6 @@ func TestState_Evaluator(t *testing.T) {
 				}
 				}
 			`,
-			inputSyncType: sync.ALL,
 			expectedOutputState: `
 				{
   					"flags": {
@@ -927,7 +1101,8 @@ func TestState_Evaluator(t *testing.T) {
 						  },
 						  "defaultVariant": "recursive",
 						  "state": "ENABLED",
-						  "source":"",
+						  "source":"testSource",
+						  "selector":"",
 						  "targeting": {
 							"if": [
 							  {
@@ -970,9 +1145,114 @@ func TestState_Evaluator(t *testing.T) {
   					}
 				}
 			`,
-			inputSyncType: sync.ALL,
 			expectedError: true,
 		},
+		"invalid targeting": {
+			inputState: `
+			{
+					"flags": {
+					"fibAlgo": {
+						"variants": {
+						"recursive": "recursive",
+						"memo": "memo",
+						"loop": "loop",
+						"binet": "binet"
+						},
+						"defaultVariant": "recursive",
+						"state": "ENABLED",
+						"targeting": {
+						"if": [
+							{
+							"in": ["@faas.com", {
+							"var": ["email"]
+							}]
+							}, "binet", "null", "loop"
+						]
+						}
+						},
+					"isColorYellow": {
+						"state": "ENABLED",
+						"variants": {
+							"on": true,
+							"off": false
+						},
+						"defaultVariant": "off",
+						"source":"testSource",
+						"targeting": {
+							"if": [
+								{
+									"==": [
+										{
+											"varr": ["color"]
+										},
+										"yellow"
+									]
+								},
+								"on",
+								"off",
+								"none"
+							]
+						}
+					}
+				},
+				"flagSources":null
+			}
+		`,
+			expectedError: false,
+			expectedOutputState: `
+			{
+					"flags": {
+					"fibAlgo": {
+						"variants": {
+						"recursive": "recursive",
+						"memo": "memo",
+						"loop": "loop",
+						"binet": "binet"
+						},
+						"defaultVariant": "recursive",
+						"state": "ENABLED",
+						"source":"testSource",
+						"selector":"",
+						"targeting": {
+						"if": [
+							{
+							"in": ["@faas.com", {
+							"var": ["email"]
+							}]
+							}, "binet", "null", "loop"
+						]
+						}
+						},
+					"isColorYellow": {
+						"state": "ENABLED",
+						"variants": {
+							"on": true,
+							"off": false
+						},
+						"defaultVariant": "off",
+						"source":"testSource",
+						"selector":"",
+						"targeting": {
+							"if": [
+								{
+									"==": [
+										{
+											"varr": ["color"]
+										},
+										"yellow"
+									]
+								},
+								"on",
+								"off",
+								"none"
+							]
+						}
+					}
+				},
+				"flagSources":null
+			}
+		`,
+		},
 		"empty evaluator": {
 			inputState: `
 				{
@@ -1000,47 +1280,15 @@ func TestState_Evaluator(t *testing.T) {
   					}
 				}
 			`,
-			inputSyncType: sync.ALL,
 			expectedError: true,
 		},
-		"unexpected sync type": {
-			inputState: `
-				{
-  					"flags": {
-						"fibAlgo": {
-						  "variants": {
-							"recursive": "recursive",
-							"memo": "memo",
-							"loop": "loop",
-							"binet": "binet"
-						  },
-						  "defaultVariant": "recursive",
-						  "state": "ENABLED",
-						  "targeting": {
-							"if": [
-							  {
-								"$ref": "emailWithFaas"
-							  }, "binet", null
-							]
-						  }
-    					}
-					},
-					"$evaluators": {
-						"emailWithFaas": ""
-  					}
-				}
-			`,
-			inputSyncType:  999,
-			expectedError:  true,
-			expectedResync: false,
-		},
 	}
 
 	for name, tt := range tests {
 		t.Run(name, func(t *testing.T) {
-			jsonEvaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
+			jsonEvaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
 
-			_, resync, err := jsonEvaluator.SetState(sync.DataSync{FlagData: tt.inputState})
+			_, resync, err := jsonEvaluator.SetState(sync.DataSync{FlagData: tt.inputState, Source: "testSource"})
 			if err != nil {
 				if !tt.expectedError {
 					t.Error(err)
@@ -1073,8 +1321,8 @@ func TestState_Evaluator(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			if !reflect.DeepEqual(expectedOutputJSON["flags"], gotOutputJSON["flags"]) {
-				t.Errorf("expected state: %v got state: %v", expectedOutputJSON, gotOutputJSON)
+			if !reflect.DeepEqual(expectedOutputJSON["flags"], gotOutputJSON) {
+				t.Errorf("expected state: %v got state: %v", expectedOutputJSON["flags"], gotOutputJSON)
 			}
 		})
 	}
@@ -1082,61 +1330,61 @@ func TestState_Evaluator(t *testing.T) {
 
 func TestFlagStateSafeForConcurrentReadWrites(t *testing.T) {
 	tests := map[string]struct {
-		dataSyncType   sync.Type
-		flagResolution func(evaluator *eval.JSONEvaluator) error
+		flagResolution func(evaluator *evaluator.JSON) error
 	}{
 		"Add_ResolveAllValues": {
-			dataSyncType: sync.ADD,
-			flagResolution: func(evaluator *eval.JSONEvaluator) error {
-				evaluator.ResolveAllValues(context.TODO(), "", nil)
+			flagResolution: func(evaluator *evaluator.JSON) error {
+				_, _, err := evaluator.ResolveAllValues(context.TODO(), "", nil)
+				if err != nil {
+					return err
+				}
 				return nil
 			},
 		},
 		"Update_ResolveAllValues": {
-			dataSyncType: sync.UPDATE,
-			flagResolution: func(evaluator *eval.JSONEvaluator) error {
-				evaluator.ResolveAllValues(context.TODO(), "", nil)
+			flagResolution: func(evaluator *evaluator.JSON) error {
+				_, _, err := evaluator.ResolveAllValues(context.TODO(), "", nil)
+				if err != nil {
+					return err
+				}
 				return nil
 			},
 		},
 		"Delete_ResolveAllValues": {
-			dataSyncType: sync.DELETE,
-			flagResolution: func(evaluator *eval.JSONEvaluator) error {
-				evaluator.ResolveAllValues(context.TODO(), "", nil)
+			flagResolution: func(evaluator *evaluator.JSON) error {
+				_, _, err := evaluator.ResolveAllValues(context.TODO(), "", nil)
+				if err != nil {
+					return err
+				}
 				return nil
 			},
 		},
 		"Add_ResolveBooleanValue": {
-			dataSyncType: sync.ADD,
-			flagResolution: func(evaluator *eval.JSONEvaluator) error {
+			flagResolution: func(evaluator *evaluator.JSON) error {
 				_, _, _, _, err := evaluator.ResolveBooleanValue(context.TODO(), "", StaticBoolFlag, nil)
 				return err
 			},
 		},
 		"Update_ResolveStringValue": {
-			dataSyncType: sync.UPDATE,
-			flagResolution: func(evaluator *eval.JSONEvaluator) error {
+			flagResolution: func(evaluator *evaluator.JSON) error {
 				_, _, _, _, err := evaluator.ResolveBooleanValue(context.TODO(), "", StaticStringValue, nil)
 				return err
 			},
 		},
 		"Delete_ResolveIntValue": {
-			dataSyncType: sync.DELETE,
-			flagResolution: func(evaluator *eval.JSONEvaluator) error {
+			flagResolution: func(evaluator *evaluator.JSON) error {
 				_, _, _, _, err := evaluator.ResolveIntValue(context.TODO(), "", StaticIntFlag, nil)
 				return err
 			},
 		},
 		"Add_ResolveFloatValue": {
-			dataSyncType: sync.ADD,
-			flagResolution: func(evaluator *eval.JSONEvaluator) error {
+			flagResolution: func(evaluator *evaluator.JSON) error {
 				_, _, _, _, err := evaluator.ResolveFloatValue(context.TODO(), "", StaticFloatFlag, nil)
 				return err
 			},
 		},
 		"Update_ResolveObjectValue": {
-			dataSyncType: sync.UPDATE,
-			flagResolution: func(evaluator *eval.JSONEvaluator) error {
+			flagResolution: func(evaluator *evaluator.JSON) error {
 				_, _, _, _, err := evaluator.ResolveObjectValue(context.TODO(), "", StaticObjectFlag, nil)
 				return err
 			},
@@ -1145,9 +1393,9 @@ func TestFlagStateSafeForConcurrentReadWrites(t *testing.T) {
 
 	for name, tt := range tests {
 		t.Run(name, func(t *testing.T) {
-			jsonEvaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
+			jsonEvaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
 
-			_, _, err := jsonEvaluator.SetState(sync.DataSync{FlagData: Flags, Type: sync.ADD})
+			_, _, err := jsonEvaluator.SetState(sync.DataSync{FlagData: Flags, Source: "testSource"})
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -1170,7 +1418,7 @@ func TestFlagStateSafeForConcurrentReadWrites(t *testing.T) {
 						errChan <- nil
 						return
 					default:
-						_, _, err := jsonEvaluator.SetState(sync.DataSync{FlagData: Flags, Type: tt.dataSyncType})
+						_, _, err := jsonEvaluator.SetState(sync.DataSync{FlagData: Flags, Source: "testSource"})
 						if err != nil {
 							errChan <- err
 							return
@@ -1210,9 +1458,9 @@ func TestFlagStateSafeForConcurrentReadWrites(t *testing.T) {
 
 func TestFlagdAmbientProperties(t *testing.T) {
 	t.Run("flagKeyIsInTheContext", func(t *testing.T) {
-		evaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
+		evaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
 
-		_, _, err := evaluator.SetState(sync.DataSync{FlagData: `{
+		_, _, err := evaluator.SetState(sync.DataSync{Source: "testSource", FlagData: `{
 			"flags": {
 				"welcome-banner": {
 					"state": "ENABLED",
@@ -1250,9 +1498,9 @@ func TestFlagdAmbientProperties(t *testing.T) {
 	})
 
 	t.Run("timestampIsInTheContext", func(t *testing.T) {
-		evaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
+		evaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
 
-		_, _, err := evaluator.SetState(sync.DataSync{FlagData: `{
+		_, _, err := evaluator.SetState(sync.DataSync{Source: "testSource", FlagData: `{
 			"flags": {
 				"welcome-banner": {
 					"state": "ENABLED",
@@ -1284,9 +1532,9 @@ func TestFlagdAmbientProperties(t *testing.T) {
 
 func TestTargetingVariantBehavior(t *testing.T) {
 	t.Run("missing variant error", func(t *testing.T) {
-		evaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
+		evaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
 
-		_, _, err := evaluator.SetState(sync.DataSync{FlagData: `{
+		_, _, err := evaluator.SetState(sync.DataSync{Source: "testSource", FlagData: `{
 			"flags": {
 				"missing-variant": {
 					"state": "ENABLED",
@@ -1312,9 +1560,9 @@ func TestTargetingVariantBehavior(t *testing.T) {
 	})
 
 	t.Run("null fallback", func(t *testing.T) {
-		evaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
+		evaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
 
-		_, _, err := evaluator.SetState(sync.DataSync{FlagData: `{
+		_, _, err := evaluator.SetState(sync.DataSync{Source: "testSource", FlagData: `{
 			"flags": {
 				"null-fallback": {
 					"state": "ENABLED",
@@ -1344,10 +1592,10 @@ func TestTargetingVariantBehavior(t *testing.T) {
 	})
 
 	t.Run("match booleans", func(t *testing.T) {
-		evaluator := eval.NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
+		evaluator := evaluator.NewJSON(logger.NewLogger(nil, false), store.NewFlags())
 
 		//nolint:dupword
-		_, _, err := evaluator.SetState(sync.DataSync{FlagData: `{
+		_, _, err := evaluator.SetState(sync.DataSync{Source: "testSource", FlagData: `{
 			"flags": {
 				"match-boolean": {
 					"state": "ENABLED",

core/pkg/evaluator/mock/ievaluator.go

@@ -0,0 +1,339 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: pkg/evaluator/ievaluator.go
+//
+// Generated by this command:
+//
+//	mockgen -source=pkg/evaluator/ievaluator.go -destination=pkg/evaluator/mock/ievaluator.go -package=evalmock
+//
+
+// Package evalmock is a generated GoMock package.
+package evalmock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	evaluator "github.com/open-feature/flagd/core/pkg/evaluator"
+	model "github.com/open-feature/flagd/core/pkg/model"
+	sync "github.com/open-feature/flagd/core/pkg/sync"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockIEvaluator is a mock of IEvaluator interface.
+type MockIEvaluator struct {
+	ctrl     *gomock.Controller
+	recorder *MockIEvaluatorMockRecorder
+	isgomock struct{}
+}
+
+// MockIEvaluatorMockRecorder is the mock recorder for MockIEvaluator.
+type MockIEvaluatorMockRecorder struct {
+	mock *MockIEvaluator
+}
+
+// NewMockIEvaluator creates a new mock instance.
+func NewMockIEvaluator(ctrl *gomock.Controller) *MockIEvaluator {
+	mock := &MockIEvaluator{ctrl: ctrl}
+	mock.recorder = &MockIEvaluatorMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockIEvaluator) EXPECT() *MockIEvaluatorMockRecorder {
+	return m.recorder
+}
+
+// GetState mocks base method.
+func (m *MockIEvaluator) GetState() (string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetState")
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetState indicates an expected call of GetState.
+func (mr *MockIEvaluatorMockRecorder) GetState() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetState", reflect.TypeOf((*MockIEvaluator)(nil).GetState))
+}
+
+// ResolveAllValues mocks base method.
+func (m *MockIEvaluator) ResolveAllValues(ctx context.Context, reqID string, context map[string]any) ([]evaluator.AnyValue, model.Metadata, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResolveAllValues", ctx, reqID, context)
+	ret0, _ := ret[0].([]evaluator.AnyValue)
+	ret1, _ := ret[1].(model.Metadata)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// ResolveAllValues indicates an expected call of ResolveAllValues.
+func (mr *MockIEvaluatorMockRecorder) ResolveAllValues(ctx, reqID, context any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveAllValues", reflect.TypeOf((*MockIEvaluator)(nil).ResolveAllValues), ctx, reqID, context)
+}
+
+// ResolveAsAnyValue mocks base method.
+func (m *MockIEvaluator) ResolveAsAnyValue(ctx context.Context, reqID, flagKey string, context map[string]any) evaluator.AnyValue {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResolveAsAnyValue", ctx, reqID, flagKey, context)
+	ret0, _ := ret[0].(evaluator.AnyValue)
+	return ret0
+}
+
+// ResolveAsAnyValue indicates an expected call of ResolveAsAnyValue.
+func (mr *MockIEvaluatorMockRecorder) ResolveAsAnyValue(ctx, reqID, flagKey, context any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveAsAnyValue", reflect.TypeOf((*MockIEvaluator)(nil).ResolveAsAnyValue), ctx, reqID, flagKey, context)
+}
+
+// ResolveBooleanValue mocks base method.
+func (m *MockIEvaluator) ResolveBooleanValue(ctx context.Context, reqID, flagKey string, context map[string]any) (bool, string, string, model.Metadata, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResolveBooleanValue", ctx, reqID, flagKey, context)
+	ret0, _ := ret[0].(bool)
+	ret1, _ := ret[1].(string)
+	ret2, _ := ret[2].(string)
+	ret3, _ := ret[3].(model.Metadata)
+	ret4, _ := ret[4].(error)
+	return ret0, ret1, ret2, ret3, ret4
+}
+
+// ResolveBooleanValue indicates an expected call of ResolveBooleanValue.
+func (mr *MockIEvaluatorMockRecorder) ResolveBooleanValue(ctx, reqID, flagKey, context any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveBooleanValue", reflect.TypeOf((*MockIEvaluator)(nil).ResolveBooleanValue), ctx, reqID, flagKey, context)
+}
+
+// ResolveFloatValue mocks base method.
+func (m *MockIEvaluator) ResolveFloatValue(ctx context.Context, reqID, flagKey string, context map[string]any) (float64, string, string, model.Metadata, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResolveFloatValue", ctx, reqID, flagKey, context)
+	ret0, _ := ret[0].(float64)
+	ret1, _ := ret[1].(string)
+	ret2, _ := ret[2].(string)
+	ret3, _ := ret[3].(model.Metadata)
+	ret4, _ := ret[4].(error)
+	return ret0, ret1, ret2, ret3, ret4
+}
+
+// ResolveFloatValue indicates an expected call of ResolveFloatValue.
+func (mr *MockIEvaluatorMockRecorder) ResolveFloatValue(ctx, reqID, flagKey, context any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveFloatValue", reflect.TypeOf((*MockIEvaluator)(nil).ResolveFloatValue), ctx, reqID, flagKey, context)
+}
+
+// ResolveIntValue mocks base method.
+func (m *MockIEvaluator) ResolveIntValue(ctx context.Context, reqID, flagKey string, context map[string]any) (int64, string, string, model.Metadata, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResolveIntValue", ctx, reqID, flagKey, context)
+	ret0, _ := ret[0].(int64)
+	ret1, _ := ret[1].(string)
+	ret2, _ := ret[2].(string)
+	ret3, _ := ret[3].(model.Metadata)
+	ret4, _ := ret[4].(error)
+	return ret0, ret1, ret2, ret3, ret4
+}
+
+// ResolveIntValue indicates an expected call of ResolveIntValue.
+func (mr *MockIEvaluatorMockRecorder) ResolveIntValue(ctx, reqID, flagKey, context any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveIntValue", reflect.TypeOf((*MockIEvaluator)(nil).ResolveIntValue), ctx, reqID, flagKey, context)
+}
+
+// ResolveObjectValue mocks base method.
+func (m *MockIEvaluator) ResolveObjectValue(ctx context.Context, reqID, flagKey string, context map[string]any) (map[string]any, string, string, model.Metadata, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResolveObjectValue", ctx, reqID, flagKey, context)
+	ret0, _ := ret[0].(map[string]any)
+	ret1, _ := ret[1].(string)
+	ret2, _ := ret[2].(string)
+	ret3, _ := ret[3].(model.Metadata)
+	ret4, _ := ret[4].(error)
+	return ret0, ret1, ret2, ret3, ret4
+}
+
+// ResolveObjectValue indicates an expected call of ResolveObjectValue.
+func (mr *MockIEvaluatorMockRecorder) ResolveObjectValue(ctx, reqID, flagKey, context any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveObjectValue", reflect.TypeOf((*MockIEvaluator)(nil).ResolveObjectValue), ctx, reqID, flagKey, context)
+}
+
+// ResolveStringValue mocks base method.
+func (m *MockIEvaluator) ResolveStringValue(ctx context.Context, reqID, flagKey string, context map[string]any) (string, string, string, model.Metadata, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResolveStringValue", ctx, reqID, flagKey, context)
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(string)
+	ret2, _ := ret[2].(string)
+	ret3, _ := ret[3].(model.Metadata)
+	ret4, _ := ret[4].(error)
+	return ret0, ret1, ret2, ret3, ret4
+}
+
+// ResolveStringValue indicates an expected call of ResolveStringValue.
+func (mr *MockIEvaluatorMockRecorder) ResolveStringValue(ctx, reqID, flagKey, context any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveStringValue", reflect.TypeOf((*MockIEvaluator)(nil).ResolveStringValue), ctx, reqID, flagKey, context)
+}
+
+// SetState mocks base method.
+func (m *MockIEvaluator) SetState(payload sync.DataSync) (model.Metadata, bool, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetState", payload)
+	ret0, _ := ret[0].(model.Metadata)
+	ret1, _ := ret[1].(bool)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// SetState indicates an expected call of SetState.
+func (mr *MockIEvaluatorMockRecorder) SetState(payload any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetState", reflect.TypeOf((*MockIEvaluator)(nil).SetState), payload)
+}
+
+// MockIResolver is a mock of IResolver interface.
+type MockIResolver struct {
+	ctrl     *gomock.Controller
+	recorder *MockIResolverMockRecorder
+	isgomock struct{}
+}
+
+// MockIResolverMockRecorder is the mock recorder for MockIResolver.
+type MockIResolverMockRecorder struct {
+	mock *MockIResolver
+}
+
+// NewMockIResolver creates a new mock instance.
+func NewMockIResolver(ctrl *gomock.Controller) *MockIResolver {
+	mock := &MockIResolver{ctrl: ctrl}
+	mock.recorder = &MockIResolverMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockIResolver) EXPECT() *MockIResolverMockRecorder {
+	return m.recorder
+}
+
+// ResolveAllValues mocks base method.
+func (m *MockIResolver) ResolveAllValues(ctx context.Context, reqID string, context map[string]any) ([]evaluator.AnyValue, model.Metadata, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResolveAllValues", ctx, reqID, context)
+	ret0, _ := ret[0].([]evaluator.AnyValue)
+	ret1, _ := ret[1].(model.Metadata)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// ResolveAllValues indicates an expected call of ResolveAllValues.
+func (mr *MockIResolverMockRecorder) ResolveAllValues(ctx, reqID, context any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveAllValues", reflect.TypeOf((*MockIResolver)(nil).ResolveAllValues), ctx, reqID, context)
+}
+
+// ResolveAsAnyValue mocks base method.
+func (m *MockIResolver) ResolveAsAnyValue(ctx context.Context, reqID, flagKey string, context map[string]any) evaluator.AnyValue {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResolveAsAnyValue", ctx, reqID, flagKey, context)
+	ret0, _ := ret[0].(evaluator.AnyValue)
+	return ret0
+}
+
+// ResolveAsAnyValue indicates an expected call of ResolveAsAnyValue.
+func (mr *MockIResolverMockRecorder) ResolveAsAnyValue(ctx, reqID, flagKey, context any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveAsAnyValue", reflect.TypeOf((*MockIResolver)(nil).ResolveAsAnyValue), ctx, reqID, flagKey, context)
+}
+
+// ResolveBooleanValue mocks base method.
+func (m *MockIResolver) ResolveBooleanValue(ctx context.Context, reqID, flagKey string, context map[string]any) (bool, string, string, model.Metadata, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResolveBooleanValue", ctx, reqID, flagKey, context)
+	ret0, _ := ret[0].(bool)
+	ret1, _ := ret[1].(string)
+	ret2, _ := ret[2].(string)
+	ret3, _ := ret[3].(model.Metadata)
+	ret4, _ := ret[4].(error)
+	return ret0, ret1, ret2, ret3, ret4
+}
+
+// ResolveBooleanValue indicates an expected call of ResolveBooleanValue.
+func (mr *MockIResolverMockRecorder) ResolveBooleanValue(ctx, reqID, flagKey, context any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveBooleanValue", reflect.TypeOf((*MockIResolver)(nil).ResolveBooleanValue), ctx, reqID, flagKey, context)
+}
+
+// ResolveFloatValue mocks base method.
+func (m *MockIResolver) ResolveFloatValue(ctx context.Context, reqID, flagKey string, context map[string]any) (float64, string, string, model.Metadata, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResolveFloatValue", ctx, reqID, flagKey, context)
+	ret0, _ := ret[0].(float64)
+	ret1, _ := ret[1].(string)
+	ret2, _ := ret[2].(string)
+	ret3, _ := ret[3].(model.Metadata)
+	ret4, _ := ret[4].(error)
+	return ret0, ret1, ret2, ret3, ret4
+}
+
+// ResolveFloatValue indicates an expected call of ResolveFloatValue.
+func (mr *MockIResolverMockRecorder) ResolveFloatValue(ctx, reqID, flagKey, context any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveFloatValue", reflect.TypeOf((*MockIResolver)(nil).ResolveFloatValue), ctx, reqID, flagKey, context)
+}
+
+// ResolveIntValue mocks base method.
+func (m *MockIResolver) ResolveIntValue(ctx context.Context, reqID, flagKey string, context map[string]any) (int64, string, string, model.Metadata, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResolveIntValue", ctx, reqID, flagKey, context)
+	ret0, _ := ret[0].(int64)
+	ret1, _ := ret[1].(string)
+	ret2, _ := ret[2].(string)
+	ret3, _ := ret[3].(model.Metadata)
+	ret4, _ := ret[4].(error)
+	return ret0, ret1, ret2, ret3, ret4
+}
+
+// ResolveIntValue indicates an expected call of ResolveIntValue.
+func (mr *MockIResolverMockRecorder) ResolveIntValue(ctx, reqID, flagKey, context any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveIntValue", reflect.TypeOf((*MockIResolver)(nil).ResolveIntValue), ctx, reqID, flagKey, context)
+}
+
+// ResolveObjectValue mocks base method.
+func (m *MockIResolver) ResolveObjectValue(ctx context.Context, reqID, flagKey string, context map[string]any) (map[string]any, string, string, model.Metadata, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResolveObjectValue", ctx, reqID, flagKey, context)
+	ret0, _ := ret[0].(map[string]any)
+	ret1, _ := ret[1].(string)
+	ret2, _ := ret[2].(string)
+	ret3, _ := ret[3].(model.Metadata)
+	ret4, _ := ret[4].(error)
+	return ret0, ret1, ret2, ret3, ret4
+}
+
+// ResolveObjectValue indicates an expected call of ResolveObjectValue.
+func (mr *MockIResolverMockRecorder) ResolveObjectValue(ctx, reqID, flagKey, context any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveObjectValue", reflect.TypeOf((*MockIResolver)(nil).ResolveObjectValue), ctx, reqID, flagKey, context)
+}
+
+// ResolveStringValue mocks base method.
+func (m *MockIResolver) ResolveStringValue(ctx context.Context, reqID, flagKey string, context map[string]any) (string, string, string, model.Metadata, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResolveStringValue", ctx, reqID, flagKey, context)
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(string)
+	ret2, _ := ret[2].(string)
+	ret3, _ := ret[3].(model.Metadata)
+	ret4, _ := ret[4].(error)
+	return ret0, ret1, ret2, ret3, ret4
+}
+
+// ResolveStringValue indicates an expected call of ResolveStringValue.
+func (mr *MockIResolverMockRecorder) ResolveStringValue(ctx, reqID, flagKey, context any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveStringValue", reflect.TypeOf((*MockIResolver)(nil).ResolveStringValue), ctx, reqID, flagKey, context)
+}

core/pkg/evaluator/semver.go

@@ -1,4 +1,4 @@
-package eval
+package evaluator
 
 import (
 	"errors"
@@ -52,12 +52,12 @@ func (svo SemVerOperator) compare(v1, v2 string) (bool, error) {
 	}
 }
 
-type SemVerComparisonEvaluator struct {
+type SemVerComparison struct {
 	Logger *logger.Logger
 }
 
-func NewSemVerComparisonEvaluator(log *logger.Logger) *SemVerComparisonEvaluator {
-	return &SemVerComparisonEvaluator{Logger: log}
+func NewSemVerComparison(log *logger.Logger) *SemVerComparison {
+	return &SemVerComparison{Logger: log}
 }
 
 // SemVerEvaluation checks if the given property matches a semantic versioning condition.
@@ -81,7 +81,7 @@ func NewSemVerComparisonEvaluator(log *logger.Logger) *SemVerComparisonEvaluator
 // 1. Target property: this needs which both resolve to a semantic versioning string
 // 2. Operator: One of the following: '=', '!=', '>', '<', '>=', '<=', '~', '^'
 // 3. Target value: this needs which both resolve to a semantic versioning string
-func (je *SemVerComparisonEvaluator) SemVerEvaluation(values, _ interface{}) interface{} {
+func (je *SemVerComparison) SemVerEvaluation(values, _ interface{}) interface{} {
 	actualVersion, targetVersion, operator, err := parseSemverEvaluationData(values)
 	if err != nil {
 		je.Logger.Error(fmt.Sprintf("parse sem_ver evaluation data: %v", err))
@@ -102,7 +102,7 @@ func parseSemverEvaluationData(values interface{}) (string, string, SemVerOperat
 	}
 
 	if len(parsed) != 3 {
-		return "", "", "", errors.New("sem_ver evaluation must contain a value, an operator and a comparison target")
+		return "", "", "", errors.New("sem_ver evaluation must contain a value, an operator, and a comparison target")
 	}
 
 	actualVersion, err := parseSemanticVersion(parsed[0])
@@ -122,11 +122,17 @@ func parseSemverEvaluationData(values interface{}) (string, string, SemVerOperat
 	return actualVersion, targetVersion, operator, nil
 }
 
-func parseSemanticVersion(v interface{}) (string, error) {
-	version, ok := v.(string)
-	if !ok {
-		return "", errors.New("sem_ver evaluation: property did not resolve to a string value")
+func ensureString(v interface{}) string {
+	if str, ok := v.(string); ok {
+		// It's already a string
+		return str
 	}
+	// Convert to string if not already
+	return fmt.Sprintf("%v", v)
+}
+
+func parseSemanticVersion(v interface{}) (string, error) {
+	version := ensureString(v)
 	// version strings are only valid in the semver package if they start with a 'v'
 	// if it's not present in the given value, we prepend it
 	if !strings.HasPrefix(version, "v") {
@@ -134,7 +140,7 @@ func parseSemanticVersion(v interface{}) (string, error) {
 	}
 
 	if !semver.IsValid(version) {
-		return "", errors.New("not a valid semantic version string")
+		return "", fmt.Errorf("'%v' is not a valid semantic version string", version)
 	}
 
 	return version, nil
@@ -143,7 +149,7 @@ func parseSemanticVersion(v interface{}) (string, error) {
 func parseOperator(o interface{}) (SemVerOperator, error) {
 	operatorString, ok := o.(string)
 	if !ok {
-		return "", errors.New("could not parse operator")
+		return "", fmt.Errorf("could not parse operator '%v'", o)
 	}
 
 	return SemVerOperator(operatorString), nil

core/pkg/evaluator/semver_test.go

@@ -1,6 +1,8 @@
-package eval
+package evaluator
 
 import (
+	"context"
+	"errors"
 	"testing"
 
 	"github.com/open-feature/flagd/core/pkg/logger"
@@ -21,6 +23,76 @@ func TestSemVerOperator_Compare(t *testing.T) {
 		want    bool
 		wantErr bool
 	}{
+		{
+			name: "invalid version",
+			svo:  Greater,
+			args: args{
+				v1: "invalid",
+				v2: "v1.0.0",
+			},
+			want:    false,
+			wantErr: true,
+		},
+		{
+			name: "preview version vs non preview version",
+			svo:  Greater,
+			args: args{
+				v1: "v1.0.0-preview.1.2",
+				v2: "v1.0.0",
+			},
+			want:    false,
+			wantErr: false,
+		},
+		{
+			name: "preview version vs preview version",
+			svo:  Greater,
+			args: args{
+				v1: "v1.0.0-preview.1.3",
+				v2: "v1.0.0-preview.1.2",
+			},
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name: "no prefixed v left greater",
+			svo:  Greater,
+			args: args{
+				v1: "0.0.1",
+				v2: "v0.0.2",
+			},
+			want:    false,
+			wantErr: false,
+		},
+		{
+			name: "no prefixed v right greater",
+			svo:  Greater,
+			args: args{
+				v1: "v0.0.1",
+				v2: "0.0.2",
+			},
+			want:    false,
+			wantErr: false,
+		},
+		{
+			name: "no prefixed v right equals",
+			svo:  Equals,
+			args: args{
+				v1: "v0.0.1",
+				v2: "0.0.1",
+			},
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name: "no prefixed v both",
+			svo:  Greater,
+			args: args{
+				v1: "0.0.1",
+				v2: "0.0.2",
+			},
+			want:    false,
+			wantErr: false,
+		},
 		{
 			name: "invalid operator",
 			svo:  "",
@@ -31,6 +103,16 @@ func TestSemVerOperator_Compare(t *testing.T) {
 			want:    false,
 			wantErr: true,
 		},
+		{
+			name: "less with large number",
+			svo:  Less,
+			args: args{
+				v1: "v1234.0.1",
+				v2: "v1235.0.2",
+			},
+			want:    true,
+			wantErr: false,
+		},
 		{
 			name: "less",
 			svo:  Less,
@@ -41,6 +123,16 @@ func TestSemVerOperator_Compare(t *testing.T) {
 			want:    true,
 			wantErr: false,
 		},
+		{
+			name: "no minor version",
+			svo:  Less,
+			args: args{
+				v1: "v1.0",
+				v2: "v1.2",
+			},
+			want:    true,
+			wantErr: false,
+		},
 		{
 			name: "not less",
 			svo:  Less,
@@ -204,19 +296,30 @@ func TestSemVerOperator_Compare(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := tt.svo.compare(tt.args.v1, tt.args.v2)
+			var operatorInterface interface{} = string(tt.svo)
+			actualVersion, targetVersion, operator, err := parseSemverEvaluationData([]interface{}{tt.args.v1, operatorInterface, tt.args.v2})
+			if err != nil {
+				require.Truef(t, tt.wantErr, "Error parsing semver evaluation data. actualVersion: %s, targetVersion: %s, operator: %s, err: %s", actualVersion, targetVersion, operator, err)
+				return
+			}
+
+			got, err := operator.compare(actualVersion, targetVersion)
 
 			if tt.wantErr {
 				require.NotNil(t, err)
 			} else {
 				require.Nil(t, err)
-				require.Equalf(t, tt.want, got, "compare(%v, %v)", tt.args.v1, tt.args.v2)
+				require.Equalf(t, tt.want, got, "compare(%v, %v) operator: %s", tt.args.v1, tt.args.v2, operator)
 			}
 		})
 	}
 }
 
 func TestJSONEvaluator_semVerEvaluation(t *testing.T) {
+	const source = "testSource"
+	var sources = []string{source}
+	ctx := context.Background()
+
 	tests := map[string]struct {
 		flags           Flags
 		flagKey         string
@@ -381,6 +484,130 @@ func TestJSONEvaluator_semVerEvaluation(t *testing.T) {
 			expectedValue:   "#FF0000",
 			expectedReason:  model.TargetingMatchReason,
 		},
+		"versions given as double - match": {
+			flags: Flags{
+				Flags: map[string]model.Flag{
+					"headerColor": {
+						State:          "ENABLED",
+						DefaultVariant: "red",
+						Variants: map[string]any{
+							"red":    "#FF0000",
+							"blue":   "#0000FF",
+							"green":  "#00FF00",
+							"yellow": "#FFFF00",
+						},
+						Targeting: []byte(`{
+											"if": [
+											  {
+												"sem_ver": [1.2, "=", "1.2"]
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"version": "1.0.0",
+			},
+			expectedVariant: "red",
+			expectedValue:   "#FF0000",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"versions given as int - match": {
+			flags: Flags{
+				Flags: map[string]model.Flag{
+					"headerColor": {
+						State:          "ENABLED",
+						DefaultVariant: "red",
+						Variants: map[string]any{
+							"red":    "#FF0000",
+							"blue":   "#0000FF",
+							"green":  "#00FF00",
+							"yellow": "#FFFF00",
+						},
+						Targeting: []byte(`{
+											"if": [
+											  {
+												"sem_ver": [1, "=", "v1.0.0"]
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"version": "1.0.0",
+			},
+			expectedVariant: "red",
+			expectedValue:   "#FF0000",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"versions and minor-version without patch version operator provided - match": {
+			flags: Flags{
+				Flags: map[string]model.Flag{
+					"headerColor": {
+						State:          "ENABLED",
+						DefaultVariant: "red",
+						Variants: map[string]any{
+							"red":    "#FF0000",
+							"blue":   "#0000FF",
+							"green":  "#00FF00",
+							"yellow": "#FFFF00",
+						},
+						Targeting: []byte(`{
+											"if": [
+											  {
+												"sem_ver": [1.2, "=", "1.2"]
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"version": "1.0.0",
+			},
+			expectedVariant: "red",
+			expectedValue:   "#FF0000",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"versions with prefixed v operator provided - match": {
+			flags: Flags{
+				Flags: map[string]model.Flag{
+					"headerColor": {
+						State:          "ENABLED",
+						DefaultVariant: "red",
+						Variants: map[string]any{
+							"red":    "#FF0000",
+							"blue":   "#0000FF",
+							"green":  "#00FF00",
+							"yellow": "#FFFF00",
+						},
+						Targeting: []byte(`{
+											"if": [
+											  {
+												"sem_ver": [{"var": "version"}, "<", "v1.2"]
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"version": "v1.0.0",
+			},
+			expectedVariant: "red",
+			expectedValue:   "#FF0000",
+			expectedReason:  model.TargetingMatchReason,
+		},
 		"versions and major-version operator provided - no match": {
 			flags: Flags{
 				Flags: map[string]model.Flag{
@@ -697,17 +924,14 @@ func TestJSONEvaluator_semVerEvaluation(t *testing.T) {
 	for name, tt := range tests {
 		t.Run(name, func(t *testing.T) {
 			log := logger.NewLogger(nil, false)
-			je := NewJSONEvaluator(
-				log,
-				store.NewFlags(),
-				WithEvaluator(
-					SemVerEvaluationName,
-					NewSemVerComparisonEvaluator(log).SemVerEvaluation,
-				),
-			)
-			je.store.Flags = tt.flags.Flags
+			s, err := store.NewStore(log, sources)
+			if err != nil {
+				t.Fatalf("NewStore failed: %v", err)
+			}
+			je := NewJSON(log, s)
+			je.store.Update(source, tt.flags.Flags, model.Metadata{})
 
-			value, variant, reason, _, err := resolve[string](reqID, tt.flagKey, tt.context, je.evaluateVariant)
+			value, variant, reason, _, err := resolve[string](ctx, reqID, tt.flagKey, tt.context, je.evaluateVariant)
 
 			if value != tt.expectedValue {
 				t.Errorf("expected value '%s', got '%s'", tt.expectedValue, value)
@@ -721,7 +945,7 @@ func TestJSONEvaluator_semVerEvaluation(t *testing.T) {
 				t.Errorf("expected reason '%s', got '%s'", tt.expectedReason, reason)
 			}
 
-			if err != tt.expectedError {
+			if !errors.Is(err, tt.expectedError) {
 				t.Errorf("expected err '%v', got '%v'", tt.expectedError, err)
 			}
 		})

core/pkg/evaluator/string_comparison.go

@@ -1,4 +1,4 @@
-package eval
+package evaluator
 
 import (
 	"errors"
@@ -68,7 +68,7 @@ func (sce *StringComparisonEvaluator) StartsWithEvaluation(values, _ interface{}
 //
 // Note that the 'ends_with'  evaluation rule must contain exactly two items, which both resolve to a
 // string value
-func (sce StringComparisonEvaluator) EndsWithEvaluation(values, _ interface{}) interface{} {
+func (sce *StringComparisonEvaluator) EndsWithEvaluation(values, _ interface{}) interface{} {
 	propertyValue, target, err := parseStringComparisonEvaluationData(values)
 	if err != nil {
 		sce.Logger.Error(fmt.Sprintf("parse ends_with evaluation data: %v", err))

core/pkg/evaluator/string_comparison_test.go

@@ -1,6 +1,8 @@
-package eval
+package evaluator
 
 import (
+	"context"
+	"errors"
 	"fmt"
 	"testing"
 
@@ -11,6 +13,10 @@ import (
 )
 
 func TestJSONEvaluator_startsWithEvaluation(t *testing.T) {
+	const source = "testSource"
+	var sources = []string{source}
+	ctx := context.Background()
+
 	tests := map[string]struct {
 		flags           Flags
 		flagKey         string
@@ -181,17 +187,14 @@ func TestJSONEvaluator_startsWithEvaluation(t *testing.T) {
 	for name, tt := range tests {
 		t.Run(name, func(t *testing.T) {
 			log := logger.NewLogger(nil, false)
-			je := NewJSONEvaluator(
-				log,
-				store.NewFlags(),
-				WithEvaluator(
-					StartsWithEvaluationName,
-					NewStringComparisonEvaluator(log).StartsWithEvaluation,
-				),
-			)
-			je.store.Flags = tt.flags.Flags
+			s, err := store.NewStore(log, sources)
+			if err != nil {
+				t.Fatalf("NewStore failed: %v", err)
+			}
+			je := NewJSON(log, s)
+			je.store.Update(source, tt.flags.Flags, model.Metadata{})
 
-			value, variant, reason, _, err := resolve[string](reqID, tt.flagKey, tt.context, je.evaluateVariant)
+			value, variant, reason, _, err := resolve[string](ctx, reqID, tt.flagKey, tt.context, je.evaluateVariant)
 
 			if value != tt.expectedValue {
 				t.Errorf("expected value '%s', got '%s'", tt.expectedValue, value)
@@ -205,7 +208,7 @@ func TestJSONEvaluator_startsWithEvaluation(t *testing.T) {
 				t.Errorf("expected reason '%s', got '%s'", tt.expectedReason, reason)
 			}
 
-			if err != tt.expectedError {
+			if !errors.Is(err, tt.expectedError) {
 				t.Errorf("expected err '%v', got '%v'", tt.expectedError, err)
 			}
 		})
@@ -213,6 +216,10 @@ func TestJSONEvaluator_startsWithEvaluation(t *testing.T) {
 }
 
 func TestJSONEvaluator_endsWithEvaluation(t *testing.T) {
+	const source = "testSource"
+	var sources = []string{source}
+	ctx := context.Background()
+
 	tests := map[string]struct {
 		flags           Flags
 		flagKey         string
@@ -383,18 +390,14 @@ func TestJSONEvaluator_endsWithEvaluation(t *testing.T) {
 	for name, tt := range tests {
 		t.Run(name, func(t *testing.T) {
 			log := logger.NewLogger(nil, false)
-			je := NewJSONEvaluator(
-				log,
-				store.NewFlags(),
-				WithEvaluator(
-					EndsWithEvaluationName,
-					NewStringComparisonEvaluator(log).EndsWithEvaluation,
-				),
-			)
+			s, err := store.NewStore(log, sources)
+			if err != nil {
+				t.Fatalf("NewStore failed: %v", err)
+			}
+			je := NewJSON(log, s)
+			je.store.Update(source, tt.flags.Flags, model.Metadata{})
 
-			je.store.Flags = tt.flags.Flags
-
-			value, variant, reason, _, err := resolve[string](reqID, tt.flagKey, tt.context, je.evaluateVariant)
+			value, variant, reason, _, err := resolve[string](ctx, reqID, tt.flagKey, tt.context, je.evaluateVariant)
 
 			if value != tt.expectedValue {
 				t.Errorf("expected value '%s', got '%s'", tt.expectedValue, value)

core/pkg/model/error.go

@@ -1,9 +1,28 @@
 package model
 
+import "fmt"
+
 const (
 	FlagNotFoundErrorCode = "FLAG_NOT_FOUND"
 	ParseErrorCode        = "PARSE_ERROR"
 	TypeMismatchErrorCode = "TYPE_MISMATCH"
 	GeneralErrorCode      = "GENERAL"
 	FlagDisabledErrorCode = "FLAG_DISABLED"
+	InvalidContextCode    = "INVALID_CONTEXT"
 )
+
+var ReadableErrorMessage = map[string]string{
+	FlagNotFoundErrorCode: "Flag not found",
+	ParseErrorCode:        "Error parsing input or configuration",
+	TypeMismatchErrorCode: "Type mismatch error",
+	GeneralErrorCode:      "General error",
+	FlagDisabledErrorCode: "Flag is disabled",
+	InvalidContextCode:    "Invalid context provided",
+}
+
+func GetErrorMessage(code string) string {
+	if msg, exists := ReadableErrorMessage[code]; exists {
+		return msg
+	}
+	return fmt.Sprintf("Unknown error code: %s", code)
+}

core/pkg/model/flag.go

@@ -2,14 +2,26 @@ package model
 
 import "encoding/json"
 
+const Key = "Key"
+const FlagSetId = "FlagSetId"
+const Source = "Source"
+const Priority = "Priority"
+
 type Flag struct {
+	Key            string          `json:"-"` // not serialized, used only for indexing
+	FlagSetId      string          `json:"-"` // not serialized, used only for indexing
+	Priority       int             `json:"-"` // not serialized, used only for indexing
 	State          string          `json:"state"`
 	DefaultVariant string          `json:"defaultVariant"`
 	Variants       map[string]any  `json:"variants"`
 	Targeting      json.RawMessage `json:"targeting,omitempty"`
 	Source         string          `json:"source"`
+	Selector       string          `json:"selector"`
+	Metadata       Metadata        `json:"metadata,omitempty"`
 }
 
 type Evaluators struct {
 	Evaluators map[string]json.RawMessage `json:"$evaluators"`
 }
+
+type Metadata = map[string]interface{}

core/pkg/notifications/notifications.go

@@ -0,0 +1,52 @@
+package notifications
+
+import (
+	"reflect"
+
+	"github.com/open-feature/flagd/core/pkg/model"
+)
+
+const typeField = "type"
+
+// Use to represent change notifications for  mode PROVIDER_CONFIGURATION_CHANGE events.
+type Notifications map[string]any
+
+// Generate notifications (deltas) from old and new flag sets for use in RPC mode PROVIDER_CONFIGURATION_CHANGE events.
+func NewFromFlags(oldFlags, newFlags map[string]model.Flag) Notifications {
+	notifications := map[string]interface{}{}
+
+	// flags removed
+	for key := range oldFlags {
+		if _, ok := newFlags[key]; !ok {
+			notifications[key] = map[string]interface{}{
+				typeField: string(model.NotificationDelete),
+			}
+		}
+	}
+
+	// flags added or modified
+	for key, newFlag := range newFlags {
+		oldFlag, exists := oldFlags[key]
+		if !exists {
+			notifications[key] = map[string]interface{}{
+				typeField: string(model.NotificationCreate),
+			}
+		} else if !flagsEqual(oldFlag, newFlag) {
+			notifications[key] = map[string]interface{}{
+				typeField: string(model.NotificationUpdate),
+			}
+		}
+	}
+
+	return notifications
+}
+
+func flagsEqual(a, b model.Flag) bool {
+	return a.State == b.State &&
+		a.DefaultVariant == b.DefaultVariant &&
+		reflect.DeepEqual(a.Variants, b.Variants) &&
+		reflect.DeepEqual(a.Targeting, b.Targeting) &&
+		a.Source == b.Source &&
+		a.Selector == b.Selector &&
+		reflect.DeepEqual(a.Metadata, b.Metadata)
+}

core/pkg/notifications/notifications_test.go

@@ -0,0 +1,102 @@
+package notifications
+
+import (
+	"testing"
+
+	"github.com/open-feature/flagd/core/pkg/model"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewFromFlags(t *testing.T) {
+	flagA := model.Flag{
+		Key:            "flagA",
+		State:          "ENABLED",
+		DefaultVariant: "on",
+		Source:         "source1",
+	}
+	flagAUpdated := model.Flag{
+		Key:            "flagA",
+		State:          "DISABLED",
+		DefaultVariant: "on",
+		Source:         "source1",
+	}
+	flagB := model.Flag{
+		Key:            "flagB",
+		State:          "ENABLED",
+		DefaultVariant: "off",
+		Source:         "source1",
+	}
+
+	tests := []struct {
+		name     string
+		oldFlags map[string]model.Flag
+		newFlags map[string]model.Flag
+		want     Notifications
+	}{
+		{
+			name:     "flag added",
+			oldFlags: map[string]model.Flag{},
+			newFlags: map[string]model.Flag{"flagA": flagA},
+			want: Notifications{
+				"flagA": map[string]interface{}{
+					"type": string(model.NotificationCreate),
+				},
+			},
+		},
+		{
+			name:     "flag deleted",
+			oldFlags: map[string]model.Flag{"flagA": flagA},
+			newFlags: map[string]model.Flag{},
+			want: Notifications{
+				"flagA": map[string]interface{}{
+					"type": string(model.NotificationDelete),
+				},
+			},
+		},
+		{
+			name:     "flag changed",
+			oldFlags: map[string]model.Flag{"flagA": flagA},
+			newFlags: map[string]model.Flag{"flagA": flagAUpdated},
+			want: Notifications{
+				"flagA": map[string]interface{}{
+					"type": string(model.NotificationUpdate),
+				},
+			},
+		},
+		{
+			name:     "flag unchanged",
+			oldFlags: map[string]model.Flag{"flagA": flagA},
+			newFlags: map[string]model.Flag{"flagA": flagA},
+			want:     Notifications{},
+		},
+		{
+			name: "mixed changes",
+			oldFlags: map[string]model.Flag{
+				"flagA": flagA,
+				"flagB": flagB,
+			},
+			newFlags: map[string]model.Flag{
+				"flagA": flagAUpdated, // updated
+				"flagC": flagA,        // added
+			},
+			want: Notifications{
+				"flagA": map[string]interface{}{
+					"type": string(model.NotificationUpdate),
+				},
+				"flagB": map[string]interface{}{
+					"type": string(model.NotificationDelete),
+				},
+				"flagC": map[string]interface{}{
+					"type": string(model.NotificationCreate),
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := NewFromFlags(tt.oldFlags, tt.newFlags)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}

core/pkg/runtime/from_config.go

@@ -1,330 +0,0 @@
-package runtime
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net/http"
-	"regexp"
-	msync "sync"
-	"time"
-
-	"github.com/open-feature/flagd/core/pkg/eval"
-	"github.com/open-feature/flagd/core/pkg/logger"
-	"github.com/open-feature/flagd/core/pkg/service"
-	flageval "github.com/open-feature/flagd/core/pkg/service/flag-evaluation"
-	"github.com/open-feature/flagd/core/pkg/store"
-	"github.com/open-feature/flagd/core/pkg/sync"
-	"github.com/open-feature/flagd/core/pkg/sync/file"
-	"github.com/open-feature/flagd/core/pkg/sync/grpc"
-	"github.com/open-feature/flagd/core/pkg/sync/grpc/credentials"
-	httpSync "github.com/open-feature/flagd/core/pkg/sync/http"
-	"github.com/open-feature/flagd/core/pkg/sync/kubernetes"
-	"github.com/open-feature/flagd/core/pkg/telemetry"
-	"github.com/robfig/cron"
-	"go.uber.org/zap"
-)
-
-// from_config is a collection of structures and parsers responsible for deriving flagd runtime
-
-const (
-	syncProviderFile       = "file"
-	syncProviderGrpc       = "grpc"
-	syncProviderKubernetes = "kubernetes"
-	syncProviderHTTP       = "http"
-	svcName                = "flagd"
-)
-
-var (
-	regCrd        *regexp.Regexp
-	regURL        *regexp.Regexp
-	regGRPC       *regexp.Regexp
-	regGRPCSecure *regexp.Regexp
-	regFile       *regexp.Regexp
-)
-
-// SourceConfig is configuration option for flagd. This maps to startup parameter sources
-type SourceConfig struct {
-	URI      string `json:"uri"`
-	Provider string `json:"provider"`
-
-	BearerToken string `json:"bearerToken,omitempty"`
-	CertPath    string `json:"certPath,omitempty"`
-	TLS         bool   `json:"tls,omitempty"`
-	ProviderID  string `json:"providerID,omitempty"`
-	Selector    string `json:"selector,omitempty"`
-	Interval    uint32 `json:"interval,omitempty"`
-}
-
-// Config is the configuration structure derived from startup arguments.
-type Config struct {
-	MetricExporter    string
-	ManagementPort    uint16
-	OtelCollectorURI  string
-	ServiceCertPath   string
-	ServiceKeyPath    string
-	ServicePort       uint16
-	ServiceSocketPath string
-
-	SyncProviders []SourceConfig
-	CORS          []string
-}
-
-func init() {
-	regCrd = regexp.MustCompile("^core.openfeature.dev/")
-	regURL = regexp.MustCompile("^https?://")
-	regGRPC = regexp.MustCompile("^" + grpc.Prefix)
-	regGRPCSecure = regexp.MustCompile("^" + grpc.PrefixSecure)
-	regFile = regexp.MustCompile("^file:")
-}
-
-// FromConfig builds a runtime from startup configurations
-// nolint: funlen
-func FromConfig(logger *logger.Logger, version string, config Config) (*Runtime, error) {
-	telCfg := telemetry.Config{
-		MetricsExporter: config.MetricExporter,
-		CollectorTarget: config.OtelCollectorURI,
-	}
-
-	// register error handling for OpenTelemetry
-	telemetry.RegisterErrorHandling(logger)
-
-	// register trace provider for the runtime
-	err := telemetry.BuildTraceProvider(context.Background(), logger, svcName, version, telCfg)
-	if err != nil {
-		return nil, fmt.Errorf("error building trace provider: %w", err)
-	}
-
-	// build metrics recorder with startup configurations
-	recorder, err := telemetry.BuildMetricsRecorder(context.Background(), svcName, version, telCfg)
-	if err != nil {
-		return nil, fmt.Errorf("error building metrics recorder: %w", err)
-	}
-
-	// build flag store & fill sources details
-	s := store.NewFlags()
-	for _, provider := range config.SyncProviders {
-		s.FlagSources = append(s.FlagSources, provider.URI)
-		s.SourceMetadata[provider.URI] = store.SourceDetails{
-			Source:   provider.URI,
-			Selector: provider.Selector,
-		}
-	}
-
-	// derive evaluator
-	evaluator := setupJSONEvaluator(logger, s)
-
-	// derive service
-	connectService := flageval.NewConnectService(
-		logger.WithFields(zap.String("component", "service")),
-		evaluator,
-		recorder)
-
-	// build sync providers
-	syncLogger := logger.WithFields(zap.String("component", "sync"))
-	iSyncs, err := syncProvidersFromConfig(syncLogger, config.SyncProviders)
-	if err != nil {
-		return nil, err
-	}
-
-	return &Runtime{
-		Logger:    logger.WithFields(zap.String("component", "runtime")),
-		Evaluator: evaluator,
-		Service:   connectService,
-		ServiceConfig: service.Configuration{
-			Port:           config.ServicePort,
-			ManagementPort: config.ManagementPort,
-			ServiceName:    svcName,
-			KeyPath:        config.ServiceKeyPath,
-			CertPath:       config.ServiceCertPath,
-			SocketPath:     config.ServiceSocketPath,
-			CORS:           config.CORS,
-			Options:        telemetry.BuildConnectOptions(telCfg),
-		},
-		SyncImpl: iSyncs,
-	}, nil
-}
-
-func setupJSONEvaluator(logger *logger.Logger, s *store.Flags) *eval.JSONEvaluator {
-	evaluator := eval.NewJSONEvaluator(
-		logger,
-		s,
-		eval.WithEvaluator(
-			eval.FractionEvaluationName,
-			eval.NewFractionalEvaluator(logger).FractionalEvaluation,
-		),
-		eval.WithEvaluator(
-			eval.StartsWithEvaluationName,
-			eval.NewStringComparisonEvaluator(logger).StartsWithEvaluation,
-		),
-		eval.WithEvaluator(
-			eval.EndsWithEvaluationName,
-			eval.NewStringComparisonEvaluator(logger).EndsWithEvaluation,
-		),
-		eval.WithEvaluator(
-			eval.SemVerEvaluationName,
-			eval.NewSemVerComparisonEvaluator(logger).SemVerEvaluation,
-		),
-		// deprecated: will be removed before v1!
-		eval.WithEvaluator(
-			eval.LegacyFractionEvaluationName,
-			eval.NewLegacyFractionalEvaluator(logger).LegacyFractionalEvaluation,
-		),
-	)
-	return evaluator
-}
-
-// syncProvidersFromConfig is a helper to build ISync implementations from SourceConfig
-func syncProvidersFromConfig(logger *logger.Logger, sources []SourceConfig) ([]sync.ISync, error) {
-	syncImpls := []sync.ISync{}
-
-	for _, syncProvider := range sources {
-		switch syncProvider.Provider {
-		case syncProviderFile:
-			syncImpls = append(syncImpls, NewFile(syncProvider, logger))
-			logger.Debug(fmt.Sprintf("using filepath sync-provider for: %q", syncProvider.URI))
-		case syncProviderKubernetes:
-			k, err := NewK8s(syncProvider.URI, logger)
-			if err != nil {
-				return nil, err
-			}
-			syncImpls = append(syncImpls, k)
-			logger.Debug(fmt.Sprintf("using kubernetes sync-provider for: %s", syncProvider.URI))
-		case syncProviderHTTP:
-			syncImpls = append(syncImpls, NewHTTP(syncProvider, logger))
-			logger.Debug(fmt.Sprintf("using remote sync-provider for: %s", syncProvider.URI))
-		case syncProviderGrpc:
-			syncImpls = append(syncImpls, NewGRPC(syncProvider, logger))
-			logger.Debug(fmt.Sprintf("using grpc sync-provider for: %s", syncProvider.URI))
-
-		default:
-			return nil, fmt.Errorf("invalid sync provider: %s, must be one of with '%s', '%s', '%s' or '%s'",
-				syncProvider.Provider, syncProviderFile, syncProviderKubernetes, syncProviderHTTP, syncProviderKubernetes)
-		}
-	}
-	return syncImpls, nil
-}
-
-func NewGRPC(config SourceConfig, logger *logger.Logger) *grpc.Sync {
-	return &grpc.Sync{
-		URI: config.URI,
-		Logger: logger.WithFields(
-			zap.String("component", "sync"),
-			zap.String("sync", "grpc"),
-		),
-		CredentialBuilder: &credentials.CredentialBuilder{},
-		CertPath:          config.CertPath,
-		ProviderID:        config.ProviderID,
-		Secure:            config.TLS,
-		Selector:          config.Selector,
-	}
-}
-
-func NewHTTP(config SourceConfig, logger *logger.Logger) *httpSync.Sync {
-	// Default to 5 seconds
-	var interval uint32 = 5
-	if config.Interval != 0 {
-		interval = config.Interval
-	}
-
-	return &httpSync.Sync{
-		URI: config.URI,
-		Client: &http.Client{
-			Timeout: time.Second * 10,
-		},
-		Logger: logger.WithFields(
-			zap.String("component", "sync"),
-			zap.String("sync", "remote"),
-		),
-		BearerToken: config.BearerToken,
-		Interval:    interval,
-		Cron:        cron.New(),
-	}
-}
-
-func NewK8s(uri string, logger *logger.Logger) (*kubernetes.Sync, error) {
-	reader, dynamic, err := kubernetes.GetClients()
-	if err != nil {
-		return nil, fmt.Errorf("error creating kubernetes clients: %w", err)
-	}
-	return kubernetes.NewK8sSync(
-		logger.WithFields(
-			zap.String("component", "sync"),
-			zap.String("sync", "kubernetes"),
-		),
-		regCrd.ReplaceAllString(uri, ""),
-		reader,
-		dynamic,
-	), nil
-}
-
-func NewFile(config SourceConfig, logger *logger.Logger) *file.Sync {
-	return &file.Sync{
-		URI: config.URI,
-		Logger: logger.WithFields(
-			zap.String("component", "sync"),
-			zap.String("sync", "filepath"),
-		),
-		Mux: &msync.RWMutex{},
-	}
-}
-
-// ParseSources parse a json formatted SourceConfig array string and performs validations on the content
-func ParseSources(sourcesFlag string) ([]SourceConfig, error) {
-	syncProvidersParsed := []SourceConfig{}
-
-	if err := json.Unmarshal([]byte(sourcesFlag), &syncProvidersParsed); err != nil {
-		return syncProvidersParsed, fmt.Errorf("error parsing sync providers: %w", err)
-	}
-	for _, sp := range syncProvidersParsed {
-		if sp.URI == "" {
-			return syncProvidersParsed, errors.New("sync provider argument parse: uri is a required field")
-		}
-		if sp.Provider == "" {
-			return syncProvidersParsed, errors.New("sync provider argument parse: provider is a required field")
-		}
-	}
-	return syncProvidersParsed, nil
-}
-
-// ParseSyncProviderURIs uri flag based sync sources to SourceConfig array. Replaces uri prefixes where necessary to
-// derive SourceConfig
-func ParseSyncProviderURIs(uris []string) ([]SourceConfig, error) {
-	syncProvidersParsed := []SourceConfig{}
-
-	for _, uri := range uris {
-		switch uriB := []byte(uri); {
-		case regFile.Match(uriB):
-			syncProvidersParsed = append(syncProvidersParsed, SourceConfig{
-				URI:      regFile.ReplaceAllString(uri, ""),
-				Provider: syncProviderFile,
-			})
-		case regCrd.Match(uriB):
-			syncProvidersParsed = append(syncProvidersParsed, SourceConfig{
-				URI:      regCrd.ReplaceAllString(uri, ""),
-				Provider: syncProviderKubernetes,
-			})
-		case regURL.Match(uriB):
-			syncProvidersParsed = append(syncProvidersParsed, SourceConfig{
-				URI:      uri,
-				Provider: syncProviderHTTP,
-			})
-		case regGRPC.Match(uriB):
-			syncProvidersParsed = append(syncProvidersParsed, SourceConfig{
-				URI:      regGRPC.ReplaceAllString(uri, ""),
-				Provider: syncProviderGrpc,
-			})
-		case regGRPCSecure.Match(uriB):
-			syncProvidersParsed = append(syncProvidersParsed, SourceConfig{
-				URI:      regGRPCSecure.ReplaceAllString(uri, ""),
-				Provider: syncProviderGrpc,
-				TLS:      true,
-			})
-		default:
-			return syncProvidersParsed, fmt.Errorf("invalid sync uri argument: %s, must start with 'file:', "+
-				"'http(s)://', 'grpc(s)://', or 'core.openfeature.dev'", uri)
-		}
-	}
-	return syncProvidersParsed, nil
-}

core/pkg/service/flag-evaluation/eventing.go

@@ -1,36 +0,0 @@
-package service
-
-import (
-	"sync"
-
-	iservice "github.com/open-feature/flagd/core/pkg/service"
-)
-
-// eventingConfiguration is a wrapper for notification subscriptions
-type eventingConfiguration struct {
-	mu   *sync.RWMutex
-	subs map[interface{}]chan iservice.Notification
-}
-
-func (eventing *eventingConfiguration) subscribe(id interface{}, notifyChan chan iservice.Notification) {
-	eventing.mu.Lock()
-	defer eventing.mu.Unlock()
-
-	eventing.subs[id] = notifyChan
-}
-
-func (eventing *eventingConfiguration) emitToAll(n iservice.Notification) {
-	eventing.mu.RLock()
-	defer eventing.mu.RUnlock()
-
-	for _, send := range eventing.subs {
-		send <- n
-	}
-}
-
-func (eventing *eventingConfiguration) unSubscribe(id interface{}) {
-	eventing.mu.Lock()
-	defer eventing.mu.Unlock()
-
-	delete(eventing.subs, id)
-}

core/pkg/service/flag-evaluation/flag_evaluator_types.go

@@ -1,114 +0,0 @@
-package service
-
-import (
-	"fmt"
-
-	schemaV1 "buf.build/gen/go/open-feature/flagd/protocolbuffers/go/schema/v1"
-	"connectrpc.com/connect"
-	"google.golang.org/protobuf/types/known/structpb"
-)
-
-type response[T constraints] interface {
-	SetResult(value T, variant, reason string, metadata map[string]interface{}) error
-}
-
-type constraints interface {
-	bool | string | map[string]any | float64 | int64
-}
-
-type booleanResponse struct {
-	*connect.Response[schemaV1.ResolveBooleanResponse]
-}
-
-func (r *booleanResponse) SetResult(value bool, variant, reason string, metadata map[string]interface{}) error {
-	r.Msg.Value = value
-	r.Msg.Variant = variant
-	r.Msg.Reason = reason
-
-	newStruct, err := structpb.NewStruct(metadata)
-	if err != nil {
-		return fmt.Errorf("failure to wrap metadata %w", err)
-	}
-
-	r.Msg.Metadata = newStruct
-	return nil
-}
-
-type stringResponse struct {
-	*connect.Response[schemaV1.ResolveStringResponse]
-}
-
-func (r *stringResponse) SetResult(value string, variant, reason string, metadata map[string]interface{}) error {
-	r.Msg.Value = value
-	r.Msg.Variant = variant
-	r.Msg.Reason = reason
-
-	newStruct, err := structpb.NewStruct(metadata)
-	if err != nil {
-		return fmt.Errorf("failure to wrap metadata %w", err)
-	}
-
-	r.Msg.Metadata = newStruct
-	return nil
-}
-
-type floatResponse struct {
-	*connect.Response[schemaV1.ResolveFloatResponse]
-}
-
-func (r *floatResponse) SetResult(value float64, variant, reason string, metadata map[string]interface{}) error {
-	r.Msg.Value = value
-	r.Msg.Variant = variant
-	r.Msg.Reason = reason
-
-	newStruct, err := structpb.NewStruct(metadata)
-	if err != nil {
-		return fmt.Errorf("failure to wrap metadata %w", err)
-	}
-
-	r.Msg.Metadata = newStruct
-	return nil
-}
-
-type intResponse struct {
-	*connect.Response[schemaV1.ResolveIntResponse]
-}
-
-func (r *intResponse) SetResult(value int64, variant, reason string, metadata map[string]interface{}) error {
-	r.Msg.Value = value
-	r.Msg.Variant = variant
-	r.Msg.Reason = reason
-
-	newStruct, err := structpb.NewStruct(metadata)
-	if err != nil {
-		return fmt.Errorf("failure to wrap metadata %w", err)
-	}
-
-	r.Msg.Metadata = newStruct
-	return nil
-}
-
-type objectResponse struct {
-	*connect.Response[schemaV1.ResolveObjectResponse]
-}
-
-func (r *objectResponse) SetResult(value map[string]any, variant, reason string,
-	metadata map[string]interface{},
-) error {
-	r.Msg.Reason = reason
-	val, err := structpb.NewStruct(value)
-	if err != nil {
-		return fmt.Errorf("struct response construction: %w", err)
-	}
-
-	r.Msg.Value = val
-	r.Msg.Variant = variant
-
-	newStruct, err := structpb.NewStruct(metadata)
-	if err != nil {
-		return fmt.Errorf("failure to wrap metadata %w", err)
-	}
-
-	r.Msg.Metadata = newStruct
-	return nil
-}

core/pkg/service/iservice.go

@@ -2,6 +2,7 @@ package service
 
 import (
 	"context"
+	"time"
 
 	"connectrpc.com/connect"
 )
@@ -23,15 +24,18 @@ type Notification struct {
 type ReadinessProbe func() bool
 
 type Configuration struct {
-	ReadinessProbe ReadinessProbe
-	Port           uint16
-	ManagementPort uint16
-	ServiceName    string
-	CertPath       string
-	KeyPath        string
-	SocketPath     string
-	CORS           []string
-	Options        []connect.HandlerOption
+	ReadinessProbe             ReadinessProbe
+	Port                       uint16
+	ManagementPort             uint16
+	ServiceName                string
+	CertPath                   string
+	KeyPath                    string
+	SocketPath                 string
+	CORS                       []string
+	Options                    []connect.HandlerOption
+	ContextValues              map[string]any
+	HeaderToContextKeyMappings map[string]string
+	StreamDeadline             time.Duration
 }
 
 /*

core/pkg/service/ofrep/models.go

@@ -0,0 +1,122 @@
+package ofrep
+
+import (
+	"fmt"
+
+	"github.com/open-feature/flagd/core/pkg/evaluator"
+	"github.com/open-feature/flagd/core/pkg/model"
+)
+
+type Request struct {
+	Context interface{} `json:"context"`
+}
+
+type EvaluationSuccess struct {
+	Value    interface{}    `json:"value"`
+	Key      string         `json:"key"`
+	Reason   string         `json:"reason"`
+	Variant  string         `json:"variant"`
+	Metadata model.Metadata `json:"metadata"`
+}
+
+type BulkEvaluationResponse struct {
+	Flags    []interface{}  `json:"flags"`
+	Metadata model.Metadata `json:"metadata"`
+}
+
+type EvaluationError struct {
+	Key          string         `json:"key"`
+	ErrorCode    string         `json:"errorCode"`
+	ErrorDetails string         `json:"errorDetails"`
+	Metadata     model.Metadata `json:"metadata"`
+}
+
+type BulkEvaluationError struct {
+	ErrorCode    string         `json:"errorCode"`
+	ErrorDetails string         `json:"errorDetails"`
+	Metadata     model.Metadata `json:"metadata"`
+}
+
+type InternalError struct {
+	ErrorDetails string `json:"errorDetails"`
+}
+
+func BulkEvaluationResponseFrom(resolutions []evaluator.AnyValue, metadata model.Metadata) BulkEvaluationResponse {
+	evaluations := make([]interface{}, 0)
+
+	for _, value := range resolutions {
+		if value.Error != nil {
+			_, evaluationError := EvaluationErrorResponseFrom(value)
+			evaluations = append(evaluations, evaluationError)
+		} else {
+			evaluations = append(evaluations, SuccessResponseFrom(value))
+		}
+	}
+
+	return BulkEvaluationResponse{
+		evaluations,
+		metadata,
+	}
+}
+
+func SuccessResponseFrom(result evaluator.AnyValue) EvaluationSuccess {
+	return EvaluationSuccess{
+		Value:    result.Value,
+		Key:      result.FlagKey,
+		Reason:   result.Reason,
+		Variant:  result.Variant,
+		Metadata: result.Metadata,
+	}
+}
+
+func ContextErrorResponseFrom(key string) EvaluationError {
+	return EvaluationError{
+		Key:          key,
+		ErrorCode:    model.InvalidContextCode,
+		ErrorDetails: "Provider context is not valid",
+	}
+}
+
+func BulkEvaluationContextError() BulkEvaluationError {
+	return BulkEvaluationError{
+		ErrorCode:    model.InvalidContextCode,
+		ErrorDetails: "Provider context is not valid",
+	}
+}
+
+func BulkEvaluationContextErrorFrom(code string, details string) BulkEvaluationError {
+	return BulkEvaluationError{
+		ErrorCode:    code,
+		ErrorDetails: details,
+	}
+}
+
+func EvaluationErrorResponseFrom(result evaluator.AnyValue) (int, EvaluationError) {
+	payload := EvaluationError{
+		Key:      result.FlagKey,
+		Metadata: result.Metadata,
+	}
+
+	status := 400
+
+	switch result.Error.Error() {
+	case model.FlagNotFoundErrorCode:
+		status = 404
+		payload.ErrorCode = model.FlagNotFoundErrorCode
+		payload.ErrorDetails = fmt.Sprintf("flag `%s` does not exist", result.FlagKey)
+	case model.FlagDisabledErrorCode:
+		status = 404
+		payload.ErrorCode = model.FlagNotFoundErrorCode
+		payload.ErrorDetails = fmt.Sprintf("flag `%s` is disabled", result.FlagKey)
+	case model.ParseErrorCode:
+		payload.ErrorCode = model.ParseErrorCode
+		payload.ErrorDetails = fmt.Sprintf("error parsing the flag `%s`", result.FlagKey)
+	case model.GeneralErrorCode:
+		fallthrough
+	default:
+		payload.ErrorCode = model.GeneralErrorCode
+		payload.ErrorDetails = "error processing the flag for evaluation"
+	}
+
+	return status, payload
+}

core/pkg/service/ofrep/models_test.go

@@ -0,0 +1,153 @@
+package ofrep
+
+import (
+	"encoding/json"
+	"errors"
+	"reflect"
+	"testing"
+
+	"github.com/open-feature/flagd/core/pkg/evaluator"
+	"github.com/open-feature/flagd/core/pkg/model"
+)
+
+func TestSuccessResult(t *testing.T) {
+	// given
+	value := evaluator.AnyValue{
+		Value:   false,
+		Variant: "false",
+		Reason:  model.StaticReason,
+		FlagKey: "key",
+		Metadata: map[string]interface{}{
+			"key": "value",
+		},
+	}
+
+	// when
+	evaluationSuccess := SuccessResponseFrom(value)
+
+	if evaluationSuccess.Key != value.FlagKey {
+		t.Errorf("expected %v, got %v", value.FlagKey, evaluationSuccess.Key)
+	}
+
+	if evaluationSuccess.Value != value.Value {
+		t.Errorf("expected %v, got %v", value.Value, evaluationSuccess.Value)
+	}
+
+	if evaluationSuccess.Variant != value.Variant {
+		t.Errorf("expected %v, got %v", value.Variant, evaluationSuccess.Variant)
+	}
+
+	if evaluationSuccess.Reason != value.Reason {
+		t.Errorf("expected %v, got %v", value.Reason, evaluationSuccess.Reason)
+	}
+
+	if !reflect.DeepEqual(evaluationSuccess.Metadata, value.Metadata) {
+		t.Errorf("metadata mismatch")
+	}
+}
+
+func TestBulkEvaluationResponse(t *testing.T) {
+	tests := []struct {
+		name             string
+		input            []evaluator.AnyValue
+		marshalledOutput string
+	}{
+		{
+			name:             "empty input",
+			input:            nil,
+			marshalledOutput: "{\"flags\":[],\"metadata\":{}}",
+		},
+		{
+			name: "valid values",
+			input: []evaluator.AnyValue{
+				{
+					Value:   false,
+					Variant: "false",
+					Reason:  model.StaticReason,
+					FlagKey: "key",
+					Metadata: map[string]interface{}{
+						"key": "value",
+					},
+				},
+				{
+					Value:    false,
+					Variant:  "false",
+					Reason:   model.ErrorReason,
+					FlagKey:  "errorFlag",
+					Error:    errors.New(model.FlagNotFoundErrorCode),
+					Metadata: map[string]interface{}{},
+				},
+			},
+			marshalledOutput: "{\"flags\":[{\"value\":false,\"key\":\"key\",\"reason\":\"STATIC\",\"variant\":\"false\",\"metadata\":{\"key\":\"value\"}},{\"key\":\"errorFlag\",\"errorCode\":\"FLAG_NOT_FOUND\",\"errorDetails\":\"flag `errorFlag` does not exist\",\"metadata\":{}}],\"metadata\":{}}",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			response := BulkEvaluationResponseFrom(test.input, model.Metadata{})
+
+			marshal, err := json.Marshal(response)
+			if err != nil {
+				t.Errorf("error marshalling the response: %v", err)
+			}
+
+			if test.marshalledOutput != string(marshal) {
+				t.Errorf("expected %s, got %s", test.marshalledOutput, string(marshal))
+			}
+		})
+	}
+}
+
+func TestErrorStatus(t *testing.T) {
+	tests := []struct {
+		name           string
+		modelError     string
+		expectedStatus int
+		expectedCode   string
+	}{
+		{
+			name:           "parsing error",
+			modelError:     model.ParseErrorCode,
+			expectedStatus: 400,
+			expectedCode:   model.ParseErrorCode,
+		},
+		{
+			name:           "flag disabled",
+			modelError:     model.FlagDisabledErrorCode,
+			expectedStatus: 404,
+			expectedCode:   model.FlagNotFoundErrorCode,
+		},
+		{
+			name:           "general error",
+			modelError:     model.GeneralErrorCode,
+			expectedStatus: 400,
+			expectedCode:   model.GeneralErrorCode,
+		},
+		{
+			name:           "flag not found",
+			modelError:     model.FlagNotFoundErrorCode,
+			expectedStatus: 404,
+			expectedCode:   model.FlagNotFoundErrorCode,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			status, evaluationError := EvaluationErrorResponseFrom(evaluator.AnyValue{
+				Value:   "value",
+				Variant: "variant",
+				Reason:  model.ErrorReason,
+				FlagKey: "key",
+				Error:   errors.New(test.modelError),
+			})
+
+			if status != test.expectedStatus {
+				t.Errorf("expected status %d, but got %d", test.expectedStatus, status)
+			}
+
+			if evaluationError.ErrorCode != test.expectedCode {
+				t.Errorf("expected error code %s, but got %s", test.expectedCode, evaluationError.ErrorCode)
+			}
+		})
+	}
+}

core/pkg/service/sync/handler.go

@@ -1,62 +0,0 @@
-package sync
-
-import (
-	"context"
-	"fmt"
-
-	rpc "buf.build/gen/go/open-feature/flagd/grpc/go/sync/v1/syncv1grpc"
-	syncv1 "buf.build/gen/go/open-feature/flagd/protocolbuffers/go/sync/v1"
-	"github.com/open-feature/flagd/core/pkg/logger"
-	"github.com/open-feature/flagd/core/pkg/sync"
-	syncStore "github.com/open-feature/flagd/core/pkg/sync-store"
-)
-
-type handler struct {
-	rpc.UnimplementedFlagSyncServiceServer
-	syncStore syncStore.ISyncStore
-	logger    *logger.Logger
-}
-
-func (l *handler) FetchAllFlags(ctx context.Context, req *syncv1.FetchAllFlagsRequest) (
-	*syncv1.FetchAllFlagsResponse,
-	error,
-) {
-	data, err := l.syncStore.FetchAllFlags(ctx, req, req.GetSelector())
-	if err != nil {
-		return &syncv1.FetchAllFlagsResponse{}, fmt.Errorf("error fetching all flags from sync store: %w", err)
-	}
-
-	return &syncv1.FetchAllFlagsResponse{
-		FlagConfiguration: data.FlagData,
-	}, nil
-}
-
-func (l *handler) SyncFlags(
-	req *syncv1.SyncFlagsRequest,
-	stream rpc.FlagSyncService_SyncFlagsServer,
-) error {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	errChan := make(chan error)
-	dataSync := make(chan sync.DataSync)
-	l.syncStore.RegisterSubscription(ctx, req.GetSelector(), req, dataSync, errChan)
-	for {
-		select {
-		case e := <-errChan:
-			return e
-		case d := <-dataSync:
-			if err := stream.Send(&syncv1.SyncFlagsResponse{
-				FlagConfiguration: d.FlagData,
-				State:             dataSyncToGrpcState(d),
-			}); err != nil {
-				return fmt.Errorf("error sending configuration change event: %w", err)
-			}
-		case <-stream.Context().Done():
-			return nil
-		}
-	}
-}
-
-func dataSyncToGrpcState(s sync.DataSync) syncv1.SyncState {
-	return syncv1.SyncState(s.Type + 1)
-}

core/pkg/store/flags.go

@@ -1,283 +0,0 @@
-package store
-
-import (
-	"encoding/json"
-	"fmt"
-	"reflect"
-	"sync"
-
-	"github.com/open-feature/flagd/core/pkg/logger"
-	"github.com/open-feature/flagd/core/pkg/model"
-)
-
-type Flags struct {
-	mx             sync.RWMutex
-	Flags          map[string]model.Flag `json:"flags"`
-	FlagSources    []string
-	SourceMetadata map[string]SourceDetails
-}
-
-type SourceDetails struct {
-	Source   string
-	Selector string
-}
-
-func (f *Flags) hasPriority(stored string, new string) bool {
-	if stored == new {
-		return true
-	}
-	for i := len(f.FlagSources) - 1; i >= 0; i-- {
-		switch f.FlagSources[i] {
-		case stored:
-			return false
-		case new:
-			return true
-		}
-	}
-	return true
-}
-
-func NewFlags() *Flags {
-	return &Flags{
-		Flags:          map[string]model.Flag{},
-		SourceMetadata: map[string]SourceDetails{},
-	}
-}
-
-func (f *Flags) Set(key string, flag model.Flag) {
-	f.mx.Lock()
-	defer f.mx.Unlock()
-	f.Flags[key] = flag
-}
-
-func (f *Flags) Get(key string) (model.Flag, bool) {
-	f.mx.RLock()
-	defer f.mx.RUnlock()
-	flag, ok := f.Flags[key]
-
-	return flag, ok
-}
-
-func (f *Flags) SelectorForFlag(flag model.Flag) string {
-	f.mx.RLock()
-	defer f.mx.RUnlock()
-
-	return f.SourceMetadata[flag.Source].Selector
-}
-
-func (f *Flags) Delete(key string) {
-	f.mx.Lock()
-	defer f.mx.Unlock()
-	delete(f.Flags, key)
-}
-
-func (f *Flags) String() (string, error) {
-	f.mx.RLock()
-	defer f.mx.RUnlock()
-	bytes, err := json.Marshal(f)
-	if err != nil {
-		return "", fmt.Errorf("unable to marshal flags: %w", err)
-	}
-
-	return string(bytes), nil
-}
-
-// GetAll returns a copy of the store's state (copy in order to be concurrency safe)
-func (f *Flags) GetAll() map[string]model.Flag {
-	f.mx.RLock()
-	defer f.mx.RUnlock()
-	state := make(map[string]model.Flag, len(f.Flags))
-
-	for key, flag := range f.Flags {
-		state[key] = flag
-	}
-
-	return state
-}
-
-// Add new flags from source.
-func (f *Flags) Add(logger *logger.Logger, source string, flags map[string]model.Flag) map[string]interface{} {
-	notifications := map[string]interface{}{}
-
-	for k, newFlag := range flags {
-		storedFlag, ok := f.Get(k)
-		if ok && !f.hasPriority(storedFlag.Source, source) {
-			logger.Debug(
-				fmt.Sprintf(
-					"not overwriting: flag %s from source %s does not have priority over %s",
-					k,
-					source,
-					storedFlag.Source,
-				),
-			)
-			continue
-		}
-
-		notifications[k] = map[string]interface{}{
-			"type":   string(model.NotificationCreate),
-			"source": source,
-		}
-
-		// Store the new version of the flag
-		newFlag.Source = source
-		f.Set(k, newFlag)
-	}
-
-	return notifications
-}
-
-// Update existing flags from source.
-func (f *Flags) Update(logger *logger.Logger, source string, flags map[string]model.Flag) map[string]interface{} {
-	notifications := map[string]interface{}{}
-
-	for k, flag := range flags {
-		storedFlag, ok := f.Get(k)
-		if !ok {
-			logger.Warn(
-				fmt.Sprintf("failed to update the flag, flag with key %s from source %s does not exist.",
-					k,
-					source))
-
-			continue
-		}
-		if !f.hasPriority(storedFlag.Source, source) {
-			logger.Debug(
-				fmt.Sprintf(
-					"not updating: flag %s from source %s does not have priority over %s",
-					k,
-					source,
-					storedFlag.Source,
-				),
-			)
-			continue
-		}
-
-		notifications[k] = map[string]interface{}{
-			"type":   string(model.NotificationUpdate),
-			"source": source,
-		}
-
-		flag.Source = source
-		f.Set(k, flag)
-	}
-
-	return notifications
-}
-
-// DeleteFlags matching flags from source.
-func (f *Flags) DeleteFlags(logger *logger.Logger, source string, flags map[string]model.Flag) map[string]interface{} {
-	logger.Debug(
-		fmt.Sprintf(
-			"store resync triggered: delete event from source %s",
-			source,
-		),
-	)
-	notifications := map[string]interface{}{}
-	if len(flags) == 0 {
-		allFlags := f.GetAll()
-		for key, flag := range allFlags {
-			if flag.Source != source {
-				continue
-			}
-			notifications[key] = map[string]interface{}{
-				"type":   string(model.NotificationDelete),
-				"source": source,
-			}
-			f.Delete(key)
-		}
-	}
-
-	for k := range flags {
-		flag, ok := f.Get(k)
-		if ok {
-			if !f.hasPriority(flag.Source, source) {
-				logger.Debug(
-					fmt.Sprintf(
-						"not deleting: flag %s from source %s cannot be deleted by %s",
-						k,
-						flag.Source,
-						source,
-					),
-				)
-				continue
-			}
-			notifications[k] = map[string]interface{}{
-				"type":   string(model.NotificationDelete),
-				"source": source,
-			}
-
-			f.Delete(k)
-		} else {
-			logger.Warn(
-				fmt.Sprintf("failed to remove flag, flag with key %s from source %s does not exist.",
-					k,
-					source))
-		}
-	}
-
-	return notifications
-}
-
-// Merge provided flags from source with currently stored flags.
-func (f *Flags) Merge(
-	logger *logger.Logger,
-	source string,
-	flags map[string]model.Flag,
-) (map[string]interface{}, bool) {
-	notifications := map[string]interface{}{}
-	resyncRequired := false
-	f.mx.Lock()
-	for k, v := range f.Flags {
-		if v.Source == source {
-			if _, ok := flags[k]; !ok {
-				// flag has been deleted
-				delete(f.Flags, k)
-				notifications[k] = map[string]interface{}{
-					"type":   string(model.NotificationDelete),
-					"source": source,
-				}
-				resyncRequired = true
-				logger.Debug(
-					fmt.Sprintf(
-						"store resync triggered: flag %s has been deleted from source %s",
-						k, source,
-					),
-				)
-				continue
-			}
-		}
-	}
-	f.mx.Unlock()
-	for k, newFlag := range flags {
-		newFlag.Source = source
-		storedFlag, ok := f.Get(k)
-		if ok {
-			if !f.hasPriority(storedFlag.Source, source) {
-				logger.Debug(
-					fmt.Sprintf(
-						"not merging: flag %s from source %s does not have priority over %s",
-						k, source, storedFlag.Source,
-					),
-				)
-				continue
-			}
-			if reflect.DeepEqual(storedFlag, newFlag) {
-				continue
-			}
-		}
-		if !ok {
-			notifications[k] = map[string]interface{}{
-				"type":   string(model.NotificationCreate),
-				"source": source,
-			}
-		} else {
-			notifications[k] = map[string]interface{}{
-				"type":   string(model.NotificationUpdate),
-				"source": source,
-			}
-		}
-		// Store the new version of the flag
-		f.Set(k, newFlag)
-	}
-	return notifications, resyncRequired
-}

core/pkg/store/flags_test.go

@@ -1,551 +0,0 @@
-package store
-
-import (
-	"testing"
-
-	"github.com/open-feature/flagd/core/pkg/logger"
-	"github.com/open-feature/flagd/core/pkg/model"
-	"github.com/stretchr/testify/require"
-)
-
-func TestHasPriority(t *testing.T) {
-	tests := []struct {
-		name         string
-		currentState *Flags
-		storedSource string
-		newSource    string
-		hasPriority  bool
-	}{
-		{
-			name:         "same source",
-			currentState: &Flags{},
-			storedSource: "A",
-			newSource:    "A",
-			hasPriority:  true,
-		},
-		{
-			name: "no priority",
-			currentState: &Flags{
-				FlagSources: []string{
-					"B",
-					"A",
-				},
-			},
-			storedSource: "A",
-			newSource:    "B",
-			hasPriority:  false,
-		},
-		{
-			name: "priority",
-			currentState: &Flags{
-				FlagSources: []string{
-					"A",
-					"B",
-				},
-			},
-			storedSource: "A",
-			newSource:    "B",
-			hasPriority:  true,
-		},
-		{
-			name: "not in sources",
-			currentState: &Flags{
-				FlagSources: []string{
-					"A",
-					"B",
-				},
-			},
-			storedSource: "C",
-			newSource:    "D",
-			hasPriority:  true,
-		},
-	}
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-			p := tt.currentState.hasPriority(tt.storedSource, tt.newSource)
-			require.Equal(t, p, tt.hasPriority)
-		})
-	}
-}
-
-func TestMergeFlags(t *testing.T) {
-	t.Parallel()
-	tests := []struct {
-		name       string
-		current    *Flags
-		new        map[string]model.Flag
-		newSource  string
-		want       *Flags
-		wantNotifs map[string]interface{}
-		wantResync bool
-	}{
-		{
-			name: "both nil",
-			current: &Flags{
-				Flags: nil,
-			},
-			new:        nil,
-			want:       &Flags{Flags: map[string]model.Flag{}},
-			wantNotifs: map[string]interface{}{},
-		},
-		{
-			name: "both empty flags",
-			current: &Flags{
-				Flags: map[string]model.Flag{},
-			},
-			new:        map[string]model.Flag{},
-			want:       &Flags{Flags: map[string]model.Flag{}},
-			wantNotifs: map[string]interface{}{},
-		},
-		{
-			name: "empty current",
-			current: &Flags{
-				Flags: nil,
-			},
-			new:        map[string]model.Flag{},
-			want:       &Flags{Flags: map[string]model.Flag{}},
-			wantNotifs: map[string]interface{}{},
-		},
-		{
-			name: "empty new",
-			current: &Flags{
-				Flags: map[string]model.Flag{},
-			},
-			new:        nil,
-			want:       &Flags{Flags: map[string]model.Flag{}},
-			wantNotifs: map[string]interface{}{},
-		},
-		{
-			name: "extra fields on each",
-			current: &Flags{
-				Flags: map[string]model.Flag{
-					"waka": {
-						DefaultVariant: "off",
-						Source:         "1",
-					},
-				},
-			},
-			new: map[string]model.Flag{
-				"paka": {
-					DefaultVariant: "on",
-				},
-			},
-			newSource: "2",
-			want: &Flags{Flags: map[string]model.Flag{
-				"waka": {
-					DefaultVariant: "off",
-					Source:         "1",
-				},
-				"paka": {
-					DefaultVariant: "on",
-					Source:         "2",
-				},
-			}},
-			wantNotifs: map[string]interface{}{
-				"paka": map[string]interface{}{"type": "write", "source": "2"},
-			},
-		},
-		{
-			name: "override",
-			current: &Flags{
-				Flags: map[string]model.Flag{"waka": {DefaultVariant: "off"}},
-			},
-			new: map[string]model.Flag{
-				"waka": {DefaultVariant: "on"},
-				"paka": {DefaultVariant: "on"},
-			},
-			want: &Flags{Flags: map[string]model.Flag{
-				"waka": {DefaultVariant: "on"},
-				"paka": {DefaultVariant: "on"},
-			}},
-			wantNotifs: map[string]interface{}{
-				"waka": map[string]interface{}{"type": "update", "source": ""},
-				"paka": map[string]interface{}{"type": "write", "source": ""},
-			},
-		},
-		{
-			name: "identical",
-			current: &Flags{
-				Flags: map[string]model.Flag{"hello": {DefaultVariant: "off"}},
-			},
-			new: map[string]model.Flag{
-				"hello": {DefaultVariant: "off"},
-			},
-			want: &Flags{Flags: map[string]model.Flag{
-				"hello": {DefaultVariant: "off"},
-			}},
-			wantNotifs: map[string]interface{}{},
-		},
-		{
-			name: "deleted flag",
-			current: &Flags{
-				Flags: map[string]model.Flag{"hello": {DefaultVariant: "off", Source: "A"}},
-			},
-			new:       map[string]model.Flag{},
-			newSource: "A",
-			want:      &Flags{Flags: map[string]model.Flag{}},
-			wantNotifs: map[string]interface{}{
-				"hello": map[string]interface{}{"type": "delete", "source": "A"},
-			},
-			wantResync: true,
-		},
-		{
-			name: "no merge priority",
-			current: &Flags{
-				FlagSources: []string{
-					"B",
-					"A",
-				},
-				Flags: map[string]model.Flag{
-					"hello": {
-						DefaultVariant: "off",
-						Source:         "A",
-					},
-				},
-			},
-			new: map[string]model.Flag{
-				"hello": {DefaultVariant: "off"},
-			},
-			newSource: "B",
-			want: &Flags{
-				FlagSources: []string{
-					"B",
-					"A",
-				},
-				Flags: map[string]model.Flag{
-					"hello": {
-						DefaultVariant: "off",
-						Source:         "A",
-					},
-				},
-			},
-			wantNotifs: map[string]interface{}{},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-			gotNotifs, resyncRequired := tt.current.Merge(logger.NewLogger(nil, false), tt.newSource, tt.new)
-			require.Equal(t, tt.want, tt.want)
-			require.Equal(t, tt.wantNotifs, gotNotifs)
-			require.Equal(t, tt.wantResync, resyncRequired)
-		})
-	}
-}
-
-func TestFlags_Add(t *testing.T) {
-	mockLogger := logger.NewLogger(nil, false)
-	mockSource := "source"
-	mockOverrideSource := "source-2"
-
-	type request struct {
-		source string
-		flags  map[string]model.Flag
-	}
-
-	tests := []struct {
-		name                     string
-		storedState              *Flags
-		addRequest               request
-		expectedState            *Flags
-		expectedNotificationKeys []string
-	}{
-		{
-			name: "Add success",
-			storedState: &Flags{
-				Flags: map[string]model.Flag{
-					"A": {Source: mockSource},
-				},
-			},
-			addRequest: request{
-				source: mockSource,
-				flags: map[string]model.Flag{
-					"B": {Source: mockSource},
-				},
-			},
-			expectedState: &Flags{
-				Flags: map[string]model.Flag{
-					"A": {Source: mockSource},
-					"B": {Source: mockSource},
-				},
-			},
-			expectedNotificationKeys: []string{"B"},
-		},
-		{
-			name: "Add multiple success",
-			storedState: &Flags{
-				Flags: map[string]model.Flag{
-					"A": {Source: mockSource},
-				},
-			},
-			addRequest: request{
-				source: mockSource,
-				flags: map[string]model.Flag{
-					"B": {Source: mockSource},
-					"C": {Source: mockSource},
-				},
-			},
-			expectedState: &Flags{
-				Flags: map[string]model.Flag{
-					"A": {Source: mockSource},
-					"B": {Source: mockSource},
-					"C": {Source: mockSource},
-				},
-			},
-			expectedNotificationKeys: []string{"B", "C"},
-		},
-		{
-			name: "Add success - conflict and override",
-			storedState: &Flags{
-				Flags: map[string]model.Flag{
-					"A": {Source: mockSource},
-				},
-			},
-			addRequest: request{
-				source: mockOverrideSource,
-				flags: map[string]model.Flag{
-					"A": {Source: mockOverrideSource},
-				},
-			},
-			expectedState: &Flags{
-				Flags: map[string]model.Flag{
-					"A": {Source: mockOverrideSource},
-				},
-			},
-			expectedNotificationKeys: []string{"A"},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			messages := tt.storedState.Add(mockLogger, tt.addRequest.source, tt.addRequest.flags)
-
-			require.Equal(t, tt.storedState, tt.expectedState)
-
-			for k := range messages {
-				require.Containsf(t, tt.expectedNotificationKeys, k,
-					"Message key %s not present in the expected key list", k)
-			}
-		})
-	}
-}
-
-func TestFlags_Update(t *testing.T) {
-	mockLogger := logger.NewLogger(nil, false)
-	mockSource := "source"
-	mockOverrideSource := "source-2"
-
-	type request struct {
-		source string
-		flags  map[string]model.Flag
-	}
-
-	tests := []struct {
-		name                     string
-		storedState              *Flags
-		UpdateRequest            request
-		expectedState            *Flags
-		expectedNotificationKeys []string
-	}{
-		{
-			name: "Update success",
-			storedState: &Flags{
-				Flags: map[string]model.Flag{
-					"A": {Source: mockSource, DefaultVariant: "True"},
-				},
-			},
-			UpdateRequest: request{
-				source: mockSource,
-				flags: map[string]model.Flag{
-					"A": {Source: mockSource, DefaultVariant: "False"},
-				},
-			},
-			expectedState: &Flags{
-				Flags: map[string]model.Flag{
-					"A": {Source: mockSource, DefaultVariant: "False"},
-				},
-			},
-			expectedNotificationKeys: []string{"A"},
-		},
-		{
-			name: "Update multiple success",
-			storedState: &Flags{
-				Flags: map[string]model.Flag{
-					"A": {Source: mockSource, DefaultVariant: "True"},
-					"B": {Source: mockSource, DefaultVariant: "True"},
-				},
-			},
-			UpdateRequest: request{
-				source: mockSource,
-				flags: map[string]model.Flag{
-					"A": {Source: mockSource, DefaultVariant: "False"},
-					"B": {Source: mockSource, DefaultVariant: "False"},
-				},
-			},
-			expectedState: &Flags{
-				Flags: map[string]model.Flag{
-					"A": {Source: mockSource, DefaultVariant: "False"},
-					"B": {Source: mockSource, DefaultVariant: "False"},
-				},
-			},
-			expectedNotificationKeys: []string{"A", "B"},
-		},
-		{
-			name: "Update success - conflict and override",
-			storedState: &Flags{
-				Flags: map[string]model.Flag{
-					"A": {Source: mockSource, DefaultVariant: "True"},
-				},
-			},
-			UpdateRequest: request{
-				source: mockOverrideSource,
-				flags: map[string]model.Flag{
-					"A": {Source: mockOverrideSource, DefaultVariant: "True"},
-				},
-			},
-			expectedState: &Flags{
-				Flags: map[string]model.Flag{
-					"A": {Source: mockOverrideSource, DefaultVariant: "True"},
-				},
-			},
-			expectedNotificationKeys: []string{"A"},
-		},
-		{
-			name: "Update fail",
-			storedState: &Flags{
-				Flags: map[string]model.Flag{
-					"A": {Source: mockSource},
-				},
-			},
-			UpdateRequest: request{
-				source: mockSource,
-				flags: map[string]model.Flag{
-					"B": {Source: mockSource},
-				},
-			},
-			expectedState: &Flags{
-				Flags: map[string]model.Flag{
-					"A": {Source: mockSource},
-				},
-			},
-			expectedNotificationKeys: []string{},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			messages := tt.storedState.Update(mockLogger, tt.UpdateRequest.source, tt.UpdateRequest.flags)
-
-			require.Equal(t, tt.storedState, tt.expectedState)
-
-			for k := range messages {
-				require.Containsf(t, tt.expectedNotificationKeys, k,
-					"Message key %s not present in the expected key list", k)
-			}
-		})
-	}
-}
-
-func TestFlags_Delete(t *testing.T) {
-	mockLogger := logger.NewLogger(nil, false)
-	mockSource := "source"
-	mockSource2 := "source2"
-
-	tests := []struct {
-		name                     string
-		storedState              *Flags
-		deleteRequest            map[string]model.Flag
-		expectedState            *Flags
-		expectedNotificationKeys []string
-	}{
-		{
-			name: "Remove success",
-			storedState: &Flags{
-				Flags: map[string]model.Flag{
-					"A": {Source: mockSource},
-					"B": {Source: mockSource},
-					"C": {Source: mockSource2},
-				},
-				FlagSources: []string{
-					mockSource,
-					mockSource2,
-				},
-			},
-			deleteRequest: map[string]model.Flag{
-				"A": {Source: mockSource},
-			},
-			expectedState: &Flags{
-				Flags: map[string]model.Flag{
-					"B": {Source: mockSource},
-					"C": {Source: mockSource2},
-				},
-				FlagSources: []string{
-					mockSource,
-					mockSource2,
-				},
-			},
-			expectedNotificationKeys: []string{"A"},
-		},
-		{
-			name: "Nothing to remove",
-			storedState: &Flags{
-				Flags: map[string]model.Flag{
-					"A": {Source: mockSource},
-					"B": {Source: mockSource},
-					"C": {Source: mockSource2},
-				},
-				FlagSources: []string{
-					mockSource,
-					mockSource2,
-				},
-			},
-			deleteRequest: map[string]model.Flag{
-				"C": {Source: mockSource},
-			},
-			expectedState: &Flags{
-				Flags: map[string]model.Flag{
-					"A": {Source: mockSource},
-					"B": {Source: mockSource},
-					"C": {Source: mockSource2},
-				},
-				FlagSources: []string{
-					mockSource,
-					mockSource2,
-				},
-			},
-			expectedNotificationKeys: []string{},
-		},
-		{
-			name: "Remove all",
-			storedState: &Flags{
-				Flags: map[string]model.Flag{
-					"A": {Source: mockSource},
-					"B": {Source: mockSource},
-					"C": {Source: mockSource2},
-				},
-			},
-			deleteRequest: map[string]model.Flag{},
-			expectedState: &Flags{
-				Flags: map[string]model.Flag{
-					"C": {Source: mockSource2},
-				},
-			},
-			expectedNotificationKeys: []string{"A", "B"},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			messages := tt.storedState.DeleteFlags(mockLogger, mockSource, tt.deleteRequest)
-
-			require.Equal(t, tt.storedState, tt.expectedState)
-
-			for k := range messages {
-				require.Containsf(t, tt.expectedNotificationKeys, k,
-					"Message key %s not present in the expected key list", k)
-			}
-		})
-	}
-}

core/pkg/store/query.go

@@ -0,0 +1,133 @@
+package store
+
+import (
+	"maps"
+	"sort"
+	"strings"
+
+	uuid "github.com/google/uuid"
+	"github.com/open-feature/flagd/core/pkg/model"
+)
+
+// flags table and index constants
+const flagsTable = "flags"
+
+const idIndex = "id"
+const keyIndex = "key"
+const sourceIndex = "source"
+const priorityIndex = "priority"
+const flagSetIdIndex = "flagSetId"
+
+// compound indices; maintain sub-indexes alphabetically; order matters; these must match what's generated in the SelectorMapToQuery func.
+const flagSetIdSourceCompoundIndex = flagSetIdIndex + "+" + sourceIndex
+const keySourceCompoundIndex = keyIndex + "+" + sourceIndex
+const flagSetIdKeySourceCompoundIndex = flagSetIdIndex + "+" + keyIndex + "+" + sourceIndex
+
+// flagSetId defaults to a UUID generated at startup to make our queries consistent
+// any flag without a "flagSetId" is assigned this one; it's never exposed externally
+var nilFlagSetId = uuid.New().String()
+
+// A selector represents a set of constraints used to query the store.
+type Selector struct {
+	indexMap map[string]string
+}
+
+// NewSelector creates a new Selector from a selector expression string.
+// For example, to select flags from source "./mySource" and flagSetId "1234", use the expression:
+// "source=./mySource,flagSetId=1234"
+func NewSelector(selectorExpression string) Selector {
+	return Selector{
+		indexMap: expressionToMap(selectorExpression),
+	}
+}
+
+func expressionToMap(sExp string) map[string]string {
+	selectorMap := make(map[string]string)
+	if sExp == "" {
+		return selectorMap
+	}
+
+	if strings.Index(sExp, "=") == -1 {
+		// if no '=' is found, treat the whole string as as source (backwards compatibility)
+		// we may may support interpreting this as a flagSetId in the future as an option
+		selectorMap[sourceIndex] = sExp
+		return selectorMap
+	}
+
+	// Split the selector by commas
+	pairs := strings.Split(sExp, ",")
+	for _, pair := range pairs {
+		// Split each pair by the first equal sign
+		parts := strings.Split(pair, "=")
+		if len(parts) == 2 {
+			key := parts[0]
+			value := parts[1]
+			selectorMap[key] = value
+		}
+	}
+	return selectorMap
+}
+
+func (s Selector) WithIndex(key string, value string) Selector {
+	m := maps.Clone(s.indexMap)
+	m[key] = value
+	return Selector{
+		indexMap: m,
+	}
+}
+
+func (s *Selector) IsEmpty() bool {
+	return s == nil || len(s.indexMap) == 0
+}
+
+// SelectorMapToQuery converts the selector map to an indexId and constraints for querying the store.
+// For a given index, a specific order and number of constraints are required.
+// Both the indexId and constraints are generated based on the keys present in the selector's internal map.
+func (s Selector) ToQuery() (indexId string, constraints []interface{}) {
+
+	if len(s.indexMap) == 2 && s.indexMap[flagSetIdIndex] != "" && s.indexMap[keyIndex] != "" {
+		// special case for flagSetId and key (this is the "id" index)
+		return idIndex, []interface{}{s.indexMap[flagSetIdIndex], s.indexMap[keyIndex]}
+	}
+
+	qs := []string{}
+	keys := make([]string, 0, len(s.indexMap))
+
+	for key := range s.indexMap {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+
+	for _, key := range keys {
+		indexId += key + "+"
+		qs = append(qs, s.indexMap[key])
+	}
+
+	indexId = strings.TrimSuffix(indexId, "+")
+	// Convert []string to []interface{}
+	c := make([]interface{}, 0, len(qs))
+	for _, v := range qs {
+		c = append(c, v)
+	}
+	constraints = c
+
+	return indexId, constraints
+}
+
+// SelectorToMetadata converts the selector's internal map to metadata for logging or tracing purposes.
+// Only includes known indices to avoid leaking sensitive information, and is usually returned as the "top level" metadata
+func (s *Selector) ToMetadata() model.Metadata {
+	meta := model.Metadata{}
+
+	if s == nil || s.indexMap == nil {
+		return meta
+	}
+
+	if s.indexMap[flagSetIdIndex] != "" {
+		meta[flagSetIdIndex] = s.indexMap[flagSetIdIndex]
+	}
+	if s.indexMap[sourceIndex] != "" {
+		meta[sourceIndex] = s.indexMap[sourceIndex]
+	}
+	return meta
+}

core/pkg/store/query_test.go

@@ -0,0 +1,193 @@
+package store
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/open-feature/flagd/core/pkg/model"
+)
+
+func TestSelector_IsEmpty(t *testing.T) {
+	tests := []struct {
+		name      string
+		selector  *Selector
+		wantEmpty bool
+	}{
+		{
+			name:      "nil selector",
+			selector:  nil,
+			wantEmpty: true,
+		},
+		{
+			name:      "nil indexMap",
+			selector:  &Selector{indexMap: nil},
+			wantEmpty: true,
+		},
+		{
+			name:      "empty indexMap",
+			selector:  &Selector{indexMap: map[string]string{}},
+			wantEmpty: true,
+		},
+		{
+			name:      "non-empty indexMap",
+			selector:  &Selector{indexMap: map[string]string{"source": "abc"}},
+			wantEmpty: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := tt.selector.IsEmpty()
+			if got != tt.wantEmpty {
+				t.Errorf("IsEmpty() = %v, want %v", got, tt.wantEmpty)
+			}
+		})
+	}
+}
+
+func TestSelector_WithIndex(t *testing.T) {
+	oldS := Selector{indexMap: map[string]string{"source": "abc"}}
+	newS := oldS.WithIndex("flagSetId", "1234")
+
+	if newS.indexMap["source"] != "abc" {
+		t.Errorf("WithIndex did not preserve existing keys")
+	}
+	if newS.indexMap["flagSetId"] != "1234" {
+		t.Errorf("WithIndex did not add new key")
+	}
+	// Ensure original is unchanged
+	if _, ok := oldS.indexMap["flagSetId"]; ok {
+		t.Errorf("WithIndex mutated original selector")
+	}
+}
+
+func TestSelector_ToQuery(t *testing.T) {
+	tests := []struct {
+		name       string
+		selector   Selector
+		wantIndex  string
+		wantConstr []interface{}
+	}{
+		{
+			name:       "flagSetId and key primary index special case",
+			selector:   Selector{indexMap: map[string]string{"flagSetId": "fsid", "key": "myKey"}},
+			wantIndex:  "id",
+			wantConstr: []interface{}{"fsid", "myKey"},
+		},
+		{
+			name:       "multiple keys sorted",
+			selector:   Selector{indexMap: map[string]string{"source": "src", "flagSetId": "fsid"}},
+			wantIndex:  "flagSetId+source",
+			wantConstr: []interface{}{"fsid", "src"},
+		},
+		{
+			name:       "single key",
+			selector:   Selector{indexMap: map[string]string{"source": "src"}},
+			wantIndex:  "source",
+			wantConstr: []interface{}{"src"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotIndex, gotConstr := tt.selector.ToQuery()
+			if gotIndex != tt.wantIndex {
+				t.Errorf("ToQuery() index = %v, want %v", gotIndex, tt.wantIndex)
+			}
+			if !reflect.DeepEqual(gotConstr, tt.wantConstr) {
+				t.Errorf("ToQuery() constraints = %v, want %v", gotConstr, tt.wantConstr)
+			}
+		})
+	}
+}
+
+func TestSelector_ToMetadata(t *testing.T) {
+	tests := []struct {
+		name     string
+		selector *Selector
+		want     model.Metadata
+	}{
+		{
+			name:     "nil selector",
+			selector: nil,
+			want:     model.Metadata{},
+		},
+		{
+			name:     "nil indexMap",
+			selector: &Selector{indexMap: nil},
+			want:     model.Metadata{},
+		},
+		{
+			name:     "empty indexMap",
+			selector: &Selector{indexMap: map[string]string{}},
+			want:     model.Metadata{},
+		},
+		{
+			name:     "flagSetId only",
+			selector: &Selector{indexMap: map[string]string{"flagSetId": "fsid"}},
+			want:     model.Metadata{"flagSetId": "fsid"},
+		},
+		{
+			name:     "source only",
+			selector: &Selector{indexMap: map[string]string{"source": "src"}},
+			want:     model.Metadata{"source": "src"},
+		},
+		{
+			name:     "flagSetId and source",
+			selector: &Selector{indexMap: map[string]string{"flagSetId": "fsid", "source": "src"}},
+			want:     model.Metadata{"flagSetId": "fsid", "source": "src"},
+		},
+		{
+			name:     "flagSetId, source, and key (key should be ignored)",
+			selector: &Selector{indexMap: map[string]string{"flagSetId": "fsid", "source": "src", "key": "myKey"}},
+			want:     model.Metadata{"flagSetId": "fsid", "source": "src"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := tt.selector.ToMetadata()
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("ToMetadata() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestNewSelector(t *testing.T) {
+	tests := []struct {
+		name    string
+		input   string
+		wantMap map[string]string
+	}{
+		{
+			name:    "source and flagSetId",
+			input:   "source=abc,flagSetId=1234",
+			wantMap: map[string]string{"source": "abc", "flagSetId": "1234"},
+		},
+		{
+			name:    "source",
+			input:   "source=abc",
+			wantMap: map[string]string{"source": "abc"},
+		},
+		{
+			name:    "no equals, treat as source",
+			input:   "mysource",
+			wantMap: map[string]string{"source": "mysource"},
+		},
+		{
+			name:    "empty string",
+			input:   "",
+			wantMap: map[string]string{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := NewSelector(tt.input)
+			if !reflect.DeepEqual(s.indexMap, tt.wantMap) {
+				t.Errorf("NewSelector(%q) indexMap = %v, want %v", tt.input, s.indexMap, tt.wantMap)
+			}
+		})
+	}
+}

core/pkg/store/store.go

@@ -0,0 +1,396 @@
+package store
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"slices"
+	"sync"
+
+	"github.com/hashicorp/go-memdb"
+	"github.com/open-feature/flagd/core/pkg/logger"
+	"github.com/open-feature/flagd/core/pkg/model"
+	"github.com/open-feature/flagd/core/pkg/notifications"
+)
+
+var noValidatedSources = []string{}
+
+type SelectorContextKey struct{}
+
+type FlagQueryResult struct {
+	Flags map[string]model.Flag
+}
+
+type IStore interface {
+	Get(ctx context.Context, key string, selector *Selector) (model.Flag, model.Metadata, error)
+	GetAll(ctx context.Context, selector *Selector) (map[string]model.Flag, model.Metadata, error)
+	Watch(ctx context.Context, selector *Selector, watcher chan<- FlagQueryResult)
+}
+
+var _ IStore = (*Store)(nil)
+
+type Store struct {
+	mx      sync.RWMutex
+	db      *memdb.MemDB
+	logger  *logger.Logger
+	sources []string
+	// deprecated: has no effect and will be removed soon.
+	FlagSources []string
+}
+
+type SourceDetails struct {
+	Source   string
+	Selector string
+}
+
+// NewStore creates a new in-memory store with the given sources.
+// The order of sources in the slice determines their priority, when queries result in duplicate flags (queries without source or flagSetId), the higher priority source "wins".
+func NewStore(logger *logger.Logger, sources []string) (*Store, error) {
+
+	// a unique index must exist for each set of constraints - for example, to look up by key and source, we need a compound index on key+source, etc
+	// we maybe want to generate these dynamically in the future to support more robust querying, but for now we will hardcode the ones we need
+	schema := &memdb.DBSchema{
+		Tables: map[string]*memdb.TableSchema{
+			flagsTable: {
+				Name: flagsTable,
+				Indexes: map[string]*memdb.IndexSchema{
+					// primary index; must be unique and named "id"
+					idIndex: {
+						Name:   idIndex,
+						Unique: true,
+						Indexer: &memdb.CompoundIndex{
+							Indexes: []memdb.Indexer{
+								&memdb.StringFieldIndex{Field: model.FlagSetId, Lowercase: false},
+								&memdb.StringFieldIndex{Field: model.Key, Lowercase: false},
+							},
+						},
+					},
+					// for looking up by source
+					sourceIndex: {
+						Name:    sourceIndex,
+						Unique:  false,
+						Indexer: &memdb.StringFieldIndex{Field: model.Source, Lowercase: false},
+					},
+					// for looking up by priority, used to maintain highest priority flag when there are duplicates and no selector is provided
+					priorityIndex: {
+						Name:    priorityIndex,
+						Unique:  false,
+						Indexer: &memdb.IntFieldIndex{Field: model.Priority},
+					},
+					// for looking up by flagSetId
+					flagSetIdIndex: {
+						Name:    flagSetIdIndex,
+						Unique:  false,
+						Indexer: &memdb.StringFieldIndex{Field: model.FlagSetId, Lowercase: false},
+					},
+					keyIndex: {
+						Name:    keyIndex,
+						Unique:  false,
+						Indexer: &memdb.StringFieldIndex{Field: model.Key, Lowercase: false},
+					},
+					flagSetIdSourceCompoundIndex: {
+						Name:   flagSetIdSourceCompoundIndex,
+						Unique: false,
+						Indexer: &memdb.CompoundIndex{
+							Indexes: []memdb.Indexer{
+								&memdb.StringFieldIndex{Field: model.FlagSetId, Lowercase: false},
+								&memdb.StringFieldIndex{Field: model.Source, Lowercase: false},
+							},
+						},
+					},
+					keySourceCompoundIndex: {
+						Name:   keySourceCompoundIndex,
+						Unique: false, // duplicate from a single source ARE allowed (they just must have different flag sets)
+						Indexer: &memdb.CompoundIndex{
+							Indexes: []memdb.Indexer{
+								&memdb.StringFieldIndex{Field: model.Key, Lowercase: false},
+								&memdb.StringFieldIndex{Field: model.Source, Lowercase: false},
+							},
+						},
+					},
+					// used to query all flags from a specific source so we know which flags to delete if a flag is missing from a source
+					flagSetIdKeySourceCompoundIndex: {
+						Name:   flagSetIdKeySourceCompoundIndex,
+						Unique: true,
+						Indexer: &memdb.CompoundIndex{
+							Indexes: []memdb.Indexer{
+								&memdb.StringFieldIndex{Field: model.FlagSetId, Lowercase: false},
+								&memdb.StringFieldIndex{Field: model.Key, Lowercase: false},
+								&memdb.StringFieldIndex{Field: model.Source, Lowercase: false},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	// Create a new data base
+	db, err := memdb.NewMemDB(schema)
+	if err != nil {
+		return nil, fmt.Errorf("unable to initialize flag database: %w", err)
+	}
+
+	// clone the sources to avoid modifying the original slice
+	s := slices.Clone(sources)
+
+	return &Store{
+		sources: s,
+		db:      db,
+		logger:  logger,
+	}, nil
+}
+
+// Deprecated: use NewStore instead - will be removed very soon.
+func NewFlags() *Store {
+	state, err := NewStore(logger.NewLogger(nil, false), noValidatedSources)
+
+	if err != nil {
+		panic(fmt.Sprintf("unable to create flag store: %v", err))
+	}
+	return state
+}
+
+func (s *Store) Get(_ context.Context, key string, selector *Selector) (model.Flag, model.Metadata, error) {
+	s.logger.Debug(fmt.Sprintf("getting flag %s", key))
+	txn := s.db.Txn(false)
+	queryMeta := selector.ToMetadata()
+
+	// if present, use the selector to query the flags
+	if !selector.IsEmpty() {
+		selector := selector.WithIndex("key", key)
+		indexId, constraints := selector.ToQuery()
+		s.logger.Debug(fmt.Sprintf("getting flag with query: %s, %v", indexId, constraints))
+		raw, err := txn.First(flagsTable, indexId, constraints...)
+		flag, ok := raw.(model.Flag)
+		if err != nil {
+			return model.Flag{}, queryMeta, fmt.Errorf("flag %s not found: %w", key, err)
+		}
+		if !ok {
+			return model.Flag{}, queryMeta, fmt.Errorf("flag %s is not a valid flag", key)
+		}
+		return flag, queryMeta, nil
+
+	}
+	// otherwise, get all flags with the given key, and keep the last one with the highest priority
+	s.logger.Debug(fmt.Sprintf("getting highest priority flag with key: %s", key))
+	it, err := txn.Get(flagsTable, keyIndex, key)
+	if err != nil {
+		return model.Flag{}, queryMeta, fmt.Errorf("flag %s not found: %w", key, err)
+	}
+	flag := model.Flag{}
+	found := false
+	for raw := it.Next(); raw != nil; raw = it.Next() {
+		nextFlag, ok := raw.(model.Flag)
+		if !ok {
+			continue
+		}
+		found = true
+		if nextFlag.Priority >= flag.Priority {
+			flag = nextFlag
+		} else {
+			s.logger.Debug(fmt.Sprintf("discarding flag %s from lower priority source %s in favor of flag from source %s", nextFlag.Key, s.sources[nextFlag.Priority], s.sources[flag.Priority]))
+		}
+	}
+
+	if !found {
+		return flag, queryMeta, fmt.Errorf("flag %s not found", key)
+	}
+	return flag, queryMeta, nil
+}
+
+func (f *Store) String() (string, error) {
+	f.logger.Debug("dumping flags to string")
+	f.mx.RLock()
+	defer f.mx.RUnlock()
+
+	state, _, err := f.GetAll(context.Background(), nil)
+	if err != nil {
+		return "", fmt.Errorf("unable to get all flags: %w", err)
+	}
+
+	bytes, err := json.Marshal(state)
+	if err != nil {
+		return "", fmt.Errorf("unable to marshal flags: %w", err)
+	}
+
+	return string(bytes), nil
+}
+
+// GetAll returns a copy of the store's state (copy in order to be concurrency safe)
+func (s *Store) GetAll(ctx context.Context, selector *Selector) (map[string]model.Flag, model.Metadata, error) {
+	flags := make(map[string]model.Flag)
+	queryMeta := selector.ToMetadata()
+	it, err := s.selectOrAll(selector)
+
+	if err != nil {
+		s.logger.Error(fmt.Sprintf("flag query error: %v", err))
+		return flags, queryMeta, err
+	}
+	flags = s.collect(it)
+	return flags, queryMeta, nil
+}
+
+// Update the flag state with the provided flags.
+func (s *Store) Update(
+	source string,
+	flags map[string]model.Flag,
+	metadata model.Metadata,
+) (map[string]interface{}, bool) {
+	resyncRequired := false
+
+	if source == "" {
+		panic("source cannot be empty")
+	}
+
+	priority := slices.Index(s.sources, source)
+	if priority == -1 {
+		// this is a hack to allow old constructors that didn't pass sources, remove when we remove "NewFlags" constructor
+		if !slices.Equal(s.sources, noValidatedSources) {
+			panic(fmt.Sprintf("source %s is not registered in the store", source))
+		}
+		// same as above - remove when we remove "NewFlags" constructor
+		priority = 0
+	}
+
+	txn := s.db.Txn(true)
+	defer txn.Abort()
+
+	// get all flags for the source we are updating
+	selector := NewSelector(sourceIndex + "=" + source)
+	oldFlags, _, _ := s.GetAll(context.Background(), &selector)
+
+	s.mx.Lock()
+	for key := range oldFlags {
+		if _, ok := flags[key]; !ok {
+			// flag has been deleted
+			s.logger.Debug(fmt.Sprintf("flag %s has been deleted from source %s", key, source))
+
+			count, err := txn.DeleteAll(flagsTable, keySourceCompoundIndex, key, source)
+			s.logger.Debug(fmt.Sprintf("deleted %d flags with key %s from source %s", count, key, source))
+
+			if err != nil {
+				s.logger.Error(fmt.Sprintf("error deleting flag: %s, %v", key, err))
+			}
+			continue
+		}
+	}
+	s.mx.Unlock()
+	for key, newFlag := range flags {
+		s.logger.Debug(fmt.Sprintf("got metadata %v", metadata))
+
+		newFlag.Key = key
+		newFlag.Source = source
+		newFlag.Priority = priority
+		newFlag.Metadata = patchMetadata(metadata, newFlag.Metadata)
+
+		// flagSetId defaults to a UUID generated at startup to make our queries isomorphic
+		flagSetId := nilFlagSetId
+		// flagSetId is inherited from the set, but can be overridden by the flag
+		setFlagSetId, ok := newFlag.Metadata["flagSetId"].(string)
+		if ok {
+			flagSetId = setFlagSetId
+		}
+		newFlag.FlagSetId = flagSetId
+
+		raw, err := txn.First(flagsTable, keySourceCompoundIndex, key, source)
+		if err != nil {
+			s.logger.Error(fmt.Sprintf("unable to get flag %s from source %s: %v", key, source, err))
+			continue
+		}
+		oldFlag, ok := raw.(model.Flag)
+		// If we already have a flag with the same key and source, we need to check if it has the same flagSetId
+		if ok {
+			if oldFlag.FlagSetId != newFlag.FlagSetId {
+				// If the flagSetId is different, we need to delete the entry, since flagSetId+key represents the primary index, and it's now been changed.
+				// This is important especially for clients listening to flagSetId changes, as they expect the flag to be removed from the set in this case.
+				_, err = txn.DeleteAll(flagsTable, idIndex, oldFlag.FlagSetId, key)
+				if err != nil {
+					s.logger.Error(fmt.Sprintf("unable to delete flags with key %s and flagSetId %s: %v", key, oldFlag.FlagSetId, err))
+					continue
+				}
+			}
+		}
+		// Store the new version of the flag
+		s.logger.Debug(fmt.Sprintf("storing flag: %v", newFlag))
+		err = txn.Insert(flagsTable, newFlag)
+		if err != nil {
+			s.logger.Error(fmt.Sprintf("unable to insert flag %s: %v", key, err))
+			continue
+		}
+	}
+
+	txn.Commit()
+	return notifications.NewFromFlags(oldFlags, flags), resyncRequired
+}
+
+// Watch the result-set of a selector for changes, sending updates to the watcher channel.
+func (s *Store) Watch(ctx context.Context, selector *Selector, watcher chan<- FlagQueryResult) {
+	go func() {
+		for {
+			ws := memdb.NewWatchSet()
+			it, err := s.selectOrAll(selector)
+			if err != nil {
+				s.logger.Error(fmt.Sprintf("error watching flags: %v", err))
+				close(watcher)
+				return
+			}
+			ws.Add(it.WatchCh())
+
+			flags := s.collect(it)
+			watcher <- FlagQueryResult{
+				Flags: flags,
+			}
+
+			if err = ws.WatchCtx(ctx); err != nil {
+				s.logger.Error(fmt.Sprintf("error watching flags: %v", err))
+				close(watcher)
+				return
+			}
+		}
+	}()
+}
+
+// returns an iterator for the given selector, or all flags if the selector is nil or empty
+func (s *Store) selectOrAll(selector *Selector) (it memdb.ResultIterator, err error) {
+	txn := s.db.Txn(false)
+	if !selector.IsEmpty() {
+		indexId, constraints := selector.ToQuery()
+		s.logger.Debug(fmt.Sprintf("getting all flags with query: %s, %v", indexId, constraints))
+		return txn.Get(flagsTable, indexId, constraints...)
+	} else {
+		// no selector, get all flags
+		return txn.Get(flagsTable, idIndex)
+	}
+}
+
+// collects flags from an iterator, ensuring that only the highest priority flag is kept when there are duplicates
+func (s *Store) collect(it memdb.ResultIterator) map[string]model.Flag {
+	flags := make(map[string]model.Flag)
+	for raw := it.Next(); raw != nil; raw = it.Next() {
+		flag := raw.(model.Flag)
+		if existing, ok := flags[flag.Key]; ok {
+			if flag.Priority < existing.Priority {
+				s.logger.Debug(fmt.Sprintf("discarding duplicate flag %s from lower priority source %s in favor of flag from source %s", flag.Key, s.sources[flag.Priority], s.sources[existing.Priority]))
+				continue // we already have a higher priority flag
+			}
+			s.logger.Debug(fmt.Sprintf("overwriting duplicate flag %s from lower priority source %s in favor of flag from source %s", flag.Key, s.sources[existing.Priority], s.sources[flag.Priority]))
+		}
+		flags[flag.Key] = flag
+	}
+	return flags
+}
+
+func patchMetadata(original, patch model.Metadata) model.Metadata {
+	patched := make(model.Metadata)
+	if original == nil && patch == nil {
+		return nil
+	}
+	for key, value := range original {
+		patched[key] = value
+	}
+	for key, value := range patch { // patch values overwrite m1 values on key conflict
+		patched[key] = value
+	}
+	return patched
+}

core/pkg/store/store_test.go

@@ -0,0 +1,487 @@
+package store
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/open-feature/flagd/core/pkg/logger"
+	"github.com/open-feature/flagd/core/pkg/model"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestUpdateFlags(t *testing.T) {
+
+	const source1 = "source1"
+	const source2 = "source2"
+	var sources = []string{source1, source2}
+
+	t.Parallel()
+	tests := []struct {
+		name        string
+		setup       func(t *testing.T) *Store
+		newFlags    map[string]model.Flag
+		source      string
+		wantFlags   map[string]model.Flag
+		setMetadata model.Metadata
+		wantNotifs  map[string]interface{}
+		wantResync  bool
+	}{
+		{
+			name: "both nil",
+			setup: func(t *testing.T) *Store {
+				s, err := NewStore(logger.NewLogger(nil, false), sources)
+				if err != nil {
+					t.Fatalf("NewStore failed: %v", err)
+				}
+				return s
+			},
+			source:     source1,
+			newFlags:   nil,
+			wantFlags:  map[string]model.Flag{},
+			wantNotifs: map[string]interface{}{},
+		},
+		{
+			name: "both empty flags",
+			setup: func(t *testing.T) *Store {
+				s, err := NewStore(logger.NewLogger(nil, false), sources)
+				if err != nil {
+					t.Fatalf("NewStore failed: %v", err)
+				}
+				return s
+			},
+			source:     source1,
+			newFlags:   map[string]model.Flag{},
+			wantFlags:  map[string]model.Flag{},
+			wantNotifs: map[string]interface{}{},
+		},
+		{
+			name: "empty new",
+			setup: func(t *testing.T) *Store {
+				s, err := NewStore(logger.NewLogger(nil, false), sources)
+				if err != nil {
+					t.Fatalf("NewStore failed: %v", err)
+				}
+				return s
+			},
+			source:     source1,
+			newFlags:   nil,
+			wantFlags:  map[string]model.Flag{},
+			wantNotifs: map[string]interface{}{},
+		},
+		{
+			name: "update from source 1 (old flag removed)",
+			setup: func(t *testing.T) *Store {
+				s, err := NewStore(logger.NewLogger(nil, false), sources)
+				if err != nil {
+					t.Fatalf("NewStore failed: %v", err)
+				}
+				s.Update(source1, map[string]model.Flag{
+					"waka": {DefaultVariant: "off"},
+				}, nil)
+				return s
+			},
+			newFlags: map[string]model.Flag{
+				"paka": {DefaultVariant: "on"},
+			},
+			source: source1,
+			wantFlags: map[string]model.Flag{
+				"paka": {Key: "paka", DefaultVariant: "on", Source: source1, FlagSetId: nilFlagSetId, Priority: 0},
+			},
+			wantNotifs: map[string]interface{}{
+				"paka": map[string]interface{}{"type": "write"},
+				"waka": map[string]interface{}{"type": "delete"},
+			},
+		},
+		{
+			name: "update from source 1 (new flag added)",
+			setup: func(t *testing.T) *Store {
+				s, err := NewStore(logger.NewLogger(nil, false), sources)
+				if err != nil {
+					t.Fatalf("NewStore failed: %v", err)
+				}
+				s.Update(source1, map[string]model.Flag{
+					"waka": {DefaultVariant: "off"},
+				}, nil)
+				return s
+			},
+			newFlags: map[string]model.Flag{
+				"paka": {DefaultVariant: "on"},
+			},
+			source: source2,
+			wantFlags: map[string]model.Flag{
+				"waka": {Key: "waka", DefaultVariant: "off", Source: source1, FlagSetId: nilFlagSetId, Priority: 0},
+				"paka": {Key: "paka", DefaultVariant: "on", Source: source2, FlagSetId: nilFlagSetId, Priority: 1},
+			},
+			wantNotifs: map[string]interface{}{"paka": map[string]interface{}{"type": "write"}},
+		},
+		{
+			name: "flag set inheritance",
+			setup: func(t *testing.T) *Store {
+				s, err := NewStore(logger.NewLogger(nil, false), sources)
+				if err != nil {
+					t.Fatalf("NewStore failed: %v", err)
+				}
+				s.Update(source1, map[string]model.Flag{}, model.Metadata{})
+				return s
+			},
+			setMetadata: model.Metadata{
+				"flagSetId": "topLevelSet", // top level set metadata, including flagSetId
+			},
+			newFlags: map[string]model.Flag{
+				"waka": {DefaultVariant: "on"},
+				"paka": {DefaultVariant: "on", Metadata: model.Metadata{"flagSetId": "flagLevelSet"}}, // overrides set level flagSetId
+			},
+			source: source1,
+			wantFlags: map[string]model.Flag{
+				"waka": {Key: "waka", DefaultVariant: "on", Source: source1, FlagSetId: "topLevelSet", Priority: 0, Metadata: model.Metadata{"flagSetId": "topLevelSet"}},
+				"paka": {Key: "paka", DefaultVariant: "on", Source: source1, FlagSetId: "flagLevelSet", Priority: 0, Metadata: model.Metadata{"flagSetId": "flagLevelSet"}},
+			},
+			wantNotifs: map[string]interface{}{
+				"paka": map[string]interface{}{"type": "write"},
+				"waka": map[string]interface{}{"type": "write"},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			store := tt.setup(t)
+			gotNotifs, resyncRequired := store.Update(tt.source, tt.newFlags, tt.setMetadata)
+			gotFlags, _, _ := store.GetAll(context.Background(), nil)
+
+			require.Equal(t, tt.wantFlags, gotFlags)
+			require.Equal(t, tt.wantNotifs, gotNotifs)
+			require.Equal(t, tt.wantResync, resyncRequired)
+		})
+	}
+}
+
+func TestGet(t *testing.T) {
+
+	sourceA := "sourceA"
+	sourceB := "sourceB"
+	sourceC := "sourceC"
+	flagSetIdB := "flagSetIdA"
+	flagSetIdC := "flagSetIdC"
+	var sources = []string{sourceA, sourceB, sourceC}
+
+	sourceASelector := NewSelector("source=" + sourceA)
+	flagSetIdCSelector := NewSelector("flagSetId=" + flagSetIdC)
+
+	t.Parallel()
+	tests := []struct {
+		name     string
+		key      string
+		selector *Selector
+		wantFlag model.Flag
+		wantErr  bool
+	}{
+		{
+			name:     "nil selector",
+			key:      "flagA",
+			selector: nil,
+			wantFlag: model.Flag{Key: "flagA", DefaultVariant: "off", Source: sourceA, FlagSetId: nilFlagSetId, Priority: 0},
+			wantErr:  false,
+		},
+		{
+			name:     "flagSetId selector",
+			key:      "dupe",
+			selector: &flagSetIdCSelector,
+			wantFlag: model.Flag{Key: "dupe", DefaultVariant: "off", Source: sourceC, FlagSetId: flagSetIdC, Priority: 2, Metadata: model.Metadata{"flagSetId": flagSetIdC}},
+			wantErr:  false,
+		},
+		{
+			name:     "source selector",
+			key:      "dupe",
+			selector: &sourceASelector,
+			wantFlag: model.Flag{Key: "dupe", DefaultVariant: "on", Source: sourceA, FlagSetId: nilFlagSetId, Priority: 0},
+			wantErr:  false,
+		},
+		{
+			name:     "flag not found with source selector",
+			key:      "flagB",
+			selector: &sourceASelector,
+			wantFlag: model.Flag{Key: "flagB", DefaultVariant: "off", Source: sourceB, FlagSetId: flagSetIdB, Priority: 1, Metadata: model.Metadata{"flagSetId": flagSetIdB}},
+			wantErr:  true,
+		},
+		{
+			name:     "flag not found with flagSetId selector",
+			key:      "flagB",
+			selector: &flagSetIdCSelector,
+			wantFlag: model.Flag{Key: "flagB", DefaultVariant: "off", Source: sourceB, FlagSetId: flagSetIdB, Priority: 1, Metadata: model.Metadata{"flagSetId": flagSetIdB}},
+			wantErr:  true,
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			sourceAFlags := map[string]model.Flag{
+				"flagA": {Key: "flagA", DefaultVariant: "off"},
+				"dupe":  {Key: "dupe", DefaultVariant: "on"},
+			}
+			sourceBFlags := map[string]model.Flag{
+				"flagB": {Key: "flagB", DefaultVariant: "off", Metadata: model.Metadata{"flagSetId": flagSetIdB}},
+			}
+			sourceCFlags := map[string]model.Flag{
+				"flagC": {Key: "flagC", DefaultVariant: "off", Metadata: model.Metadata{"flagSetId": flagSetIdC}},
+				"dupe":  {Key: "dupe", DefaultVariant: "off", Metadata: model.Metadata{"flagSetId": flagSetIdC}},
+			}
+
+			store, err := NewStore(logger.NewLogger(nil, false), sources)
+			if err != nil {
+				t.Fatalf("NewStore failed: %v", err)
+			}
+
+			store.Update(sourceA, sourceAFlags, nil)
+			store.Update(sourceB, sourceBFlags, nil)
+			store.Update(sourceC, sourceCFlags, nil)
+			gotFlag, _, err := store.Get(context.Background(), tt.key, tt.selector)
+
+			if !tt.wantErr {
+				require.Equal(t, tt.wantFlag, gotFlag)
+			} else {
+				require.Error(t, err, "expected an error for key %s with selector %v", tt.key, tt.selector)
+			}
+		})
+	}
+}
+
+func TestGetAllNoWatcher(t *testing.T) {
+
+	sourceA := "sourceA"
+	sourceB := "sourceB"
+	sourceC := "sourceC"
+	flagSetIdB := "flagSetIdA"
+	flagSetIdC := "flagSetIdC"
+	sources := []string{sourceA, sourceB, sourceC}
+
+	sourceASelector := NewSelector("source=" + sourceA)
+	flagSetIdCSelector := NewSelector("flagSetId=" + flagSetIdC)
+
+	t.Parallel()
+	tests := []struct {
+		name      string
+		selector  *Selector
+		wantFlags map[string]model.Flag
+	}{
+		{
+			name:     "nil selector",
+			selector: nil,
+			wantFlags: map[string]model.Flag{
+				// "dupe" should be overwritten by higher priority flag
+				"flagA": {Key: "flagA", DefaultVariant: "off", Source: sourceA, FlagSetId: nilFlagSetId, Priority: 0},
+				"flagB": {Key: "flagB", DefaultVariant: "off", Source: sourceB, FlagSetId: flagSetIdB, Priority: 1, Metadata: model.Metadata{"flagSetId": flagSetIdB}},
+				"flagC": {Key: "flagC", DefaultVariant: "off", Source: sourceC, FlagSetId: flagSetIdC, Priority: 2, Metadata: model.Metadata{"flagSetId": flagSetIdC}},
+				"dupe":  {Key: "dupe", DefaultVariant: "off", Source: sourceC, FlagSetId: flagSetIdC, Priority: 2, Metadata: model.Metadata{"flagSetId": flagSetIdC}},
+			},
+		},
+		{
+			name:     "source selector",
+			selector: &sourceASelector,
+			wantFlags: map[string]model.Flag{
+				// we should get the "dupe" from sourceA
+				"flagA": {Key: "flagA", DefaultVariant: "off", Source: sourceA, FlagSetId: nilFlagSetId, Priority: 0},
+				"dupe":  {Key: "dupe", DefaultVariant: "on", Source: sourceA, FlagSetId: nilFlagSetId, Priority: 0},
+			},
+		},
+		{
+			name:     "flagSetId selector",
+			selector: &flagSetIdCSelector,
+			wantFlags: map[string]model.Flag{
+				// we should get the "dupe" from flagSetIdC
+				"flagC": {Key: "flagC", DefaultVariant: "off", Source: sourceC, FlagSetId: flagSetIdC, Priority: 2, Metadata: model.Metadata{"flagSetId": flagSetIdC}},
+				"dupe":  {Key: "dupe", DefaultVariant: "off", Source: sourceC, FlagSetId: flagSetIdC, Priority: 2, Metadata: model.Metadata{"flagSetId": flagSetIdC}},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			sourceAFlags := map[string]model.Flag{
+				"flagA": {Key: "flagA", DefaultVariant: "off"},
+				"dupe":  {Key: "dupe", DefaultVariant: "on"},
+			}
+			sourceBFlags := map[string]model.Flag{
+				"flagB": {Key: "flagB", DefaultVariant: "off", Metadata: model.Metadata{"flagSetId": flagSetIdB}},
+			}
+			sourceCFlags := map[string]model.Flag{
+				"flagC": {Key: "flagC", DefaultVariant: "off", Metadata: model.Metadata{"flagSetId": flagSetIdC}},
+				"dupe":  {Key: "dupe", DefaultVariant: "off", Metadata: model.Metadata{"flagSetId": flagSetIdC}},
+			}
+
+			store, err := NewStore(logger.NewLogger(nil, false), sources)
+			if err != nil {
+				t.Fatalf("NewStore failed: %v", err)
+			}
+
+			store.Update(sourceA, sourceAFlags, nil)
+			store.Update(sourceB, sourceBFlags, nil)
+			store.Update(sourceC, sourceCFlags, nil)
+			gotFlags, _, _ := store.GetAll(context.Background(), tt.selector)
+
+			require.Equal(t, len(tt.wantFlags), len(gotFlags))
+			require.Equal(t, tt.wantFlags, gotFlags)
+		})
+	}
+}
+
+func TestWatch(t *testing.T) {
+
+	sourceA := "sourceA"
+	sourceB := "sourceB"
+	sourceC := "sourceC"
+	myFlagSetId := "myFlagSet"
+	var sources = []string{sourceA, sourceB, sourceC}
+	pauseTime := 100 * time.Millisecond // time for updates to settle
+	timeout := 1000 * time.Millisecond  // time to make sure we get enough updates, and no extras
+
+	sourceASelector := NewSelector("source=" + sourceA)
+	flagSetIdCSelector := NewSelector("flagSetId=" + myFlagSetId)
+	emptySelector := NewSelector("")
+	sourceCSelector := NewSelector("source=" + sourceC)
+
+	tests := []struct {
+		name        string
+		selector    *Selector
+		wantUpdates int
+	}{
+		{
+			name:        "flag source selector (initial, plus 1 update)",
+			selector:    &sourceASelector,
+			wantUpdates: 2,
+		},
+		{
+			name:        "flag set selector (initial, plus 3 updates)",
+			selector:    &flagSetIdCSelector,
+			wantUpdates: 4,
+		},
+		{
+			name:        "no selector (all updates)",
+			selector:    &emptySelector,
+			wantUpdates: 5,
+		},
+		{
+			name:        "flag source selector for unchanged source (initial, plus no updates)",
+			selector:    &sourceCSelector,
+			wantUpdates: 1,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			sourceAFlags := map[string]model.Flag{
+				"flagA": {Key: "flagA", DefaultVariant: "off"},
+			}
+			sourceBFlags := map[string]model.Flag{
+				"flagB": {Key: "flagB", DefaultVariant: "off", Metadata: model.Metadata{"flagSetId": myFlagSetId}},
+			}
+			sourceCFlags := map[string]model.Flag{
+				"flagC": {Key: "flagC", DefaultVariant: "off"},
+			}
+
+			store, err := NewStore(logger.NewLogger(nil, false), sources)
+			if err != nil {
+				t.Fatalf("NewStore failed: %v", err)
+			}
+
+			// setup initial flags
+			store.Update(sourceA, sourceAFlags, model.Metadata{})
+			store.Update(sourceB, sourceBFlags, model.Metadata{})
+			store.Update(sourceC, sourceCFlags, model.Metadata{})
+			watcher := make(chan FlagQueryResult, 1)
+			time.Sleep(pauseTime)
+
+			ctx, cancel := context.WithCancel(context.Background())
+			store.Watch(ctx, tt.selector, watcher)
+
+			// perform updates
+			go func() {
+
+				time.Sleep(pauseTime)
+
+				// changing a flag default variant should trigger an update
+				store.Update(sourceA, map[string]model.Flag{
+					"flagA": {Key: "flagA", DefaultVariant: "on"},
+				}, model.Metadata{})
+
+				time.Sleep(pauseTime)
+
+				// changing a flag default variant should trigger an update
+				store.Update(sourceB, map[string]model.Flag{
+					"flagB": {Key: "flagB", DefaultVariant: "on", Metadata: model.Metadata{"flagSetId": myFlagSetId}},
+				}, model.Metadata{})
+
+				time.Sleep(pauseTime)
+
+				// removing a flag set id should trigger an update (even for flag set id selectors; it should remove the flag from the set)
+				store.Update(sourceB, map[string]model.Flag{
+					"flagB": {Key: "flagB", DefaultVariant: "on"},
+				}, model.Metadata{})
+
+				time.Sleep(pauseTime)
+
+				// adding a flag set id should trigger an update
+				store.Update(sourceB, map[string]model.Flag{
+					"flagB": {Key: "flagB", DefaultVariant: "on", Metadata: model.Metadata{"flagSetId": myFlagSetId}},
+				}, model.Metadata{})
+			}()
+
+			updates := 0
+
+			for {
+				select {
+				case <-time.After(timeout):
+					assert.Equal(t, tt.wantUpdates, updates, "expected %d updates, got %d", tt.wantUpdates, updates)
+					cancel()
+					_, open := <-watcher
+					assert.False(t, open, "watcher channel should be closed after cancel")
+					return
+				case q := <-watcher:
+					if q.Flags != nil {
+						updates++
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestQueryMetadata(t *testing.T) {
+
+	sourceA := "sourceA"
+	otherSource := "otherSource"
+	nonExistingFlagSetId := "nonExistingFlagSetId"
+	var sources = []string{sourceA}
+	sourceAFlags := map[string]model.Flag{
+		"flagA": {Key: "flagA", DefaultVariant: "off"},
+		"flagB": {Key: "flagB", DefaultVariant: "on"},
+	}
+
+	store, err := NewStore(logger.NewLogger(nil, false), sources)
+	if err != nil {
+		t.Fatalf("NewStore failed: %v", err)
+	}
+
+	// setup initial flags
+	store.Update(sourceA, sourceAFlags, model.Metadata{})
+
+	selector := NewSelector("source=" + otherSource + ",flagSetId=" + nonExistingFlagSetId)
+	_, metadata, _ := store.GetAll(context.Background(), &selector)
+	assert.Equal(t, metadata, model.Metadata{"source": otherSource, "flagSetId": nonExistingFlagSetId}, "metadata did not match expected")
+
+	selector = NewSelector("source=" + otherSource + ",flagSetId=" + nonExistingFlagSetId)
+	_, metadata, _ = store.Get(context.Background(), "key", &selector)
+	assert.Equal(t, metadata, model.Metadata{"source": otherSource, "flagSetId": nonExistingFlagSetId}, "metadata did not match expected")
+}

core/pkg/sync-store/interface.go

@@ -1,26 +0,0 @@
-package store
-
-import (
-	"context"
-
-	isync "github.com/open-feature/flagd/core/pkg/sync"
-)
-
-// ISyncStore defines the interface for the sync store
-type ISyncStore interface {
-	FetchAllFlags(
-		ctx context.Context,
-		key interface{},
-		target string,
-	) (isync.DataSync, error)
-	RegisterSubscription(
-		ctx context.Context,
-		target string,
-		key interface{},
-		dataSync chan isync.DataSync,
-		errChan chan error,
-	)
-
-	// metrics hooks
-	GetActiveSubscriptionsInt64() int64
-}

core/pkg/sync/blob/blob_sync.go

@@ -0,0 +1,147 @@
+package blob
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"path/filepath"
+	"time"
+
+	"github.com/open-feature/flagd/core/pkg/logger"
+	"github.com/open-feature/flagd/core/pkg/sync"
+	"github.com/open-feature/flagd/core/pkg/utils"
+	"gocloud.dev/blob"
+	_ "gocloud.dev/blob/azureblob" // needed to initialize Azure Blob Storage driver
+	_ "gocloud.dev/blob/gcsblob"   // needed to initialize GCS driver
+	_ "gocloud.dev/blob/s3blob"    // needed to initialize s3 driver
+)
+
+type Sync struct {
+	Bucket      string
+	Object      string
+	BlobURLMux  *blob.URLMux
+	Cron        Cron
+	Logger      *logger.Logger
+	Interval    uint32
+	ready       bool
+	lastUpdated time.Time
+}
+
+// Cron defines the behaviour required of a cron
+type Cron interface {
+	AddFunc(spec string, cmd func()) error
+	Start()
+	Stop()
+}
+
+func (hs *Sync) Init(_ context.Context) error {
+	if hs.Bucket == "" {
+		return errors.New("no bucket string set")
+	}
+	if hs.Object == "" {
+		return errors.New("no object string set")
+	}
+	return nil
+}
+
+func (hs *Sync) IsReady() bool {
+	return hs.ready
+}
+
+func (hs *Sync) Sync(ctx context.Context, dataSync chan<- sync.DataSync) error {
+	hs.Logger.Info(fmt.Sprintf("starting sync from %s/%s with interval %ds", hs.Bucket, hs.Object, hs.Interval))
+	_ = hs.Cron.AddFunc(fmt.Sprintf("*/%d * * * *", hs.Interval), func() {
+		err := hs.sync(ctx, dataSync, false)
+		if err != nil {
+			hs.Logger.Warn(fmt.Sprintf("sync failed: %v", err))
+		}
+	})
+	// Initial fetch
+	hs.Logger.Debug(fmt.Sprintf("initial sync of the %s/%s", hs.Bucket, hs.Object))
+	err := hs.sync(ctx, dataSync, false)
+	if err != nil {
+		return err
+	}
+
+	hs.ready = true
+	hs.Cron.Start()
+	<-ctx.Done()
+	hs.Cron.Stop()
+
+	return nil
+}
+
+func (hs *Sync) ReSync(ctx context.Context, dataSync chan<- sync.DataSync) error {
+	return hs.sync(ctx, dataSync, true)
+}
+
+func (hs *Sync) sync(ctx context.Context, dataSync chan<- sync.DataSync, skipCheckingModTime bool) error {
+	bucket, err := hs.getBucket(ctx)
+	if err != nil {
+		return fmt.Errorf("couldn't get bucket: %v", err)
+	}
+	defer bucket.Close()
+	var updated time.Time
+	if !skipCheckingModTime {
+		updated, err = hs.fetchObjectModificationTime(ctx, bucket)
+		if err != nil {
+			return fmt.Errorf("couldn't get object attributes: %v", err)
+		}
+		if hs.lastUpdated.Equal(updated) {
+			hs.Logger.Debug("configuration hasn't changed, skipping fetching full object")
+			return nil
+		}
+		if hs.lastUpdated.After(updated) {
+			hs.Logger.Warn("configuration changed but the modification time decreased instead of increasing")
+		}
+	}
+	msg, err := hs.fetchObject(ctx, bucket)
+	if err != nil {
+		return fmt.Errorf("couldn't get object: %v", err)
+	}
+	hs.Logger.Debug(fmt.Sprintf("configuration updated: %s", msg))
+	if !skipCheckingModTime {
+		hs.lastUpdated = updated
+	}
+	dataSync <- sync.DataSync{FlagData: msg, Source: hs.Bucket + hs.Object}
+	return nil
+}
+
+func (hs *Sync) getBucket(ctx context.Context) (*blob.Bucket, error) {
+	b, err := hs.BlobURLMux.OpenBucket(ctx, hs.Bucket)
+	if err != nil {
+		return nil, fmt.Errorf("error opening bucket %s: %v", hs.Bucket, err)
+	}
+	return b, nil
+}
+
+func (hs *Sync) fetchObjectModificationTime(ctx context.Context, bucket *blob.Bucket) (time.Time, error) {
+	if hs.Object == "" {
+		return time.Time{}, errors.New("no object string set")
+	}
+	attrs, err := bucket.Attributes(ctx, hs.Object)
+	if err != nil {
+		return time.Time{}, fmt.Errorf("error fetching attributes for object %s/%s: %w", hs.Bucket, hs.Object, err)
+	}
+	return attrs.ModTime, nil
+}
+
+func (hs *Sync) fetchObject(ctx context.Context, bucket *blob.Bucket) (string, error) {
+	r, err := bucket.NewReader(ctx, hs.Object, nil)
+	if err != nil {
+		return "", fmt.Errorf("error opening reader for object %s/%s: %w", hs.Bucket, hs.Object, err)
+	}
+	defer r.Close()
+
+	data, err := io.ReadAll(r)
+	if err != nil {
+		return "", fmt.Errorf("error downloading object %s/%s: %w", hs.Bucket, hs.Object, err)
+	}
+
+	json, err := utils.ConvertToJSON(data, filepath.Ext(hs.Object), r.ContentType())
+	if err != nil {
+		return "", fmt.Errorf("error converting blob data to json: %w", err)
+	}
+	return json, nil
+}

core/pkg/sync/blob/blob_sync_test.go

@@ -0,0 +1,152 @@
+package blob
+
+import (
+	"context"
+	"log"
+	"testing"
+	"time"
+
+	"github.com/open-feature/flagd/core/pkg/logger"
+	"github.com/open-feature/flagd/core/pkg/sync"
+	synctesting "github.com/open-feature/flagd/core/pkg/sync/testing"
+	"go.uber.org/mock/gomock"
+)
+
+func TestBlobSync(t *testing.T) {
+	tests := map[string]struct {
+		scheme           string
+		bucket           string
+		object           string
+		content          string
+		convertedContent string
+	}{
+		"json file type": {
+			scheme:           "xyz",
+			bucket:           "b",
+			object:           "flags.json",
+			content:          "{\"flags\":{}}",
+			convertedContent: "{\"flags\":{}}",
+		},
+		"yaml file type": {
+			scheme:           "xyz",
+			bucket:           "b",
+			object:           "flags.yaml",
+			content:          "flags: []",
+			convertedContent: "{\"flags\":[]}",
+		},
+	}
+
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			ctrl := gomock.NewController(t)
+			mockCron := synctesting.NewMockCron(ctrl)
+			mockCron.EXPECT().AddFunc(gomock.Any(), gomock.Any()).DoAndReturn(func(spec string, cmd func()) error {
+				return nil
+			})
+			mockCron.EXPECT().Start().Times(1)
+
+			blobSync := &Sync{
+				Bucket: tt.scheme + "://" + tt.bucket,
+				Object: tt.object,
+				Cron:   mockCron,
+				Logger: logger.NewLogger(nil, false),
+			}
+			blobMock := NewMockBlob(tt.scheme, func() *Sync {
+				return blobSync
+			})
+			blobSync.BlobURLMux = blobMock.URLMux()
+
+			ctx := context.Background()
+			dataSyncChan := make(chan sync.DataSync, 1)
+
+			blobMock.AddObject(tt.object, tt.content)
+
+			go func() {
+				err := blobSync.Sync(ctx, dataSyncChan)
+				if err != nil {
+					log.Fatalf("Error start sync: %s", err.Error())
+					return
+				}
+			}()
+
+			data := <-dataSyncChan // initial sync
+			if data.FlagData != tt.convertedContent {
+				t.Errorf("expected content: %s, but received content: %s", tt.convertedContent, data.FlagData)
+			}
+			tickWithConfigChange(t, mockCron, dataSyncChan, blobMock, tt.object, tt.convertedContent)
+			tickWithoutConfigChange(t, mockCron, dataSyncChan)
+			tickWithConfigChange(t, mockCron, dataSyncChan, blobMock, tt.object, tt.convertedContent)
+			tickWithoutConfigChange(t, mockCron, dataSyncChan)
+			tickWithoutConfigChange(t, mockCron, dataSyncChan)
+		})
+	}
+}
+
+func tickWithConfigChange(t *testing.T, mockCron *synctesting.MockCron, dataSyncChan chan sync.DataSync, blobMock *MockBlob, object string, newConfig string) {
+	time.Sleep(1 * time.Millisecond) // sleep so the new file has different modification date
+	blobMock.AddObject(object, newConfig)
+	mockCron.Tick()
+	select {
+	case data, ok := <-dataSyncChan:
+		if ok {
+			if data.FlagData != newConfig {
+				t.Errorf("expected content: %s, but received content: %s", newConfig, data.FlagData)
+			}
+		} else {
+			t.Errorf("data channel unexpectedly closed")
+		}
+	default:
+		t.Errorf("data channel has no expected update")
+	}
+}
+
+func tickWithoutConfigChange(t *testing.T, mockCron *synctesting.MockCron, dataSyncChan chan sync.DataSync) {
+	mockCron.Tick()
+	select {
+	case data, ok := <-dataSyncChan:
+		if ok {
+			t.Errorf("unexpected update: %s", data.FlagData)
+		} else {
+			t.Errorf("data channel unexpectedly closed")
+		}
+	default:
+	}
+}
+
+func TestReSync(t *testing.T) {
+	const (
+		scheme = "xyz"
+		bucket = "b"
+		object = "flags.json"
+	)
+	ctrl := gomock.NewController(t)
+	mockCron := synctesting.NewMockCron(ctrl)
+
+	blobSync := &Sync{
+		Bucket: scheme + "://" + bucket,
+		Object: object,
+		Cron:   mockCron,
+		Logger: logger.NewLogger(nil, false),
+	}
+	blobMock := NewMockBlob(scheme, func() *Sync {
+		return blobSync
+	})
+	blobSync.BlobURLMux = blobMock.URLMux()
+
+	ctx := context.Background()
+	dataSyncChan := make(chan sync.DataSync, 1)
+
+	config := "my-config"
+	blobMock.AddObject(object, config)
+
+	err := blobSync.ReSync(ctx, dataSyncChan)
+	if err != nil {
+		log.Fatalf("Error start sync: %s", err.Error())
+		return
+	}
+
+	data := <-dataSyncChan
+	if data.FlagData != config {
+		t.Errorf("expected content: %s, but received content: %s", config, data.FlagData)
+	}
+}

core/pkg/sync/blob/mock_blob.go

@@ -0,0 +1,72 @@
+package blob
+
+import (
+	"context"
+	"log"
+	"net/url"
+
+	"gocloud.dev/blob"
+	"gocloud.dev/blob/memblob"
+)
+
+type MockBlob struct {
+	mux    *blob.URLMux
+	scheme string
+	opener *fakeOpener
+}
+
+type fakeOpener struct {
+	object      string
+	content     string
+	keepModTime bool
+	getSync     func() *Sync
+}
+
+func (f *fakeOpener) OpenBucketURL(ctx context.Context, _ *url.URL) (*blob.Bucket, error) {
+	bucketURL, err := url.Parse("mem://")
+	if err != nil {
+		log.Fatalf("couldn't parse url: %s: %v", "mem://", err)
+	}
+	opener := &memblob.URLOpener{}
+	bucket, err := opener.OpenBucketURL(ctx, bucketURL)
+	if err != nil {
+		log.Fatalf("couldn't open in memory bucket: %v", err)
+	}
+	if f.object != "" {
+		err = bucket.WriteAll(ctx, f.object, []byte(f.content), nil)
+		if err != nil {
+			log.Fatalf("couldn't write in memory file: %v", err)
+		}
+	}
+	if f.keepModTime && f.object != "" {
+		attrs, err := bucket.Attributes(ctx, f.object)
+		if err != nil {
+			log.Fatalf("couldn't get memory file attributes: %v", err)
+		}
+		f.getSync().lastUpdated = attrs.ModTime
+	} else {
+		f.keepModTime = true
+	}
+	return bucket, nil
+}
+
+func NewMockBlob(scheme string, getSync func() *Sync) *MockBlob {
+	mux := new(blob.URLMux)
+	opener := &fakeOpener{getSync: getSync}
+	mux.RegisterBucket(scheme, opener)
+	return &MockBlob{
+		mux:    mux,
+		scheme: scheme,
+		opener: opener,
+	}
+}
+
+func (mb *MockBlob) URLMux() *blob.URLMux {
+	return mb.mux
+}
+
+func (mb *MockBlob) AddObject(object, content string) {
+	mb.opener.object = object
+	mb.opener.content = content
+	mb.opener.keepModTime = false
+}

core/pkg/sync/builder/mock/syncbuilder.go

@@ -0,0 +1,110 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: pkg/sync/builder/syncbuilder.go
+//
+// Generated by this command:
+//
+//	mockgen -source=pkg/sync/builder/syncbuilder.go -destination=pkg/sync/builder/mock/syncbuilder.go -package=middlewaremocksyncbuildermock
+//
+
+// Package middlewaremocksyncbuildermock is a generated GoMock package.
+package middlewaremocksyncbuildermock
+
+import (
+	reflect "reflect"
+
+	logger "github.com/open-feature/flagd/core/pkg/logger"
+	sync "github.com/open-feature/flagd/core/pkg/sync"
+	gomock "go.uber.org/mock/gomock"
+	dynamic "k8s.io/client-go/dynamic"
+)
+
+// MockISyncBuilder is a mock of ISyncBuilder interface.
+type MockISyncBuilder struct {
+	ctrl     *gomock.Controller
+	recorder *MockISyncBuilderMockRecorder
+}
+
+// MockISyncBuilderMockRecorder is the mock recorder for MockISyncBuilder.
+type MockISyncBuilderMockRecorder struct {
+	mock *MockISyncBuilder
+}
+
+// NewMockISyncBuilder creates a new mock instance.
+func NewMockISyncBuilder(ctrl *gomock.Controller) *MockISyncBuilder {
+	mock := &MockISyncBuilder{ctrl: ctrl}
+	mock.recorder = &MockISyncBuilderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockISyncBuilder) EXPECT() *MockISyncBuilderMockRecorder {
+	return m.recorder
+}
+
+// SyncFromURI mocks base method.
+func (m *MockISyncBuilder) SyncFromURI(uri string, logger *logger.Logger) (sync.ISync, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SyncFromURI", uri, logger)
+	ret0, _ := ret[0].(sync.ISync)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SyncFromURI indicates an expected call of SyncFromURI.
+func (mr *MockISyncBuilderMockRecorder) SyncFromURI(uri, logger any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncFromURI", reflect.TypeOf((*MockISyncBuilder)(nil).SyncFromURI), uri, logger)
+}
+
+// SyncsFromConfig mocks base method.
+func (m *MockISyncBuilder) SyncsFromConfig(sourceConfig []sync.SourceConfig, logger *logger.Logger) ([]sync.ISync, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SyncsFromConfig", sourceConfig, logger)
+	ret0, _ := ret[0].([]sync.ISync)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SyncsFromConfig indicates an expected call of SyncsFromConfig.
+func (mr *MockISyncBuilderMockRecorder) SyncsFromConfig(sourceConfig, logger any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncsFromConfig", reflect.TypeOf((*MockISyncBuilder)(nil).SyncsFromConfig), sourceConfig, logger)
+}
+
+// MockIK8sClientBuilder is a mock of IK8sClientBuilder interface.
+type MockIK8sClientBuilder struct {
+	ctrl     *gomock.Controller
+	recorder *MockIK8sClientBuilderMockRecorder
+}
+
+// MockIK8sClientBuilderMockRecorder is the mock recorder for MockIK8sClientBuilder.
+type MockIK8sClientBuilderMockRecorder struct {
+	mock *MockIK8sClientBuilder
+}
+
+// NewMockIK8sClientBuilder creates a new mock instance.
+func NewMockIK8sClientBuilder(ctrl *gomock.Controller) *MockIK8sClientBuilder {
+	mock := &MockIK8sClientBuilder{ctrl: ctrl}
+	mock.recorder = &MockIK8sClientBuilderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockIK8sClientBuilder) EXPECT() *MockIK8sClientBuilderMockRecorder {
+	return m.recorder
+}
+
+// GetK8sClient mocks base method.
+func (m *MockIK8sClientBuilder) GetK8sClient() (dynamic.Interface, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetK8sClient")
+	ret0, _ := ret[0].(dynamic.Interface)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetK8sClient indicates an expected call of GetK8sClient.
+func (mr *MockIK8sClientBuilderMockRecorder) GetK8sClient() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetK8sClient", reflect.TypeOf((*MockIK8sClientBuilder)(nil).GetK8sClient))
+}

core/pkg/sync/builder/syncbuilder.go

@@ -0,0 +1,360 @@
+package builder
+
+import (
+	"fmt"
+	"net/http"
+	"os"
+	"regexp"
+	"time"
+
+	"github.com/open-feature/flagd/core/pkg/logger"
+	"github.com/open-feature/flagd/core/pkg/sync"
+	blobSync "github.com/open-feature/flagd/core/pkg/sync/blob"
+	"github.com/open-feature/flagd/core/pkg/sync/file"
+	"github.com/open-feature/flagd/core/pkg/sync/grpc"
+	"github.com/open-feature/flagd/core/pkg/sync/grpc/credentials"
+	httpSync "github.com/open-feature/flagd/core/pkg/sync/http"
+	"github.com/open-feature/flagd/core/pkg/sync/kubernetes"
+	"github.com/robfig/cron"
+	"go.uber.org/zap"
+	"gocloud.dev/blob"
+	"k8s.io/client-go/dynamic"
+	"k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/clientcmd"
+)
+
+const (
+	syncProviderFile       = "file"
+	syncProviderFsNotify   = "fsnotify"
+	syncProviderFileInfo   = "fileinfo"
+	syncProviderGrpc       = "grpc"
+	syncProviderKubernetes = "kubernetes"
+	syncProviderHTTP       = "http"
+	syncProviderGcs        = "gcs"
+	syncProviderAzblob     = "azblob"
+	syncProviderS3         = "s3"
+)
+
+var (
+	regCrd                *regexp.Regexp
+	regURL                *regexp.Regexp
+	regGRPC               *regexp.Regexp
+	regGRPCSecure         *regexp.Regexp
+	regGRPCCustomResolver *regexp.Regexp
+	regFile               *regexp.Regexp
+	regGcs                *regexp.Regexp
+	regAzblob             *regexp.Regexp
+	regS3                 *regexp.Regexp
+)
+
+func init() {
+	regCrd = regexp.MustCompile("^core.openfeature.dev/")
+	regURL = regexp.MustCompile("^https?://")
+	regGRPC = regexp.MustCompile("^" + grpc.Prefix)
+	regGRPCSecure = regexp.MustCompile("^" + grpc.PrefixSecure)
+	regGRPCCustomResolver = regexp.MustCompile("^" + grpc.SupportedScheme)
+	regFile = regexp.MustCompile("^file:")
+	regGcs = regexp.MustCompile("^gs://.+?/")
+	regAzblob = regexp.MustCompile("^azblob://.+?/")
+	regS3 = regexp.MustCompile("^s3://.+?/")
+}
+
+type ISyncBuilder interface {
+	SyncFromURI(uri string, logger *logger.Logger) (sync.ISync, error)
+	SyncsFromConfig(sourceConfig []sync.SourceConfig, logger *logger.Logger) ([]sync.ISync, error)
+}
+
+type SyncBuilder struct {
+	k8sClientBuilder IK8sClientBuilder
+}
+
+func NewSyncBuilder() *SyncBuilder {
+	return &SyncBuilder{
+		k8sClientBuilder: &KubernetesClientBuilder{},
+	}
+}
+
+func (sb *SyncBuilder) SyncFromURI(uri string, logger *logger.Logger) (sync.ISync, error) {
+	switch uriB := []byte(uri); {
+	// filepath may be used for debugging, not recommended in deployment
+	case regFile.Match(uriB):
+		return sb.newFile(uri, logger), nil
+	case regCrd.Match(uriB):
+		return sb.newK8s(uri, logger)
+	}
+	return nil, fmt.Errorf("unrecognized URI: %s", uri)
+}
+
+func (sb *SyncBuilder) SyncsFromConfig(sourceConfigs []sync.SourceConfig, logger *logger.Logger) ([]sync.ISync, error) {
+	syncImpls := make([]sync.ISync, len(sourceConfigs))
+	for i, syncProvider := range sourceConfigs {
+		syncImpl, err := sb.syncFromConfig(syncProvider, logger)
+		if err != nil {
+			return nil, fmt.Errorf("could not create sync provider: %w", err)
+		}
+		syncImpls[i] = syncImpl
+	}
+	return syncImpls, nil
+}
+
+func (sb *SyncBuilder) syncFromConfig(sourceConfig sync.SourceConfig, logger *logger.Logger) (sync.ISync, error) {
+	switch sourceConfig.Provider {
+	case syncProviderFile:
+		return sb.newFile(sourceConfig.URI, logger), nil
+	case syncProviderFsNotify:
+		logger.Debug(fmt.Sprintf("using fsnotify sync-provider for: %q", sourceConfig.URI))
+		return sb.newFsNotify(sourceConfig.URI, logger), nil
+	case syncProviderFileInfo:
+		logger.Debug(fmt.Sprintf("using fileinfo sync-provider for: %q", sourceConfig.URI))
+		return sb.newFileInfo(sourceConfig.URI, logger), nil
+	case syncProviderKubernetes:
+		logger.Debug(fmt.Sprintf("using kubernetes sync-provider for: %s", sourceConfig.URI))
+		return sb.newK8s(sourceConfig.URI, logger)
+	case syncProviderHTTP:
+		logger.Debug(fmt.Sprintf("using remote sync-provider for: %s", sourceConfig.URI))
+		return sb.newHTTP(sourceConfig, logger), nil
+	case syncProviderGrpc:
+		logger.Debug(fmt.Sprintf("using grpc sync-provider for: %s", sourceConfig.URI))
+		return sb.newGRPC(sourceConfig, logger), nil
+	case syncProviderGcs:
+		logger.Debug(fmt.Sprintf("using blob sync-provider with gcs driver for: %s", sourceConfig.URI))
+		return sb.newGcs(sourceConfig, logger), nil
+	case syncProviderAzblob:
+		logger.Debug(fmt.Sprintf("using blob sync-provider with azblob driver for: %s", sourceConfig.URI))
+		return sb.newAzblob(sourceConfig, logger)
+	case syncProviderS3:
+		logger.Debug(fmt.Sprintf("using blob sync-provider with s3 driver for: %s", sourceConfig.URI))
+		return sb.newS3(sourceConfig, logger), nil
+
+	default:
+		return nil, fmt.Errorf("invalid sync provider: %s, must be one of with "+
+			"'%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s' or '%s'",
+			sourceConfig.Provider, syncProviderFile, syncProviderFsNotify, syncProviderFileInfo,
+			syncProviderKubernetes, syncProviderHTTP, syncProviderGrpc, syncProviderGcs, syncProviderAzblob, syncProviderS3)
+	}
+}
+
+// newFile returns an fsinfo sync if we are in k8s or fileinfo if not
+func (sb *SyncBuilder) newFile(uri string, logger *logger.Logger) *file.Sync {
+	switch os.Getenv("KUBERNETES_SERVICE_HOST") {
+	case "":
+		// no k8s service host env; use fileinfo
+		return sb.newFileInfo(uri, logger)
+	default:
+		// default to fsnotify
+		return sb.newFsNotify(uri, logger)
+	}
+}
+
+// return a new file.Sync that uses fsnotify under the hood
+func (sb *SyncBuilder) newFsNotify(uri string, logger *logger.Logger) *file.Sync {
+	return file.NewFileSync(
+		regFile.ReplaceAllString(uri, ""),
+		file.FSNOTIFY,
+		logger.WithFields(
+			zap.String("component", "sync"),
+			zap.String("sync", syncProviderFsNotify),
+		),
+	)
+}
+
+// return a new file.Sync that uses os.Stat/fs.FileInfo under the hood
+func (sb *SyncBuilder) newFileInfo(uri string, logger *logger.Logger) *file.Sync {
+	return file.NewFileSync(
+		regFile.ReplaceAllString(uri, ""),
+		file.FILEINFO,
+		logger.WithFields(
+			zap.String("component", "sync"),
+			zap.String("sync", syncProviderFileInfo),
+		),
+	)
+}
+
+func (sb *SyncBuilder) newK8s(uri string, logger *logger.Logger) (*kubernetes.Sync, error) {
+	dynamicClient, err := sb.k8sClientBuilder.GetK8sClient()
+	if err != nil {
+		return nil, fmt.Errorf("error creating kubernetes clients: %w", err)
+	}
+
+	return kubernetes.NewK8sSync(
+		logger.WithFields(
+			zap.String("component", "sync"),
+			zap.String("sync", "kubernetes"),
+		),
+		regCrd.ReplaceAllString(uri, ""),
+		dynamicClient,
+	), nil
+}
+
+func (sb *SyncBuilder) newHTTP(config sync.SourceConfig, logger *logger.Logger) *httpSync.Sync {
+	// Default to 5 seconds
+	var interval uint32 = 5
+	if config.Interval != 0 {
+		interval = config.Interval
+	}
+
+	return &httpSync.Sync{
+		URI: config.URI,
+		Client: &http.Client{
+			Timeout: time.Second * 10,
+		},
+		Logger: logger.WithFields(
+			zap.String("component", "sync"),
+			zap.String("sync", "remote"),
+		),
+		BearerToken: config.BearerToken,
+		AuthHeader:  config.AuthHeader,
+		Interval:    interval,
+		Cron:        cron.New(),
+	}
+}
+
+func (sb *SyncBuilder) newGRPC(config sync.SourceConfig, logger *logger.Logger) *grpc.Sync {
+	return &grpc.Sync{
+		URI: config.URI,
+		Logger: logger.WithFields(
+			zap.String("component", "sync"),
+			zap.String("sync", "grpc"),
+		),
+		CredentialBuilder: &credentials.CredentialBuilder{},
+		CertPath:          config.CertPath,
+		ProviderID:        config.ProviderID,
+		Secure:            config.TLS,
+		Selector:          config.Selector,
+		MaxMsgSize:        config.MaxMsgSize,
+	}
+}
+
+func (sb *SyncBuilder) newGcs(config sync.SourceConfig, logger *logger.Logger) *blobSync.Sync {
+	// Extract bucket uri and object name from the full URI:
+	// gs://bucket/path/to/object results in gs://bucket/ as bucketUri and
+	// path/to/object as an object name.
+	bucketURI := regGcs.FindString(config.URI)
+	objectName := regGcs.ReplaceAllString(config.URI, "")
+
+	// Defaults to 5 seconds if interval is not set.
+	var interval uint32 = 5
+	if config.Interval != 0 {
+		interval = config.Interval
+	}
+
+	return &blobSync.Sync{
+		Bucket: bucketURI,
+		Object: objectName,
+
+		BlobURLMux: blob.DefaultURLMux(),
+
+		Logger: logger.WithFields(
+			zap.String("component", "sync"),
+			zap.String("sync", "gcs"),
+		),
+		Interval: interval,
+		Cron:     cron.New(),
+	}
+}
+
+func (sb *SyncBuilder) newAzblob(config sync.SourceConfig, logger *logger.Logger) (*blobSync.Sync, error) {
+	// Required to generate the azblob service URL
+	storageAccountName := os.Getenv("AZURE_STORAGE_ACCOUNT")
+	if storageAccountName == "" {
+		return nil, fmt.Errorf("environment variable AZURE_STORAGE_ACCOUNT not set or is blank")
+	}
+	if regexp.MustCompile(`\s`).MatchString(storageAccountName) {
+		return nil, fmt.Errorf("environment variable AZURE_STORAGE_ACCOUNT contains whitespace")
+	}
+
+	// Extract bucket uri and object name from the full URI:
+	// azblob://bucket/path/to/object results in azblob://bucket/ as bucketUri and
+	// path/to/object as an object name.
+	bucketURI := regAzblob.FindString(config.URI)
+	objectName := regAzblob.ReplaceAllString(config.URI, "")
+
+	// Defaults to 5 seconds if interval is not set.
+	var interval uint32 = 5
+	if config.Interval != 0 {
+		interval = config.Interval
+	}
+
+	return &blobSync.Sync{
+		Bucket: bucketURI,
+		Object: objectName,
+
+		BlobURLMux: blob.DefaultURLMux(),
+
+		Logger: logger.WithFields(
+			zap.String("component", "sync"),
+			zap.String("sync", "azblob"),
+		),
+		Interval: interval,
+		Cron:     cron.New(),
+	}, nil
+}
+
+func (sb *SyncBuilder) newS3(config sync.SourceConfig, logger *logger.Logger) *blobSync.Sync {
+	// Extract bucket uri and object name from the full URI:
+	// gs://bucket/path/to/object results in gs://bucket/ as bucketUri and
+	// path/to/object as an object name.
+	bucketURI := regS3.FindString(config.URI)
+	objectName := regS3.ReplaceAllString(config.URI, "")
+
+	// Defaults to 5 seconds if interval is not set.
+	var interval uint32 = 5
+	if config.Interval != 0 {
+		interval = config.Interval
+	}
+
+	return &blobSync.Sync{
+		Bucket: bucketURI,
+		Object: objectName,
+
+		BlobURLMux: blob.DefaultURLMux(),
+
+		Logger: logger.WithFields(
+			zap.String("component", "sync"),
+			zap.String("sync", "s3"),
+		),
+		Interval: interval,
+		Cron:     cron.New(),
+	}
+}
+
+type IK8sClientBuilder interface {
+	GetK8sClient() (dynamic.Interface, error)
+}
+
+type KubernetesClientBuilder struct{}
+
+func (kcb KubernetesClientBuilder) GetK8sClient() (dynamic.Interface, error) {
+	clusterConfig, err := k8sClusterConfig()
+	if err != nil {
+		return nil, err
+	}
+
+	dynamicClient, err := dynamic.NewForConfig(clusterConfig)
+	if err != nil {
+		return nil, fmt.Errorf("unable to create dynamicClient: %w", err)
+	}
+	return dynamicClient, nil
+}
+
+// k8sClusterConfig build K8s connection config based available configurations
+func k8sClusterConfig() (*rest.Config, error) {
+	cfg := os.Getenv("KUBECONFIG")
+
+	var clusterConfig *rest.Config
+	var err error
+
+	if cfg != "" {
+		clusterConfig, err = clientcmd.BuildConfigFromFlags("", cfg)
+		if err != nil {
+			return nil, fmt.Errorf("error building cluster config from flags: %w", err)
+		}
+	} else {
+		clusterConfig, err = rest.InClusterConfig()
+		if err != nil {
+			return nil, fmt.Errorf("error fetching cluster config: %w", err)
+		}
+	}
+
+	return clusterConfig, nil
+}

core/pkg/sync/builder/syncbuilder_test.go

@@ -0,0 +1,479 @@
+package builder
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/open-feature/flagd/core/pkg/logger"
+	"github.com/open-feature/flagd/core/pkg/sync"
+	"github.com/open-feature/flagd/core/pkg/sync/blob"
+	buildermock "github.com/open-feature/flagd/core/pkg/sync/builder/mock"
+	"github.com/open-feature/flagd/core/pkg/sync/file"
+	"github.com/open-feature/flagd/core/pkg/sync/grpc"
+	"github.com/open-feature/flagd/core/pkg/sync/http"
+	"github.com/open-feature/flagd/core/pkg/sync/kubernetes"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
+)
+
+func TestSyncBuilder_SyncFromURI(t *testing.T) {
+	type args struct {
+		uri    string
+		logger *logger.Logger
+	}
+	tests := []struct {
+		name       string
+		args       args
+		injectFunc func(builder *SyncBuilder)
+		want       sync.ISync
+		wantErr    bool
+	}{
+		{
+			name: "kubernetes sync",
+			args: args{
+				uri:    "core.openfeature.dev/ff-config",
+				logger: logger.NewLogger(nil, false),
+			},
+			injectFunc: func(builder *SyncBuilder) {
+				ctrl := gomock.NewController(t)
+
+				mockClientBuilder := buildermock.NewMockIK8sClientBuilder(ctrl)
+				mockClientBuilder.EXPECT().GetK8sClient().Times(1).Return(nil, nil)
+
+				builder.k8sClientBuilder = mockClientBuilder
+			},
+			want:    &kubernetes.Sync{},
+			wantErr: false,
+		},
+		{
+			name: "kubernetes sync - error when retrieving config",
+			args: args{
+				uri:    "core.openfeature.dev/ff-config",
+				logger: logger.NewLogger(nil, false),
+			},
+			injectFunc: func(builder *SyncBuilder) {
+				ctrl := gomock.NewController(t)
+
+				mockClientBuilder := buildermock.NewMockIK8sClientBuilder(ctrl)
+				mockClientBuilder.EXPECT().GetK8sClient().Times(1).Return(nil, errors.New("oops"))
+
+				builder.k8sClientBuilder = mockClientBuilder
+			},
+			want:    nil,
+			wantErr: true,
+		},
+		{
+			name: "file sync",
+			args: args{
+				uri:    "file:my-file",
+				logger: logger.NewLogger(nil, false),
+			},
+			want:    &file.Sync{},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sb := NewSyncBuilder()
+
+			if tt.injectFunc != nil {
+				tt.injectFunc(sb)
+			}
+
+			got, err := sb.SyncFromURI(tt.args.uri, tt.args.logger)
+			if tt.wantErr {
+				require.NotNil(t, err)
+				require.Nil(t, got)
+			} else {
+				require.Nil(t, err)
+				require.IsType(t, tt.want, got)
+			}
+		})
+	}
+}
+
+func Test_k8sClusterConfig(t *testing.T) {
+	t.Run("Cannot find KUBECONFIG file", func(tt *testing.T) {
+		tt.Setenv("KUBECONFIG", "")
+		_, err := k8sClusterConfig()
+		if err == nil {
+			tt.Error("Expected error but got none")
+		}
+	})
+	t.Run("KUBECONFIG file not existing", func(tt *testing.T) {
+		tt.Setenv("KUBECONFIG", "value")
+		_, err := k8sClusterConfig()
+		if err == nil {
+			tt.Error("Expected error but got none")
+		}
+	})
+	t.Run("Default REST Config and missing svc account", func(tt *testing.T) {
+		tt.Setenv("KUBERNETES_SERVICE_HOST", "127.0.0.1")
+		tt.Setenv("KUBERNETES_SERVICE_PORT", "8080")
+		_, err := k8sClusterConfig()
+		if err == nil {
+			tt.Error("Expected error but got none")
+		}
+	})
+}
+
+func Test_SyncsFromFromConfig(t *testing.T) {
+	lg := logger.NewLogger(nil, false)
+
+	type args struct {
+		logger  *logger.Logger
+		sources []sync.SourceConfig
+	}
+
+	tests := []struct {
+		name       string
+		args       args
+		injectFunc func(builder *SyncBuilder)
+		wantSyncs  []sync.ISync
+		wantErr    bool
+	}{
+		{
+			name: "Empty",
+			args: args{
+				logger:  lg,
+				sources: []sync.SourceConfig{},
+			},
+			wantSyncs: nil,
+			wantErr:   false,
+		},
+		{
+			name: "Error",
+			args: args{
+				logger: lg,
+				sources: []sync.SourceConfig{
+					{
+						URI:      "fake",
+						Provider: "disk",
+					},
+				},
+			},
+			wantSyncs: nil,
+			wantErr:   true,
+		},
+		{
+			name: "single",
+			args: args{
+				logger: lg,
+				sources: []sync.SourceConfig{
+					{
+						URI:        "grpc://host:port",
+						Provider:   syncProviderGrpc,
+						ProviderID: "myapp",
+						CertPath:   "/tmp/ca.cert",
+						Selector:   "source=database",
+					},
+				},
+			},
+			wantSyncs: []sync.ISync{
+				&grpc.Sync{},
+			},
+			wantErr: false,
+		},
+		{
+			name: "grpc-with-msg-size",
+			args: args{
+				logger: lg,
+				sources: []sync.SourceConfig{
+					{
+						URI:        "grpc://host:port",
+						Provider:   syncProviderGrpc,
+						ProviderID: "myapp",
+						CertPath:   "/tmp/ca.cert",
+						Selector:   "source=database",
+						MaxMsgSize: 10,
+					},
+				},
+			},
+			wantSyncs: []sync.ISync{
+				&grpc.Sync{},
+			},
+			wantErr: false,
+		},
+		{
+			name: "combined",
+			injectFunc: func(builder *SyncBuilder) {
+				t.Setenv("AZURE_STORAGE_ACCOUNT", "myaccount")
+
+				ctrl := gomock.NewController(t)
+
+				mockClientBuilder := buildermock.NewMockIK8sClientBuilder(ctrl)
+				mockClientBuilder.EXPECT().GetK8sClient().Times(1).Return(nil, nil)
+
+				builder.k8sClientBuilder = mockClientBuilder
+			},
+			args: args{
+				logger: lg,
+				sources: []sync.SourceConfig{
+					{
+						URI:        "grpc://host:port",
+						Provider:   syncProviderGrpc,
+						ProviderID: "myapp",
+						CertPath:   "/tmp/ca.cert",
+						Selector:   "source=database",
+					},
+					{
+						URI:         "https://host:port",
+						Provider:    syncProviderHTTP,
+						BearerToken: "token",
+					},
+					{
+						URI:        "https://host:port",
+						Provider:   syncProviderHTTP,
+						AuthHeader: "scheme credentials/token",
+					},
+					{
+						URI:      "/tmp/flags.json",
+						Provider: syncProviderFile,
+					},
+					{
+						URI:      "my-namespace/my-flags",
+						Provider: syncProviderKubernetes,
+					},
+					{
+						URI:      "gs://bucket/path/to/file",
+						Provider: syncProviderGcs,
+					},
+					{
+						URI:      "azblob://bucket/path/to/file",
+						Provider: syncProviderAzblob,
+					},
+					{
+						URI:      "s3://bucket/path/to/file",
+						Provider: syncProviderS3,
+					},
+				},
+			},
+			wantSyncs: []sync.ISync{
+				&grpc.Sync{},
+				&http.Sync{},
+				&http.Sync{},
+				&file.Sync{},
+				&kubernetes.Sync{},
+				&blob.Sync{},
+				&blob.Sync{},
+				&blob.Sync{},
+			},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sb := NewSyncBuilder()
+
+			if tt.injectFunc != nil {
+				tt.injectFunc(sb)
+			}
+			syncs, err := sb.SyncsFromConfig(tt.args.sources, tt.args.logger)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("syncProvidersFromConfig() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			require.Len(t, syncs, len(tt.wantSyncs))
+
+			// check if we got the expected sync types
+			for index, wantType := range tt.wantSyncs {
+				require.IsType(t, wantType, syncs[index])
+			}
+		})
+	}
+}
+
+func Test_GcsConfig(t *testing.T) {
+	lg := logger.NewLogger(nil, false)
+	defaultInterval := uint32(5)
+	tests := []struct {
+		name             string
+		uri              string
+		interval         uint32
+		expectedBucket   string
+		expectedObject   string
+		expectedInterval uint32
+	}{
+		{
+			name:             "simple path",
+			uri:              "gs://bucket/path/to/object",
+			interval:         10,
+			expectedBucket:   "gs://bucket/",
+			expectedObject:   "path/to/object",
+			expectedInterval: 10,
+		},
+		{
+			name:             "default interval",
+			uri:              "gs://bucket/path/to/object",
+			expectedBucket:   "gs://bucket/",
+			expectedObject:   "path/to/object",
+			expectedInterval: defaultInterval,
+		},
+		{
+			name:             "no object set", // Blob syncer will return error when fetching
+			uri:              "gs://bucket/",
+			expectedBucket:   "gs://bucket/",
+			expectedObject:   "",
+			expectedInterval: defaultInterval,
+		},
+		{
+			name:             "malformed uri", // Blob syncer will return error when opening bucket
+			uri:              "malformed",
+			expectedBucket:   "",
+			expectedObject:   "malformed",
+			expectedInterval: defaultInterval,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gcsSync := NewSyncBuilder().newGcs(sync.SourceConfig{
+				URI:      tt.uri,
+				Interval: tt.interval,
+			}, lg)
+			require.Equal(t, tt.expectedBucket, gcsSync.Bucket)
+			require.Equal(t, tt.expectedObject, gcsSync.Object)
+			require.Equal(t, int(tt.expectedInterval), int(gcsSync.Interval))
+		})
+	}
+}
+
+func Test_AzblobConfig(t *testing.T) {
+	lg := logger.NewLogger(nil, false)
+	defaultInterval := uint32(5)
+	tests := []struct {
+		name             string
+		uri              string
+		interval         uint32
+		storageAccount   string
+		expectedBucket   string
+		expectedObject   string
+		expectedInterval uint32
+		wantErr          bool
+	}{
+		{
+			name:             "simple path",
+			uri:              "azblob://bucket/path/to/object",
+			interval:         10,
+			storageAccount:   "myaccount",
+			expectedBucket:   "azblob://bucket/",
+			expectedObject:   "path/to/object",
+			expectedInterval: 10,
+			wantErr:          false,
+		},
+		{
+			name:             "default interval",
+			uri:              "azblob://bucket/path/to/object",
+			storageAccount:   "myaccount",
+			expectedBucket:   "azblob://bucket/",
+			expectedObject:   "path/to/object",
+			expectedInterval: defaultInterval,
+			wantErr:          false,
+		},
+		{
+			name:             "no object set", // Blob syncer will return error when fetching
+			uri:              "azblob://bucket/",
+			storageAccount:   "myaccount",
+			expectedBucket:   "azblob://bucket/",
+			expectedObject:   "",
+			expectedInterval: defaultInterval,
+			wantErr:          false,
+		},
+		{
+			name:             "malformed uri", // Blob syncer will return error when opening bucket
+			uri:              "malformed",
+			storageAccount:   "myaccount",
+			expectedBucket:   "",
+			expectedObject:   "malformed",
+			expectedInterval: defaultInterval,
+			wantErr:          false,
+		},
+		{
+			name:           "storage account not set", // Sync builder will fail and return error
+			uri:            "azblob://bucket/path/to/object",
+			storageAccount: "",
+			wantErr:        true,
+		},
+		{
+			name:           "storage account contains whitespace", // Sync builder will fail and return error
+			uri:            "azblob://bucket/path/to/object",
+			storageAccount: "my account",
+			wantErr:        true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Setenv("AZURE_STORAGE_ACCOUNT", tt.storageAccount)
+			azblobSync, err := NewSyncBuilder().newAzblob(sync.SourceConfig{
+				URI:      tt.uri,
+				Interval: tt.interval,
+			}, lg)
+
+			if (err != nil) != tt.wantErr {
+				t.Errorf("newAzblob() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+
+			if (err != nil) && (tt.wantErr == true) {
+				return
+			}
+
+			require.Equal(t, tt.expectedBucket, azblobSync.Bucket)
+			require.Equal(t, tt.expectedObject, azblobSync.Object)
+			require.Equal(t, int(tt.expectedInterval), int(azblobSync.Interval))
+		})
+	}
+}
+
+func Test_S3Config(t *testing.T) {
+	lg := logger.NewLogger(nil, false)
+	defaultInterval := uint32(5)
+	tests := []struct {
+		name             string
+		uri              string
+		interval         uint32
+		expectedBucket   string
+		expectedObject   string
+		expectedInterval uint32
+	}{
+		{
+			name:             "simple path",
+			uri:              "s3://bucket/path/to/object",
+			interval:         10,
+			expectedBucket:   "s3://bucket/",
+			expectedObject:   "path/to/object",
+			expectedInterval: 10,
+		},
+		{
+			name:             "default interval",
+			uri:              "s3://bucket/path/to/object",
+			expectedBucket:   "s3://bucket/",
+			expectedObject:   "path/to/object",
+			expectedInterval: defaultInterval,
+		},
+		{
+			name:             "no object set", // Blob syncer will return error when fetching
+			uri:              "s3://bucket/",
+			expectedBucket:   "s3://bucket/",
+			expectedObject:   "",
+			expectedInterval: defaultInterval,
+		},
+		{
+			name:             "malformed uri", // Blob syncer will return error when opening bucket
+			uri:              "malformed",
+			expectedBucket:   "",
+			expectedObject:   "malformed",
+			expectedInterval: defaultInterval,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s3Sync := NewSyncBuilder().newS3(sync.SourceConfig{
+				URI:      tt.uri,
+				Interval: tt.interval,
+			}, lg)
+			require.Equal(t, tt.expectedBucket, s3Sync.Bucket)
+			require.Equal(t, tt.expectedObject, s3Sync.Object)
+			require.Equal(t, int(tt.expectedInterval), int(s3Sync.Interval))
+		})
+	}
+}

core/pkg/sync/builder/utils.go

@@ -0,0 +1,93 @@
+package builder
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"github.com/open-feature/flagd/core/pkg/sync"
+)
+
+// ParseSources parse a json formatted SourceConfig array string and performs validations on the content
+func ParseSources(sourcesFlag string) ([]sync.SourceConfig, error) {
+	syncProvidersParsed := []sync.SourceConfig{}
+
+	if err := json.Unmarshal([]byte(sourcesFlag), &syncProvidersParsed); err != nil {
+		return syncProvidersParsed, fmt.Errorf("error parsing sync providers: %w", err)
+	}
+	for _, sp := range syncProvidersParsed {
+		if sp.URI == "" {
+			return syncProvidersParsed, errors.New("sync provider argument parse: uri is a required field")
+		}
+		if sp.Provider == "" {
+			return syncProvidersParsed, errors.New("sync provider argument parse: provider is a required field")
+		}
+		if sp.AuthHeader != "" && sp.BearerToken != "" {
+			return syncProvidersParsed, errors.New(
+				"sync provider argument parse: both authHeader and bearerToken are defined, only one is allowed at a time",
+			)
+		}
+	}
+	return syncProvidersParsed, nil
+}
+
+// ParseSyncProviderURIs uri flag based sync sources to SourceConfig array. Replaces uri prefixes where necessary to
+// derive SourceConfig
+func ParseSyncProviderURIs(uris []string) ([]sync.SourceConfig, error) {
+	syncProvidersParsed := []sync.SourceConfig{}
+
+	for _, uri := range uris {
+		switch uriB := []byte(uri); {
+		case regFile.Match(uriB):
+			syncProvidersParsed = append(syncProvidersParsed, sync.SourceConfig{
+				URI:      regFile.ReplaceAllString(uri, ""),
+				Provider: syncProviderFile,
+			})
+		case regCrd.Match(uriB):
+			syncProvidersParsed = append(syncProvidersParsed, sync.SourceConfig{
+				URI:      regCrd.ReplaceAllString(uri, ""),
+				Provider: syncProviderKubernetes,
+			})
+		case regURL.Match(uriB):
+			syncProvidersParsed = append(syncProvidersParsed, sync.SourceConfig{
+				URI:      uri,
+				Provider: syncProviderHTTP,
+			})
+		case regGRPC.Match(uriB):
+			syncProvidersParsed = append(syncProvidersParsed, sync.SourceConfig{
+				URI:      regGRPC.ReplaceAllString(uri, ""),
+				Provider: syncProviderGrpc,
+			})
+		case regGRPCSecure.Match(uriB):
+			syncProvidersParsed = append(syncProvidersParsed, sync.SourceConfig{
+				URI:      regGRPCSecure.ReplaceAllString(uri, ""),
+				Provider: syncProviderGrpc,
+				TLS:      true,
+			})
+		case regGRPCCustomResolver.Match(uriB):
+			syncProvidersParsed = append(syncProvidersParsed, sync.SourceConfig{
+				URI:      uri,
+				Provider: syncProviderGrpc,
+			})
+		case regGcs.Match(uriB):
+			syncProvidersParsed = append(syncProvidersParsed, sync.SourceConfig{
+				URI:      uri,
+				Provider: syncProviderGcs,
+			})
+		case regAzblob.Match(uriB):
+			syncProvidersParsed = append(syncProvidersParsed, sync.SourceConfig{
+				URI:      uri,
+				Provider: syncProviderAzblob,
+			})
+		case regS3.Match(uriB):
+			syncProvidersParsed = append(syncProvidersParsed, sync.SourceConfig{
+				URI:      uri,
+				Provider: syncProviderS3,
+			})
+		default:
+			return syncProvidersParsed, fmt.Errorf("invalid sync uri argument: %s, must start with 'file:', "+
+				"'http(s)://', 'grpc(s)://', 'gs://', 'azblob://' or 'core.openfeature.dev'", uri)
+		}
+	}
+	return syncProvidersParsed, nil
+}

core/pkg/sync/builder/utils_test.go

@@ -1,24 +1,22 @@
-package runtime
+package builder
 
 import (
 	"reflect"
 	"testing"
 
-	"github.com/open-feature/flagd/core/pkg/logger"
-	"github.com/open-feature/flagd/core/pkg/store"
-	"github.com/stretchr/testify/require"
+	"github.com/open-feature/flagd/core/pkg/sync"
 )
 
 func TestParseSource(t *testing.T) {
 	test := map[string]struct {
 		in        string
 		expectErr bool
-		out       []SourceConfig
+		out       []sync.SourceConfig
 	}{
 		"simple": {
 			in:        "[{\"uri\":\"config/samples/example_flags.json\",\"provider\":\"file\"}]",
 			expectErr: false,
-			out: []SourceConfig{
+			out: []sync.SourceConfig{
 				{
 					URI:      "config/samples/example_flags.json",
 					Provider: syncProviderFile,
@@ -30,10 +28,13 @@ func TestParseSource(t *testing.T) {
 					{"uri":"config/samples/example_flags.json","provider":"file"},
 					{"uri":"http://test.com","provider":"http","bearerToken":":)"},
 					{"uri":"host:port","provider":"grpc"},
-					{"uri":"default/my-crd","provider":"kubernetes"}
+					{"uri":"default/my-crd","provider":"kubernetes"},
+					{"uri":"gs://bucket-name/path/to/file","provider":"gcs"},
+					{"uri":"azblob://bucket-name/path/to/file","provider":"azblob"},
+					{"uri":"s3://bucket-name/path/to/file","provider":"s3"}
 				]`,
 			expectErr: false,
-			out: []SourceConfig{
+			out: []sync.SourceConfig{
 				{
 					URI:      "config/samples/example_flags.json",
 					Provider: syncProviderFile,
@@ -51,19 +52,34 @@ func TestParseSource(t *testing.T) {
 					URI:      "default/my-crd",
 					Provider: syncProviderKubernetes,
 				},
+				{
+					URI:      "gs://bucket-name/path/to/file",
+					Provider: syncProviderGcs,
+				},
+				{
+					URI:      "azblob://bucket-name/path/to/file",
+					Provider: syncProviderAzblob,
+				},
+				{
+					URI:      "s3://bucket-name/path/to/file",
+					Provider: syncProviderS3,
+				},
 			},
 		},
 		"multiple-syncs-with-options": {
-			in: `[{"uri":"config/samples/example_flags.json","provider":"file"},
-            		{"uri":"http://my-flag-source.json","provider":"http","bearerToken":"bearer-dji34ld2l"},
-            		{"uri":"https://secure-remote","provider":"http","bearerToken":"bearer-dji34ld2l"},
-            		{"uri":"http://site.com","provider":"http","interval":77 },
-					{"uri":"default/my-flag-config","provider":"kubernetes"},
-            		{"uri":"grpc-source:8080","provider":"grpc"},
-            		{"uri":"my-flag-source:8080","provider":"grpc", "tls":true, "certPath": "/certs/ca.cert", "providerID": "flagd-weatherapp-sidecar", "selector": "source=database,app=weatherapp"}]
-				`,
+			in: `[
+				{"uri":"config/samples/example_flags.json","provider":"file"},
+				{"uri":"http://my-flag-source.json","provider":"http","bearerToken":"bearer-dji34ld2l"},
+				{"uri":"https://secure-remote","provider":"http","bearerToken":"bearer-dji34ld2l"},
+				{"uri":"https://secure-remote","provider":"http","authHeader":"Bearer bearer-dji34ld2l"},
+				{"uri":"https://secure-remote","provider":"http","authHeader":"Basic dXNlcjpwYXNz"},
+				{"uri":"http://site.com","provider":"http","interval":77 },
+				{"uri":"default/my-flag-config","provider":"kubernetes"},
+				{"uri":"grpc-source:8080","provider":"grpc"},
+				{"uri":"my-flag-source:8080","provider":"grpc", "tls":true, "certPath": "/certs/ca.cert", "providerID": "flagd-weatherapp-sidecar", "selector": "source=database,app=weatherapp"}
+			]`,
 			expectErr: false,
-			out: []SourceConfig{
+			out: []sync.SourceConfig{
 				{
 					URI:      "config/samples/example_flags.json",
 					Provider: syncProviderFile,
@@ -78,6 +94,16 @@ func TestParseSource(t *testing.T) {
 					Provider:    syncProviderHTTP,
 					BearerToken: "bearer-dji34ld2l",
 				},
+				{
+					URI:        "https://secure-remote",
+					Provider:   syncProviderHTTP,
+					AuthHeader: "Bearer bearer-dji34ld2l",
+				},
+				{
+					URI:        "https://secure-remote",
+					Provider:   syncProviderHTTP,
+					AuthHeader: "Basic dXNlcjpwYXNz",
+				},
 				{
 					URI:      "http://site.com",
 					Provider: syncProviderHTTP,
@@ -101,15 +127,31 @@ func TestParseSource(t *testing.T) {
 				},
 			},
 		},
+		"multiple-auth-options": {
+			in: `[
+				{"uri":"https://secure-remote","provider":"http","authHeader":"Bearer bearer-dji34ld2l","bearerToken":"bearer-dji34ld2l"}
+			]`,
+			expectErr: true,
+			out: []sync.SourceConfig{
+				{
+					URI:         "https://secure-remote",
+					Provider:    syncProviderHTTP,
+					AuthHeader:  "Bearer bearer-dji34ld2l",
+					BearerToken: "bearer-dji34ld2l",
+					TLS:         false,
+					Interval:    0,
+				},
+			},
+		},
 		"empty": {
 			in:        `[]`,
 			expectErr: false,
-			out:       []SourceConfig{},
+			out:       []sync.SourceConfig{},
 		},
 		"parse-failure": {
 			in:        ``,
 			expectErr: true,
-			out:       []SourceConfig{},
+			out:       []sync.SourceConfig{},
 		},
 	}
 
@@ -134,14 +176,14 @@ func TestParseSyncProviderURIs(t *testing.T) {
 	test := map[string]struct {
 		in        []string
 		expectErr bool
-		out       []SourceConfig
+		out       []sync.SourceConfig
 	}{
 		"simple": {
 			in: []string{
 				"file:my-file.json",
 			},
 			expectErr: false,
-			out: []SourceConfig{
+			out: []sync.SourceConfig{
 				{
 					URI:      "my-file.json",
 					Provider: "file",
@@ -155,9 +197,12 @@ func TestParseSyncProviderURIs(t *testing.T) {
 				"grpc://host:port",
 				"grpcs://secure-grpc",
 				"core.openfeature.dev/default/my-crd",
+				"gs://bucket-name/path/to/file",
+				"azblob://bucket-name/path/to/file",
+				"s3://bucket-name/path/to/file",
 			},
 			expectErr: false,
-			out: []SourceConfig{
+			out: []sync.SourceConfig{
 				{
 					URI:      "my-file.json",
 					Provider: "file",
@@ -180,17 +225,29 @@ func TestParseSyncProviderURIs(t *testing.T) {
 					URI:      "default/my-crd",
 					Provider: "kubernetes",
 				},
+				{
+					URI:      "gs://bucket-name/path/to/file",
+					Provider: syncProviderGcs,
+				},
+				{
+					URI:      "azblob://bucket-name/path/to/file",
+					Provider: syncProviderAzblob,
+				},
+				{
+					URI:      "s3://bucket-name/path/to/file",
+					Provider: syncProviderS3,
+				},
 			},
 		},
 		"empty": {
 			in:        []string{},
 			expectErr: false,
-			out:       []SourceConfig{},
+			out:       []sync.SourceConfig{},
 		},
 		"parse-failure": {
 			in:        []string{"care.openfeature.dev/will/fail"},
 			expectErr: true,
-			out:       []SourceConfig{},
+			out:       []sync.SourceConfig{},
 		},
 	}
 
@@ -210,106 +267,3 @@ func TestParseSyncProviderURIs(t *testing.T) {
 		})
 	}
 }
-
-// Note - K8s configuration require K8s client, hence do not use K8s sync provider in this test
-func Test_syncProvidersFromConfig(t *testing.T) {
-	lg := logger.NewLogger(nil, false)
-
-	type args struct {
-		logger  *logger.Logger
-		sources []SourceConfig
-	}
-
-	tests := []struct {
-		name      string
-		args      args
-		wantSyncs int // simply check the count of ISync providers yield from configurations
-		wantErr   bool
-	}{
-		{
-			name: "Empty",
-			args: args{
-				logger:  lg,
-				sources: []SourceConfig{},
-			},
-			wantSyncs: 0,
-			wantErr:   false,
-		},
-		{
-			name: "Error",
-			args: args{
-				logger: lg,
-				sources: []SourceConfig{
-					{
-						URI:      "fake",
-						Provider: "disk",
-					},
-				},
-			},
-			wantSyncs: 0,
-			wantErr:   true,
-		},
-		{
-			name: "single",
-			args: args{
-				logger: lg,
-				sources: []SourceConfig{
-					{
-						URI:        "grpc://host:port",
-						Provider:   syncProviderGrpc,
-						ProviderID: "myapp",
-						CertPath:   "/tmp/ca.cert",
-						Selector:   "source=database",
-					},
-				},
-			},
-			wantSyncs: 1,
-			wantErr:   false,
-		},
-		{
-			name: "combined",
-			args: args{
-				logger: lg,
-				sources: []SourceConfig{
-					{
-						URI:        "grpc://host:port",
-						Provider:   syncProviderGrpc,
-						ProviderID: "myapp",
-						CertPath:   "/tmp/ca.cert",
-						Selector:   "source=database",
-					},
-					{
-						URI:         "https://host:port",
-						Provider:    syncProviderHTTP,
-						BearerToken: "token",
-					},
-					{
-						URI:      "/tmp/flags.json",
-						Provider: syncProviderFile,
-					},
-				},
-			},
-			wantSyncs: 3,
-			wantErr:   false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			syncs, err := syncProvidersFromConfig(tt.args.logger, tt.args.sources)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("syncProvidersFromConfig() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if tt.wantSyncs != len(syncs) {
-				t.Errorf("syncProvidersFromConfig() yielded = %v, but expected %v", len(syncs), tt.wantSyncs)
-			}
-		})
-	}
-}
-
-func Test_setupJSONEvaluator(t *testing.T) {
-	lg := logger.NewLogger(nil, false)
-
-	je := setupJSONEvaluator(lg, store.NewFlags())
-	require.NotNil(t, je)
-}

core/pkg/sync/file/fileinfo_watcher.go

@@ -0,0 +1,202 @@
+package file
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io/fs"
+	"os"
+	"sync"
+	"time"
+
+	"github.com/fsnotify/fsnotify"
+	"github.com/open-feature/flagd/core/pkg/logger"
+)
+
+// Implements file.Watcher using a timer and os.FileInfo
+type fileInfoWatcher struct {
+	// Event Chan
+	evChan chan fsnotify.Event
+	// Errors Chan
+	erChan chan error
+	// logger
+	logger *logger.Logger
+	// Func to wrap os.Stat (injection point for test helpers)
+	statFunc func(string) (fs.FileInfo, error)
+	// thread-safe interface to underlying files we are watching
+	mu      sync.RWMutex
+	watches map[string]fs.FileInfo // filename -> info
+}
+
+// NewFsNotifyWatcher returns a new fsNotifyWatcher
+func NewFileInfoWatcher(ctx context.Context, logger *logger.Logger) Watcher {
+	fiw := &fileInfoWatcher{
+		evChan:   make(chan fsnotify.Event, 32),
+		erChan:   make(chan error, 32),
+		statFunc: getFileInfo,
+		logger:   logger,
+		watches:  make(map[string]fs.FileInfo),
+	}
+	fiw.run(ctx, (1 * time.Second))
+	return fiw
+}
+
+// fileInfoWatcher explicitly implements file.Watcher
+var _ Watcher = &fileInfoWatcher{}
+
+// Close calls close on the underlying fsnotify.Watcher
+func (f *fileInfoWatcher) Close() error {
+	// close all channels and exit
+	close(f.evChan)
+	close(f.erChan)
+	return nil
+}
+
+// Add calls Add on the underlying fsnotify.Watcher
+func (f *fileInfoWatcher) Add(name string) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+
+	// exit early if name already exists
+	if _, ok := f.watches[name]; ok {
+		return nil
+	}
+
+	info, err := f.statFunc(name)
+	if err != nil {
+		return err
+	}
+
+	f.watches[name] = info
+
+	return nil
+}
+
+// Remove calls Remove on the underlying fsnotify.Watcher
+func (f *fileInfoWatcher) Remove(name string) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+
+	// no need to exit early, deleting non-existent key is a no-op
+	delete(f.watches, name)
+
+	return nil
+}
+
+// Watchlist calls watchlist on the underlying fsnotify.Watcher
+func (f *fileInfoWatcher) WatchList() []string {
+	f.mu.RLock()
+	defer f.mu.RUnlock()
+	out := []string{}
+	for name := range f.watches {
+		n := name
+		out = append(out, n)
+	}
+	return out
+}
+
+// Events returns the underlying watcher's Events chan
+func (f *fileInfoWatcher) Events() chan fsnotify.Event {
+	return f.evChan
+}
+
+// Errors returns the underlying watcher's Errors chan
+func (f *fileInfoWatcher) Errors() chan error {
+	return f.erChan
+}
+
+// run is a blocking function that starts the filewatcher's timer thread
+func (f *fileInfoWatcher) run(ctx context.Context, s time.Duration) {
+	// timer thread
+	go func() {
+		// execute update on the configured interval of time
+		ticker := time.NewTicker(s)
+		defer ticker.Stop()
+
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-ticker.C:
+				if err := f.update(); err != nil {
+					f.erChan <- err
+					return
+				}
+			}
+		}
+	}()
+}
+
+func (f *fileInfoWatcher) update() error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+
+	for path, info := range f.watches {
+		newInfo, err := f.statFunc(path)
+		if err != nil {
+			// if the file isn't there, it must have been removed
+			// fire off a remove event and remove it from the watches
+			if errors.Is(err, os.ErrNotExist) {
+				f.evChan <- fsnotify.Event{
+					Name: path,
+					Op:   fsnotify.Remove,
+				}
+				delete(f.watches, path)
+				continue
+			}
+			return err
+		}
+
+		// if the new stat doesn't match the old stat, figure out what changed
+		if info != newInfo {
+			event := f.generateEvent(path, newInfo)
+			if event != nil {
+				f.evChan <- *event
+			}
+			f.watches[path] = newInfo
+		}
+	}
+	return nil
+}
+
+// generateEvent figures out what changed and generates an fsnotify.Event for it. (if we care)
+// file removal are handled above in the update() method
+func (f *fileInfoWatcher) generateEvent(path string, newInfo fs.FileInfo) *fsnotify.Event {
+	info := f.watches[path]
+	switch {
+	// new mod time is more recent than old mod time, generate a write event
+	case newInfo.ModTime().After(info.ModTime()):
+		return &fsnotify.Event{
+			Name: path,
+			Op:   fsnotify.Write,
+		}
+		// the file modes changed, generate a chmod event
+	case info.Mode() != newInfo.Mode():
+		return &fsnotify.Event{
+			Name: path,
+			Op:   fsnotify.Chmod,
+		}
+	// nothing changed that we care about
+	default:
+		return nil
+	}
+}
+
+// getFileInfo returns the fs.FileInfo for the given path
+func getFileInfo(path string) (fs.FileInfo, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, fmt.Errorf("error from os.Open(%s): %w", path, err)
+	}
+
+	info, err := f.Stat()
+	if err != nil {
+		return info, fmt.Errorf("error from fs.Stat(%s): %w", path, err)
+	}
+
+	if err := f.Close(); err != nil {
+		return info, fmt.Errorf("err from fs.Close(%s): %w", path, err)
+	}
+
+	return info, nil
+}

core/pkg/sync/file/fileinfo_watcher_test.go

@@ -0,0 +1,248 @@
+package file
+
+import (
+	"errors"
+	"fmt"
+	"io/fs"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/fsnotify/fsnotify"
+	"github.com/google/go-cmp/cmp"
+)
+
+func Test_fileInfoWatcher_Close(t *testing.T) {
+	tests := []struct {
+		name    string
+		watcher *fileInfoWatcher
+		wantErr bool
+	}{
+		{
+			name:    "all chans close",
+			watcher: makeTestWatcher(t, map[string]fs.FileInfo{}),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := tt.watcher.Close(); (err != nil) != tt.wantErr {
+				t.Errorf("fileInfoWatcher.Close() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if _, ok := (<-tt.watcher.Errors()); ok != false {
+				t.Error("fileInfoWatcher.Close() failed to close error chan")
+			}
+			if _, ok := (<-tt.watcher.Events()); ok != false {
+				t.Error("fileInfoWatcher.Close() failed to close events chan")
+			}
+		})
+	}
+}
+
+func Test_fileInfoWatcher_Add(t *testing.T) {
+	tests := []struct {
+		name    string
+		watcher *fileInfoWatcher
+		add     []string
+		want    map[string]fs.FileInfo
+		wantErr bool
+	}{
+		{
+			name:    "add one watch",
+			watcher: makeTestWatcher(t, map[string]fs.FileInfo{}),
+			add:     []string{"/foo"},
+			want: map[string]fs.FileInfo{
+				"/foo": &mockFileInfo{},
+			},
+		},
+	}
+	for _, tt := range tests {
+		tt.watcher.statFunc = makeStatFunc(t, &mockFileInfo{})
+		t.Run(tt.name, func(t *testing.T) {
+			for _, path := range tt.add {
+				if err := tt.watcher.Add(path); (err != nil) != tt.wantErr {
+					t.Errorf("fileInfoWatcher.Add() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			}
+			if !cmp.Equal(tt.watcher.watches, tt.want, cmp.AllowUnexported(mockFileInfo{})) {
+				t.Errorf("fileInfoWatcher.Add(): want-, got+: %v ", cmp.Diff(tt.want, tt.watcher.watches))
+			}
+		})
+	}
+}
+
+func Test_fileInfoWatcher_Remove(t *testing.T) {
+	tests := []struct {
+		name       string
+		watcher    *fileInfoWatcher
+		removeThis string
+		want       []string
+	}{{
+		name:       "remove foo",
+		watcher:    makeTestWatcher(t, map[string]fs.FileInfo{"foo": &mockFileInfo{}, "bar": &mockFileInfo{}}),
+		removeThis: "foo",
+		want:       []string{"bar"},
+	}}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.watcher.Remove(tt.removeThis)
+			if err != nil {
+				t.Errorf("fileInfoWatcher.Remove() error = %v", err)
+			}
+			if !cmp.Equal(tt.watcher.WatchList(), tt.want) {
+				t.Errorf("fileInfoWatcher.Add(): want-, got+: %v ", cmp.Diff(tt.want, tt.watcher.WatchList()))
+			}
+		})
+	}
+}
+
+func Test_fileInfoWatcher_update(t *testing.T) {
+	tests := []struct {
+		name     string
+		watcher  *fileInfoWatcher
+		statFunc func(string) (fs.FileInfo, error)
+		wantErr  bool
+		want     *fsnotify.Event
+	}{
+		{
+			name: "chmod",
+			watcher: makeTestWatcher(t,
+				map[string]fs.FileInfo{
+					"foo": &mockFileInfo{
+						name: "foo",
+						mode: 0,
+					},
+				},
+			),
+			statFunc: func(_ string) (fs.FileInfo, error) {
+				return &mockFileInfo{
+					name: "foo",
+					mode: 1,
+				}, nil
+			},
+			want: &fsnotify.Event{Name: "foo", Op: fsnotify.Chmod},
+		},
+		{
+			name: "write",
+			watcher: makeTestWatcher(t,
+				map[string]fs.FileInfo{
+					"foo": &mockFileInfo{
+						name:    "foo",
+						modTime: time.Now().Local(),
+					},
+				},
+			),
+			statFunc: func(_ string) (fs.FileInfo, error) {
+				return &mockFileInfo{
+					name:    "foo",
+					modTime: (time.Now().Local().Add(5 * time.Minute)),
+				}, nil
+			},
+			want: &fsnotify.Event{Name: "foo", Op: fsnotify.Write},
+		},
+		{
+			name: "remove",
+			watcher: makeTestWatcher(t,
+				map[string]fs.FileInfo{
+					"foo": &mockFileInfo{
+						name: "foo",
+					},
+				},
+			),
+			statFunc: func(_ string) (fs.FileInfo, error) {
+				return nil, fmt.Errorf("mock file-no-existy error: %w", os.ErrNotExist)
+			},
+			want: &fsnotify.Event{Name: "foo", Op: fsnotify.Remove},
+		},
+		{
+			name: "unknown error",
+			watcher: makeTestWatcher(t,
+				map[string]fs.FileInfo{
+					"foo": &mockFileInfo{
+						name: "foo",
+					},
+				},
+			),
+			statFunc: func(_ string) (fs.FileInfo, error) {
+				return nil, errors.New("unhandled error")
+			},
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// set the statFunc
+			tt.watcher.statFunc = tt.statFunc
+			// run an update
+			// this also flexes fileinfowatcher.generateEvent()
+			err := tt.watcher.update()
+			if err != nil {
+				if tt.wantErr {
+					return
+				}
+				t.Errorf("fileInfoWatcher.update() unexpected error = %v, wantErr %v", err, tt.wantErr)
+			}
+			// slurp an event off the event chan
+			out := <-tt.watcher.Events()
+			if out != *tt.want {
+				t.Errorf("fileInfoWatcher.update() wanted %v, got %v", tt.want, out)
+			}
+		})
+	}
+}
+
+// Helpers
+
+// makeTestWatcher returns a pointer to a fileInfoWatcher suitable for testing
+func makeTestWatcher(t *testing.T, watches map[string]fs.FileInfo) *fileInfoWatcher {
+	t.Helper()
+
+	return &fileInfoWatcher{
+		evChan:  make(chan fsnotify.Event, 512),
+		erChan:  make(chan error, 512),
+		watches: watches,
+	}
+}
+
+// makeStateFunc returns an os.Stat wrapper that parrots back whatever its
+// constructor is given
+func makeStatFunc(t *testing.T, fi fs.FileInfo) func(string) (fs.FileInfo, error) {
+	t.Helper()
+	return func(_ string) (fs.FileInfo, error) {
+		return fi, nil
+	}
+}
+
+// mockFileInfo implements fs.FileInfo for mocks
+type mockFileInfo struct {
+	name    string      // base name of the file
+	size    int64       // length in bytes for regular files; system-dependent for others
+	mode    fs.FileMode // file mode bits
+	modTime time.Time   // modification time
+}
+
+// explicitly impements fs.FileInfo
+var _ fs.FileInfo = &mockFileInfo{}
+
+func (mfi *mockFileInfo) Name() string {
+	return mfi.name
+}
+
+func (mfi *mockFileInfo) Size() int64 {
+	return mfi.size
+}
+
+func (mfi *mockFileInfo) Mode() fs.FileMode {
+	return mfi.mode
+}
+
+func (mfi *mockFileInfo) ModTime() time.Time {
+	return mfi.modTime
+}
+
+func (mfi *mockFileInfo) IsDir() bool {
+	return false
+}
+
+func (mfi *mockFileInfo) Sys() any {
+	return "foo"
+}

core/pkg/sync/file/filepath_sync.go

@@ -2,45 +2,78 @@ package file
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
 	"fmt"
+	"io"
 	"os"
-	"strings"
+	"path/filepath"
 	msync "sync"
 
 	"github.com/fsnotify/fsnotify"
 	"github.com/open-feature/flagd/core/pkg/logger"
 	"github.com/open-feature/flagd/core/pkg/sync"
-	"gopkg.in/yaml.v3"
+	"github.com/open-feature/flagd/core/pkg/utils"
 )
 
+const (
+	FSNOTIFY = "fsnotify"
+	FILEINFO = "fileinfo"
+)
+
+type Watcher interface {
+	Close() error
+	Add(name string) error
+	Remove(name string) error
+	WatchList() []string
+	Events() chan fsnotify.Event
+	Errors() chan error
+}
+
 type Sync struct {
 	URI    string
 	Logger *logger.Logger
-	// FileType indicates the file type e.g., json, yaml/yml etc.,
-	fileType string
-	watcher  *fsnotify.Watcher
-	ready    bool
-	Mux      *msync.RWMutex
+	// watchType indicates how to watch the file FSNOTIFY|FILEINFO
+	watchType string
+	watcher   Watcher
+	ready     bool
+	Mux       *msync.RWMutex
+}
+
+func NewFileSync(uri string, watchType string, logger *logger.Logger) *Sync {
+	return &Sync{
+		URI:       uri,
+		watchType: watchType,
+		Logger:    logger,
+		Mux:       &msync.RWMutex{},
+	}
 }
 
 // default state is used to prevent EOF errors when handling filepath delete events + empty files
 const defaultState = "{}"
 
 func (fs *Sync) ReSync(ctx context.Context, dataSync chan<- sync.DataSync) error {
-	fs.sendDataSync(ctx, sync.ALL, dataSync)
+	fs.sendDataSync(ctx, dataSync)
 	return nil
 }
 
-func (fs *Sync) Init(_ context.Context) error {
+func (fs *Sync) Init(ctx context.Context) error {
 	fs.Logger.Info("Starting filepath sync notifier")
-	w, err := fsnotify.NewWatcher()
-	if err != nil {
-		return fmt.Errorf("error creating filepath watcher: %w", err)
+
+	switch fs.watchType {
+	case FSNOTIFY, "":
+		w, err := NewFSNotifyWatcher()
+		if err != nil {
+			return fmt.Errorf("error creating fsnotify watcher: %w", err)
+		}
+		fs.watcher = w
+	case FILEINFO:
+		w := NewFileInfoWatcher(ctx, fs.Logger)
+		fs.watcher = w
+	default:
+		return fmt.Errorf("unknown watcher type: '%s'", fs.watchType)
 	}
-	fs.watcher = w
-	if err = fs.watcher.Add(fs.URI); err != nil {
+
+	if err := fs.watcher.Add(fs.URI); err != nil {
 		return fmt.Errorf("error adding watcher %s: %w", fs.URI, err)
 	}
 	return nil
@@ -61,12 +94,12 @@ func (fs *Sync) setReady(val bool) {
 //nolint:funlen
 func (fs *Sync) Sync(ctx context.Context, dataSync chan<- sync.DataSync) error {
 	defer fs.watcher.Close()
-	fs.sendDataSync(ctx, sync.ALL, dataSync)
+	fs.sendDataSync(ctx, dataSync)
 	fs.setReady(true)
 	fs.Logger.Info(fmt.Sprintf("watching filepath: %s", fs.URI))
 	for {
 		select {
-		case event, ok := <-fs.watcher.Events:
+		case event, ok := <-fs.watcher.Events():
 			if !ok {
 				fs.Logger.Info("filepath notifier closed")
 				return errors.New("filepath notifier closed")
@@ -75,7 +108,7 @@ func (fs *Sync) Sync(ctx context.Context, dataSync chan<- sync.DataSync) error {
 			fs.Logger.Info(fmt.Sprintf("filepath event: %s %s", event.Name, event.Op.String()))
 			switch {
 			case event.Has(fsnotify.Create) || event.Has(fsnotify.Write):
-				fs.sendDataSync(ctx, sync.ALL, dataSync)
+				fs.sendDataSync(ctx, dataSync)
 			case event.Has(fsnotify.Remove):
 				// K8s exposes config maps as symlinks.
 				// Updates cause a remove event, we need to re-add the watcher in this case.
@@ -83,24 +116,24 @@ func (fs *Sync) Sync(ctx context.Context, dataSync chan<- sync.DataSync) error {
 				if err != nil {
 					// the watcher could not be re-added, so the file must have been deleted
 					fs.Logger.Error(fmt.Sprintf("error restoring watcher, file may have been deleted: %s", err.Error()))
-					fs.sendDataSync(ctx, sync.DELETE, dataSync)
+					fs.sendDataSync(ctx, dataSync)
 					continue
 				}
 
 				// Counterintuitively, remove events are the only meaningful ones seen in K8s.
 				// K8s handles mounted ConfigMap updates by modifying symbolic links, which is an atomic operation.
 				// At the point the remove event is fired, we have our new data, so we can send it down the channel.
-				fs.sendDataSync(ctx, sync.ALL, dataSync)
+				fs.sendDataSync(ctx, dataSync)
 			case event.Has(fsnotify.Chmod):
 				// on linux the REMOVE event will not fire until all file descriptors are closed, this cannot happen
 				// while the file is being watched, os.Stat is used here to infer deletion
 				if _, err := os.Stat(fs.URI); errors.Is(err, os.ErrNotExist) {
 					fs.Logger.Error(fmt.Sprintf("file has been deleted: %s", err.Error()))
-					fs.sendDataSync(ctx, sync.DELETE, dataSync)
+					fs.sendDataSync(ctx, dataSync)
 				}
 			}
 
-		case err, ok := <-fs.watcher.Errors:
+		case err, ok := <-fs.watcher.Errors():
 			if !ok {
 				fs.setReady(false)
 				return errors.New("watcher error")
@@ -114,14 +147,8 @@ func (fs *Sync) Sync(ctx context.Context, dataSync chan<- sync.DataSync) error {
 	}
 }
 
-func (fs *Sync) sendDataSync(ctx context.Context, syncType sync.Type, dataSync chan<- sync.DataSync) {
-	fs.Logger.Debug(fmt.Sprintf("Configuration %s:  %s", fs.URI, syncType.String()))
-
-	if syncType == sync.DELETE {
-		// Skip fetching and emit default state to avoid EOF errors
-		dataSync <- sync.DataSync{FlagData: defaultState, Source: fs.URI, Type: syncType}
-		return
-	}
+func (fs *Sync) sendDataSync(ctx context.Context, dataSync chan<- sync.DataSync) {
+	fs.Logger.Debug(fmt.Sprintf("Data sync received for %s", fs.URI))
 
 	msg := defaultState
 	m, err := fs.fetch(ctx)
@@ -134,45 +161,29 @@ func (fs *Sync) sendDataSync(ctx context.Context, syncType sync.Type, dataSync c
 		msg = m
 	}
 
-	dataSync <- sync.DataSync{FlagData: msg, Source: fs.URI, Type: syncType}
+	dataSync <- sync.DataSync{FlagData: msg, Source: fs.URI}
 }
 
 func (fs *Sync) fetch(_ context.Context) (string, error) {
 	if fs.URI == "" {
 		return "", errors.New("no filepath string set")
 	}
-	if fs.fileType == "" {
-		uriSplit := strings.Split(fs.URI, ".")
-		fs.fileType = uriSplit[len(uriSplit)-1]
+
+	file, err := os.Open(fs.URI)
+	if err != nil {
+		return "", fmt.Errorf("error opening file %s: %w", fs.URI, err)
 	}
-	rawFile, err := os.ReadFile(fs.URI)
+	defer file.Close()
+
+	data, err := io.ReadAll(file)
 	if err != nil {
 		return "", fmt.Errorf("error reading file %s: %w", fs.URI, err)
 	}
 
-	switch fs.fileType {
-	case "yaml", "yml":
-		return yamlToJSON(rawFile)
-	case "json":
-		return string(rawFile), nil
-	default:
-		return "", fmt.Errorf("filepath extension for URI: '%s' is not supported", fs.URI)
-	}
-}
-
-// yamlToJSON is a generic helper function to convert
-// yaml to json
-func yamlToJSON(rawFile []byte) (string, error) {
-	var ms map[string]interface{}
-	// yaml.Unmarshal unmarshals to map[interface]interface{}
-	if err := yaml.Unmarshal(rawFile, &ms); err != nil {
-		return "", fmt.Errorf("unmarshal yaml: %w", err)
-	}
-
-	r, err := json.Marshal(ms)
+	// File extension is used to determine the content type, so media type is unnecessary
+	json, err := utils.ConvertToJSON(data, filepath.Ext(fs.URI), "")
 	if err != nil {
-		return "", fmt.Errorf("convert yaml to json: %w", err)
+		return "", fmt.Errorf("error converting file content to json: %w", err)
 	}
-
-	return string(r), err
+	return json, nil
 }

core/pkg/sync/file/filepath_sync_test.go

@@ -26,7 +26,6 @@ func TestSimpleReSync(t *testing.T) {
 	expectedDataSync := sync.DataSync{
 		FlagData: "hello",
 		Source:   source,
-		Type:     sync.ALL,
 	}
 	handler := Sync{
 		URI:    source,
@@ -76,7 +75,6 @@ func TestSimpleSync(t *testing.T) {
 				{
 					FlagData: fetchFileContents,
 					Source:   fmt.Sprintf("%s/%s", readDirName, fetchFileName),
-					Type:     sync.ALL,
 				},
 			},
 		},
@@ -94,12 +92,10 @@ func TestSimpleSync(t *testing.T) {
 				{
 					FlagData: fetchFileContents,
 					Source:   fmt.Sprintf("%s/%s", updateDirName, fetchFileName),
-					Type:     sync.ALL,
 				},
 				{
 					FlagData: "new content",
 					Source:   fmt.Sprintf("%s/%s", updateDirName, fetchFileName),
-					Type:     sync.ALL,
 				},
 			},
 		},
@@ -117,12 +113,10 @@ func TestSimpleSync(t *testing.T) {
 				{
 					FlagData: fetchFileContents,
 					Source:   fmt.Sprintf("%s/%s", deleteDirName, fetchFileName),
-					Type:     sync.ALL,
 				},
 				{
 					FlagData: defaultState,
 					Source:   fmt.Sprintf("%s/%s", deleteDirName, fetchFileName),
-					Type:     sync.DELETE,
 				},
 			},
 		},
@@ -172,9 +166,6 @@ func TestSimpleSync(t *testing.T) {
 					if data.Source != syncEvent.Source {
 						t.Errorf("expected source: %s, but received source: %s", syncEvent.Source, data.Source)
 					}
-					if data.Type != syncEvent.Type {
-						t.Errorf("expected type: %b, but received type: %b", syncEvent.Type, data.Type)
-					}
 				case <-time.After(10 * time.Second):
 					t.Errorf("event not found, timeout out after 10 seconds")
 				}
@@ -190,7 +181,7 @@ func TestSimpleSync(t *testing.T) {
 
 func TestFilePathSync_Fetch(t *testing.T) {
 	successDirName := t.TempDir()
-	falureDirName := t.TempDir()
+	failureDirName := t.TempDir()
 	tests := map[string]struct {
 		fpSync         Sync
 		handleResponse func(t *testing.T, fetched string, err error)
@@ -213,9 +204,9 @@ func TestFilePathSync_Fetch(t *testing.T) {
 			},
 		},
 		"not found": {
-			fetchDirName: falureDirName,
+			fetchDirName: failureDirName,
 			fpSync: Sync{
-				URI:    fmt.Sprintf("%s/%s", falureDirName, "not_found"),
+				URI:    fmt.Sprintf("%s/%s", failureDirName, "not_found"),
 				Logger: logger.NewLogger(nil, false),
 			},
 			handleResponse: func(t *testing.T, fetched string, err error) {

core/pkg/sync/file/fsnotify_watcher.go

@@ -0,0 +1,67 @@
+package file
+
+import (
+	"fmt"
+
+	"github.com/fsnotify/fsnotify"
+)
+
+// Implements file.Watcher by wrapping fsnotify.Watcher
+// This is only necessary because fsnotify.Watcher directly exposes its Errors
+// and Events channels rather than returning them by method invocation
+type fsNotifyWatcher struct {
+	watcher *fsnotify.Watcher
+}
+
+// NewFsNotifyWatcher returns a new fsNotifyWatcher
+func NewFSNotifyWatcher() (Watcher, error) {
+	fsn, err := fsnotify.NewWatcher()
+	if err != nil {
+		return nil, fmt.Errorf("fsnotify: %w", err)
+	}
+	return &fsNotifyWatcher{
+		watcher: fsn,
+	}, nil
+}
+
+// explicitly implements file.Watcher
+var _ Watcher = &fsNotifyWatcher{}
+
+// Close calls close on the underlying fsnotify.Watcher
+func (f *fsNotifyWatcher) Close() error {
+	if err := f.watcher.Close(); err != nil {
+		return fmt.Errorf("fsnotify: %w", err)
+	}
+	return nil
+}
+
+// Add calls Add on the underlying fsnotify.Watcher
+func (f *fsNotifyWatcher) Add(name string) error {
+	if err := f.watcher.Add(name); err != nil {
+		return fmt.Errorf("fsnotify: %w", err)
+	}
+	return nil
+}
+
+// Remove calls Remove on the underlying fsnotify.Watcher
+func (f *fsNotifyWatcher) Remove(name string) error {
+	if err := f.watcher.Remove(name); err != nil {
+		return fmt.Errorf("fsnotify: %w", err)
+	}
+	return nil
+}
+
+// Watchlist calls watchlist on the underlying fsnotify.Watcher
+func (f *fsNotifyWatcher) WatchList() []string {
+	return f.watcher.WatchList()
+}
+
+// Events returns the underlying watcher's Events chan
+func (f *fsNotifyWatcher) Events() chan fsnotify.Event {
+	return f.watcher.Events
+}
+
+// Errors returns the underlying watcher's Errors chan
+func (f *fsNotifyWatcher) Errors() chan error {
+	return f.watcher.Errors
+}

core/pkg/sync/grpc/credentials/mock/builder.go

@@ -1,5 +1,10 @@
 // Code generated by MockGen. DO NOT EDIT.
 // Source: pkg/sync/grpc/credentials/builder.go
+//
+// Generated by this command:
+//
+//	mockgen -source=pkg/sync/grpc/credentials/builder.go -destination=pkg/sync/grpc/credentials/mock/builder.go -package=credendialsmock
+//
 
 // Package credendialsmock is a generated GoMock package.
 package credendialsmock
@@ -7,7 +12,7 @@ package credendialsmock
 import (
 	reflect "reflect"
 
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 	credentials "google.golang.org/grpc/credentials"
 )
 
@@ -44,7 +49,7 @@ func (m *MockBuilder) Build(secure bool, certPath string) (credentials.Transport
 }
 
 // Build indicates an expected call of Build.
-func (mr *MockBuilderMockRecorder) Build(secure, certPath interface{}) *gomock.Call {
+func (mr *MockBuilderMockRecorder) Build(secure, certPath any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Build", reflect.TypeOf((*MockBuilder)(nil).Build), secure, certPath)
 }

core/pkg/sync/grpc/grpc_sync.go

@@ -7,19 +7,22 @@ import (
 	msync "sync"
 	"time"
 
-	"buf.build/gen/go/open-feature/flagd/grpc/go/sync/v1/syncv1grpc"
-	v1 "buf.build/gen/go/open-feature/flagd/protocolbuffers/go/sync/v1"
+	"buf.build/gen/go/open-feature/flagd/grpc/go/flagd/sync/v1/syncv1grpc"
+	v1 "buf.build/gen/go/open-feature/flagd/protocolbuffers/go/flagd/sync/v1"
 	"github.com/open-feature/flagd/core/pkg/logger"
 	"github.com/open-feature/flagd/core/pkg/sync"
 	grpccredential "github.com/open-feature/flagd/core/pkg/sync/grpc/credentials"
+	_ "github.com/open-feature/flagd/core/pkg/sync/grpc/nameresolvers" // initialize custom resolvers e.g. envoy.Init()
 	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
 )
 
 const (
 	// Prefix for GRPC URL inputs. GRPC does not define a standard prefix. This prefix helps to differentiate remote
 	// URLs for REST APIs (i.e - HTTP) from GRPC endpoints.
-	Prefix       = "grpc://"
-	PrefixSecure = "grpcs://"
+	Prefix          = "grpc://"
+	PrefixSecure    = "grpcs://"
+	SupportedScheme = "(envoy|dns|uds|xds)"
 
 	// Connection retry constants
 	// Back off period is calculated with backOffBase ^ #retry-iteration. However, when #retry-iteration count reach
@@ -41,28 +44,46 @@ type FlagSyncServiceClientResponse interface {
 var once msync.Once
 
 type Sync struct {
-	CertPath          string
-	CredentialBuilder grpccredential.Builder
-	Logger            *logger.Logger
-	ProviderID        string
-	Secure            bool
-	Selector          string
-	URI               string
+	GrpcDialOptionsOverride []grpc.DialOption
+	CertPath                string
+	CredentialBuilder       grpccredential.Builder
+	Logger                  *logger.Logger
+	ProviderID              string
+	Secure                  bool
+	Selector                string
+	URI                     string
+	MaxMsgSize              int
 
 	client FlagSyncServiceClient
 	ready  bool
 }
 
-func (g *Sync) Init(ctx context.Context) error {
-	tCredentials, err := g.CredentialBuilder.Build(g.Secure, g.CertPath)
-	if err != nil {
-		err := fmt.Errorf("error building transport credentials: %w", err)
-		g.Logger.Error(err.Error())
-		return err
+func (g *Sync) Init(_ context.Context) error {
+	var rpcCon *grpc.ClientConn // Reusable client connection
+	var err error
+
+	if len(g.GrpcDialOptionsOverride) > 0 {
+		g.Logger.Debug("GRPC DialOptions override provided")
+		rpcCon, err = grpc.NewClient(g.URI, g.GrpcDialOptionsOverride...)
+	} else {
+		var tCredentials credentials.TransportCredentials
+		tCredentials, err = g.CredentialBuilder.Build(g.Secure, g.CertPath)
+		if err != nil {
+			err = fmt.Errorf("error building transport credentials: %w", err)
+			g.Logger.Error(err.Error())
+			return err
+		}
+
+		// Set MaxMsgSize if passed
+		if g.MaxMsgSize > 0 {
+			g.Logger.Info(fmt.Sprintf("setting max receive message size %d bytes default 4MB", g.MaxMsgSize))
+			dialOptions := grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(g.MaxMsgSize))
+			rpcCon, err = grpc.NewClient(g.URI, grpc.WithTransportCredentials(tCredentials), dialOptions)
+		} else {
+			rpcCon, err = grpc.NewClient(g.URI, grpc.WithTransportCredentials(tCredentials))
+		}
 	}
 
-	// Derive reusable client connection
-	rpcCon, err := grpc.DialContext(ctx, g.URI, grpc.WithTransportCredentials(tCredentials))
 	if err != nil {
 		err := fmt.Errorf("error initiating grpc client connection: %w", err)
 		g.Logger.Error(err.Error())
@@ -76,7 +97,7 @@ func (g *Sync) Init(ctx context.Context) error {
 }
 
 func (g *Sync) ReSync(ctx context.Context, dataSync chan<- sync.DataSync) error {
-	res, err := g.client.FetchAllFlags(ctx, &v1.FetchAllFlagsRequest{})
+	res, err := g.client.FetchAllFlags(ctx, &v1.FetchAllFlagsRequest{ProviderId: g.ProviderID, Selector: g.Selector})
 	if err != nil {
 		err = fmt.Errorf("error fetching all flags: %w", err)
 		g.Logger.Error(err.Error())
@@ -85,7 +106,6 @@ func (g *Sync) ReSync(ctx context.Context, dataSync chan<- sync.DataSync) error
 	dataSync <- sync.DataSync{
 		FlagData: res.GetFlagConfiguration(),
 		Source:   g.URI,
-		Type:     sync.ALL,
 	}
 	return nil
 }
@@ -168,7 +188,6 @@ func (g *Sync) connectWithRetry(
 
 // handleFlagSync wraps the stream listening and push updates through dataSync channel
 func (g *Sync) handleFlagSync(stream syncv1grpc.FlagSyncService_SyncFlagsClient, dataSync chan<- sync.DataSync) error {
-	// Set ready state once only
 	once.Do(func() {
 		g.ready = true
 	})
@@ -179,45 +198,13 @@ func (g *Sync) handleFlagSync(stream syncv1grpc.FlagSyncService_SyncFlagsClient,
 			return fmt.Errorf("error receiving payload from stream: %w", err)
 		}
 
-		switch data.State {
-		case v1.SyncState_SYNC_STATE_ALL:
-			dataSync <- sync.DataSync{
-				FlagData: data.FlagConfiguration,
-				Source:   g.URI,
-				Type:     sync.ALL,
-			}
-
-			g.Logger.Debug("received full configuration payload")
-		case v1.SyncState_SYNC_STATE_ADD:
-			dataSync <- sync.DataSync{
-				FlagData: data.FlagConfiguration,
-				Source:   g.URI,
-				Type:     sync.ADD,
-			}
-
-			g.Logger.Debug("received an add payload")
-		case v1.SyncState_SYNC_STATE_UPDATE:
-			dataSync <- sync.DataSync{
-				FlagData: data.FlagConfiguration,
-				Source:   g.URI,
-				Type:     sync.UPDATE,
-			}
-
-			g.Logger.Debug("received an update payload")
-		case v1.SyncState_SYNC_STATE_DELETE:
-			dataSync <- sync.DataSync{
-				FlagData: data.FlagConfiguration,
-				Source:   g.URI,
-				Type:     sync.DELETE,
-			}
-
-			g.Logger.Debug("received a delete payload")
-		case v1.SyncState_SYNC_STATE_PING:
-			g.Logger.Debug("received server ping")
-		case v1.SyncState_SYNC_STATE_UNSPECIFIED:
-			g.Logger.Debug("received unspecified state")
-		default:
-			g.Logger.Debug(fmt.Sprintf("received unknown state: %s", data.State.String()))
+		dataSync <- sync.DataSync{
+			FlagData:    data.FlagConfiguration,
+			SyncContext: data.SyncContext,
+			Source:      g.URI,
+			Selector:    g.Selector,
 		}
+
+		g.Logger.Debug("received full configuration payload")
 	}
 }

core/pkg/sync/grpc/grpc_sync_test.go

@@ -11,19 +11,22 @@ import (
 	"testing"
 	"time"
 
-	"buf.build/gen/go/open-feature/flagd/grpc/go/sync/v1/syncv1grpc"
-	v1 "buf.build/gen/go/open-feature/flagd/protocolbuffers/go/sync/v1"
-	"github.com/golang/mock/gomock"
+	"buf.build/gen/go/open-feature/flagd/grpc/go/flagd/sync/v1/syncv1grpc"
+	v1 "buf.build/gen/go/open-feature/flagd/protocolbuffers/go/flagd/sync/v1"
 	"github.com/open-feature/flagd/core/pkg/logger"
 	"github.com/open-feature/flagd/core/pkg/sync"
 	credendialsmock "github.com/open-feature/flagd/core/pkg/sync/grpc/credentials/mock"
-	grpcmock "github.com/open-feature/flagd/core/pkg/sync/grpc/mock"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zaptest/observer"
 	"golang.org/x/sync/errgroup"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/credentials/insecure"
 	"google.golang.org/grpc/test/bufconn"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/types/known/structpb"
 )
 
 func Test_InitWithMockCredentialBuilder(t *testing.T) {
@@ -78,6 +81,30 @@ func Test_InitWithMockCredentialBuilder(t *testing.T) {
 	}
 }
 
+func Test_InitWithSizeOverride(t *testing.T) {
+	observedZapCore, observedLogs := observer.New(zap.InfoLevel)
+	observedLogger := zap.New(observedZapCore)
+
+	mockCtrl := gomock.NewController(t)
+	mockCredentialBulder := credendialsmock.NewMockBuilder(mockCtrl)
+
+	mockCredentialBulder.EXPECT().
+		Build(gomock.Any(), gomock.Any()).
+		Return(insecure.NewCredentials(), nil)
+
+	grpcSync := Sync{
+		URI:               "grpc-target",
+		Logger:            logger.NewLogger(observedLogger, false),
+		CredentialBuilder: mockCredentialBulder,
+		MaxMsgSize:        10,
+	}
+
+	err := grpcSync.Init(context.Background())
+
+	require.Nilf(t, err, "%s: expected no error, but got non nil error", t.Name())
+	require.Equal(t, "setting max receive message size 10 bytes default 4MB", observedLogs.All()[0].Message)
+}
+
 func Test_ReSyncTests(t *testing.T) {
 	const target = "localBufCon"
 
@@ -96,7 +123,6 @@ func Test_ReSyncTests(t *testing.T) {
 			notifications: []sync.DataSync{
 				{
 					FlagData: "success",
-					Type:     sync.ALL,
 				},
 			},
 			shouldError: false,
@@ -153,9 +179,6 @@ func Test_ReSyncTests(t *testing.T) {
 
 		for _, expected := range test.notifications {
 			out := <-syncChan
-			if expected.Type != out.Type {
-				t.Errorf("Returned sync type = %v, wanted %v", out.Type, expected.Type)
-			}
 
 			if expected.FlagData != out.FlagData {
 				t.Errorf("Returned sync data = %v, wanted %v", out.FlagData, expected.FlagData)
@@ -169,159 +192,14 @@ func Test_ReSyncTests(t *testing.T) {
 	}
 }
 
-func TestSync_BasicFlagSyncStates(t *testing.T) {
-	grpcSyncImpl := Sync{
-		URI:        "grpc://test",
-		ProviderID: "",
-		Logger:     logger.NewLogger(nil, false),
-	}
-
-	mockError := errors.New("could not sync")
-
-	tests := []struct {
-		name      string
-		stream    syncv1grpc.FlagSyncService_SyncFlagsClient
-		setup     func(t *testing.T, client *grpcmock.MockFlagSyncServiceClient, clientResponse *grpcmock.MockFlagSyncServiceClientResponse)
-		want      sync.Type
-		wantError error
-		ready     bool
-	}{
-		{
-			name: "State All maps to Sync All",
-			setup: func(t *testing.T, client *grpcmock.MockFlagSyncServiceClient, clientResponse *grpcmock.MockFlagSyncServiceClientResponse) {
-				client.EXPECT().SyncFlags(gomock.Any(), gomock.Any(), gomock.Any()).Return(clientResponse, nil)
-				gomock.InOrder(
-					clientResponse.EXPECT().Recv().Return(
-						&v1.SyncFlagsResponse{
-							FlagConfiguration: "{}",
-							State:             v1.SyncState_SYNC_STATE_ALL,
-						},
-						nil,
-					),
-					clientResponse.EXPECT().Recv().Return(
-						nil, io.EOF,
-					),
-				)
-			},
-			want:  sync.ALL,
-			ready: true,
-		},
-		{
-			name: "State Add maps to Sync Add",
-			setup: func(t *testing.T, client *grpcmock.MockFlagSyncServiceClient, clientResponse *grpcmock.MockFlagSyncServiceClientResponse) {
-				client.EXPECT().SyncFlags(gomock.Any(), gomock.Any(), gomock.Any()).Return(clientResponse, nil)
-				gomock.InOrder(
-					clientResponse.EXPECT().Recv().Return(
-						&v1.SyncFlagsResponse{
-							FlagConfiguration: "{}",
-							State:             v1.SyncState_SYNC_STATE_ADD,
-						},
-						nil,
-					),
-					clientResponse.EXPECT().Recv().Return(
-						nil, io.EOF,
-					),
-				)
-			},
-			want:  sync.ADD,
-			ready: true,
-		},
-		{
-			name: "State Update maps to Sync Update",
-			setup: func(t *testing.T, client *grpcmock.MockFlagSyncServiceClient, clientResponse *grpcmock.MockFlagSyncServiceClientResponse) {
-				client.EXPECT().SyncFlags(gomock.Any(), gomock.Any(), gomock.Any()).Return(clientResponse, nil)
-				gomock.InOrder(
-					clientResponse.EXPECT().Recv().Return(
-						&v1.SyncFlagsResponse{
-							FlagConfiguration: "{}",
-							State:             v1.SyncState_SYNC_STATE_UPDATE,
-						},
-						nil,
-					),
-					clientResponse.EXPECT().Recv().Return(
-						nil, io.EOF,
-					),
-				)
-			},
-			want:  sync.UPDATE,
-			ready: true,
-		},
-		{
-			name: "State Delete maps to Sync Delete",
-			setup: func(t *testing.T, client *grpcmock.MockFlagSyncServiceClient, clientResponse *grpcmock.MockFlagSyncServiceClientResponse) {
-				client.EXPECT().SyncFlags(gomock.Any(), gomock.Any(), gomock.Any()).Return(clientResponse, nil)
-				gomock.InOrder(
-					clientResponse.EXPECT().Recv().Return(
-						&v1.SyncFlagsResponse{
-							FlagConfiguration: "{}",
-							State:             v1.SyncState_SYNC_STATE_DELETE,
-						},
-						nil,
-					),
-					clientResponse.EXPECT().Recv().Return(
-						nil, io.EOF,
-					),
-				)
-			},
-			want:  sync.DELETE,
-			ready: true,
-		},
-		{
-			name: "Error during flag sync",
-			setup: func(t *testing.T, client *grpcmock.MockFlagSyncServiceClient, clientResponse *grpcmock.MockFlagSyncServiceClientResponse) {
-				client.EXPECT().SyncFlags(gomock.Any(), gomock.Any(), gomock.Any()).Return(clientResponse, nil)
-				clientResponse.EXPECT().Recv().Return(
-					nil,
-					mockError,
-				)
-			},
-			ready: true,
-			want:  -1,
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			ctrl := gomock.NewController(t)
-			syncChan := make(chan sync.DataSync, 1)
-
-			mockClient := grpcmock.NewMockFlagSyncServiceClient(ctrl)
-			mockClientResponse := grpcmock.NewMockFlagSyncServiceClientResponse(ctrl)
-			test.setup(t, mockClient, mockClientResponse)
-
-			waitChan := make(chan struct{})
-			go func() {
-				grpcSyncImpl.client = mockClient
-				ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
-				defer cancel()
-				err := grpcSyncImpl.Sync(ctx, syncChan)
-				if err != nil {
-					t.Errorf("Error handling flag sync: %v", err)
-				}
-				close(waitChan)
-			}()
-			<-waitChan
-
-			if test.want < 0 {
-				require.Empty(t, syncChan)
-				return
-			}
-			data := <-syncChan
-
-			if grpcSyncImpl.IsReady() != test.ready {
-				t.Errorf("expected grpcSyncImpl.ready to be: '%v', got: '%v'", test.ready, grpcSyncImpl.ready)
-			}
-
-			if data.Type != test.want {
-				t.Errorf("Returned data sync state = %v, wanted %v", data.Type, test.want)
-			}
-		})
-	}
-}
-
 func Test_StreamListener(t *testing.T) {
 	const target = "localBufCon"
 
+	metadata, err := structpb.NewStruct(map[string]any{"sources": "A,B,C"})
+	if err != nil {
+		t.Fatalf("Failed to create sync context: %v", err)
+	}
+
 	tests := []struct {
 		name   string
 		input  []serverPayload
@@ -332,13 +210,12 @@ func Test_StreamListener(t *testing.T) {
 			input: []serverPayload{
 				{
 					flags: "{\"flags\": {}}",
-					state: v1.SyncState_SYNC_STATE_ALL,
 				},
 			},
 			output: []sync.DataSync{
 				{
-					FlagData: "{\"flags\": {}}",
-					Type:     sync.ALL,
+					FlagData:    "{\"flags\": {}}",
+					SyncContext: metadata,
 				},
 			},
 		},
@@ -347,67 +224,19 @@ func Test_StreamListener(t *testing.T) {
 			input: []serverPayload{
 				{
 					flags: "{}",
-					state: v1.SyncState_SYNC_STATE_ALL,
 				},
 				{
 					flags: "{\"flags\": {}}",
-					state: v1.SyncState_SYNC_STATE_DELETE,
 				},
 			},
 			output: []sync.DataSync{
 				{
-					FlagData: "{}",
-					Type:     sync.ALL,
+					FlagData:    "{}",
+					SyncContext: metadata,
 				},
 				{
-					FlagData: "{\"flags\": {}}",
-					Type:     sync.DELETE,
-				},
-			},
-		},
-		{
-			name: "Pings are ignored & not written to channel",
-			input: []serverPayload{
-				{
-					flags: "",
-					state: v1.SyncState_SYNC_STATE_PING,
-				},
-				{
-					flags: "",
-					state: v1.SyncState_SYNC_STATE_PING,
-				},
-				{
-					flags: "{\"flags\": {}}",
-					state: v1.SyncState_SYNC_STATE_DELETE,
-				},
-			},
-			output: []sync.DataSync{
-				{
-					FlagData: "{\"flags\": {}}",
-					Type:     sync.DELETE,
-				},
-			},
-		},
-		{
-			name: "Unknown states are & not written to channel",
-			input: []serverPayload{
-				{
-					flags: "",
-					state: 42,
-				},
-				{
-					flags: "",
-					state: -1,
-				},
-				{
-					flags: "{\"flags\": {}}",
-					state: v1.SyncState_SYNC_STATE_ALL,
-				},
-			},
-			output: []sync.DataSync{
-				{
-					FlagData: "{\"flags\": {}}",
-					Type:     sync.ALL,
+					FlagData:    "{\"flags\": {}}",
+					SyncContext: metadata,
 				},
 			},
 		},
@@ -460,13 +289,13 @@ func Test_StreamListener(t *testing.T) {
 		for _, expected := range test.output {
 			out := <-syncChan
 
-			if expected.Type != out.Type {
-				t.Errorf("Returned sync type = %v, wanted %v", out.Type, expected.Type)
-			}
-
 			if expected.FlagData != out.FlagData {
 				t.Errorf("Returned sync data = %v, wanted %v", out.FlagData, expected.FlagData)
 			}
+
+			if !proto.Equal(expected.SyncContext, out.SyncContext) {
+				t.Errorf("Returned sync context = %v, wanted = %v", out.SyncContext, expected.SyncContext)
+			}
 		}
 
 		// channel must be empty
@@ -550,14 +379,12 @@ func Test_SyncRetry(t *testing.T) {
 	// Setup
 	target := "grpc://local"
 	bufListener := bufconn.Listen(1)
-
-	expectType := sync.ALL
+	emptyFlagData := "{}"
 
 	// buffer based server. response ignored purposefully
 	bServer := bufferedServer{listener: bufListener, mockResponses: []serverPayload{
 		{
 			flags: "{}",
-			state: v1.SyncState_SYNC_STATE_ALL,
 		},
 	}}
 
@@ -606,7 +433,7 @@ func Test_SyncRetry(t *testing.T) {
 		t.Errorf("timeout waiting for conditions to fulfil")
 		break
 	case data := <-syncChan:
-		if data.Type != expectType {
+		if data.FlagData != emptyFlagData {
 			t.Errorf("sync start error: %s", err.Error())
 		}
 	}
@@ -626,9 +453,9 @@ func Test_SyncRetry(t *testing.T) {
 	case <-tCtx.Done():
 		cancelFunc()
 		t.Error("timeout waiting for conditions to fulfil")
-	case rsp := <-syncChan:
-		if rsp.Type != expectType {
-			t.Errorf("expected response: %s, but got: %s", expectType, rsp.Type)
+	case data := <-syncChan:
+		if data.FlagData != emptyFlagData {
+			t.Errorf("sync start error: %s", err.Error())
 		}
 	}
 }
@@ -648,7 +475,6 @@ func serve(bServer *bufferedServer) {
 
 type serverPayload struct {
 	flags string
-	state v1.SyncState
 }
 
 // bufferedServer - a mock grpc service backed by buffered connection
@@ -661,9 +487,10 @@ type bufferedServer struct {
 
 func (b *bufferedServer) SyncFlags(_ *v1.SyncFlagsRequest, stream syncv1grpc.FlagSyncService_SyncFlagsServer) error {
 	for _, response := range b.mockResponses {
+		metadata, _ := structpb.NewStruct(map[string]any{"sources": "A,B,C"})
 		err := stream.Send(&v1.SyncFlagsResponse{
 			FlagConfiguration: response.flags,
-			State:             response.state,
+			SyncContext:       metadata,
 		})
 		if err != nil {
 			fmt.Printf("Error with stream: %s", err.Error())
@@ -677,3 +504,7 @@ func (b *bufferedServer) SyncFlags(_ *v1.SyncFlagsRequest, stream syncv1grpc.Fla
 func (b *bufferedServer) FetchAllFlags(_ context.Context, _ *v1.FetchAllFlagsRequest) (*v1.FetchAllFlagsResponse, error) {
 	return b.fetchAllFlagsResponse, b.fetchAllFlagsError
 }
+
+func (b *bufferedServer) GetMetadata(_ context.Context, _ *v1.GetMetadataRequest) (*v1.GetMetadataResponse, error) {
+	return &v1.GetMetadataResponse{}, nil
+}

core/pkg/sync/grpc/mock/grpc.go

@@ -1,5 +1,10 @@
 // Code generated by MockGen. DO NOT EDIT.
 // Source: pkg/sync/grpc/grpc_sync.go
+//
+// Generated by this command:
+//
+//	mockgen -source=pkg/sync/grpc/grpc_sync.go -destination=pkg/sync/grpc/mock/grpc.go -package=grpcmock
+//
 
 // Package grpcmock is a generated GoMock package.
 package grpcmock
@@ -8,9 +13,9 @@ import (
 	context "context"
 	reflect "reflect"
 
-	syncv1grpc "buf.build/gen/go/open-feature/flagd/grpc/go/sync/v1/syncv1grpc"
-	syncv1 "buf.build/gen/go/open-feature/flagd/protocolbuffers/go/sync/v1"
-	gomock "github.com/golang/mock/gomock"
+	syncv1grpc "buf.build/gen/go/open-feature/flagd/grpc/go/flagd/sync/v1/syncv1grpc"
+	syncv1 "buf.build/gen/go/open-feature/flagd/protocolbuffers/go/flagd/sync/v1"
+	gomock "go.uber.org/mock/gomock"
 	grpc "google.golang.org/grpc"
 	metadata "google.golang.org/grpc/metadata"
 )
@@ -41,7 +46,7 @@ func (m *MockFlagSyncServiceClient) EXPECT() *MockFlagSyncServiceClientMockRecor
 // FetchAllFlags mocks base method.
 func (m *MockFlagSyncServiceClient) FetchAllFlags(ctx context.Context, in *syncv1.FetchAllFlagsRequest, opts ...grpc.CallOption) (*syncv1.FetchAllFlagsResponse, error) {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{ctx, in}
+	varargs := []any{ctx, in}
 	for _, a := range opts {
 		varargs = append(varargs, a)
 	}
@@ -52,16 +57,36 @@ func (m *MockFlagSyncServiceClient) FetchAllFlags(ctx context.Context, in *syncv
 }
 
 // FetchAllFlags indicates an expected call of FetchAllFlags.
-func (mr *MockFlagSyncServiceClientMockRecorder) FetchAllFlags(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+func (mr *MockFlagSyncServiceClientMockRecorder) FetchAllFlags(ctx, in any, opts ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{ctx, in}, opts...)
+	varargs := append([]any{ctx, in}, opts...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchAllFlags", reflect.TypeOf((*MockFlagSyncServiceClient)(nil).FetchAllFlags), varargs...)
 }
 
+// GetMetadata mocks base method.
+func (m *MockFlagSyncServiceClient) GetMetadata(ctx context.Context, in *syncv1.GetMetadataRequest, opts ...grpc.CallOption) (*syncv1.GetMetadataResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetMetadata", varargs...)
+	ret0, _ := ret[0].(*syncv1.GetMetadataResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetMetadata indicates an expected call of GetMetadata.
+func (mr *MockFlagSyncServiceClientMockRecorder) GetMetadata(ctx, in any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadata", reflect.TypeOf((*MockFlagSyncServiceClient)(nil).GetMetadata), varargs...)
+}
+
 // SyncFlags mocks base method.
 func (m *MockFlagSyncServiceClient) SyncFlags(ctx context.Context, in *syncv1.SyncFlagsRequest, opts ...grpc.CallOption) (syncv1grpc.FlagSyncService_SyncFlagsClient, error) {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{ctx, in}
+	varargs := []any{ctx, in}
 	for _, a := range opts {
 		varargs = append(varargs, a)
 	}
@@ -72,9 +97,9 @@ func (m *MockFlagSyncServiceClient) SyncFlags(ctx context.Context, in *syncv1.Sy
 }
 
 // SyncFlags indicates an expected call of SyncFlags.
-func (mr *MockFlagSyncServiceClientMockRecorder) SyncFlags(ctx, in interface{}, opts ...interface{}) *gomock.Call {
+func (mr *MockFlagSyncServiceClientMockRecorder) SyncFlags(ctx, in any, opts ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{ctx, in}, opts...)
+	varargs := append([]any{ctx, in}, opts...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncFlags", reflect.TypeOf((*MockFlagSyncServiceClient)(nil).SyncFlags), varargs...)
 }
 
@@ -160,7 +185,7 @@ func (mr *MockFlagSyncServiceClientResponseMockRecorder) Recv() *gomock.Call {
 }
 
 // RecvMsg mocks base method.
-func (m_2 *MockFlagSyncServiceClientResponse) RecvMsg(m interface{}) error {
+func (m_2 *MockFlagSyncServiceClientResponse) RecvMsg(m any) error {
 	m_2.ctrl.T.Helper()
 	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
 	ret0, _ := ret[0].(error)
@@ -168,13 +193,13 @@ func (m_2 *MockFlagSyncServiceClientResponse) RecvMsg(m interface{}) error {
 }
 
 // RecvMsg indicates an expected call of RecvMsg.
-func (mr *MockFlagSyncServiceClientResponseMockRecorder) RecvMsg(m interface{}) *gomock.Call {
+func (mr *MockFlagSyncServiceClientResponseMockRecorder) RecvMsg(m any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockFlagSyncServiceClientResponse)(nil).RecvMsg), m)
 }
 
 // SendMsg mocks base method.
-func (m_2 *MockFlagSyncServiceClientResponse) SendMsg(m interface{}) error {
+func (m_2 *MockFlagSyncServiceClientResponse) SendMsg(m any) error {
 	m_2.ctrl.T.Helper()
 	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
 	ret0, _ := ret[0].(error)
@@ -182,7 +207,7 @@ func (m_2 *MockFlagSyncServiceClientResponse) SendMsg(m interface{}) error {
 }
 
 // SendMsg indicates an expected call of SendMsg.
-func (mr *MockFlagSyncServiceClientResponseMockRecorder) SendMsg(m interface{}) *gomock.Call {
+func (mr *MockFlagSyncServiceClientResponseMockRecorder) SendMsg(m any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockFlagSyncServiceClientResponse)(nil).SendMsg), m)
 }

core/pkg/sync/grpc/nameresolvers/envoy_resolver.go

@@ -0,0 +1,84 @@
+package nameresolvers
+
+import (
+	"fmt"
+	"strings"
+
+	"google.golang.org/grpc/resolver"
+)
+
+const scheme = "envoy"
+
+type envoyBuilder struct{}
+
+// Build A custom NameResolver to resolve gRPC target uri for envoy in the
+// format of.
+//
+// Custom URI Scheme:
+//
+// envoy://[proxy-agent-host]:[proxy-agent-port]/[service-name]
+func (*envoyBuilder) Build(target resolver.Target,
+	cc resolver.ClientConn, _ resolver.BuildOptions,
+) (resolver.Resolver, error) {
+	_, err := isValidTarget(target)
+	if err != nil {
+		return nil, err
+	}
+
+	r := &envoyResolver{
+		target: target,
+		cc:     cc,
+	}
+	r.start()
+	return r, nil
+}
+
+func (*envoyBuilder) Scheme() string {
+	return scheme
+}
+
+type envoyResolver struct {
+	target resolver.Target
+	cc     resolver.ClientConn
+}
+
+// Envoy NameResolver, will always override the authority with the specified authority i.e. URL.path and
+// use the socketAddress i.e. Host:Port to connect.
+func (r *envoyResolver) start() {
+	addr := fmt.Sprintf("%s:%s", r.target.URL.Hostname(), r.target.URL.Port())
+	err := r.cc.UpdateState(resolver.State{Addresses: []resolver.Address{{Addr: addr}}})
+	if err != nil {
+		return
+	}
+}
+
+func (*envoyResolver) ResolveNow(resolver.ResolveNowOptions) {}
+
+func (*envoyResolver) Close() {}
+
+// Validate user specified target
+//
+// Sample target string:  envoy://localhost:9211/test.service
+//
+// return `true` if the target string used match the scheme and format
+func isValidTarget(target resolver.Target) (bool, error) {
+	// make sure and host and port not empty
+	// used as resolver.Address
+	if target.URL.Scheme != "envoy" || target.URL.Hostname() == "" || target.URL.Port() == "" {
+		return false, fmt.Errorf("envoy-resolver: invalid scheme or missing host/port, target: %s",
+			target)
+	}
+
+	// make sure the path is valid
+	// used as :authority e.g. test.service
+	path := target.Endpoint()
+	if path == "" || strings.Contains(path, "/") {
+		return false, fmt.Errorf("envoy-resolver: invalid path %s", path)
+	}
+
+	return true, nil
+}
+
+func init() {
+	resolver.Register(&envoyBuilder{})
+}

core/pkg/sync/grpc/nameresolvers/envoy_resolver_test.go

@@ -0,0 +1,103 @@
+package nameresolvers
+
+import (
+	"net/url"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"google.golang.org/grpc/resolver"
+)
+
+func Test_EnvoyTargetString(t *testing.T) {
+	tests := []struct {
+		name        string
+		mockURL     url.URL
+		mockError   string
+		shouldError bool
+	}{
+		{
+			name: "Should be valid string",
+			mockURL: url.URL{
+				Scheme: "envoy",
+				Host:   "localhost:8080",
+				Path:   "/test.service",
+			},
+			mockError:   "",
+			shouldError: false,
+		},
+		{
+			name: "Should be valid scheme",
+			mockURL: url.URL{
+				Scheme: "invalid",
+				Host:   "localhost:8080",
+				Path:   "/test.service",
+			},
+			mockError:   "envoy-resolver: invalid scheme or missing host/port, target: invalid://localhost:8080/test.service",
+			shouldError: true,
+		},
+		{
+			name: "Should be valid path",
+			mockURL: url.URL{
+				Scheme: "envoy",
+				Host:   "localhost:8080",
+				Path:   "/test.service/test",
+			},
+			mockError:   "envoy-resolver: invalid path test.service/test",
+			shouldError: true,
+		},
+		{
+			name: "Should be valid path",
+			mockURL: url.URL{
+				Scheme: "envoy",
+				Host:   "localhost:8080",
+				Path:   "/test.service/",
+			},
+			mockError:   "envoy-resolver: invalid path test.service/",
+			shouldError: true,
+		},
+		{
+			name: "Hostname should not be empty",
+			mockURL: url.URL{
+				Scheme: "envoy",
+				Host:   ":8080",
+				Path:   "/test.service",
+			},
+			mockError:   "envoy-resolver: invalid scheme or missing host/port, target: envoy://:8080/test.service",
+			shouldError: true,
+		},
+		{
+			name: "Port should not be empty",
+			mockURL: url.URL{
+				Scheme: "envoy",
+				Host:   "localhost",
+				Path:   "/test.service",
+			},
+			mockError:   "envoy-resolver: invalid scheme or missing host/port, target: envoy://localhost/test.service",
+			shouldError: true,
+		},
+		{
+			name: "Hostname and Port should not be empty",
+			mockURL: url.URL{
+				Scheme: "envoy",
+				Path:   "/test.service",
+			},
+			mockError:   "envoy-resolver: invalid scheme or missing host/port, target: envoy:///test.service",
+			shouldError: true,
+		},
+	}
+
+	for _, test := range tests {
+		target := resolver.Target{URL: test.mockURL}
+
+		isValid, err := isValidTarget(target)
+
+		if test.shouldError {
+			require.False(t, isValid, "Should not be valid")
+			require.NotNilf(t, err, "Error should not be nil")
+			require.Containsf(t, err.Error(), test.mockError, "Error should contains %s", test.mockError)
+		} else {
+			require.True(t, isValid, "Should be valid")
+			require.NoErrorf(t, err, "Error should be nil")
+		}
+	}
+}

core/pkg/sync/http/http_sync.go

@@ -8,9 +8,12 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	parseUrl "net/url"
+	"path/filepath"
 
 	"github.com/open-feature/flagd/core/pkg/logger"
 	"github.com/open-feature/flagd/core/pkg/sync"
+	"github.com/open-feature/flagd/core/pkg/utils"
 	"golang.org/x/crypto/sha3" //nolint:gosec
 )
 
@@ -21,8 +24,10 @@ type Sync struct {
 	LastBodySHA string
 	Logger      *logger.Logger
 	BearerToken string
+	AuthHeader  string
 	Interval    uint32
 	ready       bool
+	eTag        string
 }
 
 // Client defines the behaviour required of a http client
@@ -38,16 +43,18 @@ type Cron interface {
 }
 
 func (hs *Sync) ReSync(ctx context.Context, dataSync chan<- sync.DataSync) error {
-	msg, err := hs.Fetch(ctx)
+	msg, _, err := hs.fetchBody(ctx, true)
 	if err != nil {
 		return err
 	}
-	dataSync <- sync.DataSync{FlagData: msg, Source: hs.URI, Type: sync.ALL}
+	dataSync <- sync.DataSync{FlagData: msg, Source: hs.URI}
 	return nil
 }
 
 func (hs *Sync) Init(_ context.Context) error {
-	// noop
+	if hs.BearerToken != "" {
+		hs.Logger.Warn("Deprecation Alert: bearerToken option is deprecated, please use authHeader instead")
+	}
 	return nil
 }
 
@@ -57,7 +64,7 @@ func (hs *Sync) IsReady() bool {
 
 func (hs *Sync) Sync(ctx context.Context, dataSync chan<- sync.DataSync) error {
 	// Initial fetch
-	fetch, err := hs.Fetch(ctx)
+	fetch, _, err := hs.fetchBody(ctx, true)
 	if err != nil {
 		return err
 	}
@@ -68,43 +75,30 @@ func (hs *Sync) Sync(ctx context.Context, dataSync chan<- sync.DataSync) error {
 	hs.Logger.Debug(fmt.Sprintf("polling %s every %d seconds", hs.URI, hs.Interval))
 	_ = hs.Cron.AddFunc(fmt.Sprintf("*/%d * * * *", hs.Interval), func() {
 		hs.Logger.Debug(fmt.Sprintf("fetching configuration from %s", hs.URI))
-		body, err := hs.fetchBodyFromURL(ctx, hs.URI)
+		previousBodySHA := hs.LastBodySHA
+		body, noChange, err := hs.fetchBody(ctx, false)
 		if err != nil {
-			hs.Logger.Error(err.Error())
+			hs.Logger.Error(fmt.Sprintf("error fetching: %s", err.Error()))
 			return
 		}
 
-		if len(body) == 0 {
+		if body == "" && !noChange {
 			hs.Logger.Debug("configuration deleted")
-		} else {
-			if hs.LastBodySHA == "" {
-				hs.Logger.Debug("new configuration created")
-				msg, err := hs.Fetch(ctx)
-				if err != nil {
-					hs.Logger.Error(fmt.Sprintf("error fetching: %s", err.Error()))
-				} else {
-					dataSync <- sync.DataSync{FlagData: msg, Source: hs.URI, Type: sync.ALL}
-				}
-			} else {
-				currentSHA := hs.generateSha(body)
-				if hs.LastBodySHA != currentSHA {
-					hs.Logger.Debug("configuration modified")
-					msg, err := hs.Fetch(ctx)
-					if err != nil {
-						hs.Logger.Error(fmt.Sprintf("error fetching: %s", err.Error()))
-					} else {
-						dataSync <- sync.DataSync{FlagData: msg, Source: hs.URI, Type: sync.ALL}
-					}
-				}
+			return
+		}
 
-				hs.LastBodySHA = currentSHA
-			}
+		if previousBodySHA == "" {
+			hs.Logger.Debug("configuration created")
+			dataSync <- sync.DataSync{FlagData: body, Source: hs.URI}
+		} else if previousBodySHA != hs.LastBodySHA {
+			hs.Logger.Debug("configuration updated")
+			dataSync <- sync.DataSync{FlagData: body, Source: hs.URI}
 		}
 	})
 
 	hs.Cron.Start()
 
-	dataSync <- sync.DataSync{FlagData: fetch, Source: hs.URI, Type: sync.ALL}
+	dataSync <- sync.DataSync{FlagData: fetch, Source: hs.URI}
 
 	<-ctx.Done()
 	hs.Cron.Stop()
@@ -112,36 +106,80 @@ func (hs *Sync) Sync(ctx context.Context, dataSync chan<- sync.DataSync) error {
 	return nil
 }
 
-func (hs *Sync) fetchBodyFromURL(ctx context.Context, url string) ([]byte, error) {
-	req, err := http.NewRequestWithContext(ctx, "GET", url, bytes.NewBuffer(nil))
+func (hs *Sync) fetchBody(ctx context.Context, fetchAll bool) (string, bool, error) {
+	if hs.URI == "" {
+		return "", false, errors.New("no HTTP URL string set")
+	}
+
+	req, err := http.NewRequestWithContext(ctx, "GET", hs.URI, bytes.NewBuffer(nil))
 	if err != nil {
-		return nil, fmt.Errorf("error creating request for url %s: %w", url, err)
+		return "", false, fmt.Errorf("error creating request for url %s: %w", hs.URI, err)
 	}
 
 	req.Header.Add("Accept", "application/json")
+	req.Header.Add("Accept", "application/yaml")
 
-	if hs.BearerToken != "" {
+	if hs.AuthHeader != "" {
+		req.Header.Set("Authorization", hs.AuthHeader)
+	} else if hs.BearerToken != "" {
 		bearer := fmt.Sprintf("Bearer %s", hs.BearerToken)
 		req.Header.Set("Authorization", bearer)
 	}
 
+	if hs.eTag != "" && !fetchAll {
+		req.Header.Set("If-None-Match", hs.eTag)
+	}
+
 	resp, err := hs.Client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("error calling endpoint %s: %w", url, err)
+		return "", false, fmt.Errorf("error calling endpoint %s: %w", hs.URI, err)
 	}
 	defer func() {
 		err = resp.Body.Close()
 		if err != nil {
-			hs.Logger.Debug(fmt.Sprintf("error closing the response body: %s", err.Error()))
+			hs.Logger.Error(fmt.Sprintf("error closing the response body: %s", err.Error()))
 		}
 	}()
 
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, fmt.Errorf("unable to read body to bytes: %w", err)
+	if resp.StatusCode == 304 {
+		hs.Logger.Debug("no changes detected")
+		return "", true, nil
 	}
 
-	return body, nil
+	statusOK := resp.StatusCode >= 200 && resp.StatusCode < 300
+	if !statusOK {
+		return "", false, fmt.Errorf("error fetching from url %s: %s", hs.URI, resp.Status)
+	}
+
+	if resp.Header.Get("ETag") != "" {
+		hs.eTag = resp.Header.Get("ETag")
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", false, fmt.Errorf("unable to read body to bytes: %w", err)
+	}
+
+	json, err := utils.ConvertToJSON(body, getFileExtensions(hs.URI), resp.Header.Get("Content-Type"))
+	if err != nil {
+		return "", false, fmt.Errorf("error converting response body to json: %w", err)
+	}
+
+	if json != "" {
+		hs.LastBodySHA = hs.generateSha([]byte(body))
+	}
+
+	return json, false, nil
+}
+
+// getFileExtensions returns the file extension from the URL path
+func getFileExtensions(url string) string {
+	u, err := parseUrl.Parse(url)
+	if err != nil {
+		return ""
+	}
+
+	return filepath.Ext(u.Path)
 }
 
 func (hs *Sync) generateSha(body []byte) string {
@@ -151,17 +189,6 @@ func (hs *Sync) generateSha(body []byte) string {
 }
 
 func (hs *Sync) Fetch(ctx context.Context) (string, error) {
-	if hs.URI == "" {
-		return "", errors.New("no HTTP URL string set")
-	}
-
-	body, err := hs.fetchBodyFromURL(ctx, hs.URI)
-	if err != nil {
-		return "", err
-	}
-	if len(body) != 0 {
-		hs.LastBodySHA = hs.generateSha(body)
-	}
-
-	return string(body), nil
+	body, _, err := hs.fetchBody(ctx, false)
+	return body, err
 }

core/pkg/sync/http/http_sync_test.go

@@ -5,32 +5,36 @@ import (
 	"io"
 	"log"
 	"net/http"
-	"reflect"
 	"strings"
 	"testing"
 	"time"
 
-	"github.com/golang/mock/gomock"
 	"github.com/open-feature/flagd/core/pkg/logger"
 	"github.com/open-feature/flagd/core/pkg/sync"
 	syncmock "github.com/open-feature/flagd/core/pkg/sync/http/mock"
+	synctesting "github.com/open-feature/flagd/core/pkg/sync/testing"
+	"go.uber.org/mock/gomock"
 )
 
 func TestSimpleSync(t *testing.T) {
 	ctrl := gomock.NewController(t)
-	resp := "test response"
-
-	mockCron := syncmock.NewMockCron(ctrl)
-	mockCron.EXPECT().AddFunc(gomock.Any(), gomock.Any()).DoAndReturn(func(spec string, cmd func()) error {
+	mockCron := synctesting.NewMockCron(ctrl)
+	mockCron.EXPECT().AddFunc(gomock.Any(), gomock.Any()).DoAndReturn(func(_ string, _ func()) error {
 		return nil
 	})
 	mockCron.EXPECT().Start().Times(1)
 
 	mockClient := syncmock.NewMockClient(ctrl)
-	mockClient.EXPECT().Do(gomock.Any()).Return(&http.Response{Body: io.NopCloser(strings.NewReader(resp))}, nil)
+	responseBody := "test response"
+	resp := &http.Response{
+		Header:     map[string][]string{"Content-Type": {"application/json"}},
+		Body:       io.NopCloser(strings.NewReader(responseBody)),
+		StatusCode: http.StatusOK,
+	}
+	mockClient.EXPECT().Do(gomock.Any()).Return(resp, nil)
 
 	httpSync := Sync{
-		URI:         "http://localhost",
+		URI:         "http://localhost/flags",
 		Client:      mockClient,
 		Cron:        mockCron,
 		LastBodySHA: "",
@@ -50,8 +54,51 @@ func TestSimpleSync(t *testing.T) {
 
 	data := <-dataSyncChan
 
-	if data.FlagData != resp {
-		t.Errorf("expected content: %s, but received content: %s", resp, data.FlagData)
+	if data.FlagData != responseBody {
+		t.Errorf("expected content: %s, but received content: %s", responseBody, data.FlagData)
+	}
+}
+
+func TestExtensionWithQSSync(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	mockCron := synctesting.NewMockCron(ctrl)
+	mockCron.EXPECT().AddFunc(gomock.Any(), gomock.Any()).DoAndReturn(func(_ string, _ func()) error {
+		return nil
+	})
+	mockCron.EXPECT().Start().Times(1)
+
+	mockClient := syncmock.NewMockClient(ctrl)
+	responseBody := "test response"
+	resp := &http.Response{
+		Header:     map[string][]string{"Content-Type": {"application/json"}},
+		Body:       io.NopCloser(strings.NewReader(responseBody)),
+		StatusCode: http.StatusOK,
+	}
+	mockClient.EXPECT().Do(gomock.Any()).Return(resp, nil)
+
+	httpSync := Sync{
+		URI:         "http://localhost/flags.json?env=dev",
+		Client:      mockClient,
+		Cron:        mockCron,
+		LastBodySHA: "",
+		Logger:      logger.NewLogger(nil, false),
+	}
+
+	ctx := context.Background()
+	dataSyncChan := make(chan sync.DataSync)
+
+	go func() {
+		err := httpSync.Sync(ctx, dataSyncChan)
+		if err != nil {
+			log.Fatalf("Error start sync: %s", err.Error())
+			return
+		}
+	}()
+
+	data := <-dataSyncChan
+
+	if data.FlagData != responseBody {
+		t.Errorf("expected content: %s, but received content: %s", responseBody, data.FlagData)
 	}
 }
 
@@ -62,13 +109,17 @@ func TestHTTPSync_Fetch(t *testing.T) {
 		setup          func(t *testing.T, client *syncmock.MockClient)
 		uri            string
 		bearerToken    string
+		authHeader     string
+		eTagHeader     string
 		lastBodySHA    string
 		handleResponse func(*testing.T, Sync, string, error)
 	}{
 		"success": {
-			setup: func(t *testing.T, client *syncmock.MockClient) {
+			setup: func(_ *testing.T, client *syncmock.MockClient) {
 				client.EXPECT().Do(gomock.Any()).Return(&http.Response{
-					Body: io.NopCloser(strings.NewReader("test response")),
+					Header:     map[string][]string{"Content-Type": {"application/json"}},
+					Body:       io.NopCloser(strings.NewReader("test response")),
+					StatusCode: http.StatusOK,
 				}, nil)
 			},
 			uri: "http://localhost",
@@ -83,17 +134,19 @@ func TestHTTPSync_Fetch(t *testing.T) {
 			},
 		},
 		"return an error if no uri": {
-			setup: func(t *testing.T, client *syncmock.MockClient) {},
-			handleResponse: func(t *testing.T, _ Sync, fetched string, err error) {
+			setup: func(_ *testing.T, _ *syncmock.MockClient) {},
+			handleResponse: func(t *testing.T, _ Sync, _ string, err error) {
 				if err == nil {
 					t.Error("expected err, got nil")
 				}
 			},
 		},
 		"update last body sha": {
-			setup: func(t *testing.T, client *syncmock.MockClient) {
+			setup: func(_ *testing.T, client *syncmock.MockClient) {
 				client.EXPECT().Do(gomock.Any()).Return(&http.Response{
-					Body: io.NopCloser(strings.NewReader("test response")),
+					Header:     map[string][]string{"Content-Type": {"application/json"}},
+					Body:       io.NopCloser(strings.NewReader("test response")),
+					StatusCode: http.StatusOK,
 				}, nil)
 			},
 			uri:         "http://localhost",
@@ -111,13 +164,23 @@ func TestHTTPSync_Fetch(t *testing.T) {
 				}
 			},
 		},
-		"authorization header": {
+		"authorization with bearerToken": {
 			setup: func(t *testing.T, client *syncmock.MockClient) {
-				client.EXPECT().Do(gomock.Any()).Return(&http.Response{
-					Body: io.NopCloser(strings.NewReader("test response")),
-				}, nil)
+				expectedToken := "bearer-1234"
+				client.EXPECT().Do(gomock.Any()).DoAndReturn(func(req *http.Request) (*http.Response, error) {
+					actualAuthHeader := req.Header.Get("Authorization")
+					if actualAuthHeader != "Bearer "+expectedToken {
+						t.Fatalf("expected Authorization header to be 'Bearer %s', got %s", expectedToken, actualAuthHeader)
+					}
+					return &http.Response{
+						Header:     map[string][]string{"Content-Type": {"application/json"}},
+						Body:       io.NopCloser(strings.NewReader("test response")),
+						StatusCode: http.StatusOK,
+					}, nil
+				})
 			},
 			uri:         "http://localhost",
+			bearerToken: "bearer-1234",
 			lastBodySHA: "",
 			handleResponse: func(t *testing.T, httpSync Sync, _ string, err error) {
 				if err != nil {
@@ -132,6 +195,131 @@ func TestHTTPSync_Fetch(t *testing.T) {
 				}
 			},
 		},
+		"authorization with authHeader": {
+			setup: func(t *testing.T, client *syncmock.MockClient) {
+				expectedHeader := "Basic dXNlcjpwYXNz"
+				client.EXPECT().Do(gomock.Any()).DoAndReturn(func(req *http.Request) (*http.Response, error) {
+					actualAuthHeader := req.Header.Get("Authorization")
+					if actualAuthHeader != expectedHeader {
+						t.Fatalf("expected Authorization header to be '%s', got %s", expectedHeader, actualAuthHeader)
+					}
+					return &http.Response{
+						Header:     map[string][]string{"Content-Type": {"application/json"}},
+						Body:       io.NopCloser(strings.NewReader("test response")),
+						StatusCode: http.StatusOK,
+					}, nil
+				})
+			},
+			uri:         "http://localhost",
+			authHeader:  "Basic dXNlcjpwYXNz",
+			lastBodySHA: "",
+			handleResponse: func(t *testing.T, httpSync Sync, _ string, err error) {
+				if err != nil {
+					t.Fatalf("fetch: %v", err)
+				}
+
+				expectedLastBodySHA := "UjeJHtCU_wb7OHK-tbPoHycw0TqlHzkWJmH4y6cqg50="
+				if httpSync.LastBodySHA != expectedLastBodySHA {
+					t.Errorf(
+						"expected last body sha to be: '%s', got: '%s'", expectedLastBodySHA, httpSync.LastBodySHA,
+					)
+				}
+			},
+		},
+		"unauthorized request": {
+			setup: func(_ *testing.T, client *syncmock.MockClient) {
+				client.EXPECT().Do(gomock.Any()).Return(&http.Response{
+					Header:     map[string][]string{"Content-Type": {"application/json"}},
+					Body:       io.NopCloser(strings.NewReader("test response")),
+					StatusCode: http.StatusUnauthorized,
+				}, nil)
+			},
+			uri: "http://localhost",
+			handleResponse: func(t *testing.T, _ Sync, _ string, err error) {
+				if err == nil {
+					t.Fatalf("expected unauthorized request to return an error")
+				}
+			},
+		},
+		"not modified response etag matched": {
+			setup: func(t *testing.T, client *syncmock.MockClient) {
+				expectedIfNoneMatch := `"1af17a664e3fa8e419b8ba05c2a173169df76162a5a286e0c405b460d478f7ef"`
+				client.EXPECT().Do(gomock.Any()).DoAndReturn(func(req *http.Request) (*http.Response, error) {
+					actualIfNoneMatch := req.Header.Get("If-None-Match")
+					if actualIfNoneMatch != expectedIfNoneMatch {
+						t.Fatalf("expected If-None-Match header to be '%s', got %s", expectedIfNoneMatch, actualIfNoneMatch)
+					}
+					return &http.Response{
+						Header:     map[string][]string{"ETag": {expectedIfNoneMatch}},
+						Body:       io.NopCloser(strings.NewReader("")),
+						StatusCode: http.StatusNotModified,
+					}, nil
+				})
+			},
+			uri:        "http://localhost",
+			eTagHeader: `"1af17a664e3fa8e419b8ba05c2a173169df76162a5a286e0c405b460d478f7ef"`,
+			handleResponse: func(t *testing.T, httpSync Sync, _ string, err error) {
+				if err != nil {
+					t.Fatalf("fetch: %v", err)
+				}
+
+				expectedLastBodySHA := ""
+				expectedETag := `"1af17a664e3fa8e419b8ba05c2a173169df76162a5a286e0c405b460d478f7ef"`
+				if httpSync.LastBodySHA != expectedLastBodySHA {
+					t.Errorf(
+						"expected last body sha to be: '%s', got: '%s'", expectedLastBodySHA, httpSync.LastBodySHA,
+					)
+				}
+				if httpSync.eTag != expectedETag {
+					t.Errorf(
+						"expected last etag to be: '%s', got: '%s'", expectedETag, httpSync.eTag,
+					)
+				}
+			},
+		},
+		"modified response etag mismatched": {
+			setup: func(t *testing.T, client *syncmock.MockClient) {
+				expectedIfNoneMatch := `"1af17a664e3fa8e419b8ba05c2a173169df76162a5a286e0c405b460d478f7ef"`
+				client.EXPECT().Do(gomock.Any()).DoAndReturn(func(req *http.Request) (*http.Response, error) {
+					actualIfNoneMatch := req.Header.Get("If-None-Match")
+					if actualIfNoneMatch != expectedIfNoneMatch {
+						t.Fatalf("expected If-None-Match header to be '%s', got %s", expectedIfNoneMatch, actualIfNoneMatch)
+					}
+
+					newContent := "\"Hey there!\""
+					newETag := `"c2e01ce63d90109c4c7f4f6dcea97ed1bb2b51e3647f36caf5acbe27413a24bb"`
+
+					return &http.Response{
+						Header: map[string][]string{
+							"Content-Type": {"application/json"},
+							"Etag":         {newETag},
+						},
+						Body:       io.NopCloser(strings.NewReader(newContent)),
+						StatusCode: http.StatusOK,
+					}, nil
+				})
+			},
+			uri:        "http://localhost",
+			eTagHeader: `"1af17a664e3fa8e419b8ba05c2a173169df76162a5a286e0c405b460d478f7ef"`,
+			handleResponse: func(t *testing.T, httpSync Sync, _ string, err error) {
+				if err != nil {
+					t.Fatalf("fetch: %v", err)
+				}
+
+				expectedLastBodySHA := "wuAc5j2QEJxMf09tzql-0bsrUeNkfzbK9ay-J0E6JLs="
+				expectedETag := `"c2e01ce63d90109c4c7f4f6dcea97ed1bb2b51e3647f36caf5acbe27413a24bb"`
+				if httpSync.LastBodySHA != expectedLastBodySHA {
+					t.Errorf(
+						"expected last body sha to be: '%s', got: '%s'", expectedLastBodySHA, httpSync.LastBodySHA,
+					)
+				}
+				if httpSync.eTag != expectedETag {
+					t.Errorf(
+						"expected last etag to be: '%s', got: '%s'", expectedETag, httpSync.eTag,
+					)
+				}
+			},
+		},
 	}
 
 	for name, tt := range tests {
@@ -144,8 +332,10 @@ func TestHTTPSync_Fetch(t *testing.T) {
 				URI:         tt.uri,
 				Client:      mockClient,
 				BearerToken: tt.bearerToken,
+				AuthHeader:  tt.authHeader,
 				LastBodySHA: tt.lastBodySHA,
 				Logger:      logger.NewLogger(nil, false),
+				eTag:        tt.eTagHeader,
 			}
 
 			fetched, err := httpSync.Fetch(context.Background())
@@ -154,8 +344,33 @@ func TestHTTPSync_Fetch(t *testing.T) {
 	}
 }
 
+func TestSync_Init(t *testing.T) {
+	tests := []struct {
+		name        string
+		bearerToken string
+	}{
+		{"with bearerToken", "bearer-1234"},
+		{"without bearerToken", ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			httpSync := Sync{
+				BearerToken: tt.bearerToken,
+				Logger:      logger.NewLogger(nil, false),
+			}
+
+			if err := httpSync.Init(context.Background()); err != nil {
+				t.Errorf("Init() error = %v", err)
+			}
+		})
+	}
+}
+
 func TestHTTPSync_Resync(t *testing.T) {
 	ctrl := gomock.NewController(t)
+	source := "http://localhost"
+	emptyFlagData := "{}"
 
 	tests := map[string]struct {
 		setup             func(t *testing.T, client *syncmock.MockClient)
@@ -167,12 +382,14 @@ func TestHTTPSync_Resync(t *testing.T) {
 		wantNotifications []sync.DataSync
 	}{
 		"success": {
-			setup: func(t *testing.T, client *syncmock.MockClient) {
+			setup: func(_ *testing.T, client *syncmock.MockClient) {
 				client.EXPECT().Do(gomock.Any()).Return(&http.Response{
-					Body: io.NopCloser(strings.NewReader("test response")),
+					Header:     map[string][]string{"Content-Type": {"application/json"}},
+					Body:       io.NopCloser(strings.NewReader(emptyFlagData)),
+					StatusCode: http.StatusOK,
 				}, nil)
 			},
-			uri: "http://localhost",
+			uri: source,
 			handleResponse: func(t *testing.T, _ Sync, fetched string, err error) {
 				if err != nil {
 					t.Fatalf("fetch: %v", err)
@@ -185,15 +402,14 @@ func TestHTTPSync_Resync(t *testing.T) {
 			wantErr: false,
 			wantNotifications: []sync.DataSync{
 				{
-					Type:     sync.ALL,
-					FlagData: "",
-					Source:   "",
+					FlagData: emptyFlagData,
+					Source:   source,
 				},
 			},
 		},
 		"error response": {
-			setup: func(t *testing.T, client *syncmock.MockClient) {},
-			handleResponse: func(t *testing.T, _ Sync, fetched string, err error) {
+			setup: func(_ *testing.T, _ *syncmock.MockClient) {},
+			handleResponse: func(t *testing.T, _ Sync, _ string, err error) {
 				if err == nil {
 					t.Error("expected err, got nil")
 				}
@@ -229,8 +445,8 @@ func TestHTTPSync_Resync(t *testing.T) {
 			for _, dataSync := range tt.wantNotifications {
 				select {
 				case x := <-d:
-					if !reflect.DeepEqual(x.String(), dataSync.String()) {
-						t.Error("unexpected datasync received", x, dataSync)
+					if x.FlagData != dataSync.FlagData || x.Source != dataSync.Source {
+						t.Errorf("unexpected datasync received %v vs %v", x, dataSync)
 					}
 				case <-time.After(2 * time.Second):
 					t.Error("expected datasync not received", dataSync)

core/pkg/sync/http/mock/http.go

@@ -1,5 +1,10 @@
 // Code generated by MockGen. DO NOT EDIT.
 // Source: pkg/sync/http/http_sync.go
+//
+// Generated by this command:
+//
+//	mockgen -source=pkg/sync/http/http_sync.go -destination=pkg/sync/http/mock/http.go -package=syncmock
+//
 
 // Package syncmock is a generated GoMock package.
 package syncmock
@@ -8,7 +13,7 @@ import (
 	http "net/http"
 	reflect "reflect"
 
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockClient is a mock of Client interface.
@@ -44,68 +49,7 @@ func (m *MockClient) Do(req *http.Request) (*http.Response, error) {
 }
 
 // Do indicates an expected call of Do.
-func (mr *MockClientMockRecorder) Do(req interface{}) *gomock.Call {
+func (mr *MockClientMockRecorder) Do(req any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Do", reflect.TypeOf((*MockClient)(nil).Do), req)
 }
-
-// MockCron is a mock of Cron interface.
-type MockCron struct {
-	ctrl     *gomock.Controller
-	recorder *MockCronMockRecorder
-}
-
-// MockCronMockRecorder is the mock recorder for MockCron.
-type MockCronMockRecorder struct {
-	mock *MockCron
-}
-
-// NewMockCron creates a new mock instance.
-func NewMockCron(ctrl *gomock.Controller) *MockCron {
-	mock := &MockCron{ctrl: ctrl}
-	mock.recorder = &MockCronMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockCron) EXPECT() *MockCronMockRecorder {
-	return m.recorder
-}
-
-// AddFunc mocks base method.
-func (m *MockCron) AddFunc(spec string, cmd func()) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AddFunc", spec, cmd)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// AddFunc indicates an expected call of AddFunc.
-func (mr *MockCronMockRecorder) AddFunc(spec, cmd interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddFunc", reflect.TypeOf((*MockCron)(nil).AddFunc), spec, cmd)
-}
-
-// Start mocks base method.
-func (m *MockCron) Start() {
-	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "Start")
-}
-
-// Start indicates an expected call of Start.
-func (mr *MockCronMockRecorder) Start() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockCron)(nil).Start))
-}
-
-// Stop mocks base method.
-func (m *MockCron) Stop() {
-	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "Stop")
-}
-
-// Stop indicates an expected call of Stop.
-func (mr *MockCronMockRecorder) Stop() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockCron)(nil).Stop))
-}

core/pkg/sync/isync.go

@@ -1,36 +1,11 @@
 package sync
 
-import "context"
+import (
+	"context"
 
-type Type int
-
-// Type of the sync operation
-const (
-	// ALL - All flags of sync provider. This is the default if unset due to primitive default
-	ALL Type = iota
-	// ADD - Additional flags from sync provider
-	ADD
-	// UPDATE - Update for flag(s) previously provided
-	UPDATE
-	// DELETE - Delete for flag(s) previously provided
-	DELETE
+	"google.golang.org/protobuf/types/known/structpb"
 )
 
-func (t Type) String() string {
-	switch t {
-	case ALL:
-		return "ALL"
-	case ADD:
-		return "ADD"
-	case UPDATE:
-		return "UPDATE"
-	case DELETE:
-		return "DELETE"
-	default:
-		return "UNKNOWN"
-	}
-}
-
 /*
 ISync implementations watch for changes in the flag sources (HTTP backend, local file, K8s CRDs ...),fetch the latest
 value and communicate to the Runtime with DataSync channel
@@ -53,7 +28,23 @@ type ISync interface {
 
 // DataSync is the data contract between Runtime and sync implementations
 type DataSync struct {
-	FlagData string
-	Source   string
-	Type
+	FlagData    string
+	SyncContext *structpb.Struct
+	Source      string
+	Selector    string
+}
+
+// SourceConfig is configuration option for flagd. This maps to startup parameter sources
+type SourceConfig struct {
+	URI      string `json:"uri"`
+	Provider string `json:"provider"`
+
+	BearerToken string `json:"bearerToken,omitempty"`
+	AuthHeader  string `json:"authHeader,omitempty"`
+	CertPath    string `json:"certPath,omitempty"`
+	TLS         bool   `json:"tls,omitempty"`
+	ProviderID  string `json:"providerID,omitempty"`
+	Selector    string `json:"selector,omitempty"`
+	Interval    uint32 `json:"interval,omitempty"`
+	MaxMsgSize  int    `json:"maxMsgSize,omitempty"`
 }

core/pkg/sync/kubernetes/kubernetes_sync.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"os"
 	"strings"
 	msync "sync"
 	"time"
@@ -12,15 +11,14 @@ import (
 	"github.com/open-feature/flagd/core/pkg/logger"
 	"github.com/open-feature/flagd/core/pkg/sync"
 	"github.com/open-feature/open-feature-operator/apis/core/v1beta1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/dynamic"
 	"k8s.io/client-go/dynamic/dynamicinformer"
 	"k8s.io/client-go/kubernetes/scheme"
-	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/cache"
-	"k8s.io/client-go/tools/clientcmd"
-	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
 var (
@@ -29,6 +27,8 @@ var (
 	featureFlagResource = v1beta1.GroupVersion.WithResource("featureflags")
 )
 
+type SyncOption func(s *Sync)
+
 type Sync struct {
 	URI string
 
@@ -36,7 +36,6 @@ type Sync struct {
 	namespace     string
 	crdName       string
 	logger        *logger.Logger
-	readClient    client.Reader
 	dynamicClient dynamic.Interface
 	informer      cache.SharedInformer
 }
@@ -44,41 +43,21 @@ type Sync struct {
 func NewK8sSync(
 	logger *logger.Logger,
 	uri string,
-	reader client.Reader,
-	dynamic dynamic.Interface,
+	dynamicClient dynamic.Interface,
 ) *Sync {
 	return &Sync{
 		logger:        logger,
 		URI:           uri,
-		readClient:    reader,
-		dynamicClient: dynamic,
+		dynamicClient: dynamicClient,
 	}
 }
 
-func GetClients() (client.Reader, dynamic.Interface, error) {
-	clusterConfig, err := k8sClusterConfig()
-	if err != nil {
-		return nil, nil, err
-	}
-
-	readClient, err := client.New(clusterConfig, client.Options{Scheme: scheme.Scheme})
-	if err != nil {
-		return nil, nil, fmt.Errorf("unable to create readClient: %w", err)
-	}
-
-	dynamicClient, err := dynamic.NewForConfig(clusterConfig)
-	if err != nil {
-		return nil, nil, fmt.Errorf("unable to create dynamicClient: %w", err)
-	}
-	return readClient, dynamicClient, nil
-}
-
 func (k *Sync) ReSync(ctx context.Context, dataSync chan<- sync.DataSync) error {
 	fetch, err := k.fetch(ctx)
 	if err != nil {
 		return fmt.Errorf("unable to fetch flag configuration: %w", err)
 	}
-	dataSync <- sync.DataSync{FlagData: fetch, Source: k.URI, Type: sync.ALL}
+	dataSync <- sync.DataSync{FlagData: fetch, Source: k.URI}
 	return nil
 }
 
@@ -118,7 +97,7 @@ func (k *Sync) Sync(ctx context.Context, dataSync chan<- sync.DataSync) error {
 		return err
 	}
 
-	dataSync <- sync.DataSync{FlagData: fetch, Source: k.URI, Type: sync.ALL}
+	dataSync <- sync.DataSync{FlagData: fetch, Source: k.URI}
 
 	notifies := make(chan INotify)
 
@@ -157,7 +136,7 @@ func (k *Sync) watcher(ctx context.Context, notifies chan INotify, dataSync chan
 					continue
 				}
 
-				dataSync <- sync.DataSync{FlagData: msg, Source: k.URI, Type: sync.ALL}
+				dataSync <- sync.DataSync{FlagData: msg, Source: k.URI}
 			case DefaultEventTypeModify:
 				k.logger.Debug("Configuration modified")
 				msg, err := k.fetch(ctx)
@@ -166,7 +145,7 @@ func (k *Sync) watcher(ctx context.Context, notifies chan INotify, dataSync chan
 					continue
 				}
 
-				dataSync <- sync.DataSync{FlagData: msg, Source: k.URI, Type: sync.ALL}
+				dataSync <- sync.DataSync{FlagData: msg, Source: k.URI}
 			case DefaultEventTypeDelete:
 				k.logger.Debug("configuration deleted")
 			case DefaultEventTypeReady:
@@ -196,24 +175,30 @@ func (k *Sync) fetch(ctx context.Context) (string, error) {
 	}
 
 	// fallback to API access - this is an informer cache miss. Could happen at the startup where cache is not filled
-	var ff v1beta1.FeatureFlag
-	err = k.readClient.Get(ctx, client.ObjectKey{
-		Name:      k.crdName,
-		Namespace: k.namespace,
-	}, &ff)
+
+	ffObj, err := k.dynamicClient.
+		Resource(featureFlagResource).
+		Namespace(k.namespace).
+		Get(ctx, k.crdName, metav1.GetOptions{})
 	if err != nil {
 		return "", fmt.Errorf("unable to fetch FeatureFlag %s/%s: %w", k.namespace, k.crdName, err)
 	}
 
 	k.logger.Debug(fmt.Sprintf("resource %s served from API server", k.URI))
-	return marshallFeatureFlagSpec(&ff)
+
+	ff, err := toFFCfg(ffObj)
+	if err != nil {
+		return "", fmt.Errorf("unable to convert object %s/%s to FeatureFlag: %w", k.namespace, k.crdName, err)
+	}
+	return marshallFeatureFlagSpec(ff)
 }
 
 func (k *Sync) notify(ctx context.Context, c chan<- INotify) {
-	objectKey := client.ObjectKey{
+	objectKey := types.NamespacedName{
 		Name:      k.crdName,
 		Namespace: k.namespace,
 	}
+
 	if _, err := k.informer.AddEventHandler(cache.ResourceEventHandlerFuncs{
 		AddFunc: func(obj interface{}) {
 			k.logger.Info(fmt.Sprintf("kube sync notifier event: add: %s %s", objectKey.Namespace, objectKey.Name))
@@ -247,7 +232,7 @@ func (k *Sync) notify(ctx context.Context, c chan<- INotify) {
 }
 
 // commonHandler emits the desired event if and only if handler receive an object matching apiVersion and resource name
-func commonHandler(obj interface{}, object client.ObjectKey, emitEvent DefaultEventType, c chan<- INotify) error {
+func commonHandler(obj interface{}, object types.NamespacedName, emitEvent DefaultEventType, c chan<- INotify) error {
 	ffObj, err := toFFCfg(obj)
 	if err != nil {
 		return err
@@ -269,7 +254,7 @@ func commonHandler(obj interface{}, object client.ObjectKey, emitEvent DefaultEv
 }
 
 // updateFuncHandler handles updates. Event is emitted if and only if resource name, apiVersion of old & new are equal
-func updateFuncHandler(oldObj interface{}, newObj interface{}, object client.ObjectKey, c chan<- INotify) error {
+func updateFuncHandler(oldObj interface{}, newObj interface{}, object types.NamespacedName, c chan<- INotify) error {
 	ffOldObj, err := toFFCfg(oldObj)
 	if err != nil {
 		return err
@@ -325,32 +310,6 @@ func parseURI(uri string) (string, string, error) {
 	return s[0], s[1], nil
 }
 
-// k8sClusterConfig build K8s connection config based available configurations
-func k8sClusterConfig() (*rest.Config, error) {
-	cfg := os.Getenv("KUBECONFIG")
-
-	var clusterConfig *rest.Config
-	var err error
-
-	if cfg != "" {
-		clusterConfig, err = clientcmd.BuildConfigFromFlags("", cfg)
-		if err != nil {
-			err = fmt.Errorf("error building cluster config from flags: %w", err)
-		}
-	} else {
-		clusterConfig, err = rest.InClusterConfig()
-		if err != nil {
-			err = fmt.Errorf("error fetch cluster config: %w", err)
-		}
-	}
-
-	if err != nil {
-		return nil, err
-	}
-
-	return clusterConfig, nil
-}
-
 func marshallFeatureFlagSpec(ff *v1beta1.FeatureFlag) (string, error) {
 	b, err := json.Marshal(ff.Spec.FlagSpec)
 	if err != nil {

core/pkg/sync/kubernetes/kubernetes_sync_test.go

@@ -18,12 +18,11 @@ import (
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/dynamic/fake"
 	"k8s.io/client-go/kubernetes/scheme"
+	testing2 "k8s.io/client-go/testing"
 	"k8s.io/client-go/tools/cache"
-	"sigs.k8s.io/controller-runtime/pkg/client"
-	fakeClient "sigs.k8s.io/controller-runtime/pkg/client/fake"
-	"sigs.k8s.io/controller-runtime/pkg/controller/controllertest"
 )
 
 var Metadata = v1.TypeMeta{
@@ -131,7 +130,7 @@ func Test_commonHandler(t *testing.T) {
 
 	type args struct {
 		obj    interface{}
-		object client.ObjectKey
+		object types.NamespacedName
 	}
 	tests := []struct {
 		name      string
@@ -144,7 +143,7 @@ func Test_commonHandler(t *testing.T) {
 			name: "simple success",
 			args: args{
 				obj: toUnstructured(t, validFFCfg),
-				object: client.ObjectKey{
+				object: types.NamespacedName{
 					Namespace: cfgNs,
 					Name:      cfgName,
 				},
@@ -156,7 +155,7 @@ func Test_commonHandler(t *testing.T) {
 			name: "simple scenario - only notify if resource name matches",
 			args: args{
 				obj: toUnstructured(t, validFFCfg),
-				object: client.ObjectKey{
+				object: types.NamespacedName{
 					Namespace: cfgNs,
 					Name:      "SomeOtherResource",
 				},
@@ -173,7 +172,7 @@ func Test_commonHandler(t *testing.T) {
 						APIVersion: "someAPIVersion",
 					},
 				}),
-				object: client.ObjectKey{
+				object: types.NamespacedName{
 					Namespace: cfgNs,
 					Name:      cfgName,
 				},
@@ -243,7 +242,7 @@ func Test_updateFuncHandler(t *testing.T) {
 	type args struct {
 		oldObj interface{}
 		newObj interface{}
-		object client.ObjectKey
+		object types.NamespacedName
 	}
 	tests := []struct {
 		name      string
@@ -256,7 +255,7 @@ func Test_updateFuncHandler(t *testing.T) {
 			args: args{
 				oldObj: toUnstructured(t, validFFCfgOld),
 				newObj: toUnstructured(t, validFFCfgNew),
-				object: client.ObjectKey{
+				object: types.NamespacedName{
 					Namespace: cfgNs,
 					Name:      cfgName,
 				},
@@ -269,7 +268,7 @@ func Test_updateFuncHandler(t *testing.T) {
 			args: args{
 				oldObj: toUnstructured(t, validFFCfgOld),
 				newObj: toUnstructured(t, validFFCfgNew),
-				object: client.ObjectKey{
+				object: types.NamespacedName{
 					Namespace: cfgNs,
 					Name:      "SomeOtherResource",
 				},
@@ -282,7 +281,7 @@ func Test_updateFuncHandler(t *testing.T) {
 			args: args{
 				oldObj: toUnstructured(t, validFFCfgOld),
 				newObj: toUnstructured(t, validFFCfgOld),
-				object: client.ObjectKey{
+				object: types.NamespacedName{
 					Namespace: cfgNs,
 					Name:      "SomeOtherResource",
 				},
@@ -300,7 +299,7 @@ func Test_updateFuncHandler(t *testing.T) {
 						APIVersion: "someAPIVersion",
 					},
 				}),
-				object: client.ObjectKey{
+				object: types.NamespacedName{
 					Namespace: cfgNs,
 					Name:      cfgName,
 				},
@@ -318,7 +317,7 @@ func Test_updateFuncHandler(t *testing.T) {
 					},
 				}),
 				newObj: toUnstructured(t, validFFCfgNew),
-				object: client.ObjectKey{
+				object: types.NamespacedName{
 					Namespace: cfgNs,
 					Name:      cfgName,
 				},
@@ -371,7 +370,7 @@ func Test_updateFuncHandler(t *testing.T) {
 
 func TestSync_fetch(t *testing.T) {
 	flagSpec := v1beta1.FlagSpec{
-		Flags: map[string]v1beta1.Flag{},
+		Flags: v1beta1.Flags{FlagsMap: map[string]v1beta1.Flag{}},
 	}
 
 	validCfg := v1beta1.FeatureFlag{
@@ -387,54 +386,64 @@ func TestSync_fetch(t *testing.T) {
 	}
 
 	type args struct {
-		InformerGetFunc func(key string) (item interface{}, exists bool, err error)
-		ClientResponse  v1beta1.FeatureFlag
-		ClientError     error
+		ClientResponse v1beta1.FeatureFlag
+		ClientError    error
 	}
 
 	tests := []struct {
-		name    string
-		args    args
-		want    string
-		wantErr bool
+		name          string
+		args          args
+		injectionFunc func(s *Sync)
+		want          string
+		wantErr       bool
 	}{
 		{
 			name: "Scenario - get from informer cache",
-			args: args{
-				InformerGetFunc: func(key string) (item interface{}, exists bool, err error) {
-					return toUnstructured(t, validCfg), true, nil
-				},
+			injectionFunc: func(s *Sync) {
+				s.URI = fmt.Sprintf("%s/%s", validCfg.Namespace, validCfg.Name)
+				s.dynamicClient = fake.NewSimpleDynamicClient(scheme.Scheme, &validCfg)
+				err := s.Init(context.Background())
+				require.Nil(t, err)
 			},
 			wantErr: false,
 			want:    `{"flags":{}}`,
 		},
 		{
 			name: "Scenario - get from API if informer cache miss",
-			args: args{
-				InformerGetFunc: func(key string) (item interface{}, exists bool, err error) {
-					return nil, false, nil
-				},
-				ClientResponse: validCfg,
+			injectionFunc: func(s *Sync) {
+				s.URI = fmt.Sprintf("%s/%s", validCfg.Namespace, validCfg.Name)
+				s.dynamicClient = fake.NewSimpleDynamicClient(scheme.Scheme, &validCfg)
+				err := s.Init(context.Background())
+				require.Nil(t, err)
 			},
 			wantErr: false,
 			want:    `{"flags":{}}`,
 		},
 		{
 			name: "Scenario - error for informer cache read error",
-			args: args{
-				InformerGetFunc: func(key string) (item interface{}, exists bool, err error) {
-					return nil, false, errors.New("mock error")
-				},
+			injectionFunc: func(s *Sync) {
+				s.URI = fmt.Sprintf("%s/%s", validCfg.Namespace, validCfg.Name)
+				s.informer = &MockInformer{
+					fakeStore: cache.FakeCustomStore{
+						GetByKeyFunc: func(key string) (item interface{}, exists bool, err error) {
+							return nil, false, errors.New("mock error")
+						},
+					},
+				}
 			},
 			wantErr: true,
 		},
 		{
 			name: "Scenario - error for API get error",
-			args: args{
-				InformerGetFunc: func(key string) (item interface{}, exists bool, err error) {
-					return nil, false, nil
-				},
-				ClientError: errors.New("mock error"),
+			injectionFunc: func(s *Sync) {
+				s.URI = fmt.Sprintf("%s/%s", validCfg.Namespace, validCfg.Name)
+				fakeClient := fake.NewSimpleDynamicClient(scheme.Scheme, &validCfg)
+				fakeClient.PrependReactor("get", "featureflags", func(action testing2.Action) (handled bool, ret runtime.Object, err error) {
+					return true, nil, errors.New("could not get ff config")
+				})
+				s.dynamicClient = fakeClient
+				err := s.Init(context.Background())
+				require.Nil(t, err)
 			},
 			wantErr: true,
 		},
@@ -443,18 +452,13 @@ func TestSync_fetch(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			// Setup with args
 			k := &Sync{
-				informer: &MockInformer{
-					fakeStore: cache.FakeCustomStore{
-						GetByKeyFunc: tt.args.InformerGetFunc,
-					},
-				},
-				readClient: &MockClient{
-					getResponse: tt.args.ClientResponse,
-					clientErr:   tt.args.ClientError,
-				},
 				logger: logger.NewLogger(nil, false),
 			}
 
+			if tt.injectionFunc != nil {
+				tt.injectionFunc(k)
+			}
+
 			// Test fetch
 			got, err := k.fetch(context.Background())
 
@@ -473,7 +477,7 @@ func TestSync_fetch(t *testing.T) {
 func TestSync_watcher(t *testing.T) {
 	flagSpec := v1beta1.FeatureFlagSpec{
 		FlagSpec: v1beta1.FlagSpec{
-			Flags: map[string]v1beta1.Flag{},
+			Flags: v1beta1.Flags{FlagsMap: map[string]v1beta1.Flag{}},
 		},
 	}
 
@@ -603,18 +607,12 @@ func TestInit(t *testing.T) {
 func TestSync_ReSync(t *testing.T) {
 	const name = "myFF"
 	const ns = "myNS"
+	const payload = "{\"flags\":null}"
 	s := runtime.NewScheme()
 	ff := &unstructured.Unstructured{}
 	ff.SetUnstructuredContent(getCFG(name, ns))
 	fakeDynamicClient := fake.NewSimpleDynamicClient(s, ff)
-	validFFCfg := &v1beta1.FeatureFlag{
-		TypeMeta: Metadata,
-		ObjectMeta: v1.ObjectMeta{
-			Name:      name,
-			Namespace: ns,
-		},
-	}
-	fakeReadClient := newFakeReadClient(validFFCfg)
+
 	l, err := logger.NewZapLogger(zapcore.FatalLevel, "console")
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
@@ -631,7 +629,6 @@ func TestSync_ReSync(t *testing.T) {
 			k: Sync{
 				URI:           fmt.Sprintf("%s/%s", ns, name),
 				dynamicClient: fakeDynamicClient,
-				readClient:    fakeReadClient,
 				namespace:     ns,
 				logger:        logger.NewLogger(l, true),
 			},
@@ -643,7 +640,6 @@ func TestSync_ReSync(t *testing.T) {
 			k: Sync{
 				URI:           fmt.Sprintf("doesnt%s/exist%s", ns, name),
 				dynamicClient: fakeDynamicClient,
-				readClient:    fakeReadClient,
 				namespace:     ns,
 				logger:        logger.NewLogger(l, true),
 			},
@@ -673,8 +669,8 @@ func TestSync_ReSync(t *testing.T) {
 				i := tt.countMsg
 				for i > 0 {
 					d := <-dataChannel
-					if d.Type != sync.ALL {
-						t.Errorf("Expected %v, got %v", sync.ALL, d)
+					if d.FlagData != payload {
+						t.Errorf("Expected %v, got %v", payload, d.FlagData)
 					}
 					i--
 				}
@@ -786,31 +782,6 @@ func TestNotify(t *testing.T) {
 	}
 }
 
-func Test_k8sClusterConfig(t *testing.T) {
-	t.Run("Cannot find KUBECONFIG file", func(tt *testing.T) {
-		tt.Setenv("KUBECONFIG", "")
-		_, err := k8sClusterConfig()
-		if err == nil {
-			tt.Error("Expected error but got none")
-		}
-	})
-	t.Run("KUBECONFIG file not existing", func(tt *testing.T) {
-		tt.Setenv("KUBECONFIG", "value")
-		_, err := k8sClusterConfig()
-		if err == nil {
-			tt.Error("Expected error but got none")
-		}
-	})
-	t.Run("Default REST Config and missing svc account", func(tt *testing.T) {
-		tt.Setenv("KUBERNETES_SERVICE_HOST", "127.0.0.1")
-		tt.Setenv("KUBERNETES_SERVICE_PORT", "8080")
-		_, err := k8sClusterConfig()
-		if err == nil {
-			tt.Error("Expected error but got none")
-		}
-	})
-}
-
 func Test_NewK8sSync(t *testing.T) {
 	l, err := logger.NewZapLogger(zapcore.FatalLevel, "console")
 	if err != nil {
@@ -818,12 +789,10 @@ func Test_NewK8sSync(t *testing.T) {
 	}
 	const uri = "myURI"
 	log := logger.NewLogger(l, true)
-	rc := newFakeReadClient()
 	dc := fake.NewSimpleDynamicClient(runtime.NewScheme())
 	k := NewK8sSync(
 		log,
 		uri,
-		rc,
 		dc,
 	)
 	if k == nil {
@@ -835,19 +804,11 @@ func Test_NewK8sSync(t *testing.T) {
 	if k.logger != log {
 		t.Errorf("Object not initialized with the right logger")
 	}
-	if k.readClient != rc {
-		t.Errorf("Object not initialized with the right K8s client")
-	}
 	if k.dynamicClient != dc {
 		t.Errorf("Object not initialized with the right K8s dynamic client")
 	}
 }
 
-func newFakeReadClient(objs ...client.Object) client.Client {
-	_ = v1beta1.AddToScheme(scheme.Scheme)
-	return fakeClient.NewClientBuilder().WithScheme(scheme.Scheme).WithObjects(objs...).Build()
-}
-
 func getCFG(name, namespace string) map[string]interface{} {
 	return map[string]interface{}{
 		"apiVersion": "core.openfeature.dev/v1beta1",
@@ -879,38 +840,14 @@ func toUnstructured(t *testing.T, obj interface{}) interface{} {
 
 // Mock implementations
 
-// MockClient contains an embedded client.Reader for desired method overriding
-type MockClient struct {
-	client.Reader
-	clientErr error
-
-	getResponse v1beta1.FeatureFlag
-}
-
-func (m MockClient) Get(_ context.Context, _ client.ObjectKey, obj client.Object, _ ...client.GetOption) error {
-	// return error if error is set
-	if m.clientErr != nil {
-		return m.clientErr
-	}
-
-	// else try returning response
-	cfg, ok := obj.(*v1beta1.FeatureFlag)
-	if !ok {
-		return errors.New("must contain a pointer typed v1beta1.FeatureFlag")
-	}
-
-	*cfg = m.getResponse
-	return nil
-}
-
 // MockInformer contains an embedded controllertest.FakeInformer for desired method overriding
 type MockInformer struct {
-	controllertest.FakeInformer
-
+	cache.SharedInformer
+	fake.FakeDynamicClient
 	fakeStore cache.FakeCustomStore
 }
 
-func (m MockInformer) GetStore() cache.Store {
+func (m *MockInformer) GetStore() cache.Store {
 	return &m.fakeStore
 }
 
@@ -918,9 +855,11 @@ func TestMeasure(t *testing.T) {
 	res, err := marshallFeatureFlagSpec(&v1beta1.FeatureFlag{
 		Spec: v1beta1.FeatureFlagSpec{
 			FlagSpec: v1beta1.FlagSpec{
-				Flags: map[string]v1beta1.Flag{
-					"flag": {
-						DefaultVariant: "kubernetes",
+				Flags: v1beta1.Flags{
+					FlagsMap: map[string]v1beta1.Flag{
+						"flag": {
+							DefaultVariant: "kubernetes",
+						},
 					},
 				},
 			},

core/pkg/sync/testing/mock_cron.go

@@ -0,0 +1,74 @@
+package testing
+
+import (
+	"reflect"
+
+	"go.uber.org/mock/gomock"
+)
+
+// MockCron is a mock of Cron interface.
+type MockCron struct {
+	ctrl     *gomock.Controller
+	recorder *MockCronMockRecorder
+	cmd      func()
+}
+
+// MockCronMockRecorder is the mock recorder for MockCron.
+type MockCronMockRecorder struct {
+	mock *MockCron
+}
+
+// NewMockCron creates a new mock instance.
+func NewMockCron(ctrl *gomock.Controller) *MockCron {
+	mock := &MockCron{ctrl: ctrl}
+	mock.recorder = &MockCronMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockCron) EXPECT() *MockCronMockRecorder {
+	return m.recorder
+}
+
+// AddFunc mocks base method.
+func (m *MockCron) AddFunc(spec string, cmd func()) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AddFunc", spec, cmd)
+	ret0, _ := ret[0].(error)
+	m.cmd = cmd
+	return ret0
+}
+
+func (m *MockCron) Tick() {
+	m.cmd()
+}
+
+// AddFunc indicates an expected call of AddFunc.
+func (mr *MockCronMockRecorder) AddFunc(spec, cmd any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddFunc", reflect.TypeOf((*MockCron)(nil).AddFunc), spec, cmd)
+}
+
+// Start mocks base method.
+func (m *MockCron) Start() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Start")
+}
+
+// Start indicates an expected call of Start.
+func (mr *MockCronMockRecorder) Start() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockCron)(nil).Start))
+}
+
+// Stop mocks base method.
+func (m *MockCron) Stop() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Stop")
+}
+
+// Stop indicates an expected call of Stop.
+func (mr *MockCronMockRecorder) Stop() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockCron)(nil).Stop))
+}

core/pkg/telemetry/builder.go

@@ -2,11 +2,15 @@ package telemetry
 
 import (
 	"context"
+	"crypto/tls"
+	"crypto/x509"
 	"fmt"
+	"os"
 	"time"
 
 	"connectrpc.com/connect"
 	"connectrpc.com/otelconnect"
+	"github.com/open-feature/flagd/core/pkg/certreloader"
 	"github.com/open-feature/flagd/core/pkg/logger"
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc"
@@ -17,21 +21,29 @@ import (
 	"go.opentelemetry.io/otel/sdk/metric"
 	"go.opentelemetry.io/otel/sdk/resource"
 	"go.opentelemetry.io/otel/sdk/trace"
-	semconv "go.opentelemetry.io/otel/semconv/v1.18.0"
+	semconv "go.opentelemetry.io/otel/semconv/v1.34.0"
 	"go.uber.org/zap"
 	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/credentials/insecure"
 )
 
 const (
 	metricsExporterOtel = "otel"
-	exportInterval      = 2 * time.Second
 )
 
+type CollectorConfig struct {
+	Target         string
+	CertPath       string
+	KeyPath        string
+	ReloadInterval time.Duration
+	CAPath         string
+}
+
 // Config of the telemetry runtime. These are expected to be mapped to start-up arguments
 type Config struct {
 	MetricsExporter string
-	CollectorTarget string
+	CollectorConfig CollectorConfig
 }
 
 func RegisterErrorHandling(log *logger.Logger) {
@@ -43,7 +55,7 @@ func RegisterErrorHandling(log *logger.Logger) {
 // BuildMetricsRecorder is a helper to build telemetry.MetricsRecorder based on configurations
 func BuildMetricsRecorder(
 	ctx context.Context, svcName string, svcVersion string, config Config,
-) (*MetricsRecorder, error) {
+) (IMetricsRecorder, error) {
 	// Build metric reader based on configurations
 	mReader, err := buildMetricReader(ctx, config)
 	if err != nil {
@@ -64,13 +76,13 @@ func BuildMetricsRecorder(
 // provide the grpc collector target. Providing empty target results in skipping provider & propagator registration.
 // This results in tracers having NoopTracerProvider and propagator having No-Op TextMapPropagator performing no action
 func BuildTraceProvider(ctx context.Context, logger *logger.Logger, svc string, svcVersion string, cfg Config) error {
-	if cfg.CollectorTarget == "" {
+	if cfg.CollectorConfig.Target == "" {
 		logger.Debug("skipping trace provider setup as collector target is not set." +
 			" Traces will use NoopTracerProvider provider and propagator will use no-Op TextMapPropagator")
 		return nil
 	}
 
-	exporter, err := buildOtlpExporter(ctx, cfg.CollectorTarget)
+	exporter, err := buildOtlpExporter(ctx, cfg.CollectorConfig)
 	if err != nil {
 		return err
 	}
@@ -91,17 +103,61 @@ func BuildTraceProvider(ctx context.Context, logger *logger.Logger, svc string,
 }
 
 // BuildConnectOptions is a helper to build connect options based on telemetry configurations
-func BuildConnectOptions(cfg Config) []connect.HandlerOption {
+func BuildConnectOptions(cfg Config) ([]connect.HandlerOption, error) {
 	options := []connect.HandlerOption{}
 
 	// add interceptor if configuration is available for collector
-	if cfg.CollectorTarget != "" {
-		options = append(options, connect.WithInterceptors(
-			otelconnect.NewInterceptor(otelconnect.WithTrustRemote()),
-		))
+	if cfg.CollectorConfig.Target != "" {
+		interceptor, err := otelconnect.NewInterceptor(otelconnect.WithTrustRemote())
+		if err != nil {
+			return nil, fmt.Errorf("error creating interceptor, %w", err)
+		}
+
+		options = append(options, connect.WithInterceptors(interceptor))
 	}
 
-	return options
+	return options, nil
+}
+
+func buildTransportCredentials(_ context.Context, cfg CollectorConfig) (credentials.TransportCredentials, error) {
+	creds := insecure.NewCredentials()
+	if cfg.KeyPath != "" || cfg.CertPath != "" || cfg.CAPath != "" {
+		capool := x509.NewCertPool()
+		if cfg.CAPath != "" {
+			ca, err := os.ReadFile(cfg.CAPath)
+			if err != nil {
+				return nil, fmt.Errorf("can't read ca file from %s", cfg.CAPath)
+			}
+			if !capool.AppendCertsFromPEM(ca) {
+				return nil, fmt.Errorf("can't add CA '%s' to pool", cfg.CAPath)
+			}
+		}
+
+		reloader, err := certreloader.NewCertReloader(certreloader.Config{
+			KeyPath:        cfg.KeyPath,
+			CertPath:       cfg.CertPath,
+			ReloadInterval: cfg.ReloadInterval,
+		})
+		if err != nil {
+			return nil, fmt.Errorf("failed to create certreloader: %w", err)
+		}
+
+		tlsConfig := &tls.Config{
+			RootCAs:    capool,
+			MinVersion: tls.VersionTLS12,
+			GetCertificate: func(chi *tls.ClientHelloInfo) (*tls.Certificate, error) {
+				certs, err := reloader.GetCertificate()
+				if err != nil {
+					return nil, fmt.Errorf("failed to reload certs: %w", err)
+				}
+				return certs, nil
+			},
+		}
+
+		creds = credentials.NewTLS(tlsConfig)
+	}
+
+	return creds, nil
 }
 
 // buildMetricReader builds a metric reader based on provided configurations
@@ -117,13 +173,18 @@ func buildMetricReader(ctx context.Context, cfg Config) (metric.Reader, error) {
 	}
 
 	// Otel override require target configuration
-	if cfg.CollectorTarget == "" {
+	if cfg.CollectorConfig.Target == "" {
 		return nil, fmt.Errorf("metric exporter is set(%s) without providing otel collector target."+
 			" collector target is required for this option", cfg.MetricsExporter)
 	}
 
+	transportCredentials, err := buildTransportCredentials(ctx, cfg.CollectorConfig)
+	if err != nil {
+		return nil, fmt.Errorf("metric export would not build transport credentials: %w", err)
+	}
+
 	// Non-blocking, insecure grpc connection
-	conn, err := grpc.DialContext(ctx, cfg.CollectorTarget, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	conn, err := grpc.NewClient(cfg.CollectorConfig.Target, grpc.WithTransportCredentials(transportCredentials))
 	if err != nil {
 		return nil, fmt.Errorf("error creating client connection: %w", err)
 	}
@@ -134,13 +195,18 @@ func buildMetricReader(ctx context.Context, cfg Config) (metric.Reader, error) {
 		return nil, fmt.Errorf("error creating otel metric exporter: %w", err)
 	}
 
-	return metric.NewPeriodicReader(otelExporter, metric.WithInterval(exportInterval)), nil
+	return metric.NewPeriodicReader(otelExporter), nil
 }
 
 // buildOtlpExporter is a helper to build grpc backed otlp trace exporter
-func buildOtlpExporter(ctx context.Context, collectorTarget string) (*otlptrace.Exporter, error) {
-	// Non-blocking, insecure grpc connection
-	conn, err := grpc.DialContext(ctx, collectorTarget, grpc.WithTransportCredentials(insecure.NewCredentials()))
+func buildOtlpExporter(ctx context.Context, cfg CollectorConfig) (*otlptrace.Exporter, error) {
+	transportCredentials, err := buildTransportCredentials(ctx, cfg)
+	if err != nil {
+		return nil, fmt.Errorf("metric export would not build transport credentials: %w", err)
+	}
+
+	// Non-blocking, grpc connection
+	conn, err := grpc.NewClient(cfg.Target, grpc.WithTransportCredentials(transportCredentials))
 	if err != nil {
 		return nil, fmt.Errorf("error creating client connection: %w", err)
 	}

core/pkg/telemetry/builder_test.go

@@ -12,7 +12,7 @@ import (
 	"go.opentelemetry.io/otel/sdk/metric"
 	"go.opentelemetry.io/otel/sdk/metric/metricdata"
 	"go.opentelemetry.io/otel/sdk/resource"
-	semconv "go.opentelemetry.io/otel/semconv/v1.18.0"
+	semconv "go.opentelemetry.io/otel/semconv/v1.34.0"
 	"go.uber.org/zap"
 	"go.uber.org/zap/zaptest/observer"
 )
@@ -21,7 +21,9 @@ func TestBuildMetricsRecorder(t *testing.T) {
 	// Simple happy-path test
 	recorder, err := BuildMetricsRecorder(context.Background(), "service", "0.0.1", Config{
 		MetricsExporter: "otel",
-		CollectorTarget: "localhost:8080",
+		CollectorConfig: CollectorConfig{
+			Target: "localhost:8080",
+		},
 	})
 
 	require.Nil(t, err, "expected no error, but got: %v", err)
@@ -52,7 +54,9 @@ func TestBuildMetricReader(t *testing.T) {
 			name: "Metric exporter overriding require valid configuration combination",
 			cfg: Config{
 				MetricsExporter: metricsExporterOtel,
-				CollectorTarget: "", // collector target is unset
+				CollectorConfig: CollectorConfig{
+					Target: "", // collector target is unset
+				},
 			},
 			error: true,
 		},
@@ -60,7 +64,9 @@ func TestBuildMetricReader(t *testing.T) {
 			name: "Metric exporter overriding with valid configurations",
 			cfg: Config{
 				MetricsExporter: metricsExporterOtel,
-				CollectorTarget: "localhost:8080",
+				CollectorConfig: CollectorConfig{
+					Target: "localhost:8080",
+				},
 			},
 			error: false,
 		},
@@ -90,7 +96,9 @@ func TestBuildSpanProcessor(t *testing.T) {
 		{
 			name: "Valid configurations yield a valid processor",
 			cfg: Config{
-				CollectorTarget: "localhost:8080",
+				CollectorConfig: CollectorConfig{
+					Target: "localhost:8080",
+				},
 			},
 			error: false,
 		},
@@ -127,14 +135,19 @@ func TestBuildConnectOptions(t *testing.T) {
 		{
 			name: "Connect option is set when telemetry target is set",
 			cfg: Config{
-				CollectorTarget: "localhost:8080",
+				CollectorConfig: CollectorConfig{
+					Target: "localhost:8080",
+				},
 			},
 			optionCount: 1,
 		},
 	}
 
 	for _, test := range tests {
-		options := BuildConnectOptions(test.cfg)
+		options, err := BuildConnectOptions(test.cfg)
+		if err != nil {
+			t.Fatalf("error building connection options : %v", err)
+		}
 
 		require.Len(t, options, test.optionCount, "option count mismatch for test %s", test.name)
 	}

core/pkg/telemetry/metrics.go

@@ -10,7 +10,7 @@ import (
 	"go.opentelemetry.io/otel/sdk/instrumentation"
 	msdk "go.opentelemetry.io/otel/sdk/metric"
 	"go.opentelemetry.io/otel/sdk/resource"
-	semconv "go.opentelemetry.io/otel/semconv/v1.18.0"
+	semconv "go.opentelemetry.io/otel/semconv/v1.34.0"
 )
 
 const (
@@ -19,13 +19,47 @@ const (
 	FeatureFlagReasonKey = attribute.Key("feature_flag.reason")
 	ExceptionTypeKey     = attribute.Key("ExceptionTypeKeyName")
 
-	httpRequestDurationMetric = "http.server.duration"
-	httpResponseSizeMetric    = "http.server.response.size"
+	httpRequestDurationMetric = "http.server.request.duration"
+	httpResponseSizeMetric    = "http.server.response.body.size"
 	httpActiveRequestsMetric  = "http.server.active_requests"
 	impressionMetric          = "feature_flag." + ProviderName + ".impression"
-	reasonMetric              = "feature_flag." + ProviderName + ".evaluation.reason"
+	reasonMetric              = "feature_flag." + ProviderName + ".result.reason"
 )
 
+type IMetricsRecorder interface {
+	HTTPAttributes(svcName, url, method, code, scheme string) []attribute.KeyValue
+	HTTPRequestDuration(ctx context.Context, duration time.Duration, attrs []attribute.KeyValue)
+	HTTPResponseSize(ctx context.Context, sizeBytes int64, attrs []attribute.KeyValue)
+	InFlightRequestStart(ctx context.Context, attrs []attribute.KeyValue)
+	InFlightRequestEnd(ctx context.Context, attrs []attribute.KeyValue)
+	RecordEvaluation(ctx context.Context, err error, reason, variant, key string)
+	Impressions(ctx context.Context, reason, variant, key string)
+}
+
+type NoopMetricsRecorder struct{}
+
+func (NoopMetricsRecorder) HTTPAttributes(_, _, _, _, _ string) []attribute.KeyValue {
+	return []attribute.KeyValue{}
+}
+
+func (NoopMetricsRecorder) HTTPRequestDuration(_ context.Context, _ time.Duration, _ []attribute.KeyValue) {
+}
+
+func (NoopMetricsRecorder) HTTPResponseSize(_ context.Context, _ int64, _ []attribute.KeyValue) {
+}
+
+func (NoopMetricsRecorder) InFlightRequestStart(_ context.Context, _ []attribute.KeyValue) {
+}
+
+func (NoopMetricsRecorder) InFlightRequestEnd(_ context.Context, _ []attribute.KeyValue) {
+}
+
+func (NoopMetricsRecorder) RecordEvaluation(_ context.Context, _ error, _, _, _ string) {
+}
+
+func (NoopMetricsRecorder) Impressions(_ context.Context, _, _, _ string) {
+}
+
 type MetricsRecorder struct {
 	httpRequestDurHistogram   metric.Float64Histogram
 	httpResponseSizeHistogram metric.Float64Histogram
@@ -34,12 +68,13 @@ type MetricsRecorder struct {
 	reasons                   metric.Int64Counter
 }
 
-func (r MetricsRecorder) HTTPAttributes(svcName, url, method, code string) []attribute.KeyValue {
+func (r MetricsRecorder) HTTPAttributes(svcName, url, method, code, scheme string) []attribute.KeyValue {
 	return []attribute.KeyValue{
 		semconv.ServiceNameKey.String(svcName),
-		semconv.HTTPURLKey.String(url),
-		semconv.HTTPMethodKey.String(method),
-		semconv.HTTPStatusCodeKey.String(code),
+		semconv.HTTPRouteKey.String(url),
+		semconv.HTTPRequestMethodKey.String(method),
+		semconv.HTTPResponseStatusCodeKey.String(code),
+		semconv.URLSchemeKey.String(scheme),
 	}
 }
 

core/pkg/telemetry/metrics_test.go

@@ -10,7 +10,7 @@ import (
 	"go.opentelemetry.io/otel/sdk/metric"
 	"go.opentelemetry.io/otel/sdk/metric/metricdata"
 	"go.opentelemetry.io/otel/sdk/resource"
-	semconv "go.opentelemetry.io/otel/semconv/v1.13.0"
+	semconv "go.opentelemetry.io/otel/semconv/v1.34.0"
 )
 
 const svcName = "mySvc"
@@ -38,9 +38,10 @@ func TestHTTPAttributes(t *testing.T) {
 			},
 			want: []attribute.KeyValue{
 				semconv.ServiceNameKey.String(""),
-				semconv.HTTPURLKey.String(""),
-				semconv.HTTPMethodKey.String(""),
-				semconv.HTTPStatusCodeKey.String(""),
+				semconv.HTTPRouteKey.String(""),
+				semconv.HTTPRequestMethodKey.String(""),
+				semconv.HTTPResponseStatusCodeKey.String(""),
+				semconv.URLSchemeKey.String("http"),
 			},
 		},
 		{
@@ -53,9 +54,10 @@ func TestHTTPAttributes(t *testing.T) {
 			},
 			want: []attribute.KeyValue{
 				semconv.ServiceNameKey.String("myService"),
-				semconv.HTTPURLKey.String("#123"),
-				semconv.HTTPMethodKey.String("POST"),
-				semconv.HTTPStatusCodeKey.String("300"),
+				semconv.HTTPRouteKey.String("#123"),
+				semconv.HTTPRequestMethodKey.String("POST"),
+				semconv.HTTPResponseStatusCodeKey.String("300"),
+				semconv.URLSchemeKey.String("http"),
 			},
 		},
 		{
@@ -68,16 +70,17 @@ func TestHTTPAttributes(t *testing.T) {
 			},
 			want: []attribute.KeyValue{
 				semconv.ServiceNameKey.String("!@#$%^&*()_+|}{[];',./<>"),
-				semconv.HTTPURLKey.String(""),
-				semconv.HTTPMethodKey.String(""),
-				semconv.HTTPStatusCodeKey.String(""),
+				semconv.HTTPRouteKey.String(""),
+				semconv.HTTPRequestMethodKey.String(""),
+				semconv.HTTPResponseStatusCodeKey.String(""),
+				semconv.URLSchemeKey.String("http"),
 			},
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			rec := MetricsRecorder{}
-			res := rec.HTTPAttributes(tt.req.Service, tt.req.ID, tt.req.Method, tt.req.Code)
+			res := rec.HTTPAttributes(tt.req.Service, tt.req.ID, tt.req.Method, tt.req.Code, "http")
 			require.Equal(t, tt.want, res)
 		})
 	}
@@ -204,3 +207,35 @@ func TestMetrics(t *testing.T) {
 		})
 	}
 }
+
+// some really simple tests just to make sure all methods are actually implemented and nothing panics
+func TestNoopMetricsRecorder_HTTPAttributes(t *testing.T) {
+	no := NoopMetricsRecorder{}
+	got := no.HTTPAttributes("", "", "", "", "")
+	require.Empty(t, got)
+}
+
+func TestNoopMetricsRecorder_HTTPRequestDuration(_ *testing.T) {
+	no := NoopMetricsRecorder{}
+	no.HTTPRequestDuration(context.TODO(), 0, nil)
+}
+
+func TestNoopMetricsRecorder_InFlightRequestStart(_ *testing.T) {
+	no := NoopMetricsRecorder{}
+	no.InFlightRequestStart(context.TODO(), nil)
+}
+
+func TestNoopMetricsRecorder_InFlightRequestEnd(_ *testing.T) {
+	no := NoopMetricsRecorder{}
+	no.InFlightRequestEnd(context.TODO(), nil)
+}
+
+func TestNoopMetricsRecorder_RecordEvaluation(_ *testing.T) {
+	no := NoopMetricsRecorder{}
+	no.RecordEvaluation(context.TODO(), nil, "", "", "")
+}
+
+func TestNoopMetricsRecorder_Impressions(_ *testing.T) {
+	no := NoopMetricsRecorder{}
+	no.Impressions(context.TODO(), "", "", "")
+}

core/pkg/telemetry/utils.go

@@ -2,7 +2,7 @@ package telemetry
 
 import (
 	"go.opentelemetry.io/otel/attribute"
-	semconv "go.opentelemetry.io/otel/semconv/v1.18.0"
+	semconv "go.opentelemetry.io/otel/semconv/v1.34.0"
 )
 
 // utils contain common utilities to help with telemetry
@@ -14,7 +14,7 @@ const provider = "flagd"
 func SemConvFeatureFlagAttributes(ffKey string, ffVariant string) []attribute.KeyValue {
 	return []attribute.KeyValue{
 		semconv.FeatureFlagKey(ffKey),
-		semconv.FeatureFlagVariant(ffVariant),
+		semconv.FeatureFlagResultVariant(ffVariant),
 		semconv.FeatureFlagProviderName(provider),
 	}
 }

core/pkg/telemetry/utils_test.go

@@ -4,7 +4,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
-	semconv "go.opentelemetry.io/otel/semconv/v1.18.0"
+	semconv "go.opentelemetry.io/otel/semconv/v1.34.0"
 )
 
 func TestSemConvFeatureFlagAttributes(t *testing.T) {
@@ -35,7 +35,7 @@ func TestSemConvFeatureFlagAttributes(t *testing.T) {
 			case semconv.FeatureFlagKeyKey:
 				require.Equal(t, test.key, attribute.Value.AsString(),
 					"expected flag key: %s, but received: %s", test.key, attribute.Value.AsString())
-			case semconv.FeatureFlagVariantKey:
+			case semconv.FeatureFlagResultVariantKey:
 				require.Equal(t, test.variant, attribute.Value.AsString(),
 					"expected flag variant: %s, but received %s", test.variant, attribute.Value.AsString())
 			case semconv.FeatureFlagProviderNameKey:

core/pkg/utils/convert_to_json.go

@@ -0,0 +1,42 @@
+package utils
+
+import (
+	"fmt"
+	"mime"
+	"regexp"
+	"strings"
+)
+
+var alphanumericRegex = regexp.MustCompile("[^a-zA-Z0-9]+")
+
+// ConvertToJSON attempts to convert the content of a file to JSON based on the file extension.
+// The media type is used as a fallback in case the file extension is not recognized.
+func ConvertToJSON(data []byte, fileExtension string, mediaType string) (string, error) {
+	var detectedType string
+	if fileExtension != "" {
+		// file extension only contains alphanumeric characters
+		detectedType = alphanumericRegex.ReplaceAllString(fileExtension, "")
+	} else {
+		parsedMediaType, _, err := mime.ParseMediaType(mediaType)
+		if err != nil {
+			return "", fmt.Errorf("unable to determine file format: %w", err)
+		}
+		detectedType = parsedMediaType
+	}
+
+	// Normalize the detected type
+	detectedType = strings.ToLower(detectedType)
+
+	switch detectedType {
+	case "yaml", "yml", "application/yaml", "application/x-yaml":
+		str, err := YAMLToJSON(data)
+		if err != nil {
+			return "", fmt.Errorf("error converting blob from yaml to json: %w", err)
+		}
+		return str, nil
+	case "json", "application/json":
+		return string(data), nil
+	default:
+		return "", fmt.Errorf("unsupported file format: '%s'", detectedType)
+	}
+}

core/pkg/utils/convert_to_json_test.go

@@ -0,0 +1,107 @@
+package utils
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestConvertToJSON(t *testing.T) {
+	tests := map[string]struct {
+		data          []byte
+		fileExtension string
+		mediaType     string
+		want          string
+		wantErr       bool
+		errContains   string
+	}{
+		"json file type": {
+			data:          []byte(`{"flags": {"foo": "bar"}}`),
+			fileExtension: "json",
+			mediaType:     "application/json",
+			want:          `{"flags": {"foo": "bar"}}`,
+			wantErr:       false,
+		},
+		"json file type using in http path": {
+			data:          []byte(`{"flags": {"foo": "bar"}}`),
+			fileExtension: ".json/",
+			mediaType:     "",
+			want:          `{"flags": {"foo": "bar"}}`,
+			wantErr:       false,
+		},
+		"json file type with encoding": {
+			data:          []byte(`{"flags": {"foo": "bar"}}`),
+			fileExtension: "json",
+			mediaType:     "application/json; charset=utf-8",
+			want:          `{"flags": {"foo": "bar"}}`,
+			wantErr:       false,
+		},
+		"yaml file type": {
+			data:          []byte("flags:\n  foo: bar"),
+			fileExtension: "yaml",
+			mediaType:     "application/yaml",
+			want:          `{"flags":{"foo":"bar"}}`,
+			wantErr:       false,
+		},
+		"yaml file type with encoding": {
+			data:          []byte("flags:\n  foo: bar"),
+			fileExtension: "yaml",
+			mediaType:     "application/yaml; charset=utf-8",
+			want:          `{"flags":{"foo":"bar"}}`,
+			wantErr:       false,
+		},
+		"yml file type": {
+			data:          []byte("flags:\n  foo: bar"),
+			fileExtension: "yml",
+			mediaType:     "application/x-yaml",
+			want:          `{"flags":{"foo":"bar"}}`,
+			wantErr:       false,
+		},
+		"invalid yaml": {
+			data:          []byte("invalid: [yaml: content"),
+			fileExtension: "yaml",
+			mediaType:     "application/yaml",
+			wantErr:       true,
+			errContains:   "error converting blob from yaml to json",
+		},
+		"unsupported file type": {
+			data:          []byte("some content"),
+			fileExtension: "txt",
+			mediaType:     "text/plain",
+			wantErr:       true,
+			errContains:   "unsupported file format",
+		},
+		"empty file type with valid media type": {
+			data:          []byte(`{"flags": {"foo": "bar"}}`),
+			fileExtension: "",
+			mediaType:     "application/json",
+			want:          `{"flags": {"foo": "bar"}}`,
+			wantErr:       false,
+		},
+		"invalid media type": {
+			data:          []byte("some content"),
+			fileExtension: "",
+			mediaType:     "invalid/\\type",
+			wantErr:       true,
+			errContains:   "unable to determine file format",
+		},
+	}
+
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			got, err := ConvertToJSON(tt.data, tt.fileExtension, tt.mediaType)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ConvertToJSON() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if tt.wantErr {
+				if err == nil || !strings.Contains(err.Error(), tt.errContains) {
+					t.Errorf("ConvertToJSON() expected error containing %q, got %v", tt.errContains, err)
+				}
+				return
+			}
+			if got != tt.want {
+				t.Errorf("ConvertToJSON() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

core/pkg/utils/yaml.go

@@ -0,0 +1,27 @@
+package utils
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"gopkg.in/yaml.v3"
+)
+
+// converts YAML byte array to JSON string
+func YAMLToJSON(rawFile []byte) (string, error) {
+	if len(rawFile) == 0 {
+		return "", nil
+	}
+
+	var ms map[string]interface{}
+	if err := yaml.Unmarshal(rawFile, &ms); err != nil {
+		return "", fmt.Errorf("error unmarshaling yaml: %w", err)
+	}
+
+	r, err := json.Marshal(ms)
+	if err != nil {
+		return "", fmt.Errorf("error marshaling json: %w", err)
+	}
+
+	return string(r), err
+}