chore: fix CODEOWNERS

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

.github/workflows/build.yaml

@@ -15,40 +15,7 @@ on:
       - "README.md"
       - "docs/**"
 
-env:
-  GO_VERSION: 1.19.3
-
 jobs:
-  benchmark:
-    name: Run Benchmark
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@24cb9080177205b6e8c946b17badbe402adc938f # v3
-
-      - name: Setup go
-        uses: actions/setup-go@4d34df0c2316fe8122ab82dc22947d607c0c91f9 # v4
-        with:
-          go-version: ${{ env.GO_VERSION }}
-
-      - name: Workspace init
-        run: make workspace-init
-
-      - name: Run benchmark
-        run: 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: false
-          # Show alert with commit comment on detecting possible performance regression
-          alert-threshold: "130%"
-          comment-on-alert: true
-          fail-on-alert: false
-
   lint:
     runs-on: ubuntu-latest
     env:
@@ -56,11 +23,11 @@ jobs:
       GOBIN: /home/runner/work/open-feature/flagd/bin
     steps:
       - name: Checkout repository
-        uses: actions/checkout@24cb9080177205b6e8c946b17badbe402adc938f # v3
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4
       - name: Setup go
-        uses: actions/setup-go@4d34df0c2316fe8122ab82dc22947d607c0c91f9 # 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
 
@@ -68,11 +35,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@24cb9080177205b6e8c946b17badbe402adc938f # v3
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4
       - name: Setup go
-        uses: actions/setup-go@4d34df0c2316fe8122ab82dc22947d607c0c91f9 # 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
@@ -86,29 +53,29 @@ jobs:
       GOBIN: /home/runner/work/open-feature/flagd/bin
     steps:
       - name: Checkout repository
-        uses: actions/checkout@24cb9080177205b6e8c946b17badbe402adc938f # v3
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4
       - name: Setup go
-        uses: actions/setup-go@4d34df0c2316fe8122ab82dc22947d607c0c91f9 # 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@d9f34f8cd5cb3b3eb79b3e4b5dae3a16df499a70 # v3
+        uses: codecov/codecov-action@e0b68c6749509c5f83f984dd99a76a1c1a231044 # v4
 
   docker-local:
     runs-on: ubuntu-latest
 
     steps:
       - name: Checkout
-        uses: actions/checkout@24cb9080177205b6e8c946b17badbe402adc938f # v3
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4
         with:
           submodules: recursive
 
       - name: Setup go
-        uses: actions/setup-go@4d34df0c2316fe8122ab82dc22947d607c0c91f9 # 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
@@ -120,7 +87,7 @@ jobs:
         uses: docker/setup-buildx-action@master
 
       - name: Build
-        uses: docker/build-push-action@3b5e8027fcad23fda98b2e3ac259d8d67585f671 # v4
+        uses: docker/build-push-action@4a13e500e55cf31b7a5d59a38ab2040ab0f42f56 # v5
         with:
           context: .
           file: ./flagd/build.Dockerfile
@@ -128,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@04df1262e6247151b5ac09cd2c303ac36ad3f62b # v2
+        uses: github/codeql-action/upload-sarif@e8893c57a1f3a2b659b6b55564fdfdbbd2982911 # v3
         with:
           sarif_file: "trivy-results.sarif"
 
@@ -146,14 +115,22 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@24cb9080177205b6e8c946b17badbe402adc938f # v3
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4
         with:
           submodules: recursive
 
       - name: Setup go
-        uses: actions/setup-go@4d34df0c2316fe8122ab82dc22947d607c0c91f9 # 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
@@ -162,7 +139,17 @@ jobs:
         run: make build
 
       - name: Run flagd binary in background
-        run: ./bin/flagd start -f file:${{ github.workspace }}/test-harness/symlink_testing-flags.json &
+        run: |
+          ./bin/flagd start \
+          -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/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 test -cover ./flagd/tests/integration -run TestEvaluation
+        run: go clean -testcache && go test -cover ./test/integration

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

@@ -29,15 +29,15 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@24cb9080177205b6e8c946b17badbe402adc938f # v3
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4
         with:
           ref: gh-pages
       - name: Setup Pages
-        uses: actions/configure-pages@7110e9e03ffb4a421945e5d0607007b8e9f1f52b # v3
+        uses: actions/configure-pages@1f0c5cde4bc74cd7e1254d0cb4de8d49e9068c7d # v4
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@64bcae551a7b18bcb9a09042ddf1960979799187 # v1
+        uses: actions/upload-pages-artifact@0252fc4ba7626f0298f0cf00902a25c6afc77fa8 # v3
         with:
           path: './dev/bench'
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@73e62e651178eeba977de2dc9f4c7645b3d01015 # v2
+        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@3d60a5b2dae89d44e0c6ddc69dd7536aec2071cd # 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@3d60a5b2dae89d44e0c6ddc69dd7536aec2071cd # v2
+        uses: marocchino/sticky-pull-request-comment@331f8f5b4215f0445d3c07b4967662a32a2d3e31 # v2
         with:   
           header: pr-title-lint-error
           delete: true

.github/workflows/markdown-checks.yaml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-22.04
     steps:
       - name: Check out code
-        uses: actions/checkout@24cb9080177205b6e8c946b17badbe402adc938f # v3
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4
 
       - name: Lint Markdown files
         run: make markdownlint

.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.19.3
-
-jobs:
-  benchmark-publish:
-    name: Run Benchmark
-    if: github.repository == 'open-feature/flagd'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@24cb9080177205b6e8c946b17badbe402adc938f # v3
-
-      - name: Setup go
-        uses: actions/setup-go@4d34df0c2316fe8122ab82dc22947d607c0c91f9 # 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.19
+  DEFAULT_GO_VERSION: '~1.21'
   PUBLIC_KEY_FILE: publicKey.pub
   GOPRIVATE: buf.build/gen/go
 
@@ -19,23 +19,26 @@ jobs:
     runs-on: ubuntu-latest
     # Release-please creates a PR that tracks all changes
     steps:
-      - uses: google-github-actions/release-please-action@ee9822ec2c397e8a364d634464339ac43a06e042 # v3
+      - name: Get current date
+        id: date
+        run: echo "::set-output name=date::$(date +'%Y-%m-%d')"
+      - 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) }}
         run: |
           echo "$RELEASE_PLEASE_OUTPUT"
       - name: Determine what should be published
-        uses: actions/github-script@98814c53be79b1d30f795b907e553d8679345975 # v6
+        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7
         id: items-to-publish
         env:
-          CHANGED_ITEMS: '${{ steps.release.outputs.paths_released }}'
+          CHANGED_ITEMS: "${{ steps.release.outputs.paths_released }}"
         with:
           # Release please outputs a string representation of an array under the key paths_released
           # This script parses the output, and filters each of the changed items (provided as paths to the root of the package, e.g. flagd or core)
@@ -50,75 +53,75 @@ jobs:
             console.log("items to publish", itemsToPublish);
             return itemsToPublish;
     outputs:
+      date: ${{ steps.date.outputs.date }}
       items_to_publish: ${{ steps.items-to-publish.outputs.result }}
       flagd_version: ${{ steps.release.outputs.flagd--version }}
       flagd_tag_name: ${{ steps.release.outputs.flagd--tag_name }}
       flagd-proxy_version: ${{ steps.release.outputs.flagd-proxy--version }}
       flagd-proxy_tag_name: ${{ steps.release.outputs.flagd-proxy--tag_name }}
-      
+
   container-release:
     name: Build and push containers to GHCR
     needs: release-please
-    runs-on: ubuntu-latest 
+    environment: publish
+    runs-on: ubuntu-latest
     if: ${{ needs.release-please.outputs.items_to_publish != '' && toJson(fromJson(needs.release-please.outputs.items_to_publish)) != '[]' }}
     strategy:
-      matrix: 
+      matrix:
         path: ${{ fromJSON(needs.release-please.outputs.items_to_publish) }}
 
     env:
-      TAG: ${{ needs.release-please.outputs[format('{0}_tag_name', matrix.path)] }} 
+      TAG: ${{ needs.release-please.outputs[format('{0}_tag_name', matrix.path)] }}
       VERSION: v${{ needs.release-please.outputs[format('{0}_version', matrix.path)] }}
     steps:
       - name: Checkout
-        uses: actions/checkout@24cb9080177205b6e8c946b17badbe402adc938f # v3
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4
         with:
           ref: ${{ env.TAG }}
 
       - name: Log in to the Container registry
-        uses: docker/login-action@65b78e6e13532edd9afa3aa52ac7964289d1a9c1
+        uses: docker/login-action@3d58c274f17dffee475a5520cbe67f0a882c4dbb
         with:
           registry: ${{ env.REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
-  
+
       - name: Extract metadata (tags, labels) for Docker
         id: meta
-        uses: docker/metadata-action@9ec57ed1fcdbf14dcef7dfbe97b2010124a938b7
+        uses: docker/metadata-action@8e5442c4ef9f78752691e2d8f8d19755c6f78e81
         with:
           images: ${{ env.REGISTRY }}/${{ matrix.path }}
-  
+
       - name: Set up QEMU
         uses: docker/setup-qemu-action@master
         with:
           platforms: all
-  
+
       - name: Set up Docker Buildx
         id: buildx
         uses: docker/setup-buildx-action@master
 
-      - name: Get current date
-        id: date
-        run: echo "::set-output name=date::$(date +'%Y-%m-%d')"
-
       - name: Build
         id: build
-        uses: docker/build-push-action@3b5e8027fcad23fda98b2e3ac259d8d67585f671 # v4
+        uses: docker/build-push-action@4a13e500e55cf31b7a5d59a38ab2040ab0f42f56 # v5
         with:
           builder: ${{ steps.buildx.outputs.name }}
           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
             ${{ env.REGISTRY }}/${{ env.REPO_OWNER }}/${{ matrix.path }}:${{ env.VERSION }}
-          labels: ${{ steps.meta.outputs.labels }} 
+          labels: ${{ steps.meta.outputs.labels }}
           build-args: |
             VERSION=${{ env.VERSION }}
             COMMIT=${{ github.sha }}
-            DATE=${{ steps.date.outputs.date }}
+            DATE=${{ needs.release-please.outputs.date }}
       - name: Install Cosign
-        uses: sigstore/cosign-installer@8348525c79cd67509c593a9352954618bdc3a862
+        uses: sigstore/cosign-installer@e1523de7571e31dbe865fd2e80c5c7c23ae71eb4
 
       - name: Sign the image
         run: |
@@ -128,48 +131,40 @@ 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@448520c4f19577ffce70a8317e619089054687e3 # 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
     needs: release-please
-    runs-on: ubuntu-latest 
+    runs-on: ubuntu-latest
     if: ${{ needs.release-please.outputs.items_to_publish != '' && toJson(fromJson(needs.release-please.outputs.items_to_publish)) != '[]' }}
     strategy:
-      matrix: 
+      matrix:
         path: ${{ fromJSON(needs.release-please.outputs.items_to_publish) }}
 
     env:
-      TAG: ${{ needs.release-please.outputs[format('{0}_tag_name', matrix.path)] }} 
+      TAG: ${{ needs.release-please.outputs[format('{0}_tag_name', matrix.path)] }}
       VERSION: v${{ needs.release-please.outputs[format('{0}_version', matrix.path)] }}
       VERSION_NO_PREFIX: ${{ needs.release-please.outputs[format('{0}_version', matrix.path)] }}
+      COMMIT: ${{ github.sha }}
+      DATE: ${{ needs.release-please.outputs.date }}
+      BUILD_ARGS: '-a -ldflags "-X main.version=${VERSION} -X main.commit=${COMMIT} -X main.date=${DATE}"'
     steps:
       - name: Checkout
-        uses: actions/checkout@24cb9080177205b6e8c946b17badbe402adc938f # v3
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4
         with:
           ref: ${{ env.TAG }}
       - name: Set up Go
-        uses: actions/setup-go@4d34df0c2316fe8122ab82dc22947d607c0c91f9 # v4
+        uses: actions/setup-go@0c52d547c9bc32b1aa3301fd7a9cb496313a4491 # v5
         with:
           go-version: ${{ env.DEFAULT_GO_VERSION }}
       - name: Download cyclonedx-gomod
-        uses: CycloneDX/gh-gomod-generate-sbom@d4aee0cf5133055dbd98899978246c10c18c440f # v1
+        uses: CycloneDX/gh-gomod-generate-sbom@efc74245d6802c8cefd925620515442756c70d8f # v2
         with:
           version: v1
       - name: setup for builds
@@ -180,32 +175,34 @@ jobs:
           cd ${{ matrix.path }} && cyclonedx-gomod app > ../sbom.xml
       - name: build darwin arm64
         run: |
-          env GOOS=darwin GOARCH=arm64 go build -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 -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 -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 -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 -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 -o ./${{ matrix.path }}_windows_x86_64 ./${{ matrix.path }}/main.go
-          tar -cvzf ${{ matrix.path }}_${{ env.VERSION_NO_PREFIX }}_Windows_x86_64.tar.gz ./${{ matrix.path }}_windows_x86_64 ./LICENSE ./CHANGELOG.md ./README.md ./sbom.xml
+          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 -o ./${{ matrix.path }}_windows_i386 ./${{ matrix.path }}/main.go
-          tar -cvzf ${{ matrix.path }}_${{ env.VERSION_NO_PREFIX }}_Windows_i386.tar.gz ./${{ matrix.path }}_windows_i386 ./LICENSE ./CHANGELOG.md ./README.md ./sbom.xml
+          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 release artifacts
       - name: Bundle release assets
         uses: softprops/action-gh-release@de2c0eb89ae2a093876385947365aca7b0e5f844 # v1
         with:
@@ -213,20 +210,24 @@ jobs:
           files: |
             ./sbom.xml
             ./*.tar.gz
+            ./*.zip
   homebrew:
-   name: Bump homebrew-core formula
-   needs: release-please
-   runs-on: ubuntu-latest
-   # Only run on non-forked flagd releases
-   if: ${{ github.repository_owner == 'open-feature' && needs.release-please.outputs.flagd_tag_name }}
-   steps:
-     - uses: mislav/bump-homebrew-formula-action@v2
-       with:
-         formula-name: flagd
-         tag-name: ${{ needs.release-please.outputs.flagd_tag_name }}
-         download-url: https://github.com/${{ github.repository }}.git
-         commit-message: |
-           {{formulaName}} {{version}}
-           Created by https://github.com/mislav/bump-homebrew-formula-action
-       env:
-         COMMITTER_TOKEN: ${{ secrets.COMMITTER_TOKEN }}
+    name: Bump homebrew-core formula
+    needs: release-please
+    runs-on: ubuntu-latest
+    # Only run on non-forked flagd releases
+    if: ${{ github.repository_owner == 'open-feature' && needs.release-please.outputs.flagd_tag_name }}
+    steps:
+      - uses: mislav/bump-homebrew-formula-action@v2
+        with:
+          formula-name: flagd
+          # https://github.com/mislav/bump-homebrew-formula-action/issues/58
+          formula-path: Formula/f/flagd.rb
+          tag-name: ${{ needs.release-please.outputs.flagd_tag_name }}
+          download-url: https://github.com/${{ github.repository }}.git
+          commit-message: |
+            {{formulaName}} ${{ needs.release-please.outputs.flagd_version }}
+
+            Created by https://github.com/mislav/bump-homebrew-formula-action
+        env:
+          COMMITTER_TOKEN: ${{ secrets.COMMITTER_TOKEN }}

.gitignore

@@ -11,4 +11,16 @@ pkg/eval/flagd-definitions.json
 core-coverage.out
 go.work
 go.work.sum
-bin/
+bin/
+node_modules/
+.venv
+
+# built documentation
+site
+.cache/
+
+# coverage results
+*coverage.out
+
+# benchmark results
+benchmark.txt

.gitmodules

@@ -1,3 +1,9 @@
 [submodule "test-harness"]
 	path = test-harness
 	url = https://github.com/open-feature/test-harness.git
+[submodule "spec"]
+	path = spec
+	url = https://github.com/open-feature/spec.git
+[submodule "schemas"]
+	path = schemas
+	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,51 +1,43 @@
-run:
-  skip-dirs:
-    - (^|/)bin($|/)
-    - (^|/)examples($|/)
+version: "2"
 linters:
-  enable:
-    - asciicheck
-    - bodyclose
-    - dogsled
-    - dupl
-    - funlen
-    - gocognit
-    - goconst
-    - gocritic
-    - gocyclo
-    - revive
-    - gosec
-    - lll
-    - misspell
-    - nakedret
-    - noctx
-    - prealloc
-    - rowserrcheck
-    - exportloopref
-    - stylecheck
-    - unconvert
-    - unparam
-    - whitespace
-    - gofumpt
-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

@@ -8,11 +8,24 @@ config:
       - details
       - summary
       - img
+      - br
   github-admonition: true
   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"
-  - "docs/specification"
+  - ".venv"
   - "node_modules"
+  - "playground-app/node_modules"
   - "tmp"
+  - "**/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

.pre-commit-config.yaml

@@ -5,6 +5,6 @@ repos:
       - id: gofumpt
 
   - repo: https://github.com/golangci/golangci-lint
-    rev: v1.46.2
+    rev: v1.50.1
     hooks:
       - id: golangci-lint

.release-please-manifest.json

@@ -1,5 +1,5 @@
 {
-  "flagd": "0.5.0",
-  "flagd-proxy": "0.2.0",
-  "core": "0.5.0"
+  "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,5 +40,154 @@ 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
+a commit message containing a contributor's "signature." In adding this, the
+contributor certifies that they have the right to contribute the material in
+question.
+
+Here are the steps to sign your work:
+
+1. Verify the contribution in your commit complies with the
+   [terms of the DCO](https://developercertificate.org/).
+
+1. Add a line like the following to your commit message:
+
+   ```shell
+   Signed-off-by: Joe Smith <joe.smith@example.com>
+   ```
+
+   You MUST use your legal name -- handles or other pseudonyms are not
+   permitted.
+
+   While you could manually add DCO sign-off to every commit, there is an easier
+   way:
+
+    1. Configure your git client appropriately. This is one-time setup.
+
+       ```shell
+       git config user.name <legal name>
+       git config user.email <email address you use for GitHub>
+       ```
+
+       If you work on multiple projects that require a DCO sign-off, you can
+       configure your git client to use these settings globally instead of only
+       for Brigade:
+
+       ```shell
+       git config --global user.name <legal name>
+       git config --global user.email <email address you use for GitHub>
+       ```
+
+    1. Use the `--signoff` or `-s` (lowercase) flag when making each commit.
+       For example:
+
+       ```shell
+       git commit --message "<commit message>" --signoff
+       ```
+
+       If you ever make a commit and forget to use the `--signoff` flag, you
+       can amend your commit with this information before pushing:
+
+       ```shell
+       git commit --amend --signoff
+       ```
+
+    1. You can verify the above worked as expected using `git log`. Your latest
+       commit should look similar to this one:
+
+       ```shell
+       Author: Joe Smith <joe.smith@example.com>
+       Date:   Thu Feb 2 11:41:15 2018 -0800
+
+           Update README
+
+           Signed-off-by: Joe Smith <joe.smith@example.com>
+       ```
+
+       Notice the `Author` and `Signed-off-by` lines match. If they do not, the
+       PR will be rejected by the automated DCO check.
+
+## Conventional PR Titles
+
+When raising PRs, please format according to [conventional commit standards](https://www.conventionalcommits.org/en/v1.0.0/#summary)
+
+For example: `docs: some PR title here...`
+
 Thanks!
 Issues and pull requests following these guidelines are welcome.
+
+## Markdown Lint and Markdown Lint Fix
+
+PRs are expected to conform to markdown lint rules.
+
+Therefore, run `make markdownlint-fix` to auto-fix _most_ issues.
+Then commit the results.
+
+For those issues that cannot be auto-fixed, run `make markdownlint`
+then manually fix whatever it warns about.

Dockerfile

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

Makefile

@@ -1,8 +1,17 @@
-IMG ?= flagd:latest
 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
+ZD_TEST_NAMESPACE_FLAGD_PROXY ?= flagd-proxy-zd-test
+ZD_TEST_NAMESPACE ?= flagd-zd-test
+ZD_CLIENT_IMG ?= zd-client:latest
+FLAGD_PROXY_IMG ?= flagd-proxy:latest
+FLAGD_PROXY_IMG_ZD ?= flagd-proxy:zd
+
+DOCS_DIR ?= docs
+
 workspace-init: workspace-clean
 	go work init
 	$(foreach module, $(ALL_GO_MOD_DIRS), go work use $(module);)
@@ -30,17 +39,27 @@ build: workspace-init # default to flagd
 	make build-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
-test: # default to core
-	make test-core
+.PHONY: test
+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/symlink_testing-flags.json
-	go test -cover ./flagd/tests/integration $(ARGS)
-	cd test-harness; git restore testing-flags.json # reset testing-flags.json
+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
@@ -54,19 +73,42 @@ 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=3m --timeout=3m $(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
 
+.PHONY: deploy-dev-env
+export IMG?= ghcr.io/open-feature/flagd:latest
+deploy-dev-env: undeploy-dev-env
+	kubectl create ns "$(FLAGD_DEV_NAMESPACE)"
+	envsubst '$${IMG}' < config/deployments/flagd/deployment.yaml | kubectl apply -f - -n "$(FLAGD_DEV_NAMESPACE)"
+	kubectl apply -f config/deployments/flagd/service.yaml -n "$(FLAGD_DEV_NAMESPACE)"
+	kubectl wait --for=condition=available deployment/flagd -n "$(FLAGD_DEV_NAMESPACE)" --timeout=300s
+
+undeploy-dev-env:
+	kubectl delete ns "$(FLAGD_DEV_NAMESPACE)" --ignore-not-found=true
+
+run-zd-test:
+	kubectl delete ns "$(ZD_TEST_NAMESPACE)" --ignore-not-found=true
+	kubectl create ns "$(ZD_TEST_NAMESPACE)"
+	ZD_TEST_NAMESPACE="$(ZD_TEST_NAMESPACE)" FLAGD_DEV_NAMESPACE=$(FLAGD_DEV_NAMESPACE) IMG="$(IMG)" IMG_ZD="$(IMG_ZD)" ./test/zero-downtime/zd_test.sh
+
+run-flagd-proxy-zd-test:
+	ZD_TEST_NAMESPACE_FLAGD_PROXY="$(ZD_TEST_NAMESPACE_FLAGD_PROXY)" FLAGD_PROXY_IMG="$(FLAGD_PROXY_IMG)" FLAGD_PROXY_IMG_ZD="$(FLAGD_PROXY_IMG_ZD)" ZD_CLIENT_IMG="$(ZD_CLIENT_IMG)" ./test/zero-downtime-flagd-proxy/zd_test.sh
+
 # Markdown lint configuration
 #
 # - .markdownlintignore holds the configuration for files to be ignored
@@ -80,4 +122,45 @@ markdownlint:
 	$(MDL_CMD) davidanson/markdownlint-cli2-rules:$(MDL_DOCKER_VERSION) "**/*.md" 
 
 markdownlint-fix:
-	$(MDL_CMD) --entrypoint="markdownlint-cli2-fix" davidanson/markdownlint-cli2-rules:$(MDL_DOCKER_VERSION) "**/*.md" 
+	$(MDL_CMD) --entrypoint="markdownlint-cli2-fix" davidanson/markdownlint-cli2-rules:$(MDL_DOCKER_VERSION) "**/*.md"
+
+.PHONY: pull-schemas-submodule
+pull-schemas-submodule:
+	git submodule update schemas
+
+.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 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 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,22 +21,22 @@
 
 ## 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](docs/usage/flagd_providers.md).
-- 🆕 Easy to [extend to new languages](docs/other_resources/creating_providers.md).
+- 🌐 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.
-- 💪 Contains a [powerful and flexible rule targeting engine](docs/configuration/reusable_targeting_rules.md) and [deterministic percentage-based rollouts](docs/configuration/fractional_evaluation.md).
-- 🔦 Flag evaluation statistics and metrics are exposed and compatible with Prometheus.
+- 💪 Contains a [powerful and flexible rule targeting engine](https://flagd.dev/reference/flag-definitions/#targeting-rules) and [deterministic percentage-based rollouts](https://flagd.dev/reference/custom-operations/fractional-operation/).
+- 🔦 Flag evaluation traces and metrics are exposed and compatible with [OpenTelemetry](https://flagd.dev/reference/monitoring/#opentelemetry).
 
 ## ▶️ Quick Start
 
 Experiment with flagd in your browser using [the Killercoda tutorial](https://killercoda.com/open-feature/scenario/flagd-demo) or follow the instructions below to run on your own infrastructure.
 
-1. flagd can be run as a standalone-binary or container. [Download and install flagd or run it as a container](docs/usage/installation_options.md)
+1. flagd can be run as a standalone binary or container. [Download and install flagd or run it as a container](https://flagd.dev/installation/)
 
    Kubernetes-native? flagd can also be run [as part of the Kubernetes Operator](https://github.com/open-feature/open-feature-operator).
 
@@ -49,6 +49,8 @@ Experiment with flagd in your browser using [the Killercoda tutorial](https://ki
     ```
 
     Or use docker:
+    _Note - In Windows, use WSL system for both the file location and Docker runtime. Mixed file systems don't
+    work and this is a [limitation of Docker](https://github.com/docker/for-win/issues/8479)_
 
     ```sh
     docker run \
@@ -73,7 +75,7 @@ Experiment with flagd in your browser using [the Killercoda tutorial](https://ki
       --uri file:./example_flags.flagd.json
     ```
 
-    Or use docker:
+    Or use docker ( _Note - In Windows, this requires WSL system for both the file location and Docker runtime_):
 
     ```sh
     docker run \
@@ -85,7 +87,7 @@ Experiment with flagd in your browser using [the Killercoda tutorial](https://ki
       --uri file:./etc/flagd/example_flags.flagd.json
     ```
 
-    `--uri` can be a local file or any remote endpoint. Use `file:` prefix for local files. eg. `--uri file:/path/to/example_flags.flagd.json`. `gRPC` and `http` have their own requirements. More information can be found [here](docs/configuration/configuration.md#uri-patterns).
+    `--uri` can be a local file or any remote endpoint. Use `file:` prefix for local files. eg. `--uri file:/path/to/example_flags.flagd.json`. `gRPC` and `http` have their own requirements. More information can be found [here](https://flagd.dev/concepts/syncs/).
 
     Multiple `--uri` parameters can be specified. In other words, flagd can retrieve flags from multiple sources simultaneously.
 
@@ -94,10 +96,18 @@ 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"
     ```
 
+   For Windows we recommend using a [WSL](https://learn.microsoft.com/en-us/windows/wsl/install) terminal.
+   Otherwise, use the following with `cmd`:
+
+    ```sh
+    set json={"flagKey":"myStringFlag","context":{}}
+    curl -i -X POST -H "Content-Type: application/json" -d %json:"=\"% "localhost:8013/flagd.evaluation.v1.Service/ResolveString"
+    ```
+
     Result:
 
     ```json
@@ -108,11 +118,11 @@ Experiment with flagd in your browser using [the Killercoda tutorial](https://ki
     }
     ```
 
-    Updates to the underlying flag store (e.g. JSON file) are reflected by flagd in realtime. No restarts required.
+    Updates to the underlying flag store (e.g. JSON file) are reflected by flagd in realtime. No restart is required.
 
-    flagd also supports boolean, integer, float and object flag types. Read more on the [evaluation examples page](docs/usage/evaluation_examples.md)
+    flagd also supports boolean, integer, float and object flag types.
 
-4. Now that flagd is running, it is time to integrate into your application. Do this by using [an OpenFeature provider in a language of your choice](https://github.com/open-feature/flagd/blob/main/docs/usage/flagd_providers.md).
+4. Now that flagd is running, it is time to integrate it into your application. Do this by using [an OpenFeature provider in a language of your choice](https://openfeature.dev/ecosystem?instant_search%5BrefinementList%5D%5Bvendor%5D%5B0%5D=FlagD).
 
 ## 📐 High-level Architecture
 
@@ -120,14 +130,14 @@ Experiment with flagd in your browser using [the Killercoda tutorial](https://ki
 
 ## 📝 Further Documentation
 
-Further documentation including flagd configuration options, fractional evaluation, targeting rules and flag configuration merging strategies can be found [on this page](docs/README.md).
+Further documentation including flagd configuration options, fractional evaluation, targeting rules and flag configuration merging strategies can be found at [flagd.dev](https://flagd.dev/) or [in this repository](./docs/index.md).
 
 ## 🫶 Contributing
 
 Interested in contributing? Great, we'd love your help! To get started, take a look at the [CONTRIBUTING](CONTRIBUTING.md) guide.
 
 We also hold regular community meetings that are open to everyone.
-Check the [OpenFeature community page](https://docs.openfeature.dev/community/) for all the ways to get involved.
+Check the [OpenFeature community page](https://openfeature.dev/community/) for all the ways to get involved.
 
 Thanks so much to our contributors.
 

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

@@ -0,0 +1,75 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  labels:
+    app: flagd
+  name: flagd
+spec:
+  replicas: 1
+  strategy:
+    type: RollingUpdate
+    rollingUpdate:
+      maxSurge: 1
+      maxUnavailable: 0
+  selector:
+    matchLabels:
+      app: flagd
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: flagd
+        app: flagd
+    spec:
+      containers:
+        - name: flagd
+          image: ${IMG}
+          volumeMounts:
+            - name: config-volume
+              mountPath: /etc/flagd
+          readinessProbe:
+            httpGet:
+              path: /readyz
+              port: 8014
+            initialDelaySeconds: 5
+            periodSeconds: 5
+          livenessProbe:
+            httpGet:
+              path: /healthz
+              port: 8014
+            initialDelaySeconds: 5
+            periodSeconds: 60
+          ports:
+            - containerPort: 8013
+          args:
+            - start
+            - --uri
+            - file:/etc/flagd/config.json
+            - --debug
+      volumes:
+        - name: config-volume
+          configMap:
+            name: open-feature-flags
+            items:
+              - key: flags
+                path: config.json
+---
+# ConfigMap for Flagd OpenFeatuer provider
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: open-feature-flags
+data:
+  flags: |
+    {
+      "$schema": "https://flagd.dev/schema/v0/flags.json",
+      "flags": {
+        "myStringFlag": {
+          "state": "ENABLED",
+          "variants": {
+            "key1": "val1",
+            "key2": "val2"
+          },
+          "defaultVariant": "key1"
+        }
+      }
+    }

config/deployments/flagd/service.yaml

@@ -0,0 +1,10 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: flagd-svc
+spec:
+  selector:
+    app.kubernetes.io/name: flagd
+  ports:
+    - port: 8013
+      targetPort: 8013

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,798 @@
 # 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)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update module github.com/open-feature/open-feature-operator to v0.5.0 ([#1039](https://github.com/open-feature/flagd/issues/1039)) ([eb128d9](https://github.com/open-feature/flagd/commit/eb128d97ecb8b6916f9c5a32c21c698207f82be5))
+* **deps:** update module github.com/open-feature/open-feature-operator to v0.5.1 ([#1046](https://github.com/open-feature/flagd/issues/1046)) ([0321935](https://github.com/open-feature/flagd/commit/0321935992ef50c2fc62bd659d8858c25c88efa7))
+* **deps:** update module golang.org/x/crypto to v0.16.0 ([#1033](https://github.com/open-feature/flagd/issues/1033)) ([b79aaf2](https://github.com/open-feature/flagd/commit/b79aaf2c2ca5fe9c43c1460d6cab349d5d68b7e1))
+* **deps:** update module golang.org/x/net to v0.19.0 ([#1034](https://github.com/open-feature/flagd/issues/1034)) ([c6426b2](https://github.com/open-feature/flagd/commit/c6426b20fa241066fc844a2a000812015790cf12))
+* various edge cases in targeting ([#1041](https://github.com/open-feature/flagd/issues/1041)) ([ca38c16](https://github.com/open-feature/flagd/commit/ca38c165c606ffa4517872f170375dde37f4ac5b))
+
+## [0.7.1](https://github.com/open-feature/flagd/compare/core/v0.7.0...core/v0.7.1) (2023-11-28)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update kubernetes packages to v0.28.4 ([#1016](https://github.com/open-feature/flagd/issues/1016)) ([ae470e3](https://github.com/open-feature/flagd/commit/ae470e37f3368c81484f0c54366ccf059ea2cea6))
+* **deps:** update opentelemetry-go monorepo ([#1019](https://github.com/open-feature/flagd/issues/1019)) ([23ae555](https://github.com/open-feature/flagd/commit/23ae555ad73128dff46e911fccfef76306f5c550))
+
+
+### 🔄 Refactoring
+
+* Rename metrics-port to management-port ([#1012](https://github.com/open-feature/flagd/issues/1012)) ([5635e38](https://github.com/open-feature/flagd/commit/5635e38703cae835a53e9cce83d5bc42d00091e2))
+
+## [0.7.0](https://github.com/open-feature/flagd/compare/core/v0.6.8...core/v0.7.0) (2023-11-15)
+
+
+### ⚠ BREAKING CHANGES
+
+* OFO APIs were updated to version v1beta1, since they are more stable now. Resources of the alpha versions are no longer supported in flagd or flagd-proxy.
+
+### ✨ New Features
+
+* support OFO v1beta1 API ([#997](https://github.com/open-feature/flagd/issues/997)) ([bb6f5bf](https://github.com/open-feature/flagd/commit/bb6f5bf0fc382ade75d80a34d209beaa2edc459d))
+
+## [0.6.8](https://github.com/open-feature/flagd/compare/core/v0.6.7...core/v0.6.8) (2023-11-13)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update golang.org/x/exp digest to 9a3e603 ([#929](https://github.com/open-feature/flagd/issues/929)) ([f8db930](https://github.com/open-feature/flagd/commit/f8db930da22f52ffddd4533bdbaf8188f89250d0))
+* **deps:** update kubernetes packages to v0.28.3 ([#974](https://github.com/open-feature/flagd/issues/974)) ([d7d205f](https://github.com/open-feature/flagd/commit/d7d205f457e46de3385610ee27db6dfd41323cd1))
+* **deps:** update module github.com/diegoholiveira/jsonlogic/v3 to v3.3.1 ([#971](https://github.com/open-feature/flagd/issues/971)) ([f1a40b8](https://github.com/open-feature/flagd/commit/f1a40b862e7be69b542ab65a645c29c56b8fe307))
+* **deps:** update module github.com/diegoholiveira/jsonlogic/v3 to v3.3.2 ([#975](https://github.com/open-feature/flagd/issues/975)) ([b53c14a](https://github.com/open-feature/flagd/commit/b53c14afabd6b3f2403d9e2ea2bd26c8f1cfe8e4))
+* **deps:** update module github.com/fsnotify/fsnotify to v1.7.0 ([#981](https://github.com/open-feature/flagd/issues/981)) ([727b9d2](https://github.com/open-feature/flagd/commit/727b9d2046ccd998d2ab721df10d88b84445494f))
+* **deps:** update module golang.org/x/mod to v0.14.0 ([#991](https://github.com/open-feature/flagd/issues/991)) ([87bc12d](https://github.com/open-feature/flagd/commit/87bc12dd968e9fcf524eb0b69462222f29c6ba34))
+* **deps:** update module golang.org/x/net to v0.17.0 [security] ([#963](https://github.com/open-feature/flagd/issues/963)) ([7f54bd1](https://github.com/open-feature/flagd/commit/7f54bd1fb3fdbb7dff3a7b097f804ce843bb6e3a))
+* **deps:** update module golang.org/x/net to v0.18.0 ([#1000](https://github.com/open-feature/flagd/issues/1000)) ([e9347cc](https://github.com/open-feature/flagd/commit/e9347cc88a4174c984432571710588ac57665cb7))
+* **deps:** update module golang.org/x/sync to v0.5.0 ([#992](https://github.com/open-feature/flagd/issues/992)) ([bd24536](https://github.com/open-feature/flagd/commit/bd24536722f3c3c99b5946de0b62dba603992ba7))
+* **deps:** update module google.golang.org/grpc to v1.59.0 ([#972](https://github.com/open-feature/flagd/issues/972)) ([7d0f1f2](https://github.com/open-feature/flagd/commit/7d0f1f225ebfe83681c83cf38bf5c253a7b0ebef))
+* **deps:** update module sigs.k8s.io/controller-runtime to v0.16.3 ([#976](https://github.com/open-feature/flagd/issues/976)) ([b33c9c9](https://github.com/open-feature/flagd/commit/b33c9c97cf21eb317e4b0b1f452571d85de145b1))
+* **deps:** update opentelemetry-go monorepo ([#1001](https://github.com/open-feature/flagd/issues/1001)) ([9798aeb](https://github.com/open-feature/flagd/commit/9798aeb248764400128048b65ba27baba71b07e6))
+
+
+### 🔄 Refactoring
+
+* migrate to connectrpc/connect-go ([#990](https://github.com/open-feature/flagd/issues/990)) ([7dd5b2b](https://github.com/open-feature/flagd/commit/7dd5b2b4c284481bcba5a9c45bd6c85ad1dc6d33))
+
+## [0.6.7](https://github.com/open-feature/flagd/compare/core/v0.6.6...core/v0.6.7) (2023-10-12)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update module github.com/prometheus/client_golang to v1.17.0 ([#939](https://github.com/open-feature/flagd/issues/939)) ([9065cba](https://github.com/open-feature/flagd/commit/9065cba599ac07225b613c5acd9403ab24462078))
+* **deps:** update module github.com/rs/cors to v1.10.1 ([#946](https://github.com/open-feature/flagd/issues/946)) ([1c39862](https://github.com/open-feature/flagd/commit/1c39862297746e66189ece87892b6e4694294fb6))
+* **deps:** update module go.uber.org/zap to v1.26.0 ([#917](https://github.com/open-feature/flagd/issues/917)) ([e57e206](https://github.com/open-feature/flagd/commit/e57e206c937d5b11b81d46ee57b3e92cc454dd88))
+* **deps:** update module golang.org/x/mod to v0.13.0 ([#952](https://github.com/open-feature/flagd/issues/952)) ([be61450](https://github.com/open-feature/flagd/commit/be61450ec3fab3c294c9813df193c98e374900aa))
+* **deps:** update module golang.org/x/sync to v0.4.0 ([#949](https://github.com/open-feature/flagd/issues/949)) ([faa24a6](https://github.com/open-feature/flagd/commit/faa24a6c6f34330364e1ba0c3a847943f4e55150))
+* **deps:** update module google.golang.org/grpc to v1.58.1 ([#915](https://github.com/open-feature/flagd/issues/915)) ([06d95de](https://github.com/open-feature/flagd/commit/06d95ded9b69c9c598d08f8a6ef73ec598a817af))
+* **deps:** update module google.golang.org/grpc to v1.58.2 ([#928](https://github.com/open-feature/flagd/issues/928)) ([90f1878](https://github.com/open-feature/flagd/commit/90f1878ae482ea4a684615f733392a38301de68d))
+* **deps:** update module google.golang.org/grpc to v1.58.3 ([#960](https://github.com/open-feature/flagd/issues/960)) ([fee1558](https://github.com/open-feature/flagd/commit/fee1558da4f5418499fb09fe356d16f008423eb7))
+* **deps:** update opentelemetry-go monorepo ([#943](https://github.com/open-feature/flagd/issues/943)) ([e7cee41](https://github.com/open-feature/flagd/commit/e7cee41630e5684999b3689dbf1ab66234c65f6e))
+* erroneous warning about prop overwrite ([#924](https://github.com/open-feature/flagd/issues/924)) ([673b76a](https://github.com/open-feature/flagd/commit/673b76aeff5c27e8e031e59da5f0ed1871d3f749))
+
+
+### ✨ New Features
+
+* add `$flagd.timestamp` to json evaluator ([#958](https://github.com/open-feature/flagd/issues/958)) ([a1b04e7](https://github.com/open-feature/flagd/commit/a1b04e778df4d2f6beb881183a82161018151479))
+
+## [0.6.6](https://github.com/open-feature/flagd/compare/core/v0.6.5...core/v0.6.6) (2023-09-14)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update kubernetes packages to v0.28.2 ([#911](https://github.com/open-feature/flagd/issues/911)) ([2eda6ab](https://github.com/open-feature/flagd/commit/2eda6ab5e528f12a9ce6b6818e08abb0d783b23d))
+* **deps:** update module sigs.k8s.io/controller-runtime to v0.16.2 ([#907](https://github.com/open-feature/flagd/issues/907)) ([9976851](https://github.com/open-feature/flagd/commit/9976851d792ff3eb5fde18f19e397738eb7cacaf))
+* **deps:** update opentelemetry-go monorepo ([#906](https://github.com/open-feature/flagd/issues/906)) ([5a41226](https://github.com/open-feature/flagd/commit/5a4122658039aafcf080fcc6655c2a679622ed69))
+* use 32bit murmur calculation (64 is not stable) ([#913](https://github.com/open-feature/flagd/issues/913)) ([db8dca4](https://github.com/open-feature/flagd/commit/db8dca421cb0dba2968d47e5cc162d81401298db))
+
+## [0.6.5](https://github.com/open-feature/flagd/compare/core/v0.6.4...core/v0.6.5) (2023-09-08)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update module github.com/rs/cors to v1.10.0 ([#893](https://github.com/open-feature/flagd/issues/893)) ([fe61fbe](https://github.com/open-feature/flagd/commit/fe61fbe47a4e58562cbcb1c5201281fae1adafaf))
+* **deps:** update module golang.org/x/crypto to v0.13.0 ([#888](https://github.com/open-feature/flagd/issues/888)) ([1a9037a](https://github.com/open-feature/flagd/commit/1a9037a5b058e44fa844392d0110696b032eff6e))
+* **deps:** update module golang.org/x/net to v0.15.0 ([#889](https://github.com/open-feature/flagd/issues/889)) ([233d976](https://github.com/open-feature/flagd/commit/233d97694826d0e018be19a78259188802aba37f))
+* **deps:** update module google.golang.org/grpc to v1.58.0 ([#896](https://github.com/open-feature/flagd/issues/896)) ([853b76d](https://github.com/open-feature/flagd/commit/853b76dfa3babfebd8bdbcd3e0913380f077b8ab))
+* **deps:** update module sigs.k8s.io/controller-runtime to v0.16.1 ([#882](https://github.com/open-feature/flagd/issues/882)) ([ca3d85a](https://github.com/open-feature/flagd/commit/ca3d85a51c0ed1c1def54d7304d4b9fe69622662))
+* **deps:** update opentelemetry-go monorepo ([#868](https://github.com/open-feature/flagd/issues/868)) ([d48317f](https://github.com/open-feature/flagd/commit/d48317f61d7db7ba0398dc9ab7cdd174a0b87555))
+
+
+### 🧹 Chore
+
+* upgrade to go 1.20 ([#891](https://github.com/open-feature/flagd/issues/891)) ([977167f](https://github.com/open-feature/flagd/commit/977167fb8db330b62726097616dcd691267199ad))
+
+## [0.6.4](https://github.com/open-feature/flagd/compare/core/v0.6.3...core/v0.6.4) (2023-08-30)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update kubernetes packages to v0.28.0 ([#841](https://github.com/open-feature/flagd/issues/841)) ([cc195e1](https://github.com/open-feature/flagd/commit/cc195e1dde052d583656d5e5b49caec50f832365))
+* **deps:** update kubernetes packages to v0.28.1 ([#860](https://github.com/open-feature/flagd/issues/860)) ([f3237c2](https://github.com/open-feature/flagd/commit/f3237c2d324fbb15fd5f7fe337a0601af3b537bb))
+* **deps:** update module github.com/open-feature/open-feature-operator to v0.2.36 ([#799](https://github.com/open-feature/flagd/issues/799)) ([fa4da4b](https://github.com/open-feature/flagd/commit/fa4da4b0115e9fb40ab038b996e1e32b9f6a47ab))
+* **deps:** update module golang.org/x/crypto to v0.12.0 ([#797](https://github.com/open-feature/flagd/issues/797)) ([edae3fd](https://github.com/open-feature/flagd/commit/edae3fd466c0be62a0256c268e85cb337c9536f2))
+* **deps:** update module golang.org/x/net to v0.14.0 ([#798](https://github.com/open-feature/flagd/issues/798)) ([92c2f26](https://github.com/open-feature/flagd/commit/92c2f2676163688130737b34a115374cb5631247))
+* **deps:** update module sigs.k8s.io/controller-runtime to v0.15.1 ([#795](https://github.com/open-feature/flagd/issues/795)) ([13d62fd](https://github.com/open-feature/flagd/commit/13d62fd0fc4749f19dba0a18e1fda46a723380c5))
+* **deps:** update module sigs.k8s.io/controller-runtime to v0.16.0 ([#856](https://github.com/open-feature/flagd/issues/856)) ([88d832a](https://github.com/open-feature/flagd/commit/88d832a9d49a4bc1d6156849a59227ecab07f96e))
+
+
+### ✨ New Features
+
+* add flag key to hash in fractional evaluation ([#847](https://github.com/open-feature/flagd/issues/847)) ([ca6a35f](https://github.com/open-feature/flagd/commit/ca6a35fd72462177f45a116e9009fc30b3588b83))
+* add gRPC healthchecks ([#863](https://github.com/open-feature/flagd/issues/863)) ([da30b7b](https://github.com/open-feature/flagd/commit/da30b7babffd8487c992fa41519787c8d78ebdba))
+* support nested props in fractional evaluator ([#869](https://github.com/open-feature/flagd/issues/869)) ([50ff739](https://github.com/open-feature/flagd/commit/50ff739178fb732e38a220bb6a071260af1f2469))
+
+
+### 🧹 Chore
+
+* deprecate fractionalEvaluation for fractional ([#873](https://github.com/open-feature/flagd/issues/873)) ([243fef9](https://github.com/open-feature/flagd/commit/243fef9e1f0ed00ccf5d9a389e10d9ad6a197fb1))
+* replace xxh3 with murmur3 in bucket algorithm ([#846](https://github.com/open-feature/flagd/issues/846)) ([c3c9e4e](https://github.com/open-feature/flagd/commit/c3c9e4e40aeae7e75b1b9ab13bb9a40264be84e5))
+
+## [0.6.3](https://github.com/open-feature/flagd/compare/core/v0.6.2...core/v0.6.3) (2023-08-04)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update module github.com/diegoholiveira/jsonlogic/v3 to v3.3.0 ([#785](https://github.com/open-feature/flagd/issues/785)) ([ee9c54b](https://github.com/open-feature/flagd/commit/ee9c54b6b5cd51b947aae1ff6309ffae07ce89eb))
+* **deps:** update module github.com/open-feature/open-feature-operator to v0.2.35 ([#783](https://github.com/open-feature/flagd/issues/783)) ([9ff0b5b](https://github.com/open-feature/flagd/commit/9ff0b5b1bd3bb95581eab83f944aa60e179b207a))
+* **deps:** update module go.uber.org/zap to v1.25.0 ([#786](https://github.com/open-feature/flagd/issues/786)) ([40d0aa6](https://github.com/open-feature/flagd/commit/40d0aa66cf422db6811206d777b55396a96f330f))
+* **deps:** update module golang.org/x/net to v0.13.0 ([#784](https://github.com/open-feature/flagd/issues/784)) ([f57d023](https://github.com/open-feature/flagd/commit/f57d023174d9cc74b7d8260055f82b84a2bdcc52))
+* metric descriptions match the otel spec ([#789](https://github.com/open-feature/flagd/issues/789)) ([34befcd](https://github.com/open-feature/flagd/commit/34befcdfedc5f0479cb0ae77fe148849c341d33e))
+
+
+### ✨ New Features
+
+* add new configuration "sync-interval" which controls the HTTP polling interval ([#404](https://github.com/open-feature/flagd/issues/404)) ([ace62c7](https://github.com/open-feature/flagd/commit/ace62c7a6ab2b5b5d26642286deb6db406391d8f))
+* include falsy json fields ([#792](https://github.com/open-feature/flagd/issues/792)) ([37d91a0](https://github.com/open-feature/flagd/commit/37d91a09836f07e07b12acd13850ea5c7c9252cd))
+
+## [0.6.2](https://github.com/open-feature/flagd/compare/core/v0.6.1...core/v0.6.2) (2023-07-28)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update module buf.build/gen/go/open-feature/flagd/grpc/go to v1.3.0-20230720212818-3675556880a1.1 ([#747](https://github.com/open-feature/flagd/issues/747)) ([fb17bc6](https://github.com/open-feature/flagd/commit/fb17bc6a5c715f507b2838c150dc8a2f139a38fb))
+* **deps:** update module golang.org/x/net to v0.12.0 ([#734](https://github.com/open-feature/flagd/issues/734)) ([777b28b](https://github.com/open-feature/flagd/commit/777b28b1d512245b0046d11197f6dfa341b317d2))
+
+
+### ✨ New Features
+
+* grpc selector as scope ([#761](https://github.com/open-feature/flagd/issues/761)) ([7246e6d](https://github.com/open-feature/flagd/commit/7246e6dce648c6445f90d71fc172bbab209d9928))
+
+## [0.6.1](https://github.com/open-feature/flagd/compare/core/v0.6.0...core/v0.6.1) (2023-07-27)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update kubernetes packages to v0.27.4 ([#756](https://github.com/open-feature/flagd/issues/756)) ([dcc10f3](https://github.com/open-feature/flagd/commit/dcc10f33f5fd9a8936241725ea811b90b4f136be))
+* **deps:** update module github.com/bufbuild/connect-go to v1.10.0 ([#771](https://github.com/open-feature/flagd/issues/771)) ([c74103f](https://github.com/open-feature/flagd/commit/c74103faec068f14c87ad3ec227f5b802dbfac43))
+* **deps:** update module google.golang.org/grpc to v1.57.0 ([#773](https://github.com/open-feature/flagd/issues/773)) ([be8bf04](https://github.com/open-feature/flagd/commit/be8bf045093d89099eead2cccb86a5a7275e25d5))
+
+
+### ✨ New Features
+
+* **flagd-proxy:** introduce zero-downtime ([#752](https://github.com/open-feature/flagd/issues/752)) ([ed5e6e5](https://github.com/open-feature/flagd/commit/ed5e6e5f3ee0a923c33dbf1a8bf20f80adec71bd))
+* **flagd:** custom error handling for OTel errors ([#769](https://github.com/open-feature/flagd/issues/769)) ([bda1a92](https://github.com/open-feature/flagd/commit/bda1a92785c4348fe306a1d259b7bea91bd01c41))
+
+## [0.6.0](https://github.com/open-feature/flagd/compare/core/v0.5.4...core/v0.6.0) (2023-07-13)
+
+
+### ⚠ BREAKING CHANGES
+
+* rename metrics and service ([#730](https://github.com/open-feature/flagd/issues/730))
+
+### 🔄 Refactoring
+
+* remove protobuf dependency from eval package ([#701](https://github.com/open-feature/flagd/issues/701)) ([34ffafd](https://github.com/open-feature/flagd/commit/34ffafd9a777da3f11bd3bfa81565e774cc63214))
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update kubernetes packages to v0.27.3 ([#708](https://github.com/open-feature/flagd/issues/708)) ([5bf3a69](https://github.com/open-feature/flagd/commit/5bf3a69aa4bf95ce77ad08491bcce420620525d3))
+* **deps:** update module github.com/bufbuild/connect-go to v1.9.0 ([#722](https://github.com/open-feature/flagd/issues/722)) ([75223e2](https://github.com/open-feature/flagd/commit/75223e2fc01c4dcd0291b46a0d50b8815b31654c))
+* **deps:** update module github.com/bufbuild/connect-opentelemetry-go to v0.4.0 ([#739](https://github.com/open-feature/flagd/issues/739)) ([713e2a9](https://github.com/open-feature/flagd/commit/713e2a9834546963615046de1b6125e7fa6bf20d))
+* **deps:** update module github.com/prometheus/client_golang to v1.16.0 ([#709](https://github.com/open-feature/flagd/issues/709)) ([b8bedd2](https://github.com/open-feature/flagd/commit/b8bedd2b895026eace8204ae4ffcff771f7e8e97))
+* **deps:** update module golang.org/x/crypto to v0.10.0 ([#647](https://github.com/open-feature/flagd/issues/647)) ([7f1d7e6](https://github.com/open-feature/flagd/commit/7f1d7e66669b88b2c56b32f9cdd9be354ebcfc8e))
+* **deps:** update module golang.org/x/mod to v0.11.0 ([#705](https://github.com/open-feature/flagd/issues/705)) ([42813be](https://github.com/open-feature/flagd/commit/42813bef092ba7fffed0dd94166bfd01ea8a7582))
+* **deps:** update module golang.org/x/mod to v0.12.0 ([#729](https://github.com/open-feature/flagd/issues/729)) ([7b109c7](https://github.com/open-feature/flagd/commit/7b109c705aceb652ac2675bd0ffe82420983798b))
+* **deps:** update module golang.org/x/net to v0.11.0 ([#706](https://github.com/open-feature/flagd/issues/706)) ([27d893f](https://github.com/open-feature/flagd/commit/27d893fe78417f7b8418003edc401ab5a6c21fb9))
+* **deps:** update module golang.org/x/sync to v0.3.0 ([#707](https://github.com/open-feature/flagd/issues/707)) ([7852efb](https://github.com/open-feature/flagd/commit/7852efb84e9f071b2b482b1968d799888b6882dc))
+* **deps:** update module google.golang.org/grpc to v1.56.1 ([#710](https://github.com/open-feature/flagd/issues/710)) ([8f16573](https://github.com/open-feature/flagd/commit/8f165739aee8f28800e200b357203e88a3fd5938))
+* **deps:** update module google.golang.org/grpc to v1.56.2 ([#738](https://github.com/open-feature/flagd/issues/738)) ([521cc30](https://github.com/open-feature/flagd/commit/521cc30cde1971be000ec10d93f6d70b9b2260ee))
+* **deps:** update module google.golang.org/protobuf to v1.31.0 ([#720](https://github.com/open-feature/flagd/issues/720)) ([247239e](https://github.com/open-feature/flagd/commit/247239e76b9de1a619aad9e957ed8b44ae534b77))
+* **deps:** update opentelemetry-go monorepo ([#648](https://github.com/open-feature/flagd/issues/648)) ([c12dad8](https://github.com/open-feature/flagd/commit/c12dad89a8e761154f57739ded594b2783a14f8a))
+
+
+### ✨ New Features
+
+* **flagD:** support zero downtime during upgrades ([#731](https://github.com/open-feature/flagd/issues/731)) ([7df8d39](https://github.com/open-feature/flagd/commit/7df8d3994b75991b5e49a65728ef5e4b24a85dde))
+* rename metrics and service ([#730](https://github.com/open-feature/flagd/issues/730)) ([09c0198](https://github.com/open-feature/flagd/commit/09c0198f76a200b1b6a1f48e9c94ec0547283ca2))
+
+## [0.5.4](https://github.com/open-feature/flagd/compare/core/v0.5.3...core/v0.5.4) (2023-06-07)
+
+
+### ✨ New Features
+
+* add `sem_ver` jsonLogic evaluator ([#675](https://github.com/open-feature/flagd/issues/675)) ([a8d8ab6](https://github.com/open-feature/flagd/commit/a8d8ab6b4495457a40a2c32b8bd5be48b1fd6941))
+* add `starts_with` and `ends_with` json evaluators ([#658](https://github.com/open-feature/flagd/issues/658)) ([f932b8f](https://github.com/open-feature/flagd/commit/f932b8f4c834a5ebe27ebb860c26fdea8da20598))
+* telemetry improvements ([#653](https://github.com/open-feature/flagd/issues/653)) ([ea02cba](https://github.com/open-feature/flagd/commit/ea02cba24bde982d55956fe54de1e8f27226bfc6))
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update module github.com/bufbuild/connect-go to v1.8.0 ([#683](https://github.com/open-feature/flagd/issues/683)) ([13bb13d](https://github.com/open-feature/flagd/commit/13bb13daa11068481ba97f3432ae08de78392a91))
+* **deps:** update module github.com/bufbuild/connect-opentelemetry-go to v0.3.0 ([#669](https://github.com/open-feature/flagd/issues/669)) ([e899435](https://github.com/open-feature/flagd/commit/e899435c29c32264ea2477436e69ce92c7775ee9))
+* **deps:** update module github.com/prometheus/client_golang to v1.15.1 ([#636](https://github.com/open-feature/flagd/issues/636)) ([b22279d](https://github.com/open-feature/flagd/commit/b22279df469dc78f9d3e5bc4a59ab6baf539a8ae))
+* **deps:** update module github.com/stretchr/testify to v1.8.3 ([#662](https://github.com/open-feature/flagd/issues/662)) ([2e06d58](https://github.com/open-feature/flagd/commit/2e06d582ee9c8abfd57f8945d91261eab6cf9854))
+* **deps:** update module github.com/stretchr/testify to v1.8.4 ([#678](https://github.com/open-feature/flagd/issues/678)) ([ca8c9d6](https://github.com/open-feature/flagd/commit/ca8c9d66a0c6b21129c4c36a3c10dcf3be869ee7))
+* **deps:** update module golang.org/x/mod to v0.10.0 ([#682](https://github.com/open-feature/flagd/issues/682)) ([16199ce](https://github.com/open-feature/flagd/commit/16199ceac9ebbae68dafbd6c21239f64f8c32511))
+* **deps:** update module golang.org/x/net to v0.10.0 ([#644](https://github.com/open-feature/flagd/issues/644)) ([ccd9d35](https://github.com/open-feature/flagd/commit/ccd9d351df153039a124064f30e5829610773f27))
+* **deps:** update module golang.org/x/sync to v0.2.0 ([#638](https://github.com/open-feature/flagd/issues/638)) ([7f4a7db](https://github.com/open-feature/flagd/commit/7f4a7db8139294a21b3415710c143f182d93264a))
+* **deps:** update module google.golang.org/grpc to v1.55.0 ([#640](https://github.com/open-feature/flagd/issues/640)) ([c0d7328](https://github.com/open-feature/flagd/commit/c0d732866262240e340fe10f8ac0f6ff2a5c4f8c))
+* **deps:** update module sigs.k8s.io/controller-runtime to v0.15.0 ([#665](https://github.com/open-feature/flagd/issues/665)) ([9490ed6](https://github.com/open-feature/flagd/commit/9490ed62e2fc589af8ae7ee26bfd559797a1f83c))
+* fix connect error code handling for disabled flags ([#670](https://github.com/open-feature/flagd/issues/670)) ([86a8012](https://github.com/open-feature/flagd/commit/86a8012efcfeb3e967657f6143c143b457d64ca2))
+* remove disabled flags from bulk evaluation ([#672](https://github.com/open-feature/flagd/issues/672)) ([d2ce988](https://github.com/open-feature/flagd/commit/d2ce98838edf63b88ee9fb5ae6f8d534e1112e7e))
+
+
+### 🔄 Refactoring
+
+* introduce additional linting rules + fix discrepancies ([#616](https://github.com/open-feature/flagd/issues/616)) ([aef0b90](https://github.com/open-feature/flagd/commit/aef0b9042dcbe5b3f9a7e97960b27366fe50adfe))
+* introduce isyncstore interface ([#660](https://github.com/open-feature/flagd/issues/660)) ([c0e2fa0](https://github.com/open-feature/flagd/commit/c0e2fa00736d46db98f72114a449b2e2bf998e3d))
+
+
+### 🧹 Chore
+
+* refactor json logic evaluator to pass custom operators as options ([#691](https://github.com/open-feature/flagd/issues/691)) ([1c9bff9](https://github.com/open-feature/flagd/commit/1c9bff9a523037c3654b592dc08c193aa3295e9e))
+* update otel dependencies ([#649](https://github.com/open-feature/flagd/issues/649)) ([2114e41](https://github.com/open-feature/flagd/commit/2114e41c38951247866c0b408e5f933282902e70))
+
+## [0.5.3](https://github.com/open-feature/flagd/compare/core/v0.5.2...core/v0.5.3) (2023-05-04)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update module github.com/bufbuild/connect-go to v1.6.0 ([#585](https://github.com/open-feature/flagd/issues/585)) ([8f2f467](https://github.com/open-feature/flagd/commit/8f2f467af52a3686196a821eec61954d89d3f71d))
+* **deps:** update module github.com/bufbuild/connect-go to v1.7.0 ([#625](https://github.com/open-feature/flagd/issues/625)) ([1b24fc9](https://github.com/open-feature/flagd/commit/1b24fc923a405b337634009831ef0b9792953ce5))
+* **deps:** update module github.com/open-feature/open-feature-operator to v0.2.34 ([#604](https://github.com/open-feature/flagd/issues/604)) ([3e6a84b](https://github.com/open-feature/flagd/commit/3e6a84b455a330f541784b346d3b6199f8b423f7))
+* **deps:** update module github.com/prometheus/client_golang to v1.15.0 ([#608](https://github.com/open-feature/flagd/issues/608)) ([0597a8f](https://github.com/open-feature/flagd/commit/0597a8f23d0914b26f06b1335b49fe7c18ecb4f9))
+* **deps:** update module github.com/rs/cors to v1.9.0 ([#609](https://github.com/open-feature/flagd/issues/609)) ([97066c1](https://github.com/open-feature/flagd/commit/97066c107d14777eaad8a05b3bb051639af3179c))
+* **deps:** update module github.com/rs/xid to v1.5.0 ([#614](https://github.com/open-feature/flagd/issues/614)) ([e3dfbc6](https://github.com/open-feature/flagd/commit/e3dfbc6753bddc9e2f5c4a2633a7010123cf2f97))
+* **deps:** update module golang.org/x/crypto to v0.8.0 ([#595](https://github.com/open-feature/flagd/issues/595)) ([36016d7](https://github.com/open-feature/flagd/commit/36016d7940fa772c01dd61b071b2c9ec753cfb75))
+
+
+### ✨ New Features
+
+* Introduce connect traces ([#624](https://github.com/open-feature/flagd/issues/624)) ([28bac6a](https://github.com/open-feature/flagd/commit/28bac6a54aed79cb8d84a147ffea296c36f5bd51))
+
+
+### 🧹 Chore
+
+* add instructions for windows and fix failing unit tests ([#632](https://github.com/open-feature/flagd/issues/632)) ([6999d67](https://github.com/open-feature/flagd/commit/6999d6722581ab8e2e14bfd4b2d0341fe5216684))
+
+## [0.5.2](https://github.com/open-feature/flagd/compare/core/v0.5.1...core/v0.5.2) (2023-04-13)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update module github.com/open-feature/open-feature-operator to v0.2.32 [security] ([#606](https://github.com/open-feature/flagd/issues/606)) ([6f721af](https://github.com/open-feature/flagd/commit/6f721af379fcb0f1a74410637a313477148ef863))
+* eventing configuration setup ([#605](https://github.com/open-feature/flagd/issues/605)) ([edfbe51](https://github.com/open-feature/flagd/commit/edfbe5191651f25da991b507a3feedcbbe3c66f1))
+
+
+### ✨ New Features
+
+* introduce metrics for failed evaluations ([#584](https://github.com/open-feature/flagd/issues/584)) ([77664cd](https://github.com/open-feature/flagd/commit/77664cdf53a868f56ca040bdfe3f4930cd9a8fb4))
+* otel traces for flag evaluation ([#598](https://github.com/open-feature/flagd/issues/598)) ([1757035](https://github.com/open-feature/flagd/commit/175703548f88469f25d749e320ee48030c9f9074))
+
+## [0.5.1](https://github.com/open-feature/flagd/compare/core/v0.5.0...core/v0.5.1) (2023-04-12)
+
+
+### 🧹 Chore
+
+* move startServer functions into errGroups ([#566](https://github.com/open-feature/flagd/issues/566)) ([0223c23](https://github.com/open-feature/flagd/commit/0223c23fbd72322cf6ecbe6736968b3e6c6132bb))
+
+
+### ✨ New Features
+
+* flagd OTEL collector ([#586](https://github.com/open-feature/flagd/issues/586)) ([494bec3](https://github.com/open-feature/flagd/commit/494bec33dcc1ddf0fa5cd0866f06265618408f5e))
+
+
+### 🔄 Refactoring
+
+* remove connect-go from flagd-proxy and replace with grpc ([#589](https://github.com/open-feature/flagd/issues/589)) ([425de9a](https://github.com/open-feature/flagd/commit/425de9a1c2d1574779b905ac6debb9edfc156b15))
+
+
+### 🐛 Bug Fixes
+
+* flagd-proxy locking bug fix ([#592](https://github.com/open-feature/flagd/issues/592)) ([b166122](https://github.com/open-feature/flagd/commit/b1661225c912ee11ba4749f7ef157a0335e8781f))
+
 ## [0.5.0](https://github.com/open-feature/flagd/compare/core/v0.4.5...core/v0.5.0) (2023-03-30)
 
 

core/go.mod

@@ -1,100 +1,167 @@
 module github.com/open-feature/flagd/core
 
-go 1.19
+go 1.24.0
+
+toolchain go1.24.4
 
 require (
-	buf.build/gen/go/open-feature/flagd/bufbuild/connect-go v1.5.2-20230222100723-491ee098dd92.1
-	buf.build/gen/go/open-feature/flagd/grpc/go v1.3.0-20230317150644-afd1cc2ef580.1
-	buf.build/gen/go/open-feature/flagd/protocolbuffers/go v1.29.1-20230317150644-afd1cc2ef580.1
-	github.com/bufbuild/connect-go v1.5.2
-	github.com/diegoholiveira/jsonlogic/v3 v3.2.7
-	github.com/fsnotify/fsnotify v1.6.0
-	github.com/golang/mock v1.6.0
-	github.com/open-feature/open-feature-operator v0.2.31
-	github.com/open-feature/schemas v0.2.8
-	github.com/prometheus/client_golang v1.14.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.8.3
-	github.com/rs/xid v1.4.0
-	github.com/stretchr/testify v1.8.2
+	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.14.0
-	go.opentelemetry.io/otel/exporters/prometheus v0.36.0
-	go.opentelemetry.io/otel/metric v0.36.0
-	go.opentelemetry.io/otel/sdk v1.13.0
-	go.opentelemetry.io/otel/sdk/metric v0.36.0
-	go.uber.org/zap v1.24.0
-	golang.org/x/crypto v0.7.0
-	golang.org/x/net v0.8.0
-	golang.org/x/sync v0.1.0
-	google.golang.org/grpc v1.54.0
-	google.golang.org/protobuf v1.30.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.26.3
-	k8s.io/client-go v0.26.3
-	sigs.k8s.io/controller-runtime v0.14.6
+	k8s.io/apimachinery v0.33.2
+	k8s.io/client-go v0.33.2
 )
 
 require (
+	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/cespare/xxhash/v2 v2.2.0 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/emicklei/go-restful/v3 v3.10.1 // indirect
-	github.com/evanphx/json-patch v4.12.0+incompatible // indirect
-	github.com/evanphx/json-patch/v5 v5.6.0 // indirect
-	github.com/go-logr/logr v1.2.3 // 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-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/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
-	github.com/golang/protobuf v1.5.2 // indirect
-	github.com/google/gnostic v0.6.9 // indirect
-	github.com/google/go-cmp v0.5.9 // indirect
-	github.com/google/gofuzz v1.2.0 // indirect
-	github.com/google/uuid v1.3.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/kr/pretty v0.3.0 // 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.3.0 // indirect
-	github.com/prometheus/common v0.40.0 // indirect
-	github.com/prometheus/procfs v0.9.0 // 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/otel/trace v1.14.0 // indirect
-	go.uber.org/atomic v1.10.0 // indirect
-	go.uber.org/multierr v1.9.0 // indirect
-	golang.org/x/oauth2 v0.5.0 // indirect
-	golang.org/x/sys v0.6.0 // indirect
-	golang.org/x/term v0.6.0 // indirect
-	golang.org/x/text v0.8.0 // indirect
-	golang.org/x/time v0.3.0 // indirect
-	gomodules.xyz/jsonpatch/v2 v2.2.0 // indirect
-	google.golang.org/appengine v1.6.7 // indirect
-	google.golang.org/genproto v0.0.0-20230221151758-ace64dc21148 // 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/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.26.3 // indirect
-	k8s.io/apiextensions-apiserver v0.26.1 // indirect
-	k8s.io/component-base v0.26.1 // indirect
-	k8s.io/klog/v2 v2.90.0 // indirect
-	k8s.io/kube-openapi v0.0.0-20230217203603-ff9a8e8fa21d // indirect
-	k8s.io/utils v0.0.0-20230220204549-a5ecb0141aa5 // 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,117 +0,0 @@
-package eval
-
-import (
-	"errors"
-	"fmt"
-	"math"
-
-	"github.com/zeebo/xxh3"
-)
-
-type fractionalEvaluationDistribution struct {
-	variant    string
-	percentage int
-}
-
-func (je *JSONEvaluator) fractionalEvaluation(values, data interface{}) interface{} {
-	valueToDistribute, feDistributions, err := parseFractionalEvaluationData(values, data)
-	if err != nil {
-		je.Logger.Error(fmt.Sprintf("parse fractional evaluation data: %v", err))
-		return nil
-	}
-
-	return distributeValue(valueToDistribute, feDistributions)
-}
-
-func parseFractionalEvaluationData(values, data interface{}) (string, []fractionalEvaluationDistribution, 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 := parseFractionalEvaluationDistributions(valuesArray)
-	if err != nil {
-		return "", nil, err
-	}
-
-	return valueToDistribute, feDistributions, nil
-}
-
-func parseFractionalEvaluationDistributions(values []interface{}) ([]fractionalEvaluationDistribution, error) {
-	sumOfPercentages := 0
-	var feDistributions []fractionalEvaluationDistribution
-	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, fractionalEvaluationDistribution{
-			variant:    variant,
-			percentage: int(percentage),
-		})
-	}
-
-	if sumOfPercentages != 100 {
-		return nil, fmt.Errorf("percentages must sum to 100, got: %d", sumOfPercentages)
-	}
-
-	return feDistributions, nil
-}
-
-func distributeValue(value string, feDistribution []fractionalEvaluationDistribution) 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/fractional_evaluation_test.go

@@ -1,442 +0,0 @@
-package eval
-
-import (
-	"testing"
-
-	"github.com/open-feature/flagd/core/pkg/store"
-
-	"github.com/open-feature/flagd/core/pkg/logger"
-	"github.com/open-feature/flagd/core/pkg/model"
-	"google.golang.org/protobuf/types/known/structpb"
-)
-
-func TestFractionalEvaluation(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         *structpb.Struct
-		expectedValue   string
-		expectedVariant string
-		expectedReason  string
-		expectedError   error
-	}{
-		"test@faas.com": {
-			flags:   flags,
-			flagKey: "headerColor",
-			context: &structpb.Struct{Fields: map[string]*structpb.Value{
-				"email": {Kind: &structpb.Value_StringValue{
-					StringValue: "test@faas.com",
-				}},
-			}},
-			expectedVariant: "red",
-			expectedValue:   "#FF0000",
-			expectedReason:  model.TargetingMatchReason,
-		},
-		"test2@faas.com": {
-			flags:   flags,
-			flagKey: "headerColor",
-			context: &structpb.Struct{Fields: map[string]*structpb.Value{
-				"email": {Kind: &structpb.Value_StringValue{
-					StringValue: "test2@faas.com",
-				}},
-			}},
-			expectedVariant: "yellow",
-			expectedValue:   "#FFFF00",
-			expectedReason:  model.TargetingMatchReason,
-		},
-		"test3@faas.com": {
-			flags:   flags,
-			flagKey: "headerColor",
-			context: &structpb.Struct{Fields: map[string]*structpb.Value{
-				"email": {Kind: &structpb.Value_StringValue{
-					StringValue: "test3@faas.com",
-				}},
-			}},
-			expectedVariant: "red",
-			expectedValue:   "#FF0000",
-			expectedReason:  model.TargetingMatchReason,
-		},
-		"test4@faas.com": {
-			flags:   flags,
-			flagKey: "headerColor",
-			context: &structpb.Struct{Fields: map[string]*structpb.Value{
-				"email": {Kind: &structpb.Value_StringValue{
-					StringValue: "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: &structpb.Struct{Fields: map[string]*structpb.Value{
-				"email": {Kind: &structpb.Value_StringValue{
-					StringValue: "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:         &structpb.Struct{},
-			expectedVariant: "red",
-			expectedValue:   "#FF0000",
-			expectedReason:  model.DefaultReason,
-		},
-		"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: &structpb.Struct{Fields: map[string]*structpb.Value{
-				"email": {Kind: &structpb.Value_StringValue{
-					StringValue: "foo@foo.com",
-				}},
-			}},
-			expectedVariant: "red",
-			expectedValue:   "#FF0000",
-			expectedReason:  model.DefaultReason,
-		},
-		"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: &structpb.Struct{Fields: map[string]*structpb.Value{
-				"email": {Kind: &structpb.Value_StringValue{
-					StringValue: "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) {
-			je := NewJSONEvaluator(logger.NewLogger(nil, false), store.NewFlags())
-			je.store.Flags = tt.flags.Flags
-
-			value, variant, reason, err := resolve[string](
-				reqID, tt.flagKey, tt.context, je.evaluateVariant, je.store.Flags[tt.flagKey].Variants,
-			)
-
-			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 != tt.expectedError {
-				t.Errorf("expected err '%v', got '%v'", tt.expectedError, err)
-			}
-		})
-	}
-}
-
-func BenchmarkFractionalEvaluation(b *testing.B) {
-	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         *structpb.Struct
-		expectedValue   string
-		expectedVariant string
-		expectedReason  string
-		expectedError   error
-	}{
-		"test@faas.com": {
-			flags:   flags,
-			flagKey: "headerColor",
-			context: &structpb.Struct{Fields: map[string]*structpb.Value{
-				"email": {Kind: &structpb.Value_StringValue{
-					StringValue: "test@faas.com",
-				}},
-			}},
-			expectedVariant: "red",
-			expectedValue:   "#FF0000",
-			expectedReason:  model.TargetingMatchReason,
-		},
-		"test2@faas.com": {
-			flags:   flags,
-			flagKey: "headerColor",
-			context: &structpb.Struct{Fields: map[string]*structpb.Value{
-				"email": {Kind: &structpb.Value_StringValue{
-					StringValue: "test2@faas.com",
-				}},
-			}},
-			expectedVariant: "yellow",
-			expectedValue:   "#FFFF00",
-			expectedReason:  model.TargetingMatchReason,
-		},
-		"test3@faas.com": {
-			flags:   flags,
-			flagKey: "headerColor",
-			context: &structpb.Struct{Fields: map[string]*structpb.Value{
-				"email": {Kind: &structpb.Value_StringValue{
-					StringValue: "test3@faas.com",
-				}},
-			}},
-			expectedVariant: "red",
-			expectedValue:   "#FF0000",
-			expectedReason:  model.TargetingMatchReason,
-		},
-		"test4@faas.com": {
-			flags:   flags,
-			flagKey: "headerColor",
-			context: &structpb.Struct{Fields: map[string]*structpb.Value{
-				"email": {Kind: &structpb.Value_StringValue{
-					StringValue: "test4@faas.com",
-				}},
-			}},
-			expectedVariant: "blue",
-			expectedValue:   "#0000FF",
-			expectedReason:  model.TargetingMatchReason,
-		},
-	}
-	reqID := "test"
-	for name, tt := range tests {
-		b.Run(name, func(b *testing.B) {
-			je := JSONEvaluator{store: &store.Flags{Flags: tt.flags.Flags}}
-			for i := 0; i < b.N; i++ {
-				value, variant, reason, err := resolve[string](
-					reqID, tt.flagKey, tt.context, je.evaluateVariant, je.store.Flags[tt.flagKey].Variants,
-				)
-
-				if value != tt.expectedValue {
-					b.Errorf("expected value '%s', got '%s'", tt.expectedValue, value)
-				}
-
-				if variant != tt.expectedVariant {
-					b.Errorf("expected variant '%s', got '%s'", tt.expectedVariant, variant)
-				}
-
-				if reason != tt.expectedReason {
-					b.Errorf("expected reason '%s', got '%s'", tt.expectedReason, reason)
-				}
-
-				if err != tt.expectedError {
-					b.Errorf("expected err '%v', got '%v'", tt.expectedError, err)
-				}
-			}
-		})
-	}
-}

core/pkg/eval/ievaluator.go

@@ -1,55 +0,0 @@
-package eval
-
-import (
-	"github.com/open-feature/flagd/core/pkg/sync"
-	"google.golang.org/protobuf/types/known/structpb"
-)
-
-type AnyValue struct {
-	Value   interface{}
-	Variant string
-	Reason  string
-	FlagKey string
-}
-
-func NewAnyValue(value interface{}, variant string, reason string, flagKey string) AnyValue {
-	return AnyValue{
-		Value:   value,
-		Variant: variant,
-		Reason:  reason,
-		FlagKey: flagKey,
-	}
-}
-
-/*
-IEvaluator implementations store the state of the flags,
-do parsing and validation of the flag state and evaluate flags in response to handlers.
-*/
-type IEvaluator interface {
-	GetState() (string, error)
-	SetState(payload sync.DataSync) (map[string]interface{}, bool, error)
-
-	ResolveBooleanValue(
-		reqID string,
-		flagKey string,
-		context *structpb.Struct) (value bool, variant string, reason string, err error)
-	ResolveStringValue(
-		reqID string,
-		flagKey string,
-		context *structpb.Struct) (value string, variant string, reason string, err error)
-	ResolveIntValue(
-		reqID string,
-		flagKey string,
-		context *structpb.Struct) (value int64, variant string, reason string, err error)
-	ResolveFloatValue(
-		reqID string,
-		flagKey string,
-		context *structpb.Struct) (value float64, variant string, reason string, err error)
-	ResolveObjectValue(
-		reqID string,
-		flagKey string,
-		context *structpb.Struct) (value map[string]any, variant string, reason string, err error)
-	ResolveAllValues(
-		reqID string,
-		context *structpb.Struct) (values []AnyValue)
-}

core/pkg/eval/json_evaluator.go

@@ -1,354 +0,0 @@
-package eval
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"regexp"
-	"strconv"
-	"strings"
-
-	"github.com/open-feature/flagd/core/pkg/store"
-	"github.com/open-feature/flagd/core/pkg/sync"
-
-	"github.com/diegoholiveira/jsonlogic/v3"
-	"github.com/open-feature/flagd/core/pkg/logger"
-	"github.com/open-feature/flagd/core/pkg/model"
-	schema "github.com/open-feature/schemas/json"
-	"github.com/xeipuuv/gojsonschema"
-	"go.uber.org/zap"
-	"google.golang.org/protobuf/types/known/structpb"
-)
-
-var regBrace *regexp.Regexp
-
-func init() {
-	regBrace = regexp.MustCompile("^[^{]*{|}[^}]*$")
-}
-
-type JSONEvaluator struct {
-	store  *store.Flags
-	Logger *logger.Logger
-}
-
-type constraints interface {
-	bool | string | map[string]any | float64
-}
-
-const (
-	Disabled = "DISABLED"
-)
-
-func NewJSONEvaluator(logger *logger.Logger, s *store.Flags) *JSONEvaluator {
-	ev := JSONEvaluator{
-		Logger: logger.WithFields(
-			zap.String("component", "evaluator"),
-			zap.String("evaluator", "json"),
-		),
-		store: s,
-	}
-	jsonlogic.AddOperator("fractionalEvaluation", ev.fractionalEvaluation)
-	return &ev
-}
-
-func (je *JSONEvaluator) GetState() (string, error) {
-	return je.store.String()
-}
-
-func (je *JSONEvaluator) SetState(payload sync.DataSync) (map[string]interface{}, bool, error) {
-	var newFlags Flags
-	err := je.configToFlags(payload.FlagData, &newFlags)
-	if err != nil {
-		return nil, false, err
-	}
-
-	switch payload.Type {
-	case sync.ALL:
-		n, resync := je.store.Merge(je.Logger, payload.Source, newFlags.Flags)
-		return n, resync, nil
-	case sync.ADD:
-		return je.store.Add(je.Logger, payload.Source, newFlags.Flags), false, nil
-	case sync.UPDATE:
-		return je.store.Update(je.Logger, payload.Source, newFlags.Flags), false, nil
-	case sync.DELETE:
-		return je.store.DeleteFlags(je.Logger, payload.Source, newFlags.Flags), true, nil
-	default:
-		return nil, false, fmt.Errorf("unsupported sync type: %d", payload.Type)
-	}
-}
-
-func resolve[T constraints](reqID string, key string, context *structpb.Struct,
-	variantEval func(string, string, *structpb.Struct) (string, string, error),
-	variants map[string]any) (
-	value T,
-	variant string,
-	reason string,
-	err error,
-) {
-	variant, reason, err = variantEval(reqID, key, context)
-	if err != nil {
-		return value, variant, reason, err
-	}
-
-	var ok bool
-	value, ok = variants[variant].(T)
-	if !ok {
-		return value, variant, model.ErrorReason, errors.New(model.TypeMismatchErrorCode)
-	}
-
-	return value, variant, reason, nil
-}
-
-func (je *JSONEvaluator) ResolveAllValues(reqID string, context *structpb.Struct) []AnyValue {
-	values := []AnyValue{}
-	var value interface{}
-	var variant string
-	var reason string
-	var err error
-	allFlags := je.store.GetAll()
-	for flagKey, flag := range allFlags {
-		defaultValue := flag.Variants[flag.DefaultVariant]
-		switch defaultValue.(type) {
-		case bool:
-			value, variant, reason, err = resolve[bool](
-				reqID,
-				flagKey,
-				context,
-				je.evaluateVariant,
-				allFlags[flagKey].Variants,
-			)
-		case string:
-			value, variant, reason, err = resolve[string](
-				reqID,
-				flagKey,
-				context,
-				je.evaluateVariant,
-				allFlags[flagKey].Variants,
-			)
-		case float64:
-			value, variant, reason, err = resolve[float64](
-				reqID,
-				flagKey,
-				context,
-				je.evaluateVariant,
-				allFlags[flagKey].Variants,
-			)
-		case map[string]any:
-			value, variant, reason, err = resolve[map[string]any](
-				reqID,
-				flagKey,
-				context,
-				je.evaluateVariant,
-				allFlags[flagKey].Variants,
-			)
-		}
-		if err != nil {
-			je.Logger.ErrorWithID(reqID, fmt.Sprintf("bulk evaluation: key: %s returned error: %s", flagKey, err.Error()))
-			continue
-		}
-		values = append(values, NewAnyValue(value, variant, reason, flagKey))
-	}
-	return values
-}
-
-func (je *JSONEvaluator) ResolveBooleanValue(reqID string, flagKey string, context *structpb.Struct) (
-	value bool,
-	variant string,
-	reason string,
-	err error,
-) {
-	je.Logger.DebugWithID(reqID, fmt.Sprintf("evaluating boolean flag: %s", flagKey))
-	flag, _ := je.store.Get(flagKey)
-	return resolve[bool](reqID, flagKey, context, je.evaluateVariant, flag.Variants)
-}
-
-func (je *JSONEvaluator) ResolveStringValue(reqID string, flagKey string, context *structpb.Struct) (
-	value string,
-	variant string,
-	reason string,
-	err error,
-) {
-	je.Logger.DebugWithID(reqID, fmt.Sprintf("evaluating string flag: %s", flagKey))
-	flag, _ := je.store.Get(flagKey)
-	return resolve[string](reqID, flagKey, context, je.evaluateVariant, flag.Variants)
-}
-
-func (je *JSONEvaluator) ResolveFloatValue(reqID string, flagKey string, context *structpb.Struct) (
-	value float64,
-	variant string,
-	reason string,
-	err error,
-) {
-	je.Logger.DebugWithID(reqID, fmt.Sprintf("evaluating float flag: %s", flagKey))
-	flag, _ := je.store.Get(flagKey)
-	value, variant, reason, err = resolve[float64](
-		reqID, flagKey, context, je.evaluateVariant, flag.Variants)
-	return
-}
-
-func (je *JSONEvaluator) ResolveIntValue(reqID string, flagKey string, context *structpb.Struct) (
-	value int64,
-	variant string,
-	reason string,
-	err error,
-) {
-	je.Logger.DebugWithID(reqID, fmt.Sprintf("evaluating int flag: %s", flagKey))
-	flag, _ := je.store.Get(flagKey)
-	var val float64
-	val, variant, reason, err = resolve[float64](
-		reqID, flagKey, context, je.evaluateVariant, flag.Variants)
-	value = int64(val)
-	return
-}
-
-func (je *JSONEvaluator) ResolveObjectValue(reqID string, flagKey string, context *structpb.Struct) (
-	value map[string]any,
-	variant string,
-	reason string,
-	err error,
-) {
-	je.Logger.DebugWithID(reqID, fmt.Sprintf("evaluating object flag: %s", flagKey))
-	flag, _ := je.store.Get(flagKey)
-	return resolve[map[string]any](reqID, flagKey, context, je.evaluateVariant, flag.Variants)
-}
-
-// runs the rules (if defined) to determine the variant, otherwise falling through to the default
-func (je *JSONEvaluator) evaluateVariant(
-	reqID string,
-	flagKey string,
-	context *structpb.Struct,
-) (variant string, reason string, err error) {
-	flag, ok := je.store.Get(flagKey)
-	if !ok {
-		// flag not found
-		je.Logger.DebugWithID(reqID, fmt.Sprintf("requested flag could not be found: %s", flagKey))
-		return "", model.ErrorReason, errors.New(model.FlagNotFoundErrorCode)
-	}
-
-	if flag.State == Disabled {
-		je.Logger.DebugWithID(reqID, fmt.Sprintf("requested flag is disabled: %s", flagKey))
-		return "", model.ErrorReason, errors.New(model.FlagDisabledErrorCode)
-	}
-
-	// get the targeting logic, if any
-	targeting := flag.Targeting
-
-	if targeting != nil && string(targeting) != "{}" {
-		targetingBytes, err := targeting.MarshalJSON()
-		if err != nil {
-			je.Logger.ErrorWithID(reqID, fmt.Sprintf("Error parsing rules for flag: %s, %s", flagKey, err))
-			return "", model.ErrorReason, err
-		}
-
-		b, err := json.Marshal(context)
-		if err != nil {
-			je.Logger.ErrorWithID(reqID, fmt.Sprintf("error parsing context for flag: %s, %s, %v", flagKey, err, context))
-
-			return "", model.ErrorReason, errors.New(model.ErrorReason)
-		}
-		var result bytes.Buffer
-		// evaluate json-logic 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))
-			return "", model.ErrorReason, err
-		}
-		// strip whitespace and quotes from the variant
-		variant = strings.ReplaceAll(strings.TrimSpace(result.String()), "\"", "")
-
-		// if this is a valid variant, return it
-		if _, ok := flag.Variants[variant]; ok {
-			return variant, model.TargetingMatchReason, nil
-		}
-
-		je.Logger.DebugWithID(reqID, fmt.Sprintf("returning default variant for flagKey: %s, variant is not valid", flagKey))
-		reason = model.DefaultReason
-	} else {
-		reason = model.StaticReason
-	}
-
-	return flag.DefaultVariant, reason, nil
-}
-
-// 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)
-
-	result, err := gojsonschema.Validate(schemaLoader, flagStringLoader)
-	if err != nil {
-		return err
-	} else if !result.Valid() {
-		return fmt.Errorf("JSON schema validation failed: %s", buildErrorString(result.Errors()))
-	}
-
-	transposedConfig, err := je.transposeEvaluators(config)
-	if err != nil {
-		return fmt.Errorf("transposing evaluators: %w", err)
-	}
-
-	err = json.Unmarshal([]byte(transposedConfig), &newFlags)
-	if err != nil {
-		return fmt.Errorf("unmarshalling provided configurations: %w", err)
-	}
-
-	return validateDefaultVariants(newFlags)
-}
-
-// validateDefaultVariants returns an error if any of the default variants aren't valid
-func validateDefaultVariants(flags *Flags) error {
-	for name, flag := range flags.Flags {
-		if _, ok := flag.Variants[flag.DefaultVariant]; !ok {
-			return fmt.Errorf(
-				"default variant: '%s' isn't a valid variant of flag: '%s'", flag.DefaultVariant, name,
-			)
-		}
-	}
-
-	return nil
-}
-
-func (je *JSONEvaluator) transposeEvaluators(state string) (string, error) {
-	var evaluators Evaluators
-	if err := json.Unmarshal([]byte(state), &evaluators); err != nil {
-		return "", fmt.Errorf("unmarshal: %w", err)
-	}
-
-	for evalName, evalRaw := range evaluators.Evaluators {
-		// replace any occurrences of "evaluator": "evalName"
-		regex, err := regexp.Compile(fmt.Sprintf(`"\$ref":(\s)*"%s"`, evalName))
-		if err != nil {
-			return "", fmt.Errorf("compile regex: %w", err)
-		}
-
-		marshalledEval, err := evalRaw.MarshalJSON()
-		if err != nil {
-			return "", fmt.Errorf("marshal evaluator: %w", err)
-		}
-
-		evalValue := string(marshalledEval)
-		if len(evalValue) < 3 {
-			return "", errors.New("evaluator object is empty")
-		}
-		evalValue = regBrace.ReplaceAllString(evalValue, "")
-		state = regex.ReplaceAllString(state, evalValue)
-	}
-
-	return state, nil
-}
-
-// buildErrorString efficiently converts json schema errors to a formatted string, usable for logging
-func buildErrorString(errors []gojsonschema.ResultError) string {
-	var builder strings.Builder
-
-	for i, err := range errors {
-		builder.WriteByte(' ')
-		builder.WriteString(strconv.Itoa(i + 1))
-		builder.WriteByte(':')
-		builder.WriteString(err.String())
-		builder.WriteByte(' ')
-	}
-
-	return builder.String()
-}

core/pkg/eval/mock/ievaluator.go

@@ -1,167 +0,0 @@
-// Code generated by MockGen. DO NOT EDIT.
-// Source: pkg/eval/ievaluator.go
-
-// Package evalmock is a generated GoMock package.
-package evalmock
-
-import (
-	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"
-	structpb "google.golang.org/protobuf/types/known/structpb"
-)
-
-// 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(reqID string, context *structpb.Struct) []eval.AnyValue {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResolveAllValues", reqID, context)
-	ret0, _ := ret[0].([]eval.AnyValue)
-	return ret0
-}
-
-// ResolveAllValues indicates an expected call of ResolveAllValues.
-func (mr *MockIEvaluatorMockRecorder) ResolveAllValues(reqID, context interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveAllValues", reflect.TypeOf((*MockIEvaluator)(nil).ResolveAllValues), reqID, context)
-}
-
-// ResolveBooleanValue mocks base method.
-func (m *MockIEvaluator) ResolveBooleanValue(reqID, flagKey string, context *structpb.Struct) (bool, string, string, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResolveBooleanValue", reqID, flagKey, context)
-	ret0, _ := ret[0].(bool)
-	ret1, _ := ret[1].(string)
-	ret2, _ := ret[2].(string)
-	ret3, _ := ret[3].(error)
-	return ret0, ret1, ret2, ret3
-}
-
-// ResolveBooleanValue indicates an expected call of ResolveBooleanValue.
-func (mr *MockIEvaluatorMockRecorder) ResolveBooleanValue(reqID, flagKey, context interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveBooleanValue", reflect.TypeOf((*MockIEvaluator)(nil).ResolveBooleanValue), reqID, flagKey, context)
-}
-
-// ResolveFloatValue mocks base method.
-func (m *MockIEvaluator) ResolveFloatValue(reqID, flagKey string, context *structpb.Struct) (float64, string, string, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResolveFloatValue", reqID, flagKey, context)
-	ret0, _ := ret[0].(float64)
-	ret1, _ := ret[1].(string)
-	ret2, _ := ret[2].(string)
-	ret3, _ := ret[3].(error)
-	return ret0, ret1, ret2, ret3
-}
-
-// ResolveFloatValue indicates an expected call of ResolveFloatValue.
-func (mr *MockIEvaluatorMockRecorder) ResolveFloatValue(reqID, flagKey, context interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveFloatValue", reflect.TypeOf((*MockIEvaluator)(nil).ResolveFloatValue), reqID, flagKey, context)
-}
-
-// ResolveIntValue mocks base method.
-func (m *MockIEvaluator) ResolveIntValue(reqID, flagKey string, context *structpb.Struct) (int64, string, string, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResolveIntValue", reqID, flagKey, context)
-	ret0, _ := ret[0].(int64)
-	ret1, _ := ret[1].(string)
-	ret2, _ := ret[2].(string)
-	ret3, _ := ret[3].(error)
-	return ret0, ret1, ret2, ret3
-}
-
-// ResolveIntValue indicates an expected call of ResolveIntValue.
-func (mr *MockIEvaluatorMockRecorder) ResolveIntValue(reqID, flagKey, context interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveIntValue", reflect.TypeOf((*MockIEvaluator)(nil).ResolveIntValue), reqID, flagKey, context)
-}
-
-// ResolveObjectValue mocks base method.
-func (m *MockIEvaluator) ResolveObjectValue(reqID, flagKey string, context *structpb.Struct) (map[string]any, string, string, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResolveObjectValue", reqID, flagKey, context)
-	ret0, _ := ret[0].(map[string]any)
-	ret1, _ := ret[1].(string)
-	ret2, _ := ret[2].(string)
-	ret3, _ := ret[3].(error)
-	return ret0, ret1, ret2, ret3
-}
-
-// ResolveObjectValue indicates an expected call of ResolveObjectValue.
-func (mr *MockIEvaluatorMockRecorder) ResolveObjectValue(reqID, flagKey, context interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveObjectValue", reflect.TypeOf((*MockIEvaluator)(nil).ResolveObjectValue), reqID, flagKey, context)
-}
-
-// ResolveStringValue mocks base method.
-func (m *MockIEvaluator) ResolveStringValue(reqID, flagKey string, context *structpb.Struct) (string, string, string, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ResolveStringValue", reqID, flagKey, context)
-	ret0, _ := ret[0].(string)
-	ret1, _ := ret[1].(string)
-	ret2, _ := ret[2].(string)
-	ret3, _ := ret[3].(error)
-	return ret0, ret1, ret2, ret3
-}
-
-// ResolveStringValue indicates an expected call of ResolveStringValue.
-func (mr *MockIEvaluatorMockRecorder) ResolveStringValue(reqID, flagKey, context interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveStringValue", reflect.TypeOf((*MockIEvaluator)(nil).ResolveStringValue), 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

@@ -0,0 +1,677 @@
+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) {
+	const source = "testSource"
+	var sources = []string{source}
+	ctx := context.Background()
+
+	commonFlags := 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"]
+													  }]
+											  },
+											  {
+												"fractional": [
+												  {"cat": [{"var": "$flagd.flagKey"}, {"var": "email"}]},
+												  [
+												  "red",
+												  25
+												  ],
+												  [
+												  "blue",
+												  25
+												  ],
+												  [
+												  "green",
+												  25
+												  ],
+												  [
+												  "yellow",
+												  25
+												  ]
+												]
+											  }, null
+											]
+										  }`),
+			},
+			"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
+					]				  
+				}`),
+			},
+		},
+	}
+
+	tests := map[string]struct {
+		flags             Flags
+		flagKey           string
+		context           map[string]any
+		expectedValue     string
+		expectedVariant   string
+		expectedReason    string
+		expectedErrorCode string
+	}{
+		"rachel@faas.com": {
+			flags:   commonFlags,
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "rachel@faas.com",
+			},
+			expectedVariant: "yellow",
+			expectedValue:   "#FFFF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"monica@faas.com": {
+			flags:   commonFlags,
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "monica@faas.com",
+			},
+			expectedVariant: "blue",
+			expectedValue:   "#0000FF",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"joey@faas.com": {
+			flags:   commonFlags,
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "joey@faas.com",
+			},
+			expectedVariant: "red",
+			expectedValue:   "#FF0000",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"ross@faas.com": {
+			flags:   commonFlags,
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "ross@faas.com",
+			},
+			expectedVariant: "green",
+			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{
+					"footerColor": {
+						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": [
+										{"var": "email"},
+										[
+										"red",
+										25
+									  	],
+									  	[
+										"blue",
+										25
+										],
+										[
+										"green",
+										25
+									  	],
+									  	[
+										"yellow",
+										25
+									  	]
+									]
+								}, null
+							]
+						}`),
+					},
+				},
+			},
+			flagKey: "footerColor",
+			context: map[string]any{
+				"email": "ross@faas.com",
+			},
+			expectedVariant: "red",
+			expectedValue:   "#FF0000",
+			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"]
+													  }]
+											  },
+											  {
+												"fractional": [
+												  "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(`{
+							"fractional": [
+								{"var": "email"},
+								[
+								"red",
+								25
+								],
+								[
+								"blue",
+								25
+								],
+								[
+								"green",
+								25
+								],
+								[
+								"yellow",
+								25
+								]
+							]
+							}`),
+					},
+				},
+			},
+			flagKey:         "headerColor",
+			context:         map[string]any{},
+			expectedVariant: "red",
+			expectedValue:   "#FF0000",
+			expectedReason:  model.DefaultReason,
+		},
+		"get variant for non-percentage 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",
+								25
+								],
+								[
+								"blue",
+								25
+								]
+							]
+							}`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "foo@foo.com",
+			},
+			expectedVariant: "red",
+			expectedValue:   "#FF0000",
+			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{
+				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": [
+								[
+								"blue",
+								50
+								],
+								[
+								"green",
+								50
+								]
+							]
+							}`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"targetingKey": "foo@foo.com",
+			},
+			expectedVariant: "blue",
+			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)
+			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](ctx, 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)
+				}
+			}
+		})
+	}
+}
+
+func BenchmarkFractionalEvaluation(b *testing.B) {
+	const source = "testSource"
+	var sources = []string{source}
+	ctx := context.Background()
+
+	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"]
+								}]
+						},
+						{
+						"fractional": [
+							{"var": "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_a@faas.com": {
+			flags:   flags,
+			flagKey: "headerColor",
+			context: map[string]any{
+				"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,
+		},
+		"test_c@faas.com": {
+			flags:   flags,
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "test_c@faas.com",
+			},
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"test_d@faas.com": {
+			flags:   flags,
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "test_d@faas.com",
+			},
+			expectedVariant: "blue",
+			expectedValue:   "#0000FF",
+			expectedReason:  model.TargetingMatchReason,
+		},
+	}
+	reqID := "test"
+	for name, tt := range tests {
+		b.Run(name, func(b *testing.B) {
+			log := logger.NewLogger(nil, false)
+			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](
+					ctx, reqID, tt.flagKey, tt.context, je.evaluateVariant)
+
+				if value != tt.expectedValue {
+					b.Errorf("expected value '%s', got '%s'", tt.expectedValue, value)
+				}
+
+				if variant != tt.expectedVariant {
+					b.Errorf("expected variant '%s', got '%s'", tt.expectedVariant, variant)
+				}
+
+				if reason != tt.expectedReason {
+					b.Errorf("expected reason '%s', got '%s'", tt.expectedReason, reason)
+				}
+
+				if err != nil {
+					errorCode := err.Error()
+					if errorCode != tt.expectedErrorCode {
+						b.Errorf("expected err '%v', got '%v'", tt.expectedErrorCode, err)
+					}
+				}
+			}
+		})
+	}
+}
+
+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

@@ -0,0 +1,82 @@
+package evaluator
+
+import (
+	"context"
+
+	"github.com/open-feature/flagd/core/pkg/model"
+	"github.com/open-feature/flagd/core/pkg/sync"
+)
+
+type AnyValue struct {
+	Value    interface{}
+	Variant  string
+	Reason   string
+	FlagKey  string
+	Metadata model.Metadata
+	Error    error
+}
+
+func NewAnyValue(
+	value interface{}, variant string, reason string, flagKey string, metadata model.Metadata,
+	err error,
+) AnyValue {
+	return AnyValue{
+		Value:    value,
+		Variant:  variant,
+		Reason:   reason,
+		FlagKey:  flagKey,
+		Metadata: metadata,
+		Error:    err,
+	}
+}
+
+/*
+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 model.Metadata, err error)
+	ResolveStringValue(
+		ctx context.Context,
+		reqID string,
+		flagKey string,
+		context map[string]any) (
+		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 model.Metadata, err error)
+	ResolveFloatValue(
+		ctx context.Context,
+		reqID string,
+		flagKey string,
+		context map[string]any) (
+		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 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) (resolutions []AnyValue, metadata model.Metadata, err error)
+}

core/pkg/evaluator/ievaluator_test.go

@@ -0,0 +1,21 @@
+package evaluator
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestAnyValue(t *testing.T) {
+	obj := AnyValue{
+		Value:    "val",
+		Variant:  "variant",
+		Reason:   "reason",
+		FlagKey:  "key",
+		Metadata: map[string]interface{}{},
+		Error:    fmt.Errorf("err"),
+	}
+
+	require.Equal(t, obj, NewAnyValue("val", "variant", "reason", "key", map[string]interface{}{}, fmt.Errorf("err")))
+}

core/pkg/evaluator/json.go

@@ -0,0 +1,539 @@
+package evaluator
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+	"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"
+	"github.com/xeipuuv/gojsonschema"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/codes"
+	"go.opentelemetry.io/otel/trace"
+	"go.uber.org/zap"
+	"golang.org/x/exp/maps"
+)
+
+const (
+	SelectorMetadataKey = "scope"
+	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"`
+}
+
+type variantEvaluator func(context.Context, string, string, map[string]any) (
+	variant string, variants map[string]interface{}, reason string, metadata map[string]interface{}, error error)
+
+// Deprecated - this will be remove in the next release
+func WithEvaluator(name string, evalFunc func(interface{}, interface{}) interface{}) JSONEvaluatorOption {
+	return func(_ *JSON) {
+		jsonlogic.AddOperator(name, evalFunc)
+	}
+}
+
+// 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,
+		Logger:         logger,
+		jsonEvalTracer: tracer,
+		Resolver:       NewResolver(s, logger, tracer),
+	}
+
+	for _, o := range opts {
+		o(&ev)
+	}
+
+	return &ev
+}
+
+func (je *JSON) GetState() (string, error) {
+	s, err := je.store.String()
+	if err != nil {
+		return "", fmt.Errorf("unable to fetch evaluator state: %w", err)
+	}
+	return s, nil
+}
+
+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)))
+	defer span.End()
+
+	var definition Definition
+
+	err := configToFlagDefinition(je.Logger, payload.FlagData, &definition)
+	if err != nil {
+		span.SetStatus(codes.Error, "flagSync error")
+		span.RecordError(err)
+		return nil, false, err
+	}
+
+	var events map[string]interface{}
+	var reSync bool
+
+	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)))
+
+	return events, reSync, nil
+}
+
+// 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{}
+
+	for flagKey, flag := range allFlags {
+		if flag.State == Disabled {
+			// ignore evaluation of disabled flag
+			continue
+		}
+
+		defaultValue := flag.Variants[flag.DefaultVariant]
+		switch defaultValue.(type) {
+		case bool:
+			value, variant, reason, metadata, err = resolve[bool](ctx, reqID, flagKey, context, je.evaluateVariant)
+		case string:
+			value, variant, reason, metadata, err = resolve[string](ctx, reqID, flagKey, context, je.evaluateVariant)
+		case float64:
+			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](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, flagSetMetadata, nil
+}
+
+func (je *Resolver) ResolveBooleanValue(
+	ctx context.Context, reqID string, flagKey string, context map[string]any) (
+	value bool,
+	variant string,
+	reason string,
+	metadata map[string]interface{},
+	err error,
+) {
+	_, span := je.tracer.Start(ctx, "resolveBoolean")
+	defer span.End()
+
+	je.Logger.DebugWithID(reqID, fmt.Sprintf("evaluating boolean flag: %s", flagKey))
+	return resolve[bool](ctx, reqID, flagKey, context, je.evaluateVariant)
+}
+
+func (je *Resolver) ResolveStringValue(
+	ctx context.Context, reqID string, flagKey string, context map[string]any) (
+	value string,
+	variant string,
+	reason string,
+	metadata map[string]interface{},
+	err error,
+) {
+	_, span := je.tracer.Start(ctx, "resolveString")
+	defer span.End()
+
+	je.Logger.DebugWithID(reqID, fmt.Sprintf("evaluating string flag: %s", flagKey))
+	return resolve[string](ctx, reqID, flagKey, context, je.evaluateVariant)
+}
+
+func (je *Resolver) ResolveFloatValue(
+	ctx context.Context, reqID string, flagKey string, context map[string]any) (
+	value float64,
+	variant string,
+	reason string,
+	metadata map[string]interface{},
+	err error,
+) {
+	_, 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](ctx, reqID, flagKey, context, je.evaluateVariant)
+	return
+}
+
+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.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](ctx, reqID, flagKey, context, je.evaluateVariant)
+	value = int64(val)
+	return
+}
+
+func (je *Resolver) 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,
+) {
+	_, 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](ctx, reqID, flagKey, context, je.evaluateVariant)
+}
+
+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(ctx, reqID, key, context)
+	if err != nil {
+		return value, variant, reason, metadata, err
+	}
+
+	var ok bool
+	value, ok = variants[variant].(T)
+	if !ok {
+		return value, variant, model.ErrorReason, metadata, errors.New(model.TypeMismatchErrorCode)
+	}
+
+	return value, variant, reason, metadata, nil
+}
+
+// nolint: funlen
+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,
+) {
+
+	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)
+	}
+
+	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 {
+		je.Logger.DebugWithID(reqID, fmt.Sprintf("requested flag is disabled: %s", flagKey))
+		return "", flag.Variants, model.ErrorReason, metadata, errors.New(model.FlagDisabledErrorCode)
+	}
+
+	// get the targeting logic, if any
+	targeting := flag.Targeting
+
+	if targeting != nil && string(targeting) != "{}" {
+		targetingBytes, err := targeting.MarshalJSON()
+		if err != nil {
+			je.Logger.ErrorWithID(reqID, fmt.Sprintf("Error parsing rules for flag: %s, %s", flagKey, err))
+			return "", flag.Variants, model.ErrorReason, metadata, errors.New(model.ParseErrorCode)
+		}
+
+		evalCtx = setFlagdProperties(je.Logger, evalCtx, flagdProperties{
+			FlagKey:   flagKey,
+			Timestamp: time.Now().Unix(),
+		})
+
+		b, err := json.Marshal(evalCtx)
+		if err != nil {
+			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)
+		}
+
+		var result bytes.Buffer
+		// 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 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
+		}
+
+		// strip whitespace and quotes from the variant
+		variant = strings.ReplaceAll(trimmed, "\"", "")
+
+		// if this is a valid variant, return it
+		if _, ok := flag.Variants[variant]; ok {
+			return variant, flag.Variants, model.TargetingMatchReason, metadata, nil
+		}
+		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.GeneralErrorCode)
+	}
+
+	if flag.DefaultVariant == "" {
+		return "", flag.Variants, model.ErrorReason, metadata, errors.New(model.FlagNotFoundErrorCode)
+	}
+
+	return flag.DefaultVariant, flag.Variants, model.StaticReason, metadata, nil
+}
+
+func setFlagdProperties(
+	log *logger.Logger,
+	context map[string]any,
+	properties flagdProperties,
+) map[string]any {
+	if context == nil {
+		context = map[string]any{}
+	}
+
+	newContext := maps.Clone(context)
+
+	if _, ok := newContext[flagdPropertiesKey]; ok {
+		log.Warn("overwriting $flagd properties in the context")
+	}
+
+	newContext[flagdPropertiesKey] = properties
+
+	return newContext
+}
+
+func getFlagdProperties(context map[string]any) (flagdProperties, bool) {
+	properties, ok := context[flagdPropertiesKey]
+	if !ok {
+		return flagdProperties{}, false
+	}
+
+	b, err := json.Marshal(properties)
+	if err != nil {
+		return flagdProperties{}, false
+	}
+
+	var p flagdProperties
+	if err := json.Unmarshal(b, &p); err != nil {
+		return flagdProperties{}, false
+	}
+
+	return p, true
+}
+
+func loadAndCompileSchema(log *logger.Logger) *gojsonschema.Schema {
+	schemaLoader := gojsonschema.NewSchemaLoader()
+
+	// 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))
+	}
+
+	// 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), &definition)
+	if err != nil {
+		return fmt.Errorf("unmarshalling provided configurations: %w", err)
+	}
+
+	return validateDefaultVariants(definition)
+}
+
+// validateDefaultVariants returns an error if any of the default variants aren't valid
+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,
+			)
+		}
+	}
+
+	return nil
+}
+
+func transposeEvaluators(state string) (string, error) {
+	var evaluators Evaluators
+	if err := json.Unmarshal([]byte(state), &evaluators); err != nil {
+		return "", fmt.Errorf("unmarshal: %w", err)
+	}
+
+	for evalName, evalRaw := range evaluators.Evaluators {
+		// replace any occurrences of "evaluator": "evalName"
+		regex, err := regexp.Compile(fmt.Sprintf(`"\$ref":(\s)*"%s"`, evalName))
+		if err != nil {
+			return "", fmt.Errorf("compile regex: %w", err)
+		}
+
+		marshalledEval, err := evalRaw.MarshalJSON()
+		if err != nil {
+			return "", fmt.Errorf("marshal evaluator: %w", err)
+		}
+
+		evalValue := string(marshalledEval)
+		if len(evalValue) < 3 {
+			return "", errors.New("evaluator object is empty")
+		}
+		evalValue = regBrace.ReplaceAllString(evalValue, "")
+		state = regex.ReplaceAllString(state, evalValue)
+	}
+
+	return state, nil
+}
+
+// buildErrorString efficiently converts json schema errors to a formatted string, usable for logging
+func buildErrorString(errors []gojsonschema.ResultError) string {
+	var builder strings.Builder
+
+	for i, err := range errors {
+		builder.WriteByte(' ')
+		builder.WriteString(strconv.Itoa(i + 1))
+		builder.WriteByte(':')
+		builder.WriteString(err.String())
+		builder.WriteByte(' ')
+	}
+
+	return builder.String()
+}

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/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

@@ -0,0 +1,156 @@
+package evaluator
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/open-feature/flagd/core/pkg/logger"
+	"golang.org/x/mod/semver"
+)
+
+const SemVerEvaluationName = "sem_ver"
+
+type SemVerOperator string
+
+const (
+	Equals         SemVerOperator = "="
+	NotEqual       SemVerOperator = "!="
+	Less           SemVerOperator = "<"
+	LessOrEqual    SemVerOperator = "<="
+	GreaterOrEqual SemVerOperator = ">="
+	Greater        SemVerOperator = ">"
+	MatchMajor     SemVerOperator = "^"
+	MatchMinor     SemVerOperator = "~"
+)
+
+func (svo SemVerOperator) compare(v1, v2 string) (bool, error) {
+	cmpRes := semver.Compare(v1, v2)
+	switch svo {
+	case Less:
+		return cmpRes == -1, nil
+	case Equals:
+		return cmpRes == 0, nil
+	case NotEqual:
+		return cmpRes != 0, nil
+	case LessOrEqual:
+		return cmpRes == -1 || cmpRes == 0, nil
+	case GreaterOrEqual:
+		return cmpRes == +1 || cmpRes == 0, nil
+	case Greater:
+		return cmpRes == +1, nil
+	case MatchMinor:
+		v1MajorMinor := semver.MajorMinor(v1)
+		v2MajorMinor := semver.MajorMinor(v2)
+		return semver.Compare(v1MajorMinor, v2MajorMinor) == 0, nil
+	case MatchMajor:
+		v1Major := semver.Major(v1)
+		v2Major := semver.Major(v2)
+		return semver.Compare(v1Major, v2Major) == 0, nil
+	default:
+		return false, errors.New("invalid operator")
+	}
+}
+
+type SemVerComparison struct {
+	Logger *logger.Logger
+}
+
+func NewSemVerComparison(log *logger.Logger) *SemVerComparison {
+	return &SemVerComparison{Logger: log}
+}
+
+// SemVerEvaluation checks if the given property matches a semantic versioning condition.
+// It returns 'true', if the value of the given property meets the condition, 'false' if not.
+// As an example, it can be used in the following way inside an 'if' evaluation:
+//
+//	{
+//	  "if": [
+//			{
+//				"sem_ver": [{"var": "version"}, ">=", "1.0.0"]
+//			},
+//			"red", null
+//			]
+//	}
+//
+// This rule can be applied to the following data object, where the evaluation will resolve to 'true':
+//
+// { "version": "2.0.0" }
+//
+// Note that the 'sem_ver' evaluation rule must contain exactly three items:
+// 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 *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))
+		return false
+	}
+	res, err := operator.compare(actualVersion, targetVersion)
+	if err != nil {
+		je.Logger.Error(fmt.Sprintf("sem_ver evaluation: %v", err))
+		return false
+	}
+	return res
+}
+
+func parseSemverEvaluationData(values interface{}) (string, string, SemVerOperator, error) {
+	parsed, ok := values.([]interface{})
+	if !ok {
+		return "", "", "", errors.New("sem_ver evaluation is not an array")
+	}
+
+	if len(parsed) != 3 {
+		return "", "", "", errors.New("sem_ver evaluation must contain a value, an operator, and a comparison target")
+	}
+
+	actualVersion, err := parseSemanticVersion(parsed[0])
+	if err != nil {
+		return "", "", "", fmt.Errorf("sem_ver evaluation: could not parse target property value: %w", err)
+	}
+
+	operator, err := parseOperator(parsed[1])
+	if err != nil {
+		return "", "", "", fmt.Errorf("sem_ver evaluation: could not parse operator: %w", err)
+	}
+
+	targetVersion, err := parseSemanticVersion(parsed[2])
+	if err != nil {
+		return "", "", "", fmt.Errorf("sem_ver evaluation: could not parse target value: %w", err)
+	}
+	return actualVersion, targetVersion, operator, nil
+}
+
+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") {
+		version = "v" + version
+	}
+
+	if !semver.IsValid(version) {
+		return "", fmt.Errorf("'%v' is not a valid semantic version string", version)
+	}
+
+	return version, nil
+}
+
+func parseOperator(o interface{}) (SemVerOperator, error) {
+	operatorString, ok := o.(string)
+	if !ok {
+		return "", fmt.Errorf("could not parse operator '%v'", o)
+	}
+
+	return SemVerOperator(operatorString), nil
+}

core/pkg/evaluator/semver_test.go

@@ -0,0 +1,953 @@
+package evaluator
+
+import (
+	"context"
+	"errors"
+	"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/require"
+)
+
+func TestSemVerOperator_Compare(t *testing.T) {
+	type args struct {
+		v1 string
+		v2 string
+	}
+	tests := []struct {
+		name    string
+		svo     SemVerOperator
+		args    args
+		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:  "",
+			args: args{
+				v1: "v0.0.1",
+				v2: "v0.0.2",
+			},
+			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,
+			args: args{
+				v1: "v0.0.1",
+				v2: "v0.0.2",
+			},
+			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,
+			args: args{
+				v1: "v0.0.1",
+				v2: "v0.0.1",
+			},
+			want:    false,
+			wantErr: false,
+		},
+		{
+			name: "less or equal",
+			svo:  LessOrEqual,
+			args: args{
+				v1: "v0.0.1",
+				v2: "v0.0.2",
+			},
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name: "less or equal 2",
+			svo:  LessOrEqual,
+			args: args{
+				v1: "v0.0.1",
+				v2: "v0.0.1",
+			},
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name: "equal",
+			svo:  Equals,
+			args: args{
+				v1: "v0.0.1",
+				v2: "v0.0.1",
+			},
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name: "not equal",
+			svo:  Equals,
+			args: args{
+				v1: "v0.0.2",
+				v2: "v0.0.1",
+			},
+			want:    false,
+			wantErr: false,
+		},
+		{
+			name: "unequal",
+			svo:  NotEqual,
+			args: args{
+				v1: "v0.0.2",
+				v2: "v0.0.1",
+			},
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name: "not unequal",
+			svo:  NotEqual,
+			args: args{
+				v1: "v0.0.1",
+				v2: "v0.0.1",
+			},
+			want:    false,
+			wantErr: false,
+		},
+		{
+			name: "greater or equal 1",
+			svo:  GreaterOrEqual,
+			args: args{
+				v1: "v0.0.2",
+				v2: "v0.0.1",
+			},
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name: "greater or equal 2",
+			svo:  GreaterOrEqual,
+			args: args{
+				v1: "v0.0.1",
+				v2: "v0.0.1",
+			},
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name: "not greater or equal",
+			svo:  GreaterOrEqual,
+			args: args{
+				v1: "v0.0.1",
+				v2: "v0.0.2",
+			},
+			want:    false,
+			wantErr: false,
+		},
+		{
+			name: "greater",
+			svo:  Greater,
+			args: args{
+				v1: "v0.0.2",
+				v2: "v0.0.1",
+			},
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name: "not greater",
+			svo:  Greater,
+			args: args{
+				v1: "v0.0.1",
+				v2: "v0.0.1",
+			},
+			want:    false,
+			wantErr: false,
+		},
+		{
+			name: "matching major version",
+			svo:  MatchMajor,
+			args: args{
+				v1: "v1.3.4",
+				v2: "v1.5.3",
+			},
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name: "not matching major version",
+			svo:  MatchMajor,
+			args: args{
+				v1: "v2.1.1",
+				v2: "v1.1.1",
+			},
+			want:    false,
+			wantErr: false,
+		},
+		{
+			name: "matching minor version",
+			svo:  MatchMinor,
+			args: args{
+				v1: "v1.3.4",
+				v2: "v1.3.1",
+			},
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name: "not matching minor version",
+			svo:  MatchMinor,
+			args: args{
+				v1: "v2.2.1",
+				v2: "v2.1.1",
+			},
+			want:    false,
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			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) 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
+		context         map[string]any
+		expectedValue   string
+		expectedVariant string
+		expectedReason  string
+		expectedError   error
+	}{
+		"versions and 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.0.0", ">", "0.1.0"]
+											  },
+											  "red", null
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"version": "1.0.0",
+			},
+			expectedVariant: "red",
+			expectedValue:   "#FF0000",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"resolve target property using nested operation - 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"}, ">", "1.0.0"]
+											  },
+											  "red", null
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"version": "1.0.1",
+			},
+			expectedVariant: "red",
+			expectedValue:   "#FF0000",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"versions and operator provided - no 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.0.0", ">", "1.0.0"]
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"version": "1.0.0",
+			},
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"versions and major-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.3", "^", "1.5.6"]
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"version": "1.0.0",
+			},
+			expectedVariant: "red",
+			expectedValue:   "#FF0000",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"versions and minor-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.3", "~", "1.2.6"]
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"version": "1.0.0",
+			},
+			expectedVariant: "red",
+			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{
+					"headerColor": {
+						State:          "ENABLED",
+						DefaultVariant: "red",
+						Variants: map[string]any{
+							"red":    "#FF0000",
+							"blue":   "#0000FF",
+							"green":  "#00FF00",
+							"yellow": "#FFFF00",
+						},
+						Targeting: []byte(`{
+											"if": [
+											  {
+												"sem_ver": ["2.2.3", "^", "1.2.3"]
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"version": "1.0.0",
+			},
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"versions and minor-version operator provided - no 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.3.3", "~", "1.2.6"]
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"version": "1.0.0",
+			},
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"resolve target property using nested operation - no 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"}, ">", "1.0.0"]
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"version": "0.0.1",
+			},
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"error during parsing (not an array) - return default": {
+			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": "not an array"
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "user@faas.com",
+			},
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"error during parsing (wrong number of items in array) - return default": {
+			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": ["not", "enough"]
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "user@faas.com",
+			},
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"error during parsing (invalid property value) - return default": {
+			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": ["invalid", ">", "1.0.0"]
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "user@faas.com",
+			},
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"error during parsing (invalid property type) - return default": {
+			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.0, ">", "1.0.0"]
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "user@faas.com",
+			},
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"error during parsing (invalid operator) - return default": {
+			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.0.0", "invalid", "1.0.0"]
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "user@faas.com",
+			},
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"error during parsing (invalid operator type) - return default": {
+			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.0.0", 1, "1.0.0"]
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "user@faas.com",
+			},
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"error during parsing (invalid target version) - return default": {
+			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.0.0", ">", "invalid"]
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "user@faas.com",
+			},
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
+	}
+
+	const reqID = "default"
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			log := logger.NewLogger(nil, false)
+			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](ctx, 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 !errors.Is(err, tt.expectedError) {
+				t.Errorf("expected err '%v', got '%v'", tt.expectedError, err)
+			}
+		})
+	}
+}

core/pkg/evaluator/string_comparison.go

@@ -0,0 +1,125 @@
+package evaluator
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/open-feature/flagd/core/pkg/logger"
+)
+
+const (
+	StartsWithEvaluationName = "starts_with"
+	EndsWithEvaluationName   = "ends_with"
+)
+
+type StringComparisonEvaluator struct {
+	Logger *logger.Logger
+}
+
+func NewStringComparisonEvaluator(log *logger.Logger) *StringComparisonEvaluator {
+	return &StringComparisonEvaluator{Logger: log}
+}
+
+// StartsWithEvaluation checks if the given property starts with a certain prefix.
+// It returns 'true', if the value of the given property starts with the prefix, 'false' if not.
+// As an example, it can be used in the following way inside an 'if' evaluation:
+//
+//	{
+//	  "if": [
+//			{
+//				"starts_with": [{"var": "email"}, "user@faas"]
+//			},
+//			"red", null
+//			]
+//	}
+//
+// This rule can be applied to the following data object, where the evaluation will resolve to 'true':
+//
+// { "email": "user@faas.com" }
+//
+// Note that the 'starts_with' evaluation rule must contain exactly two items, which both resolve to a
+// string value
+func (sce *StringComparisonEvaluator) StartsWithEvaluation(values, _ interface{}) interface{} {
+	propertyValue, target, err := parseStringComparisonEvaluationData(values)
+	if err != nil {
+		sce.Logger.Error(fmt.Sprintf("parse starts_with evaluation data: %v", err))
+		return nil
+	}
+	return strings.HasPrefix(propertyValue, target)
+}
+
+// EndsWithEvaluation checks if the given property ends with a certain prefix.
+// It returns 'true', if the value of the given property starts with the prefix, 'false' if not.
+// As an example, it can be used in the following way inside an 'if' evaluation:
+//
+//	{
+//	  "if": [
+//			{
+//				"ends_with": [{"var": "email"}, "faas.com"]
+//			},
+//			"red", null
+//			]
+//	}
+//
+// This rule can be applied to the following data object, where the evaluation will resolve to 'true':
+//
+// { "email": "user@faas.com" }
+//
+// 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{} {
+	propertyValue, target, err := parseStringComparisonEvaluationData(values)
+	if err != nil {
+		sce.Logger.Error(fmt.Sprintf("parse ends_with evaluation data: %v", err))
+		return false
+	}
+	return strings.HasSuffix(propertyValue, target)
+}
+
+// parseStringComparisonEvaluationData tries to parse the input for the starts_with/ends_with evaluation.
+// this evaluator requires an array containing exactly two strings.
+// Note that, when used with jsonLogic, those two items can also have been objects in the original 'values' object,
+// which have been resolved to string values by jsonLogic before this function is called.
+// As an example, the following values object:
+//
+//	{
+//	  "if": [
+//			{
+//				"starts_with": [{"var": "email"}, "user@faas"]
+//			},
+//			"red", null
+//			]
+//	}
+//
+// with the following data object:
+//
+// { "email": "user@faas.com" }
+//
+// will have been resolved to
+//
+// ["user@faas.com", "user@faas"]
+//
+// at the time this function is reached.
+func parseStringComparisonEvaluationData(values interface{}) (string, string, error) {
+	parsed, ok := values.([]interface{})
+	if !ok {
+		return "", "", errors.New("[start/end]s_with evaluation is not an array")
+	}
+
+	if len(parsed) != 2 {
+		return "", "", errors.New("[start/end]s_with evaluation must contain a value and a comparison target")
+	}
+
+	property, ok := parsed[0].(string)
+	if !ok {
+		return "", "", errors.New("[start/end]s_with evaluation: property did not resolve to a string value")
+	}
+
+	targetValue, ok := parsed[1].(string)
+	if !ok {
+		return "", "", errors.New("[start/end]s_with evaluation: target value did not resolve to a string value")
+	}
+
+	return property, targetValue, nil
+}

core/pkg/evaluator/string_comparison_test.go

@@ -0,0 +1,503 @@
+package evaluator
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"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 TestJSONEvaluator_startsWithEvaluation(t *testing.T) {
+	const source = "testSource"
+	var sources = []string{source}
+	ctx := context.Background()
+
+	tests := map[string]struct {
+		flags           Flags
+		flagKey         string
+		context         map[string]any
+		expectedValue   string
+		expectedVariant string
+		expectedReason  string
+		expectedError   error
+	}{
+		"two strings 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": [
+											  {
+												"starts_with": ["user@faas.com", "user@faas"]
+											  },
+											  "red", null
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "user@faas.com",
+			},
+			expectedVariant: "red",
+			expectedValue:   "#FF0000",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"resolve target property using nested operation - 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": [
+											  {
+												"starts_with": [{"var": "email"}, "user@faas"]
+											  },
+											  "red", null
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "user@faas.com",
+			},
+			expectedVariant: "red",
+			expectedValue:   "#FF0000",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"two strings provided - no 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": [
+											  {
+												"starts_with": ["user@faas.com", "nope"]
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "user@faas.com",
+			},
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"resolve target property using nested operation - no 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": [
+											  {
+												"starts_with": [{"var": "email"}, "nope"]
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "user@faas.com",
+			},
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"error during parsing - return default": {
+			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": [
+											  {
+												"starts_with": "no-array"
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "user@faas.com",
+			},
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
+	}
+
+	const reqID = "default"
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			log := logger.NewLogger(nil, false)
+			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](ctx, 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 !errors.Is(err, tt.expectedError) {
+				t.Errorf("expected err '%v', got '%v'", tt.expectedError, err)
+			}
+		})
+	}
+}
+
+func TestJSONEvaluator_endsWithEvaluation(t *testing.T) {
+	const source = "testSource"
+	var sources = []string{source}
+	ctx := context.Background()
+
+	tests := map[string]struct {
+		flags           Flags
+		flagKey         string
+		context         map[string]any
+		expectedValue   string
+		expectedVariant string
+		expectedReason  string
+		expectedError   error
+	}{
+		"two strings 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": [
+											  {
+												"ends_with": ["user@faas.com", "faas.com"]
+											  },
+											  "red", null
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "user@faas.com",
+			},
+			expectedVariant: "red",
+			expectedValue:   "#FF0000",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"resolve target property using nested operation - 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": [
+											  {
+												"ends_with": [{"var": "email"}, "faas.com"]
+											  },
+											  "red", null
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "user@faas.com",
+			},
+			expectedVariant: "red",
+			expectedValue:   "#FF0000",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"two strings provided - no 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": [
+											  {
+												"ends_with": ["user@faas.com", "nope"]
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "user@faas.com",
+			},
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"resolve target property using nested operation - no 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": [
+											  {
+												"ends_with": [{"var": "email"}, "nope"]
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "user@faas.com",
+			},
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
+		"error during parsing - return default": {
+			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": [
+											  {
+												"ends_with": "no-array"
+											  },
+											  "red", "green"
+											]
+										  }`),
+					},
+				},
+			},
+			flagKey: "headerColor",
+			context: map[string]any{
+				"email": "user@faas.com",
+			},
+			expectedVariant: "green",
+			expectedValue:   "#00FF00",
+			expectedReason:  model.TargetingMatchReason,
+		},
+	}
+
+	const reqID = "default"
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			log := logger.NewLogger(nil, false)
+			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](ctx, 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 != tt.expectedError {
+				t.Errorf("expected err '%v', got '%v'", tt.expectedError, err)
+			}
+		})
+	}
+}
+
+func Test_parseStringComparisonEvaluationData(t *testing.T) {
+	type args struct {
+		values interface{}
+	}
+	tests := []struct {
+		name            string
+		args            args
+		wantProperty    string
+		wantTargetValue string
+		wantErr         assert.ErrorAssertionFunc
+	}{
+		{
+			name: "return two string values",
+			args: args{
+				values: []interface{}{"a", "b"},
+			},
+			wantProperty:    "a",
+			wantTargetValue: "b",
+			wantErr: func(t assert.TestingT, err error, i ...interface{}) bool {
+				assert.Nil(t, err)
+				return false
+			},
+		},
+		{
+			name: "provided object is not an array",
+			args: args{
+				values: "not-an-array",
+			},
+			wantProperty:    "",
+			wantTargetValue: "",
+			wantErr: func(t assert.TestingT, err error, i ...interface{}) bool {
+				assert.NotNil(t, err)
+				return true
+			},
+		},
+		{
+			name: "provided object does not have two elements",
+			args: args{
+				values: []interface{}{"a"},
+			},
+			wantProperty:    "",
+			wantTargetValue: "",
+			wantErr: func(t assert.TestingT, err error, i ...interface{}) bool {
+				assert.NotNil(t, err)
+				return true
+			},
+		},
+		{
+			name: "property is not a string",
+			args: args{
+				values: []interface{}{1, "b"},
+			},
+			wantProperty:    "",
+			wantTargetValue: "",
+			wantErr: func(t assert.TestingT, err error, i ...interface{}) bool {
+				assert.NotNil(t, err)
+				return true
+			},
+		},
+		{
+			name: "targetValue is not a string",
+			args: args{
+				values: []interface{}{"a", 1},
+			},
+			wantProperty:    "",
+			wantTargetValue: "",
+			wantErr: func(t assert.TestingT, err error, i ...interface{}) bool {
+				assert.NotNil(t, err)
+				return true
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, got1, err := parseStringComparisonEvaluationData(tt.args.values)
+			if !tt.wantErr(t, err, fmt.Sprintf("parseStringComparisonEvaluationData(%v)", tt.args.values)) {
+				return
+			}
+			assert.Equalf(t, tt.wantProperty, got, "parseStringComparisonEvaluationData(%v)", tt.args.values)
+			assert.Equalf(t, tt.wantTargetValue, got1, "parseStringComparisonEvaluationData(%v)", tt.args.values)
+		})
+	}
+}

core/pkg/logger/logger.go

@@ -1,6 +1,7 @@
 package logger
 
 import (
+	"fmt"
 	"sync"
 
 	"go.uber.org/zap"
@@ -188,7 +189,11 @@ func NewZapLogger(level zapcore.Level, logFormat string) (*zap.Logger, error) {
 		},
 		DisableCaller: false,
 	}
-	return cfg.Build()
+	l, err := cfg.Build()
+	if err != nil {
+		return nil, fmt.Errorf("unable to build logger from config: %w", err)
+	}
+	return l, nil
 }
 
 // NewLogger returns the logging wrapper for a given *zap.logger.

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/otel/metrics.go

@@ -1,109 +0,0 @@
-package otel
-
-import (
-	"context"
-	"time"
-
-	"github.com/prometheus/client_golang/prometheus"
-	"go.opentelemetry.io/otel/attribute"
-	"go.opentelemetry.io/otel/metric/instrument"
-	"go.opentelemetry.io/otel/metric/unit"
-	"go.opentelemetry.io/otel/sdk/instrumentation"
-	"go.opentelemetry.io/otel/sdk/metric"
-	"go.opentelemetry.io/otel/sdk/metric/aggregation"
-	semconv "go.opentelemetry.io/otel/semconv/v1.18.0"
-)
-
-type MetricsRecorder struct {
-	httpRequestDurHistogram   instrument.Float64Histogram
-	httpResponseSizeHistogram instrument.Float64Histogram
-	httpRequestsInflight      instrument.Int64UpDownCounter
-	impressions               instrument.Int64Counter
-}
-
-func (r MetricsRecorder) HTTPAttributes(svcName, url, method, code string) []attribute.KeyValue {
-	return []attribute.KeyValue{
-		semconv.ServiceNameKey.String(svcName),
-		semconv.HTTPURLKey.String(url),
-		semconv.HTTPMethodKey.String(method),
-		semconv.HTTPStatusCodeKey.String(code),
-	}
-}
-
-func (r MetricsRecorder) HTTPRequestDuration(ctx context.Context, duration time.Duration, attrs []attribute.KeyValue) {
-	r.httpRequestDurHistogram.Record(ctx, duration.Seconds(), attrs...)
-}
-
-func (r MetricsRecorder) HTTPResponseSize(ctx context.Context, sizeBytes int64, attrs []attribute.KeyValue) {
-	r.httpResponseSizeHistogram.Record(ctx, float64(sizeBytes), attrs...)
-}
-
-func (r MetricsRecorder) InFlightRequestStart(ctx context.Context, attrs []attribute.KeyValue) {
-	r.httpRequestsInflight.Add(ctx, 1, attrs...)
-}
-
-func (r MetricsRecorder) InFlightRequestEnd(ctx context.Context, attrs []attribute.KeyValue) {
-	r.httpRequestsInflight.Add(ctx, -1, attrs...)
-}
-
-func (r MetricsRecorder) Impressions(ctx context.Context, key, variant string) {
-	r.impressions.Add(ctx, 1, []attribute.KeyValue{
-		semconv.FeatureFlagKey(key),
-		semconv.FeatureFlagVariant(variant),
-		semconv.FeatureFlagProviderName("flagd"),
-	}...)
-}
-
-func getDurationView(svcName, viewName string, bucket []float64) metric.View {
-	return metric.NewView(
-		metric.Instrument{
-			// we change aggregation only for instruments with this name and scope
-			Name: viewName,
-			Scope: instrumentation.Scope{
-				Name: svcName,
-			},
-		},
-		metric.Stream{Aggregation: aggregation.ExplicitBucketHistogram{
-			Boundaries: bucket,
-		}},
-	)
-}
-
-func NewOTelRecorder(exporter metric.Reader, serviceName string) *MetricsRecorder {
-	const requestDurationName = "http_request_duration_seconds"
-	const responseSizeName = "http_response_size_bytes"
-
-	// create a metric provider with custom bucket size for histograms
-	provider := metric.NewMeterProvider(
-		metric.WithReader(exporter),
-		// for the request duration metric we use the default bucket size which are tailored for response time in seconds
-		metric.WithView(getDurationView(requestDurationName, serviceName, prometheus.DefBuckets)),
-		// for response size we want 8 exponential bucket starting from 100 Bytes
-		metric.WithView(getDurationView(responseSizeName, serviceName, prometheus.ExponentialBuckets(100, 10, 8))),
-	)
-	meter := provider.Meter(serviceName)
-	// we can ignore errors from OpenTelemetry since they could occur if we select the wrong aggregator
-	hduration, _ := meter.Float64Histogram(
-		requestDurationName,
-		instrument.WithDescription("The latency of the HTTP requests"),
-	)
-	hsize, _ := meter.Float64Histogram(
-		responseSizeName,
-		instrument.WithDescription("The size of the HTTP responses"),
-		instrument.WithUnit(unit.Bytes),
-	)
-	reqCounter, _ := meter.Int64UpDownCounter(
-		"http_requests_inflight",
-		instrument.WithDescription("The number of inflight requests being handled at the same time"),
-	)
-	impressions, _ := meter.Int64Counter(
-		"impressions",
-		instrument.WithDescription("The number of evaluation for a given flag"),
-	)
-	return &MetricsRecorder{
-		httpRequestDurHistogram:   hduration,
-		httpResponseSizeHistogram: hsize,
-		httpRequestsInflight:      reqCounter,
-		impressions:               impressions,
-	}
-}

core/pkg/otel/metrics_test.go

@@ -1,154 +0,0 @@
-package otel
-
-import (
-	"context"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-	"go.opentelemetry.io/otel/attribute"
-	"go.opentelemetry.io/otel/sdk/metric"
-	semconv "go.opentelemetry.io/otel/semconv/v1.13.0"
-)
-
-const svcName = "mySvc"
-
-func TestHTTPAttributes(t *testing.T) {
-	type HTTPReqProperties struct {
-		Service string
-		ID      string
-		Method  string
-		Code    string
-	}
-
-	tests := []struct {
-		name string
-		req  HTTPReqProperties
-		want []attribute.KeyValue
-	}{
-		{
-			name: "empty attributes",
-			req: HTTPReqProperties{
-				Service: "",
-				ID:      "",
-				Method:  "",
-				Code:    "",
-			},
-			want: []attribute.KeyValue{
-				semconv.ServiceNameKey.String(""),
-				semconv.HTTPURLKey.String(""),
-				semconv.HTTPMethodKey.String(""),
-				semconv.HTTPStatusCodeKey.String(""),
-			},
-		},
-		{
-			name: "some values",
-			req: HTTPReqProperties{
-				Service: "myService",
-				ID:      "#123",
-				Method:  "POST",
-				Code:    "300",
-			},
-			want: []attribute.KeyValue{
-				semconv.ServiceNameKey.String("myService"),
-				semconv.HTTPURLKey.String("#123"),
-				semconv.HTTPMethodKey.String("POST"),
-				semconv.HTTPStatusCodeKey.String("300"),
-			},
-		},
-		{
-			name: "special chars",
-			req: HTTPReqProperties{
-				Service: "!@#$%^&*()_+|}{[];',./<>",
-				ID:      "",
-				Method:  "",
-				Code:    "",
-			},
-			want: []attribute.KeyValue{
-				semconv.ServiceNameKey.String("!@#$%^&*()_+|}{[];',./<>"),
-				semconv.HTTPURLKey.String(""),
-				semconv.HTTPMethodKey.String(""),
-				semconv.HTTPStatusCodeKey.String(""),
-			},
-		},
-	}
-	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)
-			require.Equal(t, tt.want, res)
-		})
-	}
-}
-
-func TestNewOTelRecorder(t *testing.T) {
-	exp := metric.NewManualReader()
-	rec := NewOTelRecorder(exp, svcName)
-	require.NotNil(t, rec, "Expected object to be created")
-	require.NotNil(t, rec.httpRequestDurHistogram, "Expected httpRequestDurHistogram to be created")
-	require.NotNil(t, rec.httpResponseSizeHistogram, "Expected httpResponseSizeHistogram to be created")
-	require.NotNil(t, rec.httpRequestsInflight, "Expected httpRequestsInflight to be created")
-}
-
-func TestMetrics(t *testing.T) {
-	exp := metric.NewManualReader()
-	rec := NewOTelRecorder(exp, svcName)
-	ctx := context.TODO()
-	attrs := []attribute.KeyValue{
-		semconv.ServiceNameKey.String(svcName),
-	}
-	const n = 5
-	type MetricF func()
-	tests := []struct {
-		name       string
-		metricFunc MetricF
-	}{
-		{
-			name: "HTTPRequestDuration",
-			metricFunc: func() {
-				for i := 0; i < n; i++ {
-					rec.HTTPRequestDuration(ctx, 10, attrs)
-				}
-			},
-		},
-		{
-			name: "HTTPResponseSize",
-			metricFunc: func() {
-				for i := 0; i < n; i++ {
-					rec.HTTPResponseSize(ctx, 100, attrs)
-				}
-			},
-		},
-		{
-			name: "InFlightRequestStart",
-			metricFunc: func() {
-				for i := 0; i < n; i++ {
-					rec.InFlightRequestStart(ctx, attrs)
-					rec.InFlightRequestEnd(ctx, attrs)
-				}
-			},
-		},
-		{
-			name: "Impressions",
-			metricFunc: func() {
-				for i := 0; i < n; i++ {
-					rec.Impressions(ctx, "key", "variant")
-				}
-			},
-		},
-	}
-	i := 0
-	for _, tt := range tests {
-		i++
-		tt.metricFunc()
-		data, err := exp.Collect(context.TODO())
-		if err != nil {
-			t.Errorf("Got %v", err)
-		}
-		if len(data.ScopeMetrics) != 1 {
-			t.Errorf("A single scope is expected, got %d", len(data.ScopeMetrics))
-		}
-		scopeMetrics := data.ScopeMetrics[0]
-		require.Equal(t, svcName, scopeMetrics.Scope.Name)
-		require.Equal(t, i, len(scopeMetrics.Metrics))
-	}
-}

core/pkg/runtime/from_config.go

@@ -1,274 +0,0 @@
-package runtime
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net/http"
-	"regexp"
-	msync "sync"
-	"time"
-
-	"github.com/open-feature/flagd/core/pkg/sync/grpc/credentials"
-
-	"github.com/open-feature/flagd/core/pkg/service"
-
-	"go.opentelemetry.io/otel/exporters/prometheus"
-
-	"github.com/open-feature/flagd/core/pkg/eval"
-	"github.com/open-feature/flagd/core/pkg/logger"
-	"github.com/open-feature/flagd/core/pkg/otel"
-	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"
-	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"
-)
-
-// from_config is a collection of structures and parsers responsible for deriving flagd runtime
-
-const (
-	syncProviderFile       = "file"
-	syncProviderGrpc       = "grpc"
-	syncProviderKubernetes = "kubernetes"
-	syncProviderHTTP       = "http"
-	svcName                = "openfeature/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"`
-}
-
-// Config is the configuration structure derived from startup arguments.
-type Config struct {
-	ServicePort       uint16
-	MetricsPort       uint16
-	ServiceSocketPath string
-	ServiceCertPath   string
-	ServiceKeyPath    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
-func FromConfig(logger *logger.Logger, config Config) (*Runtime, error) {
-	// build connect service
-	exporter, err := prometheus.New()
-	if err != nil {
-		return nil, err
-	}
-
-	connectService := &flageval.ConnectService{
-		Logger: logger.WithFields(
-			zap.String("component", "service"),
-		),
-		Metrics: otel.NewOTelRecorder(exporter, svcName),
-	}
-
-	// build flag store
-	s := store.NewFlags()
-	sources := []string{}
-	for _, sync := range config.SyncProviders {
-		sources = append(sources, sync.URI)
-	}
-	s.FlagSources = sources
-
-	// 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: eval.NewJSONEvaluator(logger, s),
-		Service:   connectService,
-		ServiceConfig: service.Configuration{
-			Port:        config.ServicePort,
-			MetricsPort: config.MetricsPort,
-			ServiceName: svcName,
-			KeyPath:     config.ServiceKeyPath,
-			CertPath:    config.ServiceCertPath,
-			SocketPath:  config.ServiceSocketPath,
-			CORS:        config.CORS,
-		},
-		SyncImpl: iSyncs,
-	}, nil
-}
-
-// 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 {
-	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,
-		Cron:        cron.New(),
-	}
-}
-
-func NewK8s(uri string, logger *logger.Logger) (*kubernetes.Sync, error) {
-	reader, dynamic, err := kubernetes.GetClients()
-	if err != nil {
-		return nil, 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("unable to parse 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/runtime/runtime.go

@@ -1,117 +0,0 @@
-package runtime
-
-import (
-	"context"
-	"errors"
-	"os"
-	"os/signal"
-	msync "sync"
-	"syscall"
-
-	"github.com/open-feature/flagd/core/pkg/eval"
-	"github.com/open-feature/flagd/core/pkg/logger"
-	"github.com/open-feature/flagd/core/pkg/service"
-	"github.com/open-feature/flagd/core/pkg/sync"
-	"golang.org/x/sync/errgroup"
-)
-
-type Runtime struct {
-	Evaluator     eval.IEvaluator
-	Logger        *logger.Logger
-	Service       service.IFlagEvaluationService
-	ServiceConfig service.Configuration
-	SyncImpl      []sync.ISync
-
-	mu msync.Mutex
-}
-
-// nolint: funlen
-func (r *Runtime) Start() error {
-	if r.Service == nil {
-		return errors.New("no service set")
-	}
-	if len(r.SyncImpl) == 0 {
-		return errors.New("no sync implementation set")
-	}
-	if r.Evaluator == nil {
-		return errors.New("no evaluator set")
-	}
-	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
-	defer cancel()
-	g, gCtx := errgroup.WithContext(ctx)
-	dataSync := make(chan sync.DataSync, len(r.SyncImpl))
-	// Initialize DataSync channel watcher
-	g.Go(func() error {
-		for {
-			select {
-			case data := <-dataSync:
-				// resync events are triggered when a delete occurs during flag merges in the store
-				// resync events may trigger further resync events, however for a flag to be deleted from the store
-				// its source must match, preventing the opportunity for resync events to snowball
-				if resyncRequired := r.updateWithNotify(data); resyncRequired {
-					for _, s := range r.SyncImpl {
-						p := s
-						go func() {
-							g.Go(func() error {
-								return p.ReSync(gCtx, dataSync)
-							})
-						}()
-					}
-				}
-			case <-gCtx.Done():
-				return nil
-			}
-		}
-	})
-	// Init sync providers
-	for _, s := range r.SyncImpl {
-		if err := s.Init(gCtx); err != nil {
-			return err
-		}
-	}
-	// Start sync provider
-	for _, s := range r.SyncImpl {
-		p := s
-		g.Go(func() error {
-			return p.Sync(gCtx, dataSync)
-		})
-	}
-	g.Go(func() error {
-		// Readiness probe rely on the runtime
-		r.ServiceConfig.ReadinessProbe = r.isReady
-		return r.Service.Serve(gCtx, r.Evaluator, r.ServiceConfig)
-	})
-	<-gCtx.Done()
-	return g.Wait()
-}
-
-func (r *Runtime) isReady() bool {
-	// if all providers can watch for flag changes, we are ready.
-	for _, p := range r.SyncImpl {
-		if !p.IsReady() {
-			return false
-		}
-	}
-	return true
-}
-
-// updateWithNotify helps to update state and notify listeners
-func (r *Runtime) updateWithNotify(payload sync.DataSync) bool {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-
-	notifications, resyncRequired, err := r.Evaluator.SetState(payload)
-	if err != nil {
-		r.Logger.Error(err.Error())
-		return false
-	}
-
-	r.Service.Notify(service.Notification{
-		Type: service.ConfigurationChange,
-		Data: map[string]interface{}{
-			"flags": notifications,
-		},
-	})
-
-	return resyncRequired
-}

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

@@ -1,165 +0,0 @@
-//nolint:dupl
-package service
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net"
-	"net/http"
-	"sync"
-	"time"
-
-	"github.com/open-feature/flagd/core/pkg/service/middleware"
-
-	schemaConnectV1 "buf.build/gen/go/open-feature/flagd/bufbuild/connect-go/schema/v1/schemav1connect"
-	"github.com/open-feature/flagd/core/pkg/eval"
-	"github.com/open-feature/flagd/core/pkg/logger"
-	"github.com/open-feature/flagd/core/pkg/otel"
-	"github.com/open-feature/flagd/core/pkg/service"
-	corsmw "github.com/open-feature/flagd/core/pkg/service/middleware/cors"
-	h2cmw "github.com/open-feature/flagd/core/pkg/service/middleware/h2c"
-	metricsmw "github.com/open-feature/flagd/core/pkg/service/middleware/metrics"
-	"github.com/prometheus/client_golang/prometheus/promhttp"
-	"go.uber.org/zap"
-)
-
-const ErrorPrefix = "FlagdError:"
-
-type ConnectService struct {
-	Logger                *logger.Logger
-	Eval                  eval.IEvaluator
-	Metrics               *otel.MetricsRecorder
-	eventingConfiguration *eventingConfiguration
-	server                http.Server
-}
-
-func (s *ConnectService) Serve(ctx context.Context, eval eval.IEvaluator, svcConf service.Configuration) error {
-	s.Eval = eval
-	s.eventingConfiguration = &eventingConfiguration{
-		subs: make(map[interface{}]chan service.Notification),
-		mu:   &sync.RWMutex{},
-	}
-	lis, err := s.setupServer(svcConf)
-	if err != nil {
-		return err
-	}
-
-	errChan := make(chan error, 1)
-	go func() {
-		s.Logger.Info(fmt.Sprintf("Flag Evaluation listening at %s", lis.Addr()))
-		if svcConf.CertPath != "" && svcConf.KeyPath != "" {
-			if err := s.server.ServeTLS(
-				lis,
-				svcConf.CertPath,
-				svcConf.KeyPath,
-			); err != nil && !errors.Is(err, http.ErrServerClosed) {
-				errChan <- err
-			}
-		} else {
-			if err := s.server.Serve(
-				lis,
-			); err != nil && !errors.Is(err, http.ErrServerClosed) {
-				errChan <- err
-			}
-		}
-		close(errChan)
-	}()
-
-	go s.startMetricsServer(svcConf)
-
-	select {
-	case err := <-errChan:
-		return err
-	case <-ctx.Done():
-		return s.server.Shutdown(ctx)
-	}
-}
-
-func (s *ConnectService) setupServer(svcConf service.Configuration) (net.Listener, error) {
-	var lis net.Listener
-	var err error
-	mux := http.NewServeMux()
-	if svcConf.SocketPath != "" {
-		lis, err = net.Listen("unix", svcConf.SocketPath)
-	} else {
-		address := fmt.Sprintf(":%d", svcConf.Port)
-		lis, err = net.Listen("tcp", address)
-	}
-	if err != nil {
-		return nil, err
-	}
-	fes := NewFlagEvaluationService(
-		s.Logger.WithFields(zap.String("component", "flagservice")),
-		s.Eval,
-		s.Metrics,
-	)
-	path, handler := schemaConnectV1.NewServiceHandler(fes)
-	mux.Handle(path, handler)
-
-	s.server = http.Server{
-		ReadHeaderTimeout: time.Second,
-		Handler:           handler,
-	}
-
-	// Add middlewares
-
-	metricsMiddleware := metricsmw.NewHTTPMetric(metricsmw.Config{
-		Service:        svcConf.ServiceName,
-		MetricRecorder: s.Metrics,
-		Logger:         s.Logger,
-		HandlerID:      "",
-	})
-
-	s.AddMiddleware(metricsMiddleware)
-
-	corsMiddleware := corsmw.New(svcConf.CORS)
-	s.AddMiddleware(corsMiddleware)
-
-	if svcConf.CertPath == "" || svcConf.KeyPath == "" {
-		h2cMiddleware := h2cmw.New()
-		s.AddMiddleware(h2cMiddleware)
-	}
-
-	return lis, nil
-}
-
-func (s *ConnectService) AddMiddleware(mw middleware.IMiddleware) {
-	s.server.Handler = mw.Handler(s.server.Handler)
-}
-
-func (s *ConnectService) Notify(n service.Notification) {
-	s.eventingConfiguration.mu.RLock()
-	defer s.eventingConfiguration.mu.RUnlock()
-	for _, send := range s.eventingConfiguration.subs {
-		send <- n
-	}
-}
-
-func (s *ConnectService) startMetricsServer(svcConf service.Configuration) {
-	s.Logger.Info(fmt.Sprintf("metrics and probes listening at %d", svcConf.MetricsPort))
-	server := &http.Server{
-		Addr:              fmt.Sprintf(":%d", svcConf.MetricsPort),
-		ReadHeaderTimeout: 3 * time.Second,
-	}
-	server.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/healthz":
-			w.WriteHeader(http.StatusOK)
-		case "/readyz":
-			if svcConf.ReadinessProbe() {
-				w.WriteHeader(http.StatusOK)
-			} else {
-				w.WriteHeader(http.StatusPreconditionFailed)
-			}
-		case "/metrics":
-			promhttp.Handler().ServeHTTP(w, r)
-		default:
-			w.WriteHeader(http.StatusNotFound)
-		}
-	})
-	err := server.ListenAndServe()
-	if err != nil {
-		panic(err)
-	}
-}

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

@@ -1,172 +0,0 @@
-package service
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"os"
-	"testing"
-	"time"
-
-	middlewaremock "github.com/open-feature/flagd/core/pkg/service/middleware/mock"
-
-	schemaGrpcV1 "buf.build/gen/go/open-feature/flagd/grpc/go/schema/v1/schemav1grpc"
-	schemaV1 "buf.build/gen/go/open-feature/flagd/protocolbuffers/go/schema/v1"
-	"github.com/golang/mock/gomock"
-	mock "github.com/open-feature/flagd/core/pkg/eval/mock"
-	"github.com/open-feature/flagd/core/pkg/logger"
-	"github.com/open-feature/flagd/core/pkg/model"
-	"github.com/open-feature/flagd/core/pkg/otel"
-	iservice "github.com/open-feature/flagd/core/pkg/service"
-	"github.com/stretchr/testify/require"
-	"go.opentelemetry.io/otel/sdk/metric"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials/insecure"
-	"google.golang.org/protobuf/types/known/structpb"
-)
-
-func TestConnectService_UnixConnection(t *testing.T) {
-	type evalFields struct {
-		result  bool
-		variant string
-		reason  string
-		err     error
-	}
-
-	tests := []struct {
-		name       string
-		socketPath string
-		evalFields evalFields
-		req        *schemaV1.ResolveBooleanRequest
-		want       *schemaV1.ResolveBooleanResponse
-		wantErr    error
-	}{
-		{
-			name:       "happy path",
-			socketPath: "/tmp/flagd.sock",
-			evalFields: evalFields{
-				result:  true,
-				variant: "on",
-				reason:  model.DefaultReason,
-				err:     nil,
-			},
-			req: &schemaV1.ResolveBooleanRequest{
-				FlagKey: "myBoolFlag",
-				Context: &structpb.Struct{},
-			},
-			want: &schemaV1.ResolveBooleanResponse{
-				Value:   true,
-				Reason:  model.DefaultReason,
-				Variant: "on",
-			},
-			wantErr: nil,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// try to ensure the socket file doesn't exist
-			_ = os.Remove(tt.socketPath)
-			ctrl := gomock.NewController(t)
-			eval := mock.NewMockIEvaluator(ctrl)
-			eval.EXPECT().ResolveBooleanValue(gomock.Any(), tt.req.FlagKey, gomock.Any()).Return(
-				tt.evalFields.result,
-				tt.evalFields.variant,
-				tt.evalFields.reason,
-				tt.evalFields.err,
-			).AnyTimes()
-			// configure OTel Metrics
-			exp := metric.NewManualReader()
-			metricRecorder := otel.NewOTelRecorder(exp, tt.name)
-			svc := ConnectService{
-				Logger:  logger.NewLogger(nil, false),
-				Metrics: metricRecorder,
-			}
-			serveConf := iservice.Configuration{
-				ReadinessProbe: func() bool {
-					return true
-				},
-				SocketPath: tt.socketPath,
-			}
-			ctx := context.Background()
-			ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
-			defer cancel()
-
-			go func() {
-				err := svc.Serve(ctx, eval, serveConf)
-				fmt.Println(err)
-			}()
-			conn, err := grpc.Dial(
-				fmt.Sprintf("unix://%s", tt.socketPath),
-				grpc.WithTransportCredentials(insecure.NewCredentials()),
-				grpc.WithBlock(),
-				grpc.WithTimeout(2*time.Second),
-			)
-			if err != nil {
-				t.Errorf("grpc - fail to dial: %v", err)
-				return
-			}
-			client := schemaGrpcV1.NewServiceClient(
-				conn,
-			)
-
-			res, err := client.ResolveBoolean(ctx, tt.req)
-			if (err != nil) && !errors.Is(err, tt.wantErr) {
-				t.Errorf("ConnectService.ResolveBoolean() error = %v, wantErr %v", err, tt.wantErr)
-			}
-			require.Equal(t, tt.want.Reason, res.Reason)
-			require.Equal(t, tt.want.Value, res.Value)
-			require.Equal(t, tt.want.Variant, res.Variant)
-		})
-	}
-}
-
-func TestAddMiddleware(t *testing.T) {
-	const port = 12345
-	ctrl := gomock.NewController(t)
-
-	mwMock := middlewaremock.NewMockIMiddleware(ctrl)
-
-	mwMock.EXPECT().Handler(gomock.Any()).Return(
-		http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
-			writer.WriteHeader(http.StatusOK)
-		}))
-
-	exp := metric.NewManualReader()
-	metricRecorder := otel.NewOTelRecorder(exp, "my-exporter")
-
-	svc := ConnectService{
-		Logger:  logger.NewLogger(nil, false),
-		Metrics: metricRecorder,
-	}
-
-	serveConf := iservice.Configuration{
-		ReadinessProbe: func() bool {
-			return true
-		},
-		Port: port,
-	}
-	ctx := context.Background()
-	ctx, cancel := context.WithCancel(ctx)
-	defer cancel()
-
-	go func() {
-		err := svc.Serve(ctx, nil, serveConf)
-		fmt.Println(err)
-	}()
-
-	require.Eventually(t, func() bool {
-		resp, err := http.Get(fmt.Sprintf("http://localhost:%d/schema.v1.Service/ResolveAll", port))
-		// with the default http handler we should get a method not allowed (405) when attempting a GET request
-		return err == nil && resp.StatusCode == http.StatusMethodNotAllowed
-	}, 3*time.Second, 100*time.Millisecond)
-
-	svc.AddMiddleware(mwMock)
-
-	// with the injected middleware, the GET method should work
-	resp, err := http.Get(fmt.Sprintf("http://localhost:%d/schema.v1.Service/ResolveAll", port))
-
-	require.Nil(t, err)
-	// verify that the status we return in the mocked middleware
-	require.Equal(t, http.StatusOK, resp.StatusCode)
-}

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

@@ -1,293 +0,0 @@
-package service
-
-import (
-	"context"
-	"fmt"
-	"sync"
-	"time"
-
-	schemaV1 "buf.build/gen/go/open-feature/flagd/protocolbuffers/go/schema/v1"
-	"github.com/bufbuild/connect-go"
-	"github.com/open-feature/flagd/core/pkg/eval"
-	"github.com/open-feature/flagd/core/pkg/logger"
-	"github.com/open-feature/flagd/core/pkg/model"
-	"github.com/open-feature/flagd/core/pkg/otel"
-	"github.com/open-feature/flagd/core/pkg/service"
-	"github.com/rs/xid"
-	"go.uber.org/zap"
-	"google.golang.org/protobuf/types/known/structpb"
-)
-
-type FlagEvaluationService struct {
-	logger                *logger.Logger
-	eval                  eval.IEvaluator
-	metrics               *otel.MetricsRecorder
-	eventingConfiguration *eventingConfiguration
-}
-
-type eventingConfiguration struct {
-	mu   *sync.RWMutex
-	subs map[interface{}]chan service.Notification
-}
-
-func NewFlagEvaluationService(log *logger.Logger,
-	eval eval.IEvaluator, metricsRecorder *otel.MetricsRecorder,
-) *FlagEvaluationService {
-	return &FlagEvaluationService{
-		logger:  log,
-		eval:    eval,
-		metrics: metricsRecorder,
-		eventingConfiguration: &eventingConfiguration{
-			subs: make(map[interface{}]chan service.Notification),
-			mu:   &sync.RWMutex{},
-		},
-	}
-}
-
-func (s *FlagEvaluationService) ResolveAll(
-	ctx context.Context,
-	req *connect.Request[schemaV1.ResolveAllRequest],
-) (*connect.Response[schemaV1.ResolveAllResponse], error) {
-	reqID := xid.New().String()
-	defer s.logger.ClearFields(reqID)
-	res := &schemaV1.ResolveAllResponse{
-		Flags: make(map[string]*schemaV1.AnyFlag),
-	}
-	values := s.eval.ResolveAllValues(reqID, req.Msg.GetContext())
-	for _, value := range values {
-		// register the impression for each flag evaluated
-		s.metrics.Impressions(ctx, value.FlagKey, value.Variant)
-		switch v := value.Value.(type) {
-		case bool:
-			res.Flags[value.FlagKey] = &schemaV1.AnyFlag{
-				Reason:  value.Reason,
-				Variant: value.Variant,
-				Value: &schemaV1.AnyFlag_BoolValue{
-					BoolValue: v,
-				},
-			}
-		case string:
-			res.Flags[value.FlagKey] = &schemaV1.AnyFlag{
-				Reason:  value.Reason,
-				Variant: value.Variant,
-				Value: &schemaV1.AnyFlag_StringValue{
-					StringValue: v,
-				},
-			}
-		case float64:
-			res.Flags[value.FlagKey] = &schemaV1.AnyFlag{
-				Reason:  value.Reason,
-				Variant: value.Variant,
-				Value: &schemaV1.AnyFlag_DoubleValue{
-					DoubleValue: v,
-				},
-			}
-		case map[string]any:
-			val, err := structpb.NewStruct(v)
-			if err != nil {
-				s.logger.ErrorWithID(reqID, fmt.Sprintf("struct response construction: %v", err))
-				continue
-			}
-			res.Flags[value.FlagKey] = &schemaV1.AnyFlag{
-				Reason:  value.Reason,
-				Variant: value.Variant,
-				Value: &schemaV1.AnyFlag_ObjectValue{
-					ObjectValue: val,
-				},
-			}
-		}
-	}
-	return connect.NewResponse(res), nil
-}
-
-func (s *FlagEvaluationService) EventStream(
-	ctx context.Context,
-	req *connect.Request[schemaV1.EventStreamRequest],
-	stream *connect.ServerStream[schemaV1.EventStreamResponse],
-) error {
-	requestNotificationChan := make(chan service.Notification, 1)
-	s.eventingConfiguration.mu.Lock()
-	s.eventingConfiguration.subs[req] = requestNotificationChan
-	s.eventingConfiguration.mu.Unlock()
-	defer func() {
-		s.eventingConfiguration.mu.Lock()
-		delete(s.eventingConfiguration.subs, req)
-		s.eventingConfiguration.mu.Unlock()
-	}()
-	requestNotificationChan <- service.Notification{
-		Type: service.ProviderReady,
-	}
-	for {
-		select {
-		case <-time.After(20 * time.Second):
-			err := stream.Send(&schemaV1.EventStreamResponse{
-				Type: string(service.KeepAlive),
-			})
-			if err != nil {
-				s.logger.Error(err.Error())
-			}
-		case notification := <-requestNotificationChan:
-			d, err := structpb.NewStruct(notification.Data)
-			if err != nil {
-				s.logger.Error(err.Error())
-			}
-			err = stream.Send(&schemaV1.EventStreamResponse{
-				Type: string(notification.Type),
-				Data: d,
-			})
-			if err != nil {
-				s.logger.Error(err.Error())
-			}
-		case <-ctx.Done():
-			return nil
-		}
-	}
-}
-
-func resolve[T constraints](
-	goCtx context.Context,
-	logger *logger.Logger,
-	resolver func(reqID, flagKey string, ctx *structpb.Struct) (T, string, string, error),
-	flagKey string,
-	ctx *structpb.Struct,
-	resp response[T],
-	metrics *otel.MetricsRecorder,
-) error {
-	reqID := xid.New().String()
-	defer logger.ClearFields(reqID)
-
-	logger.WriteFields(
-		reqID,
-		zap.String("flag-key", flagKey),
-		zap.Strings("context-keys", formatContextKeys(ctx)),
-	)
-
-	result, variant, reason, evalErr := resolver(reqID, flagKey, ctx)
-	if evalErr != nil {
-		logger.WarnWithID(reqID, fmt.Sprintf("returning error response, reason: %v", evalErr))
-		reason = model.ErrorReason
-		evalErr = errFormat(evalErr)
-	} else {
-		metrics.Impressions(goCtx, flagKey, variant)
-	}
-
-	if err := resp.SetResult(result, variant, reason); err != nil && evalErr == nil {
-		logger.ErrorWithID(reqID, err.Error())
-		return err
-	}
-
-	return evalErr
-}
-
-func (s *FlagEvaluationService) ResolveBoolean(
-	ctx context.Context,
-	req *connect.Request[schemaV1.ResolveBooleanRequest],
-) (*connect.Response[schemaV1.ResolveBooleanResponse], error) {
-	res := connect.NewResponse(&schemaV1.ResolveBooleanResponse{})
-	err := resolve[bool](
-		ctx,
-		s.logger,
-		s.eval.ResolveBooleanValue,
-		req.Msg.GetFlagKey(),
-		req.Msg.GetContext(),
-		&booleanResponse{res},
-		s.metrics,
-	)
-
-	return res, err
-}
-
-func (s *FlagEvaluationService) ResolveString(
-	ctx context.Context,
-	req *connect.Request[schemaV1.ResolveStringRequest],
-) (*connect.Response[schemaV1.ResolveStringResponse], error) {
-	res := connect.NewResponse(&schemaV1.ResolveStringResponse{})
-	err := resolve[string](
-		ctx,
-		s.logger,
-		s.eval.ResolveStringValue,
-		req.Msg.GetFlagKey(),
-		req.Msg.GetContext(),
-		&stringResponse{res},
-		s.metrics,
-	)
-
-	return res, err
-}
-
-func (s *FlagEvaluationService) ResolveInt(
-	ctx context.Context,
-	req *connect.Request[schemaV1.ResolveIntRequest],
-) (*connect.Response[schemaV1.ResolveIntResponse], error) {
-	res := connect.NewResponse(&schemaV1.ResolveIntResponse{})
-	err := resolve[int64](
-		ctx,
-		s.logger,
-		s.eval.ResolveIntValue,
-		req.Msg.GetFlagKey(),
-		req.Msg.GetContext(),
-		&intResponse{res},
-		s.metrics,
-	)
-
-	return res, err
-}
-
-func (s *FlagEvaluationService) ResolveFloat(
-	ctx context.Context,
-	req *connect.Request[schemaV1.ResolveFloatRequest],
-) (*connect.Response[schemaV1.ResolveFloatResponse], error) {
-	res := connect.NewResponse(&schemaV1.ResolveFloatResponse{})
-	err := resolve[float64](
-		ctx,
-		s.logger,
-		s.eval.ResolveFloatValue,
-		req.Msg.GetFlagKey(),
-		req.Msg.GetContext(),
-		&floatResponse{res},
-		s.metrics,
-	)
-
-	return res, err
-}
-
-func (s *FlagEvaluationService) ResolveObject(
-	ctx context.Context,
-	req *connect.Request[schemaV1.ResolveObjectRequest],
-) (*connect.Response[schemaV1.ResolveObjectResponse], error) {
-	res := connect.NewResponse(&schemaV1.ResolveObjectResponse{})
-	err := resolve[map[string]any](
-		ctx,
-		s.logger,
-		s.eval.ResolveObjectValue,
-		req.Msg.GetFlagKey(),
-		req.Msg.GetContext(),
-		&objectResponse{res},
-		s.metrics,
-	)
-
-	return res, err
-}
-
-func formatContextKeys(context *structpb.Struct) []string {
-	res := []string{}
-	for k := range context.AsMap() {
-		res = append(res, k)
-	}
-	return res
-}
-
-func errFormat(err error) error {
-	switch err.Error() {
-	case model.FlagNotFoundErrorCode:
-		return connect.NewError(connect.CodeNotFound, fmt.Errorf("%s, %s", ErrorPrefix, err.Error()))
-	case model.TypeMismatchErrorCode:
-		return connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("%s, %s", ErrorPrefix, err.Error()))
-	case model.DisabledReason:
-		return connect.NewError(connect.CodeUnavailable, fmt.Errorf("%s, %s", ErrorPrefix, err.Error()))
-	case model.ParseErrorCode:
-		return connect.NewError(connect.CodeDataLoss, fmt.Errorf("%s, %s", ErrorPrefix, err.Error()))
-	}
-
-	return err
-}

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

@@ -1,77 +0,0 @@
-package service
-
-import (
-	"fmt"
-
-	schemaV1 "buf.build/gen/go/open-feature/flagd/protocolbuffers/go/schema/v1"
-	"github.com/bufbuild/connect-go"
-	"google.golang.org/protobuf/types/known/structpb"
-)
-
-type response[T constraints] interface {
-	SetResult(value T, variant, reason string) 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) error {
-	r.Msg.Value = value
-	r.Msg.Variant = variant
-	r.Msg.Reason = reason
-	return nil
-}
-
-type stringResponse struct {
-	*connect.Response[schemaV1.ResolveStringResponse]
-}
-
-func (r *stringResponse) SetResult(value, variant, reason string) error {
-	r.Msg.Value = value
-	r.Msg.Variant = variant
-	r.Msg.Reason = reason
-	return nil
-}
-
-type floatResponse struct {
-	*connect.Response[schemaV1.ResolveFloatResponse]
-}
-
-func (r *floatResponse) SetResult(value float64, variant, reason string) error {
-	r.Msg.Value = value
-	r.Msg.Variant = variant
-	r.Msg.Reason = reason
-	return nil
-}
-
-type intResponse struct {
-	*connect.Response[schemaV1.ResolveIntResponse]
-}
-
-func (r *intResponse) SetResult(value int64, variant, reason string) error {
-	r.Msg.Value = value
-	r.Msg.Variant = variant
-	r.Msg.Reason = reason
-	return nil
-}
-
-type objectResponse struct {
-	*connect.Response[schemaV1.ResolveObjectResponse]
-}
-
-func (r *objectResponse) SetResult(value map[string]any, variant, reason string) 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
-	return nil
-}

core/pkg/service/iservice.go

@@ -2,14 +2,16 @@ package service
 
 import (
 	"context"
+	"time"
 
-	"github.com/open-feature/flagd/core/pkg/eval"
+	"connectrpc.com/connect"
 )
 
 type NotificationType string
 
 const (
 	ConfigurationChange NotificationType = "configuration_change"
+	Shutdown            NotificationType = "provider_shutdown"
 	ProviderReady       NotificationType = "provider_ready"
 	KeepAlive           NotificationType = "keep_alive"
 )
@@ -22,14 +24,18 @@ type Notification struct {
 type ReadinessProbe func() bool
 
 type Configuration struct {
-	ReadinessProbe ReadinessProbe
-	Port           uint16
-	MetricsPort    uint16
-	ServiceName    string
-	CertPath       string
-	KeyPath        string
-	SocketPath     string
-	CORS           []string
+	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
 }
 
 /*
@@ -37,8 +43,9 @@ IFlagEvaluationService implementations define handlers for a particular transpor
 which call the IEvaluator implementation.
 */
 type IFlagEvaluationService interface {
-	Serve(ctx context.Context, eval eval.IEvaluator, svcConf Configuration) error
+	Serve(ctx context.Context, svcConf Configuration) error
 	Notify(n Notification)
+	Shutdown()
 }
 
 /*

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,59 +0,0 @@
-package sync
-
-import (
-	"context"
-
-	syncv1 "buf.build/gen/go/open-feature/flagd/protocolbuffers/go/sync/v1"
-	"github.com/bufbuild/connect-go"
-	"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 {
-	syncStore *syncStore.SyncStore
-	logger    *logger.Logger
-}
-
-func (l *handler) FetchAllFlags(ctx context.Context, req *connect.Request[syncv1.FetchAllFlagsRequest]) (
-	*connect.Response[syncv1.FetchAllFlagsResponse],
-	error,
-) {
-	data, err := l.syncStore.FetchAllFlags(ctx, req, req.Msg.GetSelector())
-	if err != nil {
-		return connect.NewResponse(&syncv1.FetchAllFlagsResponse{}), err
-	}
-
-	return connect.NewResponse(&syncv1.FetchAllFlagsResponse{
-		FlagConfiguration: data.FlagData,
-	}), nil
-}
-
-func (l *handler) SyncFlags(
-	ctx context.Context,
-	req *connect.Request[syncv1.SyncFlagsRequest],
-	stream *connect.ServerStream[syncv1.SyncFlagsResponse],
-) error {
-	errChan := make(chan error)
-	dataSync := make(chan sync.DataSync)
-	l.syncStore.RegisterSubscription(ctx, req.Msg.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 err
-			}
-		case <-ctx.Done():
-			return nil
-		}
-	}
-}
-
-func dataSyncToGrpcState(s sync.DataSync) syncv1.SyncState {
-	return syncv1.SyncState(s.Type + 1)
-}

core/pkg/service/sync/server.go

@@ -1,126 +0,0 @@
-package sync
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net"
-	"net/http"
-	"time"
-
-	rpc "buf.build/gen/go/open-feature/flagd/bufbuild/connect-go/sync/v1/syncv1connect"
-	"github.com/open-feature/flagd/core/pkg/logger"
-	iservice "github.com/open-feature/flagd/core/pkg/service"
-	syncStore "github.com/open-feature/flagd/core/pkg/sync-store"
-	"github.com/prometheus/client_golang/prometheus/promhttp"
-	"golang.org/x/net/http2"
-	"golang.org/x/net/http2/h2c"
-	"golang.org/x/sync/errgroup"
-)
-
-type Server struct {
-	server        *http.Server
-	metricsServer *http.Server
-	Logger        *logger.Logger
-	handler       handler
-	config        iservice.Configuration
-}
-
-func NewServer(ctx context.Context, logger *logger.Logger) *Server {
-	syncStore := syncStore.NewSyncStore(ctx, logger)
-	return &Server{
-		handler: handler{
-			logger:    logger,
-			syncStore: syncStore,
-		},
-		Logger: logger,
-	}
-}
-
-func (s *Server) Serve(ctx context.Context, svcConf iservice.Configuration) error {
-	s.config = svcConf
-
-	g, gCtx := errgroup.WithContext(ctx)
-
-	g.Go(s.startServer)
-	g.Go(s.startMetricsServer)
-	g.Go(func() error {
-		<-gCtx.Done()
-		if s.server != nil {
-			if err := s.server.Shutdown(gCtx); err != nil {
-				return err
-			}
-		}
-		return nil
-	})
-	g.Go(func() error {
-		<-gCtx.Done()
-		if s.metricsServer != nil {
-			if err := s.metricsServer.Shutdown(gCtx); err != nil {
-				return err
-			}
-		}
-		return nil
-	})
-	g.Go(s.captureMetrics)
-
-	err := g.Wait()
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func (s *Server) startServer() error {
-	var lis net.Listener
-	var err error
-	mux := http.NewServeMux()
-	address := fmt.Sprintf(":%d", s.config.Port)
-	lis, err = net.Listen("tcp", address)
-	if err != nil {
-		return err
-	}
-	path, handler := rpc.NewFlagSyncServiceHandler(&s.handler)
-	mux.Handle(path, handler)
-
-	s.server = &http.Server{
-		ReadHeaderTimeout: time.Second,
-		Handler:           h2c.NewHandler(mux, &http2.Server{}),
-	}
-
-	if err := s.server.Serve(
-		lis,
-	); err != nil && !errors.Is(err, http.ErrServerClosed) {
-		return err
-	}
-
-	return nil
-}
-
-func (s *Server) startMetricsServer() error {
-	s.Logger.Info(fmt.Sprintf("binding metrics to %d", s.config.MetricsPort))
-	s.metricsServer = &http.Server{
-		ReadHeaderTimeout: 3 * time.Second,
-		Addr:              fmt.Sprintf(":%d", s.config.MetricsPort),
-	}
-	s.metricsServer.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/healthz":
-			w.WriteHeader(http.StatusOK)
-		case "/readyz":
-			if s.config.ReadinessProbe() {
-				w.WriteHeader(http.StatusOK)
-			} else {
-				w.WriteHeader(http.StatusPreconditionFailed)
-			}
-		case "/metrics":
-			promhttp.Handler().ServeHTTP(w, r)
-		default:
-			w.WriteHeader(http.StatusNotFound)
-		}
-	})
-	if err := s.metricsServer.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
-		return err
-	}
-	return nil
-}

core/pkg/store/flags.go

@@ -1,268 +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              `json:"flagSources"`
-}
-
-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{}}
-}
-
-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) 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 "", 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,552 +0,0 @@
-package store
-
-import (
-	"testing"
-
-	"github.com/open-feature/flagd/core/pkg/model"
-
-	"github.com/open-feature/flagd/core/pkg/logger"
-	"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/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,22 +1,22 @@
-package runtime
+package builder
 
 import (
 	"reflect"
 	"testing"
 
-	"github.com/open-feature/flagd/core/pkg/logger"
+	"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,
@@ -28,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,
@@ -49,18 +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":"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,
@@ -75,6 +94,21 @@ 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,
+					Interval: 77,
+				},
 				{
 					URI:      "default/my-flag-config",
 					Provider: syncProviderKubernetes,
@@ -93,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{},
 		},
 	}
 
@@ -126,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",
@@ -147,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",
@@ -172,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{},
 		},
 	}
 
@@ -202,99 +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)
-			}
-		})
-	}
-}

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,48 +2,79 @@ package file
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
 	"fmt"
+	"io"
 	"os"
-	"strings"
+	"path/filepath"
 	msync "sync"
 
-	"gopkg.in/yaml.v3"
-
 	"github.com/fsnotify/fsnotify"
 	"github.com/open-feature/flagd/core/pkg/logger"
 	"github.com/open-feature/flagd/core/pkg/sync"
+	"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 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
-	err = fs.watcher.Add(fs.URI)
-	if err != nil {
-		return err
+
+	if err := fs.watcher.Add(fs.URI); err != nil {
+		return fmt.Errorf("error adding watcher %s: %w", fs.URI, err)
 	}
 	return nil
 }
@@ -63,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")
@@ -77,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.
@@ -85,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")
@@ -116,61 +147,43 @@ 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()))
+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
-	if syncType != sync.DELETE {
-		m, err := fs.fetch(ctx)
-		if err != nil {
-			fs.Logger.Error(fmt.Sprintf("Error fetching %s: %s", fs.URI, err.Error()))
-		}
-		if m == "" {
-			fs.Logger.Warn(fmt.Sprintf("file %s is empty", fs.URI))
-		} else {
-			msg = m
-		}
+	m, err := fs.fetch(ctx)
+	if err != nil {
+		fs.Logger.Error(fmt.Sprintf("Error fetching %s: %s", fs.URI, err.Error()))
+	}
+	if m == "" {
+		fs.Logger.Warn(fmt.Sprintf("file %s is empty", fs.URI))
+	} else {
+		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]
-	}
-	rawFile, err := os.ReadFile(fs.URI)
+
+	file, err := os.Open(fs.URI)
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("error opening file %s: %w", fs.URI, err)
 	}
+	defer file.Close()
 
-	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)
+	data, err := io.ReadAll(file)
 	if err != nil {
-		return "", fmt.Errorf("convert yaml to json: %w", err)
+		return "", fmt.Errorf("error reading file %s: %w", fs.URI, err)
 	}
 
-	return string(r), err
+	// 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("error converting file content to json: %w", err)
+	}
+	return json, nil
 }

core/pkg/sync/file/filepath_sync_test.go

@@ -5,132 +5,118 @@ import (
 	"fmt"
 	"log"
 	"os"
+	"path/filepath"
 	"reflect"
 	msync "sync"
 	"testing"
 	"time"
 
-	"github.com/open-feature/flagd/core/pkg/sync"
-
 	"github.com/open-feature/flagd/core/pkg/logger"
+	"github.com/open-feature/flagd/core/pkg/sync"
 )
 
 const (
-	fetchDirName      = "test"
 	fetchFileName     = "to_fetch.json"
 	fetchFileContents = "fetch me"
 )
 
 func TestSimpleReSync(t *testing.T) {
-	tests := map[string]struct {
-		fileContents     string
-		expectedDataSync sync.DataSync
-	}{
-		"simple-read": {
-			fileContents: "hello",
-			expectedDataSync: sync.DataSync{
-				FlagData: "hello",
-				Source:   fmt.Sprintf("%s/%s", fetchDirName, fetchFileName),
-				Type:     sync.ALL,
-			},
-		},
+	fetchDirName := t.TempDir()
+	source := filepath.Join(fetchDirName, fetchFileName)
+	expectedDataSync := sync.DataSync{
+		FlagData: "hello",
+		Source:   source,
 	}
-
 	handler := Sync{
-		URI:    fmt.Sprintf("%s/%s", fetchDirName, fetchFileName),
+		URI:    source,
 		Logger: logger.NewLogger(nil, false),
 	}
 
-	for test, tt := range tests {
-		t.Run(test, func(t *testing.T) {
-			defer t.Cleanup(cleanupFilePath)
-			setupDir(t)
-			createFile(t)
-			writeToFile(t, tt.fileContents)
+	createFile(t, fetchDirName)
+	writeToFile(t, fetchDirName, "hello")
+	ctx := context.Background()
+	dataSyncChan := make(chan sync.DataSync, 1)
 
-			ctx := context.Background()
-			dataSyncChan := make(chan sync.DataSync, 1)
+	go func() {
+		err := handler.ReSync(ctx, dataSyncChan)
+		if err != nil {
+			log.Fatalf("Error start sync: %s", err.Error())
+			return
+		}
+	}()
 
-			go func() {
-				err := handler.ReSync(ctx, dataSyncChan)
-				if err != nil {
-					log.Fatalf("Error start sync: %s", err.Error())
-					return
-				}
-			}()
-
-			select {
-			case s := <-dataSyncChan:
-				if !reflect.DeepEqual(tt.expectedDataSync, s) {
-					t.Errorf("resync failed, incorrect datasync value, got %v want %v", s, tt.expectedDataSync)
-				}
-			case <-time.After(5 * time.Second):
-				t.Error("timed out waiting for datasync")
-			}
-		})
+	select {
+	case s := <-dataSyncChan:
+		if !reflect.DeepEqual(expectedDataSync, s) {
+			t.Errorf("resync failed, incorrect datasync value, got %v want %v", s, expectedDataSync)
+		}
+	case <-time.After(5 * time.Second):
+		t.Error("timed out waiting for datasync")
 	}
 }
 
 func TestSimpleSync(t *testing.T) {
+	readDirName := t.TempDir()
+	updateDirName := t.TempDir()
+	deleteDirName := t.TempDir()
 	tests := map[string]struct {
 		manipulationFuncs []func(t *testing.T)
 		expectedDataSync  []sync.DataSync
+		fetchDirName      string
 	}{
 		"simple-read": {
+			fetchDirName: readDirName,
 			manipulationFuncs: []func(t *testing.T){
 				func(t *testing.T) {
-					writeToFile(t, fetchFileContents)
+					writeToFile(t, readDirName, fetchFileContents)
 				},
 			},
 			expectedDataSync: []sync.DataSync{
 				{
 					FlagData: fetchFileContents,
-					Source:   fmt.Sprintf("%s/%s", fetchDirName, fetchFileName),
-					Type:     sync.ALL,
+					Source:   fmt.Sprintf("%s/%s", readDirName, fetchFileName),
 				},
 			},
 		},
 		"update-event": {
+			fetchDirName: updateDirName,
 			manipulationFuncs: []func(t *testing.T){
 				func(t *testing.T) {
-					writeToFile(t, fetchFileContents)
+					writeToFile(t, updateDirName, fetchFileContents)
 				},
 				func(t *testing.T) {
-					writeToFile(t, "new content")
+					writeToFile(t, updateDirName, "new content")
 				},
 			},
 			expectedDataSync: []sync.DataSync{
 				{
 					FlagData: fetchFileContents,
-					Source:   fmt.Sprintf("%s/%s", fetchDirName, fetchFileName),
-					Type:     sync.ALL,
+					Source:   fmt.Sprintf("%s/%s", updateDirName, fetchFileName),
 				},
 				{
 					FlagData: "new content",
-					Source:   fmt.Sprintf("%s/%s", fetchDirName, fetchFileName),
-					Type:     sync.ALL,
+					Source:   fmt.Sprintf("%s/%s", updateDirName, fetchFileName),
 				},
 			},
 		},
 		"delete-event": {
+			fetchDirName: deleteDirName,
 			manipulationFuncs: []func(t *testing.T){
 				func(t *testing.T) {
-					writeToFile(t, fetchFileContents)
+					writeToFile(t, deleteDirName, fetchFileContents)
 				},
 				func(t *testing.T) {
-					deleteFile(t, fetchDirName, fetchFileName)
+					deleteFile(t, deleteDirName, fetchFileName)
 				},
 			},
 			expectedDataSync: []sync.DataSync{
 				{
 					FlagData: fetchFileContents,
-					Source:   fmt.Sprintf("%s/%s", fetchDirName, fetchFileName),
-					Type:     sync.ALL,
+					Source:   fmt.Sprintf("%s/%s", deleteDirName, fetchFileName),
 				},
 				{
 					FlagData: defaultState,
-					Source:   fmt.Sprintf("%s/%s", fetchDirName, fetchFileName),
-					Type:     sync.DELETE,
+					Source:   fmt.Sprintf("%s/%s", deleteDirName, fetchFileName),
 				},
 			},
 		},
@@ -138,16 +124,14 @@ func TestSimpleSync(t *testing.T) {
 
 	for test, tt := range tests {
 		t.Run(test, func(t *testing.T) {
-			defer t.Cleanup(cleanupFilePath)
-			setupDir(t)
-			createFile(t)
+			createFile(t, tt.fetchDirName)
 
 			ctx := context.Background()
 
 			dataSyncChan := make(chan sync.DataSync, len(tt.expectedDataSync))
 
 			syncHandler := Sync{
-				URI:    fmt.Sprintf("%s/%s", fetchDirName, fetchFileName),
+				URI:    fmt.Sprintf("%s/%s", tt.fetchDirName, fetchFileName),
 				Logger: logger.NewLogger(nil, false),
 				Mux:    &msync.RWMutex{},
 			}
@@ -182,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")
 				}
@@ -199,13 +180,17 @@ func TestSimpleSync(t *testing.T) {
 }
 
 func TestFilePathSync_Fetch(t *testing.T) {
+	successDirName := t.TempDir()
+	failureDirName := t.TempDir()
 	tests := map[string]struct {
 		fpSync         Sync
 		handleResponse func(t *testing.T, fetched string, err error)
+		fetchDirName   string
 	}{
 		"success": {
+			fetchDirName: successDirName,
 			fpSync: Sync{
-				URI:    fmt.Sprintf("%s/%s", fetchDirName, fetchFileName),
+				URI:    fmt.Sprintf("%s/%s", successDirName, fetchFileName),
 				Logger: logger.NewLogger(nil, false),
 			},
 			handleResponse: func(t *testing.T, fetched string, err error) {
@@ -219,8 +204,9 @@ func TestFilePathSync_Fetch(t *testing.T) {
 			},
 		},
 		"not found": {
+			fetchDirName: failureDirName,
 			fpSync: Sync{
-				URI:    fmt.Sprintf("%s/%s", fetchDirName, "not_found"),
+				URI:    fmt.Sprintf("%s/%s", failureDirName, "not_found"),
 				Logger: logger.NewLogger(nil, false),
 			},
 			handleResponse: func(t *testing.T, fetched string, err error) {
@@ -233,10 +219,8 @@ func TestFilePathSync_Fetch(t *testing.T) {
 
 	for name, tt := range tests {
 		t.Run(name, func(t *testing.T) {
-			setupDir(t)
-			createFile(t)
-			writeToFile(t, fetchFileContents)
-			defer t.Cleanup(cleanupFilePath)
+			createFile(t, tt.fetchDirName)
+			writeToFile(t, tt.fetchDirName, fetchFileContents)
 
 			data, err := tt.fpSync.fetch(context.Background())
 
@@ -246,16 +230,15 @@ func TestFilePathSync_Fetch(t *testing.T) {
 }
 
 func TestIsReadySyncFlag(t *testing.T) {
+	fetchDirName := t.TempDir()
 	fpSync := Sync{
 		URI:    fmt.Sprintf("%s/%s", fetchDirName, fetchFileName),
 		Logger: logger.NewLogger(nil, false),
 		Mux:    &msync.RWMutex{},
 	}
 
-	setupDir(t)
-	createFile(t)
-	writeToFile(t, fetchFileContents)
-	defer t.Cleanup(cleanupFilePath)
+	createFile(t, fetchDirName)
+	writeToFile(t, fetchDirName, fetchFileContents)
 	if fpSync.IsReady() != false {
 		t.Errorf("expected not to be ready")
 	}
@@ -283,31 +266,25 @@ func TestIsReadySyncFlag(t *testing.T) {
 	}
 }
 
-func cleanupFilePath() {
-	if err := os.RemoveAll(fetchDirName); err != nil {
-		log.Fatalf("rmdir: %v", err)
-	}
-}
-
 func deleteFile(t *testing.T, dirName string, fileName string) {
 	if err := os.Remove(fmt.Sprintf("%s/%s", dirName, fileName)); err != nil {
 		t.Fatal(err)
 	}
 }
 
-func setupDir(t *testing.T) {
-	if err := os.Mkdir(fetchDirName, os.ModePerm); err != nil {
+func createFile(t *testing.T, fetchDirName string) {
+	f, err := os.Create(fmt.Sprintf("%s/%s", fetchDirName, fetchFileName))
+	defer func(file *os.File) {
+		if err := file.Close(); err != nil {
+			log.Fatalf("close file: %v", err)
+		}
+	}(f)
+	if err != nil {
 		t.Fatal(err)
 	}
 }
 
-func createFile(t *testing.T) {
-	if _, err := os.Create(fmt.Sprintf("%s/%s", fetchDirName, fetchFileName)); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func writeToFile(t *testing.T, fileContents string) {
+func writeToFile(t *testing.T, fetchDirName, fileContents string) {
 	file, err := os.OpenFile(fmt.Sprintf("%s/%s", fetchDirName, fetchFileName), os.O_RDWR, 0o644)
 	if err != nil {
 		t.Fatal(err)

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/builder.go

@@ -38,7 +38,7 @@ func (cb *CredentialBuilder) Build(secure bool, certPath string) (credentials.Tr
 	// Rely on provided certificate
 	certBytes, err := os.ReadFile(certPath)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("unable to read file %s: %w", certPath, err)
 	}
 
 	cp := x509.NewCertPool()

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,21 +7,22 @@ import (
 	msync "sync"
 	"time"
 
-	grpccredential "github.com/open-feature/flagd/core/pkg/sync/grpc/credentials"
-
-	"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
@@ -43,29 +44,49 @@ 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 {
-		g.Logger.Error(fmt.Sprintf("error building transport credentials: %s", 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 {
-		g.Logger.Error(fmt.Sprintf("error initiating grpc client connection: %s", err.Error()))
+		err := fmt.Errorf("error initiating grpc client connection: %w", err)
+		g.Logger.Error(err.Error())
 		return err
 	}
 
@@ -76,15 +97,15 @@ 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 {
-		g.Logger.Error(fmt.Sprintf("fetching all flags: %s", err.Error()))
+		err = fmt.Errorf("error fetching all flags: %w", err)
+		g.Logger.Error(err.Error())
 		return err
 	}
 	dataSync <- sync.DataSync{
 		FlagData: res.GetFlagConfiguration(),
 		Source:   g.URI,
-		Type:     sync.ALL,
 	}
 	return nil
 }
@@ -97,14 +118,14 @@ func (g *Sync) Sync(ctx context.Context, dataSync chan<- sync.DataSync) error {
 	// Initialize SyncFlags client. This fails if server connection establishment fails (ex:- grpc server offline)
 	syncClient, err := g.client.SyncFlags(ctx, &v1.SyncFlagsRequest{ProviderId: g.ProviderID, Selector: g.Selector})
 	if err != nil {
-		return err
+		return fmt.Errorf("unable to sync flags: %w", err)
 	}
 
 	// Initial stream listening. Error will be logged and continue and retry connection establishment
 	err = g.handleFlagSync(syncClient, dataSync)
 	if err == nil {
 		// This should not happen as handleFlagSync expects to return with an error
-		return err
+		return nil
 	}
 
 	g.Logger.Warn(fmt.Sprintf("error with stream listener: %s", err.Error()))
@@ -137,15 +158,15 @@ func (g *Sync) connectWithRetry(
 	for {
 		var sleep time.Duration
 		if iteration >= backOffLimit {
-			sleep = constantBackOffDelay
+			sleep = constantBackOffDelay * time.Second
 		} else {
 			iteration++
-			sleep = time.Duration(math.Pow(backOffBase, float64(iteration)))
+			sleep = time.Duration(math.Pow(backOffBase, float64(iteration))) * time.Second
 		}
 
 		// Block the next connection attempt and check the context
 		select {
-		case <-time.After(sleep * time.Second):
+		case <-time.After(sleep):
 			break
 		case <-ctx.Done():
 			// context done means we shall exit
@@ -167,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
 	})
@@ -175,46 +195,16 @@ func (g *Sync) handleFlagSync(stream syncv1grpc.FlagSyncService_SyncFlagsClient,
 	for {
 		data, err := stream.Recv()
 		if err != nil {
-			return err
+			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")
-		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

@@ -1,3 +1,4 @@
+//nolint:wrapcheck
 package grpc
 
 import (
@@ -10,22 +11,22 @@ import (
 	"testing"
 	"time"
 
-	"github.com/golang/mock/gomock"
-	credendialsmock "github.com/open-feature/flagd/core/pkg/sync/grpc/credentials/mock"
-	"github.com/stretchr/testify/require"
-	"google.golang.org/grpc/credentials"
-
-	"golang.org/x/sync/errgroup"
-
-	"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"
-	grpcmock "github.com/open-feature/flagd/core/pkg/sync/grpc/mock"
+	credendialsmock "github.com/open-feature/flagd/core/pkg/sync/grpc/credentials/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) {
@@ -80,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"
 
@@ -98,7 +123,6 @@ func Test_ReSyncTests(t *testing.T) {
 			notifications: []sync.DataSync{
 				{
 					FlagData: "success",
-					Type:     sync.ALL,
 				},
 			},
 			shouldError: false,
@@ -155,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)
@@ -171,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
@@ -334,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,
 				},
 			},
 		},
@@ -349,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,
 				},
 			},
 		},
@@ -462,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
@@ -552,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,
 		},
 	}}
 
@@ -608,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())
 		}
 	}
@@ -628,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())
 		}
 	}
 }
@@ -650,7 +475,6 @@ func serve(bServer *bufferedServer) {
 
 type serverPayload struct {
 	flags string
-	state v1.SyncState
 }
 
 // bufferedServer - a mock grpc service backed by buffered connection
@@ -663,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())
@@ -679,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
-
-	ready bool
+	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
 	}
@@ -65,44 +72,33 @@ func (hs *Sync) Sync(ctx context.Context, dataSync chan<- sync.DataSync) error {
 	// Set ready state
 	hs.ready = true
 
-	_ = hs.Cron.AddFunc("*/5 * * * *", func() {
-		body, err := hs.fetchBodyFromURL(ctx, hs.URI)
+	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))
+		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()
@@ -110,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, 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, 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, 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 {
@@ -149,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,33 +5,36 @@ import (
 	"io"
 	"log"
 	"net/http"
-	"reflect"
 	"strings"
 	"testing"
 	"time"
 
-	"github.com/open-feature/flagd/core/pkg/sync"
-
-	"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: "",
@@ -51,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)
 	}
 }
 
@@ -63,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",
@@ -84,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",
@@ -112,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 {
@@ -133,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 {
@@ -145,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())
@@ -155,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)
@@ -168,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)
@@ -186,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")
 				}
@@ -230,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

@@ -2,32 +2,33 @@ package kubernetes
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
-	"os"
 	"strings"
 	msync "sync"
 	"time"
 
 	"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/v1alpha1"
+	"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 (
-	resyncPeriod                     = 1 * time.Minute
-	apiVersion                       = fmt.Sprintf("%s/%s", v1alpha1.GroupVersion.Group, v1alpha1.GroupVersion.Version)
-	featureFlagConfigurationResource = v1alpha1.GroupVersion.WithResource("featureflagconfigurations")
+	resyncPeriod        = 1 * time.Minute
+	apiVersion          = fmt.Sprintf("%s/%s", v1beta1.GroupVersion.Group, v1beta1.GroupVersion.Version)
+	featureFlagResource = v1beta1.GroupVersion.WithResource("featureflags")
 )
 
+type SyncOption func(s *Sync)
+
 type Sync struct {
 	URI string
 
@@ -35,7 +36,6 @@ type Sync struct {
 	namespace     string
 	crdName       string
 	logger        *logger.Logger
-	readClient    client.Reader
 	dynamicClient dynamic.Interface
 	informer      cache.SharedInformer
 }
@@ -43,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, err
-	}
-
-	dynamicClient, err := dynamic.NewForConfig(clusterConfig)
-	if err != nil {
-		return nil, nil, 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 err
+		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
 }
 
@@ -86,18 +66,18 @@ func (k *Sync) Init(_ context.Context) error {
 
 	k.namespace, k.crdName, err = parseURI(k.URI)
 	if err != nil {
-		return err
+		return fmt.Errorf("unable to parse uri %s: %w", k.URI, err)
 	}
 
-	if err := v1alpha1.AddToScheme(scheme.Scheme); err != nil {
-		return err
+	if err := v1beta1.AddToScheme(scheme.Scheme); err != nil {
+		return fmt.Errorf("unable to v1beta1 types to scheme: %w", err)
 	}
 
 	// The created informer will not do resyncs if the given defaultEventHandlerResyncPeriod is zero.
 	// For more details on resync implications refer to tools/cache/shared_informer.go
 	factory := dynamicinformer.NewFilteredDynamicSharedInformerFactory(k.dynamicClient, resyncPeriod, k.namespace, nil)
 
-	k.informer = factory.ForResource(featureFlagConfigurationResource).Informer()
+	k.informer = factory.ForResource(featureFlagResource).Informer()
 
 	return nil
 }
@@ -112,11 +92,12 @@ func (k *Sync) Sync(ctx context.Context, dataSync chan<- sync.DataSync) error {
 	// Initial fetch
 	fetch, err := k.fetch(ctx)
 	if err != nil {
-		k.logger.Error(fmt.Sprintf("error with the initial fetch: %s", err.Error()))
+		err = fmt.Errorf("error with the initial fetch: %w", err)
+		k.logger.Error(err.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)
 
@@ -155,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)
@@ -164,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:
@@ -180,7 +161,7 @@ func (k *Sync) fetch(ctx context.Context) (string, error) {
 	// first check the store - avoid overloading API
 	item, exist, err := k.informer.GetStore().GetByKey(k.URI)
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("unable to get %s from store: %w", k.URI, err)
 	}
 
 	if exist {
@@ -190,28 +171,34 @@ func (k *Sync) fetch(ctx context.Context) (string, error) {
 		}
 
 		k.logger.Debug(fmt.Sprintf("resource %s served from the informer cache", k.URI))
-		return configuration.Spec.FeatureFlagSpec, nil
+		return marshallFeatureFlagSpec(configuration)
 	}
 
 	// fallback to API access - this is an informer cache miss. Could happen at the startup where cache is not filled
-	var ff v1alpha1.FeatureFlagConfiguration
-	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 "", err
+		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 ff.Spec.FeatureFlagSpec, nil
+
+	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))
@@ -245,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
@@ -267,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
@@ -298,16 +285,16 @@ func updateFuncHandler(oldObj interface{}, newObj interface{}, object client.Obj
 }
 
 // toFFCfg attempts to covert unstructured payload to configurations
-func toFFCfg(object interface{}) (*v1alpha1.FeatureFlagConfiguration, error) {
+func toFFCfg(object interface{}) (*v1beta1.FeatureFlag, error) {
 	u, ok := object.(*unstructured.Unstructured)
 	if !ok {
 		return nil, fmt.Errorf("provided value is not of type *unstructured.Unstructured")
 	}
 
-	var ffObj v1alpha1.FeatureFlagConfiguration
+	var ffObj v1beta1.FeatureFlag
 	err := runtime.DefaultUnstructuredConverter.FromUnstructured(u.Object, &ffObj)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("unable to convert unstructured to v1beta1.FeatureFlag: %w", err)
 	}
 
 	return &ffObj, nil
@@ -323,22 +310,10 @@ 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)
-	} else {
-		clusterConfig, err = rest.InClusterConfig()
-	}
-
+func marshallFeatureFlagSpec(ff *v1beta1.FeatureFlag) (string, error) {
+	b, err := json.Marshal(ff.Spec.FlagSpec)
 	if err != nil {
-		return nil, err
+		return "", fmt.Errorf("failed to marshall FlagSpec: %s", err.Error())
 	}
-
-	return clusterConfig, nil
+	return string(b), nil
 }