chore: release v2.86.0

* style: `New dataset` button as `secondary`

* fix: missing UI-only access check on archive item

* style button consistently

.codespellrc

@@ -1,4 +1,4 @@
 [codespell]
 skip = .git,*.pdf,*.svg,package-lock.json,*.prisma,pnpm-lock.yaml
-ignore-words-list = afterall,vertx
+ignore-words-list = afterall,vertx,notIn
 

.env.dev.example

@@ -34,11 +34,25 @@ EMAIL_FROM_ADDRESS=""  # Defines the email address to use as the from address.
 SMTP_CONNECTION_URL=""  # Defines the connection url for smtp server.
 
 # S3 storage
-S3_ENDPOINT=
-S3_ACCESS_KEY_ID=
-S3_SECRET_ACCESS_KEY=
-S3_BUCKET_NAME=
-S3_REGION=
+S3_ENDPOINT=http://localhost:9090
+S3_ACCESS_KEY_ID=minio
+S3_SECRET_ACCESS_KEY=miniosecret
+S3_BUCKET_NAME=mybucket
+S3_REGION=us-east-1
+## Necessary for minio compatibility
+S3_FORCE_PATH_STYLE=true
+
+# S3 Event Bucket Upload
+## Set to true to test uploading all events to S3
+LANGFUSE_S3_EVENT_UPLOAD_ENABLED=false
+LANGFUSE_S3_EVENT_UPLOAD_BUCKET=mybucket
+LANGFUSE_S3_EVENT_UPLOAD_ACCESS_KEY_ID=minio
+LANGFUSE_S3_EVENT_UPLOAD_SECRET_ACCESS_KEY=miniosecret
+LANGFUSE_S3_EVENT_UPLOAD_REGION=us-east-1
+LANGFUSE_S3_EVENT_UPLOAD_ENDPOINT=http://localhost:9090
+## Necessary for minio compatibility
+LANGFUSE_S3_EVENT_UPLOAD_FORCE_PATH_STYLE=true
+LANGFUSE_S3_EVENT_UPLOAD_PREFIX=events/
 
 # Set during docker build of application
 # Used to disable environment verification at build time
@@ -48,6 +62,8 @@ REDIS_HOST="127.0.0.1"
 REDIS_PORT=6379
 REDIS_AUTH="myredissecret"
 
-LANGFUSE_WORKER_PASSWORD=mybasicauthsecret
 # openssl rand -hex 32 used only here
 ENCRYPTION_KEY=0000000000000000000000000000000000000000000000000000000000000000 
+
+# speeds up local development by not executing init scripts on server startup
+NEXT_PUBLIC_LANGFUSE_RUN_NEXT_INIT="false"

.env.local.example

@@ -18,7 +18,5 @@ REDIS_HOST="127.0.0.1"
 REDIS_PORT=6379
 REDIS_AUTH="myredissecret"
 
-LANGFUSE_WORKER_PASSWORD=myworkerpassword
-
 # openssl rand -hex 32 used only here
 ENCRYPTION_KEY=0000000000000000000000000000000000000000000000000000000000000000

.env.prod.example

@@ -28,17 +28,28 @@ ENCRYPTION_KEY="0000000000000000000000000000000000000000000000000000000000000000
 # Use CSP headers to enforce HTTPS, optional
 # LANGFUSE_CSP_ENFORCE_HTTPS="true"
 
+# Configure base path for self-hosting, optional
+# Note: You need to build the docker image with the base path set and cannot use the pre-built docker image if you set this.
+# NEXT_PUBLIC_BASE_PATH="/app"
 
 # Docker only, optional
 # PORT=3000
 # HOSTNAME=localhost
 
+# Opentelemetry, optional
+OTEL_EXPORTER_OTLP_ENDPOINT="http://localhost:4318"
+OTEL_SERVICE_NAME="langfuse"
+
 # Default role for users who sign up, optional, can be org or org+project
 # LANGFUSE_DEFAULT_ORG_ID=
 # LANGFUSE_DEFAULT_ORG_ROLE=
 # LANGFUSE_DEFAULT_PROJECT_ID=
 # LANGFUSE_DEFAULT_PROJECT_ROLE=
 
+# Logging, optional
+# LANGFUSE_LOG_LEVEL=info
+# LANGFUSE_LOG_FORMAT=text
+
 # Enable experimental features, optional
 # LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES=true
 
@@ -56,6 +67,10 @@ ENCRYPTION_KEY="0000000000000000000000000000000000000000000000000000000000000000
 # AUTH_GITHUB_CLIENT_ID=
 # AUTH_GITHUB_CLIENT_SECRET=
 # AUTH_GITHUB_ALLOW_ACCOUNT_LINKING=false
+# AUTH_GITLAB_CLIENT_ID=
+# AUTH_GITLAB_CLIENT_SECRET=
+# AUTH_GITLAB_ALLOW_ACCOUNT_LINKING=false
+# AUTH_GITLAB_ISSUER=
 # AUTH_AZURE_AD_CLIENT_ID=
 # AUTH_AZURE_AD_CLIENT_SECRET=
 # AUTH_AZURE_AD_TENANT_ID=
@@ -93,10 +108,33 @@ ENCRYPTION_KEY="0000000000000000000000000000000000000000000000000000000000000000
 # S3_REGION=
 # BATCH_EXPORT_DOWNLOAD_LINK_EXPIRATION_HOURS=
 
+# S3 storage for events, optional, used to persist all incoming events
+# LANGFUSE_S3_EVENT_UPLOAD_ENABLED="true"
+# LANGFUSE_S3_EVENT_UPLOAD_BUCKET=
+# Optional prefix to be used within the bucket. Must end with `/` if set
+# LANGFUSE_S3_EVENT_UPLOAD_PREFIX=events/
+# The following four options are optional and fallback to the normal SDK credential provider chain if omitted
+# See https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
+# LANGFUSE_S3_EVENT_UPLOAD_ENDPOINT=
+# LANGFUSE_S3_EVENT_UPLOAD_REGION=
+# LANGFUSE_S3_EVENT_UPLOAD_ACCESS_KEY_ID=
+# LANGFUSE_S3_EVENT_UPLOAD_SECRET_ACCESS_KEY=
+
 # Exports are streamed to S3 in pages to avoid memory issues
 # The page size can be adjusted if needed to optimize performance
 # DB_EXPORT_PAGE_SIZE=1000
 
+# Automated provisioning of default resources
+# LANGFUSE_INIT_ORG_ID=org-id
+# LANGFUSE_INIT_ORG_NAME=org-name
+# LANGFUSE_INIT_PROJECT_ID=project-id
+# LANGFUSE_INIT_PROJECT_NAME=project-name
+# LANGFUSE_INIT_PROJECT_PUBLIC_KEY=pk-1234567890
+# LANGFUSE_INIT_PROJECT_SECRET_KEY=sk-1234567890
+# LANGFUSE_INIT_USER_EMAIL=user@example.com
+# LANGFUSE_INIT_USER_NAME=User Name
+# LANGFUSE_INIT_USER_PASSWORD=password
+
 
 
 ### START Enterprise Edition Configuration
@@ -109,6 +147,12 @@ ENCRYPTION_KEY="0000000000000000000000000000000000000000000000000000000000000000
 # LANGFUSE_UI_DOCUMENTATION_HREF=https://docs.example.com
 # LANGFUSE_UI_SUPPORT_HREF=https://support.example.com
 # LANGFUSE_UI_FEEDBACK_HREF=https://feedback.example.com
+# LANGFUSE_UI_LOGO_LIGHT_MODE_HREF=https://static.langfuse.com/langfuse-dev/example-logo-light-mode.png
+# LANGFUSE_UI_LOGO_DARK_MODE_HREF=https://static.langfuse.com/langfuse-dev/example-logo-dark-mode.png
+# LANGFUSE_UI_DEFAULT_MODEL_ADAPTER=Anthropic # OpenAI, Anthropic, Azure
+# LANGFUSE_UI_DEFAULT_BASE_URL_OPENAI=https://api.openai.com/v1
+# LANGFUSE_UI_DEFAULT_BASE_URL_ANTHROPIC=https://api.anthropic.com
+# LANGFUSE_UI_DEFAULT_BASE_URL_AZURE_OPENAI=https://{instanceName}.openai.azure.com/openai/deployments
 
 ### END Enterprise Edition Configuration
 
@@ -145,7 +189,6 @@ ENCRYPTION_KEY="0000000000000000000000000000000000000000000000000000000000000000
 # NEXT_SENTRY_PROJECT=
 # SENTRY_AUTH_TOKEN=
 # SENTRY_CSP_REPORT_URI=
-# LANGFUSE_WORKER_BETTERSTACK_TOKEN=
 
 
 # Cloudflare Turnstile
@@ -194,14 +237,10 @@ ENCRYPTION_KEY="0000000000000000000000000000000000000000000000000000000000000000
 # CLICKHOUSE_PASSWORD=
 
 # Ingestion
-# LANGFUSE_INGESTION_BUFFER_TTL_SECONDS=
-# LANGFUSE_INGESTION_FLUSH_DELAY_MS= 
-# LANGFUSE_INGESTION_FLUSH_ATTEMPTS= 
-# LANGFUSE_INGESTION_FLUSH_PROCESSING_CONCURRENCY=
-# LANGFUSE_INGESTION_CLICKHOUSE_WRITE_BATCH_SIZE= 
+# LANGFUSE_INGESTION_QUEUE_DELAY_SECONDS=
+# LANGFUSE_INGESTION_CLICKHOUSE_WRITE_BATCH_SIZE=
 # LANGFUSE_INGESTION_CLICKHOUSE_WRITE_INTERVAL_MS= 
 # LANGFUSE_INGESTION_CLICKHOUSE_MAX_ATTEMPTS=
-# LANGFUSE_LOG_LEVEL= 
 # LANGFUSE_LEGACY_INGESTION_WORKER_CONCURRENCY=
 # LANGFUSE_ASYNC_INGESTION_PROCESSING="true"
 # QUEUE_CONSUMER_LEGACY_INGESTION_QUEUE_IS_ENABLED="true"

.github/dependabot.yml

@@ -32,6 +32,10 @@ updates:
         patterns:
           - "lodash"
           - "@types/lodash"
+      express:
+        patterns:
+          - "express"
+          - "@types/express"
       observability:
         patterns:
           - "dd-trace"

.github/workflows/_deploy_ecs_service.yml

@@ -0,0 +1,75 @@
+name: WorkflowCall - Deploy to ECS Service
+on:
+  workflow_call:
+    inputs:
+      environment:
+        type: string
+        description: Deployment environment
+        required: true
+      service:
+        type: string
+        description: Name of the service to be deployed, e.g. web-ingestion, web, or worker.
+        required: true
+jobs:
+  ecs-deploy:
+    runs-on: ubuntu-latest
+    environment: ${{ inputs.environment }}
+    steps:
+      - name: Get app name
+        uses: winterjung/split@v2
+        id: split
+        with:
+          msg: ${{ inputs.service }}
+          separator: "-"
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Authenticate with AWS
+        # GitHub/AWS recommend to use OIDC here: https://github.com/aws-actions/configure-aws-credentials?tab=readme-ov-file#oidc
+        # Probably more painful to configure, but would remove all long-lived credentials.
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ vars.AWS_REGION }}
+      - name: Login to AWS ECR
+        id: login-ecr
+        uses: aws-actions/amazon-ecr-login@v2
+      - name: Build, tag, and push Docker image
+        env:
+          REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          REPOSITORY: ${{ steps.split.outputs._0 }}
+          IMAGE_TAG: ${{ github.sha }}
+        run: |
+          docker build \
+            -t $REGISTRY/$REPOSITORY:$IMAGE_TAG \
+            -f ./${{ steps.split.outputs._0 }}/Dockerfile \
+            --build-arg NEXT_PUBLIC_LANGFUSE_CLOUD_REGION=${{ vars.NEXT_PUBLIC_LANGFUSE_CLOUD_REGION }} \
+            --build-arg NEXT_LANGFUSE_TRACING_SAMPLE_RATE=${{ vars.NEXT_LANGFUSE_TRACING_SAMPLE_RATE }} \
+            --build-arg NEXT_PUBLIC_SENTRY_ENVIRONMENT=${{ vars.NEXT_PUBLIC_SENTRY_ENVIRONMENT }} \
+            --build-arg NEXT_PUBLIC_DEMO_ORG_ID=${{ vars.NEXT_PUBLIC_DEMO_ORG_ID }} \
+            --build-arg NEXT_PUBLIC_DEMO_PROJECT_ID=${{ vars.NEXT_PUBLIC_DEMO_PROJECT_ID }} \
+            --build-arg NEXT_PUBLIC_SENTRY_DSN=${{ vars.NEXT_PUBLIC_SENTRY_DSN }} \
+            --build-arg NEXT_PUBLIC_BUILD_ID=${{ github.sha }} \
+            --build-arg NEXT_PUBLIC_POSTHOG_KEY=${{ vars.NEXT_PUBLIC_POSTHOG_KEY }} \
+            --build-arg NEXT_PUBLIC_POSTHOG_HOST=${{ vars.NEXT_PUBLIC_POSTHOG_HOST }} \
+            --build-arg NEXT_PUBLIC_CRISP_WEBSITE_ID=${{ vars.NEXT_PUBLIC_CRISP_WEBSITE_ID }} \
+            --build-arg SENTRY_AUTH_TOKEN=${{ secrets.SENTRY_AUTH_TOKEN }} \
+            --build-arg SENTRY_ORG=${{ vars.SENTRY_ORG }} \
+            --build-arg SENTRY_PROJECT=${{ vars.SENTRY_PROJECT }} \
+            .
+          docker push $REGISTRY/$REPOSITORY:$IMAGE_TAG
+
+      - name: Render AWS ECS Task Definition
+        id: render-task-definition
+        uses: aws-actions/amazon-ecs-render-task-definition@v1
+        with:
+          container-name: ${{ inputs.service }}
+          image: ${{ steps.login-ecr.outputs.registry }}/${{ steps.split.outputs._0 }}:${{ github.sha }}
+          task-definition-family: ${{ inputs.environment }}-${{ inputs.service }}
+      - name: Update AWS ECS Service
+        uses: aws-actions/amazon-ecs-deploy-task-definition@v2
+        with:
+          task-definition: ${{ steps.render-task-definition.outputs.task-definition }}
+          service: ${{ inputs.environment }}-${{ inputs.service }}
+          cluster: ${{ inputs.environment }}-cluster
+          wait-for-service-stability: true

.github/workflows/ci.yml.template

@@ -22,7 +22,7 @@ jobs:
 
     steps:
       - name: Checkout repo
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Start containers
         run: docker compose -f "docker-compose.yml" up -d --build
@@ -31,7 +31,7 @@ jobs:
         uses: pnpm/action-setup@v2.2.4
 
       - name: Setup Node 18
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@v4
         with:
           node-version: 18
 

.github/workflows/codeql.yml

@@ -0,0 +1,92 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: ["main", "production", "v*"]
+  pull_request:
+    branches: ["main", "production", "v*"]
+  schedule:
+    - cron: "31 13 * * 0"
+
+jobs:
+  analyze:
+    name: Analyze (${{ matrix.language }})
+    # Runner size impacts CodeQL analysis time. To learn more, please see:
+    #   - https://gh.io/recommended-hardware-resources-for-running-codeql
+    #   - https://gh.io/supported-runners-and-hardware-resources
+    #   - https://gh.io/using-larger-runners (GitHub.com only)
+    # Consider using larger runners or machines with greater resources for possible analysis time improvements.
+    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
+    permissions:
+      # required for all workflows
+      security-events: write
+
+      # required to fetch internal or private CodeQL packs
+      packages: read
+
+      # only required for workflows in private repositories
+      actions: read
+      contents: read
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - language: javascript-typescript
+            build-mode: none
+        # CodeQL supports the following values keywords for 'language': 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'swift'
+        # Use `c-cpp` to analyze code written in C, C++ or both
+        # Use 'java-kotlin' to analyze code written in Java, Kotlin or both
+        # Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both
+        # To learn more about changing the languages that are analyzed or customizing the build mode for your analysis,
+        # see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning.
+        # If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how
+        # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      # Initializes the CodeQL tools for scanning.
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v3
+        with:
+          languages: ${{ matrix.language }}
+          build-mode: ${{ matrix.build-mode }}
+          # If you wish to specify custom queries, you can do so here or in a config file.
+          # By default, queries listed here will override any specified in a config file.
+          # Prefix the list here with "+" to use these queries and those in the config file.
+
+          # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+          # queries: security-extended,security-and-quality
+
+      # If the analyze step fails for one of the languages you are analyzing with
+      # "We were unable to automatically build your code", modify the matrix above
+      # to set the build mode to "manual" for that language. Then modify this step
+      # to build your code.
+      # ℹ️ Command-line programs to run using the OS shell.
+      # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+      - if: matrix.build-mode == 'manual'
+        shell: bash
+        run: |
+          echo 'If you are using a "manual" build mode for one or more of the' \
+            'languages you are analyzing, replace this with the commands to build' \
+            'your code, for example:'
+          echo '  make bootstrap'
+          echo '  make release'
+          exit 1
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v3
+        with:
+          category: "/language:${{matrix.language}}"

.github/workflows/deploy.yml

@@ -0,0 +1,106 @@
+on:
+  push:
+    branches:
+      - main
+      - production
+  workflow_dispatch:
+    inputs:
+      service:
+        description: 'Service to be deployed'
+        type: choice
+        options:
+          - all
+          - web
+          - web-ingestion
+          - worker
+        required: true
+      environment:
+        description: 'Environment to deploy to'
+        type: choice
+        options:
+          - staging
+          - prod-eu-temp
+          - prod-eu
+          - prod-us
+        required: true
+
+concurrency:
+  # Support concurrent `push` and `workflow_dispatch`` actions
+  group: deploy-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: true
+
+name: Deploy to ECS
+jobs:
+  affected-services:
+    runs-on: ubuntu-latest
+    outputs:
+      services: ${{ steps.affected-services.outputs.result }}
+    steps:
+      - name: Get affected services
+        id: affected-services
+        uses: actions/github-script@v7
+        with:
+          script: |
+            if (context.eventName === "workflow_dispatch") {
+              if (context.payload.inputs.service === "all") {
+                return `["web", "web-ingestion", "worker"]`
+              }
+              return `["${context.payload.inputs.service}"]`
+            }
+            if (context.eventName === "push") {
+              return `["web", "web-ingestion", "worker"]`
+            }
+            return "[]"
+          result-encoding: string
+      - name: Print services to build
+        uses: actions/github-script@v7
+        env:
+          services: ${{ steps.affected-services.outputs.result }}
+        with:
+          result-encoding: string
+          script: |
+            console.log('Services', `${process.env.services}` ?? 'n/a');
+
+  affected-environments:
+    runs-on: ubuntu-latest
+    outputs:
+      environments: ${{ steps.affected-environments.outputs.result }}
+    steps:
+      - name: Get affected environments
+        id: affected-environments
+        uses: actions/github-script@v7
+        with:
+          script: |
+            if (context.eventName === "workflow_dispatch") {
+              return `["${context.payload.inputs.environment}"]`
+            }
+            if (context.eventName === "push") {
+              if (context.ref === "refs/heads/main") {
+                return `["staging"]`
+              }
+              if (context.ref === "refs/heads/production") {
+                return `["prod-eu-temp", "prod-eu", "prod-us"]`
+              }
+            }
+            return "[]"
+          result-encoding: string
+      - name: Print environments to build
+        uses: actions/github-script@v7
+        env:
+          environments: ${{ steps.affected-environments.outputs.result }}
+        with:
+          result-encoding: string
+          script: |
+            console.log('Environments', `${process.env.environments}` ?? 'n/a');
+
+  ecs-deploy:
+    uses: ./.github/workflows/_deploy_ecs_service.yml
+    needs: [affected-services, affected-environments]
+    secrets: inherit
+    strategy:
+      matrix:
+        service: ${{ fromJson(needs.affected-services.outputs.services) }}
+        environment: ${{ fromJson(needs.affected-environments.outputs.environments) }}
+    with:
+      service: ${{ matrix.service }}
+      environment: ${{ matrix.environment }}

.github/workflows/licencecheck.yml

@@ -14,10 +14,10 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - name: Setup node
-        uses: actions/setup-node@v2
+        uses: actions/setup-node@v4
         with:
           node-version: 18
 

.github/workflows/pipeline.yml

@@ -16,11 +16,11 @@ jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: pnpm/action-setup@v3
         with:
           version: 9.5.0
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v4
         with:
           node-version: 20
           cache: "pnpm"
@@ -35,24 +35,22 @@ jobs:
         run: pnpm run lint
 
   test-docker-build:
+    timeout-minutes: 20
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
-
+        uses: actions/checkout@v4
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME_READ }}
+          password: ${{ secrets.DOCKERHUB_TOKEN_READ }}
+      - name: Set NEXT_PUBLIC_BUILD_ID
+        run: echo "NEXT_PUBLIC_BUILD_ID=$(git rev-parse --short HEAD)" >> $GITHUB_ENV
       - name: Build and run both images from compose
         run: |
           docker compose -f docker-compose.build.yml up -d
           sleep 5 # Wait for PostgreSQL to accept connections
-
-      - name: Check server health
-        run: |
-          timeout 10 bash -c 'until curl -f http://localhost:3000/api/public/health; do sleep 2; done'
-
-      - name: Check worker health
-        run: |
-          timeout 10 bash -c 'until curl -f http://localhost:3030/api/health; do sleep 2; done'
-
       - name: Ensure no unhealthy status
         run: |
           if docker-compose ps | grep "(unhealthy)"; then
@@ -61,6 +59,12 @@ jobs:
           else
             echo "All services are healthy"
           fi
+      - name: Check worker health
+        run: |
+          timeout 10 bash -c 'until curl -f http://localhost:3030/api/health; do sleep 2; done'
+      - name: Check server health
+        run: |
+          timeout 10 bash -c 'until curl -f http://localhost:3000/api/public/health; do sleep 2; done'
 
   tests-web:
     timeout-minutes: 20
@@ -75,27 +79,28 @@ jobs:
         uses: pierotofy/set-swap-space@master
         with:
           swap-size-gb: 10
-
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: pnpm/action-setup@v3
         with:
           version: 9.5.0
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME_READ }}
+          password: ${{ secrets.DOCKERHUB_TOKEN_READ }}
       - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@v4
         with:
           node-version: ${{ matrix.node-version }}
           cache: "pnpm"
           cache-dependency-path: "pnpm-lock.yaml"
-
       - name: install dependencies
         run: |
           pnpm install
-
       - name: Load default env
         run: |
           cp .env.dev.example .env
-          grep -v -e '^REDIS_HOST=' .env.dev.example > .env
-
+          grep -v -e '^S3_BUCKET_NAME=' -e '^REDIS_HOST=' -e '^NEXT_PUBLIC_LANGFUSE_RUN_NEXT_INIT=' .env.dev.example > .env
       - name: Run + migrate
         run: |
           docker compose -f docker-compose.dev.yml up -d
@@ -103,22 +108,23 @@ jobs:
           docker compose ps
         env:
           POSTGRES_VERSION: ${{ matrix.postgres-version }}
-
       - name: Seed DB
         run: |
           pnpm run db:migrate
-          pnpm run db:seed
-
       - name: Build
         run: pnpm run build
-        env:
-          SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
-          SENTRY_ORG: ${{ vars.SENTRY_ORG }}
-          SENTRY_PROJECT: ${{ vars.SENTRY_PROJECT }}
-
       - name: Start Langfuse
         run: (pnpm run start&)
-
+        env:
+          LANGFUSE_INIT_ORG_ID: "seed-org-id"
+          LANGFUSE_INIT_ORG_NAME: "Seed Org"
+          LANGFUSE_INIT_PROJECT_ID: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a"
+          LANGFUSE_INIT_PROJECT_NAME: "Seed Project"
+          LANGFUSE_INIT_PROJECT_PUBLIC_KEY: "pk-lf-1234567890"
+          LANGFUSE_INIT_PROJECT_SECRET_KEY: "sk-lf-1234567890"
+          LANGFUSE_INIT_USER_EMAIL: "demo@langfuse.com"
+          LANGFUSE_INIT_USER_NAME: "Demo User"
+          LANGFUSE_INIT_USER_PASSWORD: "password"
       - name: run tests
         run: pnpm --filter=web run test
 
@@ -135,41 +141,39 @@ jobs:
         uses: pierotofy/set-swap-space@master
         with:
           swap-size-gb: 10
-
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: pnpm/action-setup@v3
         with:
           version: 9.5.0
-
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME_READ }}
+          password: ${{ secrets.DOCKERHUB_TOKEN_READ }}
       - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@v4
         with:
           node-version: ${{ matrix.node-version }}
           cache: "pnpm"
           cache-dependency-path: "pnpm-lock.yaml"
-
       - name: install dependencies
         run: |
           pnpm install
-
       - name: Install golang-migrate for Clickhouse migrations
         run: |
           curl -L https://github.com/golang-migrate/migrate/releases/download/v4.16.2/migrate.linux-amd64.tar.gz | tar xvz
           sudo mv migrate /usr/bin/migrate
           which migrate
-
       - name: Load default env
         run: |
           cp .env.dev.example .env
           cp .env.dev.example web/.env
           cp .env.dev.example worker/.env
-
       - name: Run + migrate
         run: |
           docker compose -f docker-compose.dev.yml up -d
           sleep 5 # Wait for PostgreSQL to accept connections
           docker compose ps
-
       - name: Ensure no unhealthy status
         run: |
           if docker compose ps | grep "(unhealthy)"; then
@@ -178,101 +182,95 @@ jobs:
           else
             echo "All services are healthy"
           fi
-
       - name: Seed DB
         run: |
           pnpm run db:migrate
           pnpm run db:seed
           pnpm run --filter=shared ch:up
-
       - name: Build
         run: pnpm --filter=worker... run build
-
       - name: run tests
         run: pnpm --filter=worker run test
+
   e2e-tests:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: pnpm/action-setup@v3
         with:
           version: 9.5.0
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v4
         with:
           node-version: 20
           cache: "pnpm"
           cache-dependency-path: "pnpm-lock.yaml"
-
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME_READ }}
+          password: ${{ secrets.DOCKERHUB_TOKEN_READ }}
       - name: install dependencies
         run: |
           pnpm install
-
       - name: Load default env
         run: |
           cp .env.dev.example .env
           cp .env.dev.example web/.env
-
       - name: Run + migrate
         run: |
           docker compose -f docker-compose.dev.yml up -d
           docker compose ps
           sleep 5 # Wait for PostgreSQL to accept connections
-
       - name: Seed DB
         run: |
           pnpm run db:migrate
           pnpm run db:seed
-
       - name: Build
         run: pnpm run build
-
       - name: Install playwright
         run: pnpm --filter=web exec playwright install --with-deps
-
       - name: Run e2e tests
         run: pnpm --filter=web run test:e2e
 
   e2e-server-tests:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME_READ }}
+          password: ${{ secrets.DOCKERHUB_TOKEN_READ }}
       - uses: pnpm/action-setup@v3
         with:
           version: 9.5.0
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v4
         with:
           node-version: 20
           cache: "pnpm"
           cache-dependency-path: "pnpm-lock.yaml"
-
       - name: install dependencies
         run: |
           pnpm install
-
       - name: Load default env
         run: |
           cp .env.dev.example .env
           echo "LANGFUSE_ASYNC_INGESTION_PROCESSING=true" >> .env
           echo "LANGFUSE_CACHE_API_KEY_ENABLED=true" >> .env
           echo "LANGFUSE_CACHE_PROMPT_ENABLED=true" >> .env
-
       - name: Run + migrate
         run: |
           docker compose -f docker-compose.dev.yml up -d
           docker compose ps
           sleep 5 # Wait for PostgreSQL to accept connections
-
       - name: Seed DB
         run: |
           pnpm run db:migrate
           pnpm run db:seed:examples
-
       - name: Build
         run: pnpm run build
-
       - name: Run server
         run: (pnpm run start&)
-
       - name: Run e2e tests
         run: pnpm --filter=web run test:e2e:server
 
@@ -313,35 +311,31 @@ jobs:
         with:
           version: 9.5.0
       - name: Setup node
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@v4
         with:
           node-version: 20
           cache-dependency-path: "pnpm-lock.yaml"
-
       - name: Checkout
-        uses: actions/checkout@v3
-
+        uses: actions/checkout@v4
+      - name: Set NEXT_PUBLIC_BUILD_ID
+        run: echo "NEXT_PUBLIC_BUILD_ID=$(git rev-parse --short HEAD)" >> $GITHUB_ENV
       - name: Log in to the GitHub Container registry
         uses: docker/login-action@v2
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
-
       - name: Log in to Docker Hub
         uses: docker/login-action@v2
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
-
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v3
-
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
         with:
           driver-opts: network=host
-
       - name: Extract metadata (tags, labels) for Docker
         id: meta-web
         uses: docker/metadata-action@v4
@@ -356,7 +350,6 @@ jobs:
             type=semver,pattern={{version}}
             type=semver,pattern={{major}}.{{minor}}
             type=semver,pattern={{major}}
-
       - name: Build and push Docker image (web)
         uses: docker/build-push-action@v4
         with:
@@ -368,7 +361,6 @@ jobs:
           platforms: |
             linux/amd64
             ${{ startsWith(github.ref, 'refs/tags/') && 'linux/arm64' || '' }}
-
       - name: Extract metadata (tags, labels) for Docker
         id: meta-worker
         uses: docker/metadata-action@v4
@@ -383,7 +375,6 @@ jobs:
             type=semver,pattern={{version}}
             type=semver,pattern={{major}}.{{minor}}
             type=semver,pattern={{major}}
-
       - name: Build and push Docker image (worker)
         uses: docker/build-push-action@v4
         with:

.github/workflows/porter_stack_web_eu_temp.yml

@@ -1,29 +0,0 @@
-"on":
-  push:
-    branches:
-      - production
-name: Deploy to web
-jobs:
-  porter-deploy:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-      - name: Set Github tag
-        id: vars
-        run: echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
-      - name: Setup porter
-        uses: porter-dev/setup-porter@v0.1.0
-      - name: Deploy stack
-        timeout-minutes: 30
-        run: exec porter apply
-        env:
-          PORTER_CLUSTER: "4060"
-          PORTER_DEPLOYMENT_TARGET_ID: 3be075c0-b121-4123-aec1-5dc571626b0c
-          PORTER_HOST: https://dashboard.porter.run
-          PORTER_PR_NUMBER: ${{ github.event.number }}
-          PORTER_PROJECT: "12565"
-          PORTER_REPO_NAME: ${{ github.event.repository.name }}
-          PORTER_STACK_NAME: web
-          PORTER_TAG: ${{ steps.vars.outputs.sha_short }}
-          PORTER_TOKEN: ${{ secrets.PORTER_STACK_12565_4060 }}

.github/workflows/porter_stack_web_staging.yml

@@ -1,29 +0,0 @@
-"on":
-  push:
-    branches:
-      - main
-name: Deploy to web (Staging)
-jobs:
-  porter-deploy:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-      - name: Set Github tag
-        id: vars
-        run: echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
-      - name: Setup porter
-        uses: porter-dev/setup-porter@v0.1.0
-      - name: Deploy stack
-        timeout-minutes: 30
-        run: exec porter apply
-        env:
-          PORTER_CLUSTER: "4037"
-          PORTER_DEPLOYMENT_TARGET_ID: c22d8fa2-f97c-4e1f-9cae-83cc6bfbad35
-          PORTER_HOST: https://dashboard.getporter.dev
-          PORTER_PR_NUMBER: ${{ github.event.number }}
-          PORTER_PROJECT: "12565"
-          PORTER_REPO_NAME: ${{ github.event.repository.name }}
-          PORTER_STACK_NAME: web
-          PORTER_TAG: ${{ steps.vars.outputs.sha_short }}
-          PORTER_TOKEN: ${{ secrets.PORTER_STACK_12565_4037 }}

.github/workflows/porter_stack_web_us_temp.yml

@@ -1,29 +0,0 @@
-"on":
-  push:
-    branches:
-      - production
-name: Deploy to web (US temp)
-jobs:
-  porter-deploy:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-      - name: Set Github tag
-        id: vars
-        run: echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
-      - name: Setup porter
-        uses: porter-dev/setup-porter@v0.1.0
-      - name: Deploy stack
-        timeout-minutes: 30
-        run: exec porter apply
-        env:
-          PORTER_CLUSTER: "4054"
-          PORTER_DEPLOYMENT_TARGET_ID: cddc0f2a-bb19-401a-9819-29f59f76b101
-          PORTER_HOST: https://dashboard.porter.run
-          PORTER_PR_NUMBER: ${{ github.event.number }}
-          PORTER_PROJECT: "12565"
-          PORTER_REPO_NAME: ${{ github.event.repository.name }}
-          PORTER_STACK_NAME: web
-          PORTER_TAG: ${{ steps.vars.outputs.sha_short }}
-          PORTER_TOKEN: ${{ secrets.PORTER_STACK_12565_4054 }}

.github/workflows/porter_stack_worker_eu_temp.yml

@@ -1,29 +0,0 @@
-"on":
-  push:
-    branches:
-      - production
-name: Deploy to worker (EU temp)
-jobs:
-  porter-deploy:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-      - name: Set Github tag
-        id: vars
-        run: echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
-      - name: Setup porter
-        uses: porter-dev/setup-porter@v0.1.0
-      - name: Deploy stack
-        timeout-minutes: 30
-        run: exec porter apply
-        env:
-          PORTER_CLUSTER: "4060"
-          PORTER_DEPLOYMENT_TARGET_ID: 3be075c0-b121-4123-aec1-5dc571626b0c
-          PORTER_HOST: https://dashboard.porter.run
-          PORTER_PR_NUMBER: ${{ github.event.number }}
-          PORTER_PROJECT: "12565"
-          PORTER_REPO_NAME: ${{ github.event.repository.name }}
-          PORTER_STACK_NAME: worker
-          PORTER_TAG: ${{ steps.vars.outputs.sha_short }}
-          PORTER_TOKEN: ${{ secrets.PORTER_STACK_12565_4060 }}

.github/workflows/porter_stack_worker_staging.yml

@@ -1,29 +0,0 @@
-"on":
-  push:
-    branches:
-      - main
-name: Deploy to worker (staging)
-jobs:
-  porter-deploy:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-      - name: Set Github tag
-        id: vars
-        run: echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
-      - name: Setup porter
-        uses: porter-dev/setup-porter@v0.1.0
-      - name: Deploy stack
-        timeout-minutes: 30
-        run: exec porter apply
-        env:
-          PORTER_CLUSTER: "4037"
-          PORTER_DEPLOYMENT_TARGET_ID: c22d8fa2-f97c-4e1f-9cae-83cc6bfbad35
-          PORTER_HOST: https://dashboard.getporter.dev
-          PORTER_PR_NUMBER: ${{ github.event.number }}
-          PORTER_PROJECT: "12565"
-          PORTER_REPO_NAME: ${{ github.event.repository.name }}
-          PORTER_STACK_NAME: worker
-          PORTER_TAG: ${{ steps.vars.outputs.sha_short }}
-          PORTER_TOKEN: ${{ secrets.PORTER_STACK_12565_4037 }}

.github/workflows/porter_stack_worker_us_temp.yml

@@ -1,29 +0,0 @@
-"on":
-  push:
-    branches:
-      - production
-name: Deploy to worker (US temp)
-jobs:
-  porter-deploy:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-      - name: Set Github tag
-        id: vars
-        run: echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
-      - name: Setup porter
-        uses: porter-dev/setup-porter@v0.1.0
-      - name: Deploy stack
-        timeout-minutes: 30
-        run: exec porter apply
-        env:
-          PORTER_CLUSTER: "4054"
-          PORTER_DEPLOYMENT_TARGET_ID: cddc0f2a-bb19-401a-9819-29f59f76b101
-          PORTER_HOST: https://dashboard.porter.run
-          PORTER_PR_NUMBER: ${{ github.event.number }}
-          PORTER_PROJECT: "12565"
-          PORTER_REPO_NAME: ${{ github.event.repository.name }}
-          PORTER_STACK_NAME: worker
-          PORTER_TAG: ${{ steps.vars.outputs.sha_short }}
-          PORTER_TOKEN: ${{ secrets.PORTER_STACK_12565_4054 }}

.vscode/launch.json

@@ -2,10 +2,10 @@
   "version": "0.2.0",
   "configurations": [
     {
-      "name": "Next.js: debug server-side",
+      "name": "Web and Worker: server side",
       "type": "node-terminal",
       "request": "launch",
-      "command": "npm run dev"
+      "command": "pnpm run dev"
     },
     {
       "name": "Next.js: debug client-side",

README.md

@@ -1,8 +1,7 @@
-![langfuse_logo_1024](https://github.com/user-attachments/assets/f17d8fc1-8206-4afa-a5ec-774826be88a8)
+![Langfuse GitHub Banner](https://github.com/langfuse/langfuse/assets/121163007/6035f0f3-d691-4963-b5d0-10cf506e9d42)
 
-<div align="center"><h1> Langfuse: Open Source LLM Observability & Engineering Platform</h4></div>
-<div align="center"><h2> Debug and improve your LLM app</h4></div>
-<div align="center"><h3> LLM Observability, Prompt Management, LLM Evaluations, Datasets, LLM Metrics and Prompt Playground</h4></div>
+<div align="center"><h1>Langfuse: Open Source LLM Engineering Platform</h1></div>
+<div align="center"><h4>LLM Observability, Prompt Management, LLM Evaluations,<br/>Datasets, LLM Metrics, and Prompt Playground</h4></div>
 
 <div align="center">
    <div>
@@ -28,15 +27,15 @@
    </div>
    <span>Langfuse uses <a href="https://github.com/orgs/langfuse/discussions"><strong>Github Discussions</strong></a>  for Support and Feature Requests.</span>
    <br/>
-   <span>We're hiring. <a href="https://langfuse.com/careers"><strong>Join us</strong></a> in Backend Engineering, Product Engineering, and Developer Relations.</span>
+   <span>We're hiring. <a href="https://langfuse.com/careers"><strong>Join us</strong></a> in Product Engineering and Developer Relations.</span>
    <br/>
    <br/>
    <div>
       <a href="https://github.com/langfuse/langfuse/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-MIT-red.svg?style=flat-square" alt="MIT License"></a>
       <a href="https://www.ycombinator.com/companies/langfuse"><img src="https://img.shields.io/badge/Y%20Combinator-W23-orange?style=flat-square" alt="Y Combinator W23"></a>
       <a href="https://github.com/langfuse/langfuse/pkgs/container/langfuse"><img alt="Docker Image" src="https://img.shields.io/badge/docker-langfuse-blue?logo=Docker&logoColor=white&style=flat-square"></a>
-      <a href="https://www.npmjs.com/package/langfuse"><img src="https://img.shields.io/npm/v/langfuse?style=flat-square&label=npm+langfuse" alt="langfuse npm package"></a>
-      <a href="https://pypi.python.org/pypi/langfuse"><img src="https://img.shields.io/pypi/v/langfuse.svg?style=flat-square&label=pypi+langfuse" alt="langfuse Python package on PyPi"></a>
+      <a href="https://pypi.python.org/pypi/langfuse"><img src="https://img.shields.io/pypi/dm/langfuse?style=flat-square&logo=python&logoColor=white&label=pypi%20langfuse&color=blue" alt="langfuse Python package on PyPi"></a>
+      <a href="https://www.npmjs.com/package/langfuse"><img src="https://img.shields.io/npm/dm/langfuse?style=flat-square&logo=npm&logoColor=white&label=npm%20langfuse&color=blue" alt="langfuse npm package"></a>
    </div>
 </div>
 </br>
@@ -93,10 +92,10 @@ docker compose up -d
 
 ### Self-host (docker)
 
-Langfuse is simple to self-host and keep updated. It currently requires only a single docker container.
+Langfuse is simple to self-host and keep updated. It currently requires only a single docker container and a postgres database.
 [→ Self Hosting Instructions](https://langfuse.com/docs/deployment/self-host)
 
-Templated deployments: [Railway, GCP Cloud Run, AWS Fargate, Kubernetes and others](https://langfuse.com/docs/deployment/self-host#platform-specific-information)
+Templated deployments: [Railway, GCP, AWS, Azure, Kubernetes and others](https://langfuse.com/docs/deployment/self-host#platform-specific-information)
 
 ## Get Started
 
@@ -108,31 +107,31 @@ You need a Langfuse public and secret key to get started. Sign up [here](https:/
 
 Note: We recommend using our fully async, typed [SDKs](https://langfuse.com/docs/sdk) that allow you to instrument any LLM application with any underlying model. They are available in [Python (Decorators)](https://langfuse.com/docs/sdk/python) & [JS/TS](https://langfuse.com/docs/sdk/typescript). The SDKs will always be the most fully featured and stable way to ingest data into Langfuse.
 
-You may want to use another integration to get started quickly or implement a use case that we do not yet support. However, we recommend to migrate to the Langfuse SDKs over time to ensure performance and stability.
-
 See the [→ Quickstart](https://langfuse.com/docs/get-started) to integrate Langfuse.
 
 ### LLM Observability Integrations
 
-| Integration                                              | Supports                   | Description                                                                                                                                      |
-| -------------------------------------------------------- | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
-| [SDK](/docs/sdk)                                         | Python, JS/TS              | Manual instrumentation using the SDKs for full flexibility.                                                                                      |
-| [OpenAI](/docs/integrations/openai)                      | Python, JS/TS              | Automated instrumentation using drop-in replacement of OpenAI SDK.                                                                               |
-| [Langchain](/docs/integrations/langchain)                | Python, JS/TS              | Automated instrumentation by passing callback handler to Langchain application.                                                                  |
-| [LlamaIndex](/docs/integrations/llama-index/get-started) | Python                     | Automated instrumentation via LlamaIndex callback system.                                                                                        |
-| [Haystack](/docs/integrations/haystack)                  | Python                     | Automated instrumentation via Haystack content tracing system.                                                                                   |
-| [LiteLLM](/docs/integrations/litellm)                    | Python, JS/TS (proxy only) | Use any LLM as a drop in replacement for GPT. Use Azure, OpenAI, Cohere, Anthropic, Ollama, VLLM, Sagemaker, HuggingFace, Replicate (100+ LLMs). |
-| [API](/docs/api)                                         |                            | Directly call the public API. OpenAPI spec available.                                                                                            |
+| Integration                                                                  | Supports                   | Description                                                                                                                                      |
+| ---------------------------------------------------------------------------- | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| [SDK](https://langfuse.com/docs/sdk)                                         | Python, JS/TS              | Manual instrumentation using the SDKs for full flexibility.                                                                                      |
+| [OpenAI](https://langfuse.com/docs/integrations/openai)                      | Python, JS/TS              | Automated instrumentation using drop-in replacement of OpenAI SDK.                                                                               |
+| [Langchain](https://langfuse.com/docs/integrations/langchain)                | Python, JS/TS              | Automated instrumentation by passing callback handler to Langchain application.                                                                  |
+| [LlamaIndex](https://langfuse.com/docs/integrations/llama-index/get-started) | Python                     | Automated instrumentation via LlamaIndex callback system.                                                                                        |
+| [Haystack](https://langfuse.com/docs/integrations/haystack)                  | Python                     | Automated instrumentation via Haystack content tracing system.                                                                                   |
+| [LiteLLM](https://langfuse.com/docs/integrations/litellm)                    | Python, JS/TS (proxy only) | Use any LLM as a drop in replacement for GPT. Use Azure, OpenAI, Cohere, Anthropic, Ollama, VLLM, Sagemaker, HuggingFace, Replicate (100+ LLMs). |
+| [Vercel AI SDK](https://langfuse.com/docs/integrations/vercel-ai-sdk)        | JS/TS                      | TypeScript toolkit designed to help developers build AI-powered applications with React, Next.js, Vue, Svelte, Node.js.                          |
+| [API](https://langfuse.com/docs/api)                                         |                            | Directly call the public API. OpenAPI spec available.                                                                                            |
 
-Packages that integrate with Langfuse:
+Packages integrated with Langfuse:
 
-| Name                                                       | Description                                                                                                             |
-| ---------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
-| [Instructor](/docs/integrations/instructor)                | Library to get structured LLM outputs (JSON, Pydantic)                                                                  |
-| [Mirascope](/docs/integrations/mirascope)                  | Python toolkit for building LLM applications.                                                                           |
-| [AI SDK by Vercel](/docs/sdk/typescript/example-vercel-ai) | Typescript SDK that makes streaming LLM outputs super easy.                                                             |
-| [Flowise](/docs/integrations/flowise)                      | JS/TS no-code builder for customized LLM flows.                                                                         |
-| [Langflow](/docs/integrations/langflow)                    | Python-based UI for LangChain, designed with react-flow to provide an effortless way to experiment and prototype flows. |
+| Name                                                            | Description                                                                                                             |
+| --------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
+| [Instructor](https://langfuse.com/docs/integrations/instructor) | Library to get structured LLM outputs (JSON, Pydantic)                                                                  |
+| [Dify](https://langfuse.com/docs/integrations/dify)             | Open source LLM app development platform with no-code builder.                                                          |
+| [Ollama](https://langfuse.com/docs/integrations/ollama)         | Easily run open source LLMs on your own machine.                                                                        |
+| [Mirascope](https://langfuse.com/docs/integrations/mirascope)   | Python toolkit for building LLM applications.                                                                           |
+| [Flowise](https://langfuse.com/docs/integrations/flowise)       | JS/TS no-code builder for customized LLM flows.                                                                         |
+| [Langflow](https://langfuse.com/docs/integrations/langflow)     | Python-based UI for LangChain, designed with react-flow to provide an effortless way to experiment and prototype flows. |
 
 ## Questions and feedback
 
@@ -140,13 +139,13 @@ Packages that integrate with Langfuse:
 
 - [Roadmap](https://langfuse.com/roadmap)
 - [GitHub Discussions](https://github.com/orgs/langfuse/discussions)
-- [Feature Requests](https://langfuse.com/idea
+- [Feature Requests](https://langfuse.com/ideas)
 
 ### Support and feedback
 
 In order of preference the best way to communicate with us:
 
-- [GitHub Discussions](https://github.com/orgs/langfuse/discussions): Contribute [ideas](https://langfuse.com/idea) [support requests](https://github.com/orgs/langfuse/discussions/categories/support) and [report bugs](https://github.com/langfuse/langfuse/issues/new?labels=%F0%9F%90%9E%E2%9D%94+unconfirmed+bug&projects=&template=bug_report.yml&title=bug%3A+) (preferred as we create a permanent, indexed artifact for other community members)
+- [GitHub Discussions](https://github.com/orgs/langfuse/discussions) (preferred): Contribute [ideas](https://langfuse.com/ideas), [support requests](https://langfuse.com/gh-support) and [report bugs](https://langfuse.com/issues)
 - [Discord](https://langfuse.com/discord): community support
 - Privately: contact at langfuse dot com
 

docker-compose.build.yml

@@ -20,8 +20,15 @@ services:
       - NEXTAUTH_URL=http://localhost:3000
       - TELEMETRY_ENABLED=${TELEMETRY_ENABLED:-true}
       - LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES=${LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES:-false}
-      - LANGFUSE_WORKER_HOST=${LANGFUSE_WORKER_HOST:-worker}
-      - LANGFUSE_WORKER_PASSWORD=${LANGFUSE_WORKER_PASSWORD:-mybasicauthsecret}
+      - LANGFUSE_INIT_ORG_ID=${LANGFUSE_INIT_ORG_ID:-}
+      - LANGFUSE_INIT_ORG_NAME=${LANGFUSE_INIT_ORG_NAME:-}
+      - LANGFUSE_INIT_PROJECT_ID=${LANGFUSE_INIT_PROJECT_ID:-}
+      - LANGFUSE_INIT_PROJECT_NAME=${LANGFUSE_INIT_PROJECT_NAME:-}
+      - LANGFUSE_INIT_PROJECT_PUBLIC_KEY=${LANGFUSE_INIT_PROJECT_PUBLIC_KEY:-}
+      - LANGFUSE_INIT_PROJECT_SECRET_KEY=${LANGFUSE_INIT_PROJECT_SECRET_KEY:-}
+      - LANGFUSE_INIT_USER_EMAIL=${LANGFUSE_INIT_USER_EMAIL:-}
+      - LANGFUSE_INIT_USER_NAME=${LANGFUSE_INIT_USER_NAME:-}
+      - LANGFUSE_INIT_USER_PASSWORD=${LANGFUSE_INIT_USER_PASSWORD:-}
     restart: always
     healthcheck:
       test: ["CMD", "curl", "-f", "http://localhost:3000/api/public/health"]
@@ -49,7 +56,6 @@ services:
       - REDIS_HOST=${REDIS_HOST:-redis}
       - REDIS_PORT=${REDIS_PORT:-6379}
       - REDIS_AUTH=${REDIS_AUTH:-myredissecret}
-      - LANGFUSE_WORKER_PASSWORD=${LANGFUSE_WORKER_PASSWORD:-mybasicauthsecret}
     restart: always
     healthcheck:
       test: ["CMD", "curl", "-f", "http://localhost:3030/api/health"]

docker-compose.dev.yml

@@ -17,6 +17,38 @@ services:
     depends_on:
       - postgres
 
+  minio:
+    image: minio/minio
+    container_name: minio
+    command: server /data --console-address ":9001"
+    environment:
+      MINIO_ACCESS_KEY: minio
+      MINIO_SECRET_KEY: miniosecret
+    ports:
+      - "9090:9000"
+      - "9091:9001"
+    volumes:
+      - langfuse_minio_data:/data
+    healthcheck:
+      test: ["CMD", "mc", "ready", "local"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+      start_period: 5s
+
+  miniocreatebucket:
+    image: minio/mc
+    container_name: miniocreatebucket
+    entrypoint: ["/bin/sh", "-c"]
+    command: >
+      "mc alias set minio http://minio:9000 minio miniosecret && 
+       mc rm -r --force minio/mybucket || true &&
+       mc mb minio/mybucket && 
+       mc policy set download minio/mybucket"
+    depends_on:
+      minio:
+        condition: service_healthy
+
   redis:
     image: redis:7.2.4
     restart: always
@@ -45,3 +77,5 @@ volumes:
     driver: local
   langfuse_clickhouse_logs:
     driver: local
+  langfuse_minio_data:
+    driver: local

docker-compose.yml

@@ -14,6 +14,15 @@ services:
       - NEXTAUTH_URL=http://localhost:3000
       - TELEMETRY_ENABLED=${TELEMETRY_ENABLED:-true}
       - LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES=${LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES:-false}
+      - LANGFUSE_INIT_ORG_ID=${LANGFUSE_INIT_ORG_ID:-}
+      - LANGFUSE_INIT_ORG_NAME=${LANGFUSE_INIT_ORG_NAME:-}
+      - LANGFUSE_INIT_PROJECT_ID=${LANGFUSE_INIT_PROJECT_ID:-}
+      - LANGFUSE_INIT_PROJECT_NAME=${LANGFUSE_INIT_PROJECT_NAME:-}
+      - LANGFUSE_INIT_PROJECT_PUBLIC_KEY=${LANGFUSE_INIT_PROJECT_PUBLIC_KEY:-}
+      - LANGFUSE_INIT_PROJECT_SECRET_KEY=${LANGFUSE_INIT_PROJECT_SECRET_KEY:-}
+      - LANGFUSE_INIT_USER_EMAIL=${LANGFUSE_INIT_USER_EMAIL:-}
+      - LANGFUSE_INIT_USER_NAME=${LANGFUSE_INIT_USER_NAME:-}
+      - LANGFUSE_INIT_USER_PASSWORD=${LANGFUSE_INIT_USER_PASSWORD:-}
 
   db:
     image: postgres

ee/package.json

@@ -25,8 +25,9 @@
   },
   "dependencies": {
     "@langfuse/shared": "workspace:*",
-    "@opentelemetry/api": ">=1.0.0 <1.9.0",
-    "next": "^14.2.6",
+    "@opentelemetry/api": ">=1.0.0 <1.10.0",
+    "axios": "^1.7.7",
+    "next": "^14.2.15",
     "next-auth": "^4.24.7",
     "zod": "^3.23.8"
   },
@@ -39,9 +40,14 @@
     "eslint-config-prettier": "^9.1.0",
     "eslint-config-standard": "^17.1.0",
     "eslint-plugin-prettier": "^5.1.3",
-    "prettier": "^3.2.5",
+    "prettier": "^3.3.3",
     "ts-node": "^10.9.2",
     "tsc-watch": "^6.2.0",
     "typescript": "^5.4.5"
+  },
+  "pnpm": {
+    "overrides": {
+      "jsonpath-plus": "10.0.0"
+    }
   }
 }

ee/prettierrc.json

@@ -1,4 +0,0 @@
-{
-  "trailingComma": "es5",
-  "printWidth": 120
-}

ee/src/env.ts

@@ -1,9 +1,12 @@
 import { z } from "zod";
-import { env as sharedEnv } from "@langfuse/shared";
+import { env as sharedEnv, removeEmptyEnvVariables } from "@langfuse/shared";
 
 const EnvSchema = z.object({
   NEXT_PUBLIC_LANGFUSE_CLOUD_REGION: z.string().optional(),
   LANGFUSE_EE_LICENSE_KEY: z.string().optional(),
 });
 
-export const env = { ...sharedEnv, ...EnvSchema.parse(process.env) };
+export const env = {
+  ...sharedEnv,
+  ...EnvSchema.parse(removeEmptyEnvVariables(process.env)),
+};

fern/apis/server/definition/comments.yml

@@ -0,0 +1,73 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/fern-api/fern/main/fern.schema.json
+imports:
+  pagination: ./utils/pagination.yml
+  commons: ./commons.yml
+service:
+  auth: true
+  base-path: /api/public
+  endpoints:
+    create:
+      docs: Create a comment. Comments may be attached to different object types (trace, observation, session, prompt).
+      method: POST
+      path: /comments
+      request: CreateCommentRequest
+      response: CreateCommentResponse
+    get:
+      docs: Get all comments
+      method: GET
+      path: /comments
+      request:
+        name: GetCommentsRequest
+        query-parameters:
+          page:
+            type: optional<integer>
+            docs: Page number, starts at 1.
+          limit:
+            type: optional<integer>
+            docs: Limit of items per page. If you encounter api issues due to too large page sizes, try to reduce the limit
+          objectType:
+            type: optional<string>
+            docs: Filter comments by object type (trace, observation, session, prompt).
+          objectId:
+            type: optional<string>
+            docs: Filter comments by object id. If objectType is not provided, an error will be thrown.
+          authorUserId:
+            type: optional<string>
+            docs: Filter comments by author user id.
+      response: GetCommentsResponse
+    get-by-id:
+      docs: Get a comment by id
+      method: GET
+      path: /comments/{commentId}
+      path-parameters:
+        commentId:
+          type: string
+          docs: The unique langfuse identifier of a comment
+      response: commons.Comment
+types:
+  CreateCommentRequest:
+    properties:
+      projectId:
+        type: string
+        docs: The id of the project to attach the comment to.
+      objectType:
+        type: string
+        docs: The type of the object to attach the comment to (trace, observation, session, prompt).
+      objectId:
+        type: string
+        docs: The id of the object to attach the comment to. If this does not reference a valid existing object, an error will be thrown.
+      content:
+        type: string
+        docs: The content of the comment. May include markdown. Currently limited to 500 characters.
+      authorUserId:
+        type: optional<string>
+        docs: The id of the user who created the comment.
+  CreateCommentResponse:
+    properties:
+      id:
+        type: string
+        docs: The id of the created object in Langfuse
+  GetCommentsResponse:
+    properties:
+      data: list<commons.Comment>
+      meta: pagination.MetaResponse

fern/apis/server/definition/commons.yml

@@ -240,6 +240,9 @@ types:
       configId:
         type: optional<string>
         docs: Reference a score config on a score. When set, config and score name must be equal and value must comply to optionally defined numerical range
+      queueId:
+        type: optional<string>
+        docs: Reference an annotation queue on a score. Populated if the score was initially created in an annotation queue.
   NumericScore:
     extends: BaseScore
     properties:
@@ -283,6 +286,18 @@ types:
       - double
       - string
     docs: The value of the score. Must be passed as string for categorical scores, and numeric for boolean and numeric scores
+
+  Comment:
+    properties:
+      id: string
+      projectId: string
+      createdAt: datetime
+      updatedAt: datetime
+      objectType: CommentObjectType
+      objectId: string
+      content: string
+      authorUserId: optional<string>
+
   Dataset:
     properties:
       id: string
@@ -402,6 +417,12 @@ types:
       - optional<integer>
       - optional<boolean>
       - optional<list<string>>
+  CommentObjectType:
+    enum:
+      - TRACE
+      - OBSERVATION
+      - SESSION
+      - PROMPT
   DatasetStatus:
     enum:
       - ACTIVE

fern/apis/server/definition/metrics.yml

@@ -31,10 +31,10 @@ service:
             docs: Optional filter for metrics where traces include all of these tags
           fromTimestamp:
             type: optional<datetime>
-            docs: Optional filter to only include traces on or after a certain datetime (ISO 8601)
+            docs: Optional filter to only include traces and observations on or after a certain datetime (ISO 8601)
           toTimestamp:
             type: optional<datetime>
-            docs: Optional filter to only include traces before a certain datetime (ISO 8601)
+            docs: Optional filter to only include traces and observations before a certain datetime (ISO 8601)
       response: DailyMetrics
 types:
   DailyMetrics:

fern/apis/server/definition/models.yml

@@ -55,7 +55,7 @@ types:
         type: string
       startDate:
         docs: Apply only to generations which are newer than this ISO date.
-        type: optional<date>
+        type: optional<datetime>
       unit:
         docs: Unit used by this model.
         type: commons.ModelUsageUnit

fern/apis/server/definition/score.yml

@@ -52,10 +52,17 @@ service:
           configId:
             type: optional<string>
             docs: Retrieve only scores with a specific configId.
+          queueId:
+            type: optional<string>
+            docs: Retrieve only scores with a specific annotation queueId.
           dataType:
             type: optional<commons.ScoreDataType>
             docs: Retrieve only scores with a specific dataType.
-      response: Scores
+          traceTags:
+            type: optional<list<string>>
+            allow-multiple: true
+            docs: Only scores linked to traces that include all of these tags will be returned.
+      response: GetScoresResponse
     get-by-id:
       docs: Get a score
       method: GET
@@ -132,7 +139,19 @@ types:
       id:
         type: string
         docs: The id of the created object in Langfuse
-  Scores:
+  GetScoresResponseTraceData:
     properties:
-      data: list<commons.Score>
+      userId:
+        type: optional<string>
+        docs: The user ID associated with the trace referenced by score
+      tags:
+        type: optional<list<string>>
+        docs: A list of tags associated with the trace referenced by score
+  GetScoresResponseData:
+    properties:
+      <<: commons.Score
+      trace: GetScoresResponseTraceData
+  GetScoresResponse:
+    properties:
+      data: list<GetScoresResponseData>
       meta: pagination.MetaResponse

fern/apis/server/generators.yml

@@ -3,32 +3,22 @@ groups:
   local:
     generators:
       - name: fernapi/fern-openapi
-        version: 0.0.28
+        version: 0.0.31
         output:
           location: local-file-system
           path: ../../../web/public/generated/api
-        config:
-          namespaceExport: Langfuse
-          allowCustomFetcher: true
       - name: fernapi/fern-python-sdk
-        version: 1.1.0-rc2
+        version: 2.16.0
         output:
           location: local-file-system
           path: ../../../generated/python
         config:
           client_class_name: FernLangfuse
           improved_imports: false
+          inline_request_params: false
           pydantic_config:
             require_optional_fields: false
             use_str_enums: false
-      - name: fernapi/fern-typescript-node-sdk
-        version: 0.7.1
-        output:
-          location: local-file-system
-          path: ../../../generated/typescript-server
-        config:
-          namespaceExport: Langfuse
-          allowCustomFetcher: true
       - name: fernapi/fern-postman
         version: 0.0.45
         output:

fern/fern.config.json

@@ -1,4 +1,4 @@
 {
   "organization": "finto",
-  "version": "0.30.3"
+  "version": "0.43.7"
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "langfuse",
-  "version": "2.76.0",
+  "version": "2.86.0",
   "author": "engineering@langfuse.com",
   "license": "MIT",
   "private": true,
@@ -33,7 +33,7 @@
     "braces": "3.0.3",
     "dotenv-cli": "^7.4.2",
     "husky": "^9.0.11",
-    "prettier": "^3.2.5",
+    "prettier": "^3.3.3",
     "release-it": "^17.3.0",
     "turbo": "^1.13.4"
   },
@@ -80,5 +80,10 @@
       }
     }
   },
+  "pnpm": {
+    "overrides": {
+      "jsonpath-plus": "10.0.0"
+    }
+  },
   "packageManager": "pnpm@9.5.0"
 }

packages/config-eslint/package.json

@@ -11,7 +11,7 @@
     "@typescript-eslint/eslint-plugin": "^7.1.0",
     "@typescript-eslint/parser": "^7.12.0",
     "@vercel/style-guide": "^6.0.0",
-    "eslint-config-next": "^14.2.6",
+    "eslint-config-next": "^14.2.15",
     "eslint-config-prettier": "^9.1.0",
     "eslint-config-turbo": "^1.13.4",
     "eslint-plugin-only-warn": "^1.1.0",

packages/shared/clickhouse/migrations/0001_traces.up.sql

@@ -15,12 +15,13 @@ CREATE TABLE traces (
     `session_id` Nullable(String),
     `created_at` DateTime64(3) DEFAULT now(),
     `updated_at` DateTime64(3) DEFAULT now(),
+    event_ts DateTime64(3),
     INDEX idx_id id TYPE bloom_filter(0.001) GRANULARITY 1,
     INDEX idx_res_metadata_key mapKeys(metadata) TYPE bloom_filter(0.01) GRANULARITY 1,
     INDEX idx_res_metadata_value mapValues(metadata) TYPE bloom_filter(0.01) GRANULARITY 1
 ) ENGINE = ReplacingMergeTree Partition by toYYYYMM(timestamp)
 ORDER BY (
         project_id,
-        toUnixTimestamp(timestamp),
+        toDate(timestamp),
         id
-    );
+    );

packages/shared/clickhouse/migrations/0002_observations.up.sql

@@ -35,6 +35,7 @@ CREATE TABLE observations (
     `prompt_version` Nullable(UInt16),
     `created_at` DateTime64(3) DEFAULT now(),
     `updated_at` DateTime64(3) DEFAULT now(),
+    event_ts DateTime64(3),
     INDEX idx_id id TYPE bloom_filter() GRANULARITY 1,
     INDEX idx_trace_id trace_id TYPE bloom_filter() GRANULARITY 1,
     INDEX idx_project_id project_id TYPE bloom_filter() GRANULARITY 1,
@@ -44,7 +45,7 @@ CREATE TABLE observations (
 ORDER BY (
         project_id,
         `type`,
-        trace_id,
-        toUnixTimestamp(start_time),
+        toDate(start_time),
         id
-    );
+    );
+

packages/shared/clickhouse/migrations/0003_scores.up.sql

@@ -14,12 +14,13 @@ CREATE TABLE scores (
     `string_value` Nullable(String),
     `created_at` DateTime64(3) DEFAULT now(),
     `updated_at` DateTime64(3) DEFAULT now(),
+    event_ts DateTime64(3),
     INDEX idx_id id TYPE bloom_filter(0.001) GRANULARITY 1,
-    INDEX idx_project_id trace_id TYPE bloom_filter(0.001) GRANULARITY 1
+    INDEX idx_project_trace_observation (project_id, trace_id, observation_id) TYPE bloom_filter(0.001) GRANULARITY 1
 ) ENGINE = ReplacingMergeTree Partition by toYYYYMM(timestamp)
 ORDER BY (
         project_id,
-        trace_id,
-        toUnixTimestamp(timestamp),
+        toDate(timestamp),
+        name,
         id
-    );
+    )

packages/shared/clickhouse/migrations/0004_observations_wide.down.sql

@@ -0,0 +1,3 @@
+DROP TABLE IF EXISTS mv_observations_to_observations_wide;
+DROP TABLE IF EXISTS mv_traces_to_observations_wide;
+DROP TABLE IF EXISTS observations_wide;

packages/shared/clickhouse/migrations/0004_observations_wide.up.sql

@@ -0,0 +1,175 @@
+CREATE TABLE observations_wide
+(
+    `id` String,
+    trace_id Nullable(String),
+    `name` Nullable(String),
+    `project_id` String,
+    `user_id` Nullable(String),
+    `metadata` Map(String, String),
+    `release` Nullable(String),
+    `version` Nullable(String),
+    `public` Bool,
+    `bookmarked` Bool,
+    `tags` Array(String),
+    `input` Nullable(String),
+    `output` Nullable(String),
+    `session_id` Nullable(String),
+    `created_at` DateTime64(3),
+    `updated_at` DateTime64(3),
+    event_ts DateTime64(3),
+    `type` LowCardinality(String),
+    `parent_observation_id` Nullable(String),
+    `start_time` DateTime64(3),
+    `end_time` Nullable(DateTime64(3)),
+    `level` LowCardinality(String),
+    `status_message` Nullable(String),
+    `provided_model_name` Nullable(String),
+    `internal_model_id` Nullable(String),
+    `model_parameters` Nullable(String),
+    `provided_input_usage_units` Nullable(Decimal64(12)),
+    `provided_output_usage_units` Nullable(Decimal64(12)),
+    `provided_total_usage_units` Nullable(Decimal64(12)),
+    `input_usage_units` Nullable(Decimal64(12)),
+    `output_usage_units` Nullable(Decimal64(12)),
+    `total_usage_units` Nullable(Decimal64(12)),
+    `unit` Nullable(String),
+    `provided_input_cost` Nullable(Decimal64(12)),
+    `provided_output_cost` Nullable(Decimal64(12)),
+    `provided_total_cost` Nullable(Decimal64(12)),
+    `input_cost` Nullable(Decimal64(12)),
+    `output_cost` Nullable(Decimal64(12)),
+    `total_cost` Nullable(Decimal64(12)),
+    `completion_start_time` Nullable(DateTime64(3)),
+    `prompt_id` Nullable(String),
+    `prompt_name` Nullable(String),
+    `prompt_version` Nullable(UInt16),
+    trace_timestamp DateTime64(3),
+    trace_name String,
+    trace_user_id Nullable(String),
+    trace_metadata Map(String, String),
+    trace_release Nullable(String),
+    trace_version Nullable(String),
+    trace_public Bool,
+    trace_bookmarked Bool,
+    trace_tags Array(String),
+    trace_input Nullable(String),
+    trace_output Nullable(String),
+    trace_session_id Nullable(String),
+    trace_event_ts DateTime64(3)
+) ENGINE = ReplacingMergeTree Partition by toYYYYMM(start_time)
+ORDER BY (
+        project_id,
+        `type`,
+        toDate(start_time),
+        id
+    );
+
+CREATE MATERIALIZED VIEW mv_traces_to_observations_wide TO observations_wide AS
+SELECT 
+    argMax(t.`name`, o.event_ts) as trace_name,
+    argMax(t.timestamp, o.event_ts) as trace_timestamp,
+    argMax(t.user_id, o.event_ts) as trace_user_id,
+    argMax(t.metadata, o.event_ts) as trace_metadata,
+    argMax(t.release, o.event_ts) as trace_release,
+    argMax(t.version, o.event_ts) as trace_version,
+    argMax(t.project_id, o.event_ts) as trace_project_id,
+    argMax(t.public, o.event_ts) as trace_public,
+    argMax(t.bookmarked, o.event_ts) as trace_bookmarked,
+    argMax(t.tags, o.event_ts) as trace_tags,
+    argMax(t.input, o.event_ts) as trace_input,
+    argMax(t.output, o.event_ts) as trace_output,
+    argMax(t.session_id, o.event_ts) as trace_session_id,
+    argMax(t.event_ts, o.event_ts) as trace_event_ts,
+    o.id as id,
+    argMax(o.trace_id, o.event_ts) as trace_id,
+    argMax(o.name, o.event_ts) as `name`,
+    o.project_id as project_id,
+    argMax(o.metadata, o.event_ts) as metadata,
+    argMax(o.type, o.event_ts) as type,
+    argMax(o.parent_observation_id, o.event_ts) as parent_observation_id,
+    argMax(o.start_time, o.event_ts) as start_time,
+    argMax(o.end_time, o.event_ts) as end_time,
+    argMax(o.level, o.event_ts) as level,
+    argMax(o.status_message, o.event_ts) as status_message,
+    argMax(o.provided_model_name, o.event_ts) as provided_model_name,
+    argMax(o.internal_model_id, o.event_ts) as internal_model_id,
+    argMax(o.model_parameters, o.event_ts) as model_parameters,
+    argMax(o.provided_input_usage_units, o.event_ts) as provided_input_usage_units,
+    argMax(o.provided_output_usage_units, o.event_ts) as provided_output_usage_units,
+    argMax(o.provided_total_usage_units, o.event_ts) as provided_total_usage_units,
+    argMax(o.input_usage_units, o.event_ts) as input_usage_units,
+    argMax(o.output_usage_units, o.event_ts) as output_usage_units,
+    argMax(o.total_usage_units, o.event_ts) as total_usage_units,
+    argMax(o.unit, o.event_ts) as unit,
+    argMax(o.provided_input_cost, o.event_ts) as provided_input_cost,
+    argMax(o.provided_output_cost, o.event_ts) as provided_output_cost,
+    argMax(o.provided_total_cost, o.event_ts) as provided_total_cost,
+    argMax(o.input_cost, o.event_ts) as input_cost,
+    argMax(o.output_cost, o.event_ts) as output_cost,
+    argMax(o.total_cost, o.event_ts) as total_cost,
+    argMax(o.completion_start_time, o.event_ts) as completion_start_time,
+    argMax(o.prompt_id, o.event_ts) as prompt_id,
+    argMax(o.prompt_name, o.event_ts) as prompt_name,
+    argMax(o.prompt_version, o.event_ts) as prompt_version,
+    argMax(o.created_at, o.event_ts) as created_at,
+    argMax(o.updated_at, o.event_ts) as updated_at,
+    argMax(o.event_ts, o.event_ts) as event_ts
+FROM traces t
+INNER JOIN observations o ON t.id = o.trace_id
+GROUP BY o.id, o.project_id;
+
+CREATE MATERIALIZED VIEW mv_observations_to_observations_wide TO observations_wide AS
+SELECT 
+  argMax(t.timestamp, o.event_ts) as trace_timestamp,
+    argMax(t.name, o.event_ts) as trace_name,
+    argMax(t.user_id, o.event_ts) as trace_user_id,
+    argMax(t.metadata, o.event_ts) as trace_metadata,
+    argMax(t.release, o.event_ts) as trace_release,
+    argMax(t.version, o.event_ts) as trace_version,
+    argMax(t.project_id, o.event_ts) as trace_project_id,
+    argMax(t.public, o.event_ts) as trace_public,
+    argMax(t.bookmarked, o.event_ts) as trace_bookmarked,
+    argMax(t.tags, o.event_ts) as trace_tags,
+    argMax(t.input, o.event_ts) as trace_input,
+    argMax(t.output, o.event_ts) as trace_output,
+    argMax(t.session_id, o.event_ts) as trace_session_id,
+    argMax(t.event_ts, o.event_ts) as trace_event_ts,
+    o.id as id,
+    argMax(o.trace_id, o.event_ts) as trace_id,
+    argMax(o.name, o.event_ts) as name,
+    o.project_id as project_id,
+    argMax(o.metadata, o.event_ts) as metadata,
+    argMax(o.type, o.event_ts) as type,
+    argMax(o.parent_observation_id, o.event_ts) as parent_observation_id,
+    argMax(o.start_time, o.event_ts) as start_time,
+    argMax(o.end_time, o.event_ts) as end_time,
+    argMax(o.level, o.event_ts) as level,
+    argMax(o.status_message, o.event_ts) as status_message,
+    argMax(o.provided_model_name, o.event_ts) as provided_model_name,
+    argMax(o.internal_model_id, o.event_ts) as internal_model_id,
+    argMax(o.model_parameters, o.event_ts) as model_parameters,
+    argMax(o.provided_input_usage_units, o.event_ts) as provided_input_usage_units,
+    argMax(o.provided_output_usage_units, o.event_ts) as provided_output_usage_units,
+    argMax(o.provided_total_usage_units, o.event_ts) as provided_total_usage_units,
+    argMax(o.input_usage_units, o.event_ts) as input_usage_units,
+    argMax(o.output_usage_units, o.event_ts) as output_usage_units,
+    argMax(o.total_usage_units, o.event_ts) as total_usage_units,
+    argMax(o.unit, o.event_ts) as unit,
+    argMax(o.provided_input_cost, o.event_ts) as provided_input_cost,
+    argMax(o.provided_output_cost, o.event_ts) as provided_output_cost,
+    argMax(o.provided_total_cost, o.event_ts) as provided_total_cost,
+    argMax(o.input_cost, o.event_ts) as input_cost,
+    argMax(o.output_cost, o.event_ts) as output_cost,
+    argMax(o.total_cost, o.event_ts) as total_cost,
+    argMax(o.completion_start_time, o.event_ts) as completion_start_time,
+    argMax(o.prompt_id, o.event_ts) as prompt_id,
+    argMax(o.prompt_name, o.event_ts) as prompt_name,
+    argMax(o.prompt_version, o.event_ts) as prompt_version,
+    argMax(o.created_at, o.event_ts) as created_at,
+    argMax(o.updated_at, o.event_ts) as updated_at,
+    argMax(o.event_ts, o.event_ts) as event_ts
+FROM observations o
+LEFT OUTER JOIN traces t ON t.id = o.trace_id
+GROUP BY o.id, o.project_id;
+
+

packages/shared/clickhouse/migrations/0005_traces_wide.down.sql

@@ -0,0 +1,3 @@
+DROP TABLE IF EXISTS mv_observations_to_traces_wide;
+DROP TABLE IF EXISTS mv_traces_to_traces_wide;
+DROP TABLE IF EXISTS traces_wide;

packages/shared/clickhouse/migrations/0005_traces_wide.up.sql

@@ -0,0 +1,172 @@
+CREATE TABLE traces_wide
+(
+    `id` String,
+    trace_id Nullable(String),
+    `name` Nullable(String),
+    `project_id` String,
+    `user_id` Nullable(String),
+    `metadata` Map(String, String),
+    `release` Nullable(String),
+    `version` Nullable(String),
+    `public` Bool,
+    `bookmarked` Bool,
+    `tags` Array(String),
+    `input` Nullable(String),
+    `output` Nullable(String),
+    `session_id` Nullable(String),
+    `created_at` DateTime64(3),
+    `updated_at` DateTime64(3),
+    event_ts DateTime64(3),
+    `type` LowCardinality(String),
+    `parent_observation_id` Nullable(String),
+    `start_time` DateTime64(3),
+    `end_time` Nullable(DateTime64(3)),
+    `level` LowCardinality(String),
+    `status_message` Nullable(String),
+    `provided_model_name` Nullable(String),
+    `internal_model_id` Nullable(String),
+    `model_parameters` Nullable(String),
+    `provided_input_usage_units` Nullable(Decimal64(12)),
+    `provided_output_usage_units` Nullable(Decimal64(12)),
+    `provided_total_usage_units` Nullable(Decimal64(12)),
+    `input_usage_units` Nullable(Decimal64(12)),
+    `output_usage_units` Nullable(Decimal64(12)),
+    `total_usage_units` Nullable(Decimal64(12)),
+    `unit` Nullable(String),
+    `provided_input_cost` Nullable(Decimal64(12)),
+    `provided_output_cost` Nullable(Decimal64(12)),
+    `provided_total_cost` Nullable(Decimal64(12)),
+    `input_cost` Nullable(Decimal64(12)),
+    `output_cost` Nullable(Decimal64(12)),
+    `total_cost` Nullable(Decimal64(12)),
+    `completion_start_time` Nullable(DateTime64(3)),
+    `prompt_id` Nullable(String),
+    `prompt_name` Nullable(String),
+    `prompt_version` Nullable(UInt16),
+    trace_timestamp DateTime64(3),
+    trace_name String,
+    trace_user_id Nullable(String),
+    trace_metadata Map(String, String),
+    trace_release Nullable(String),
+    trace_version Nullable(String),
+    trace_public Bool,
+    trace_bookmarked Bool,
+    trace_tags Array(String),
+    trace_input Nullable(String),
+    trace_output Nullable(String),
+    trace_session_id Nullable(String),
+    trace_event_ts DateTime64(3)
+) ENGINE = ReplacingMergeTree Partition by toYYYYMM(start_time)
+ORDER BY (
+        project_id,
+        `type`,
+        toDate(start_time),
+        id
+    );
+
+CREATE MATERIALIZED VIEW mv_traces_to_traces_wide TO traces_wide AS
+SELECT 
+    argMax(t.`name`, t.event_ts) as trace_name,
+    argMax(t.timestamp, t.event_ts) as trace_timestamp,
+    argMax(t.user_id, t.event_ts) as trace_user_id,
+    argMax(t.metadata, t.event_ts) as trace_metadata,
+    argMax(t.release, t.event_ts) as trace_release,
+    argMax(t.version, t.event_ts) as trace_version,
+    argMax(t.public, t.event_ts) as trace_public,
+    argMax(t.bookmarked, t.event_ts) as trace_bookmarked,
+    argMax(t.tags, t.event_ts) as trace_tags,
+    argMax(t.input, t.event_ts) as trace_input,
+    argMax(t.output, t.event_ts) as trace_output,
+    argMax(t.session_id, t.event_ts) as trace_session_id,
+    argMax(t.event_ts, t.event_ts) as trace_event_ts,
+    o.id as id,
+    argMax(o.trace_id, t.event_ts) as trace_id,
+    argMax(o.name, t.event_ts) as `name`,
+    o.project_id as project_id,
+    argMax(o.metadata, t.event_ts) as metadata,
+    argMax(o.type, t.event_ts) as type,
+    argMax(o.parent_observation_id, t.event_ts) as parent_observation_id,
+    argMax(o.start_time, t.event_ts) as start_time,
+    argMax(o.end_time, t.event_ts) as end_time,
+    argMax(o.level, t.event_ts) as level,
+    argMax(o.status_message, t.event_ts) as status_message,
+    argMax(o.provided_model_name, t.event_ts) as provided_model_name,
+    argMax(o.internal_model_id, t.event_ts) as internal_model_id,
+    argMax(o.model_parameters, t.event_ts) as model_parameters,
+    argMax(o.provided_input_usage_units, t.event_ts) as provided_input_usage_units,
+    argMax(o.provided_output_usage_units, t.event_ts) as provided_output_usage_units,
+    argMax(o.provided_total_usage_units, t.event_ts) as provided_total_usage_units,
+    argMax(o.input_usage_units, t.event_ts) as input_usage_units,
+    argMax(o.output_usage_units, t.event_ts) as output_usage_units,
+    argMax(o.total_usage_units, t.event_ts) as total_usage_units,
+    argMax(o.unit, t.event_ts) as unit,
+    argMax(o.provided_input_cost, t.event_ts) as provided_input_cost,
+    argMax(o.provided_output_cost, t.event_ts) as provided_output_cost,
+    argMax(o.provided_total_cost, t.event_ts) as provided_total_cost,
+    argMax(o.input_cost, t.event_ts) as input_cost,
+    argMax(o.output_cost, t.event_ts) as output_cost,
+    argMax(o.total_cost, t.event_ts) as total_cost,
+    argMax(o.completion_start_time, t.event_ts) as completion_start_time,
+    argMax(o.prompt_id, t.event_ts) as prompt_id,
+    argMax(o.prompt_name, t.event_ts) as prompt_name,
+    argMax(o.prompt_version, t.event_ts) as prompt_version,
+    argMax(o.created_at, t.event_ts) as created_at,
+    argMax(o.updated_at, t.event_ts) as updated_at,
+    argMax(o.event_ts, t.event_ts) as event_ts
+FROM traces t
+LEFT JOIN observations o ON t.id = o.trace_id
+GROUP BY o.id, o.project_id;
+
+CREATE MATERIALIZED VIEW mv_observations_to_traces_wide TO traces_wide AS
+SELECT 
+    argMax(t.timestamp, o.event_ts) as trace_timestamp,
+    argMax(t.name, o.event_ts) as trace_name,
+    argMax(t.user_id, o.event_ts) as trace_user_id,
+    argMax(t.metadata, o.event_ts) as trace_metadata,
+    argMax(t.release, o.event_ts) as trace_release,
+    argMax(t.version, o.event_ts) as trace_version,
+    argMax(t.public, o.event_ts) as trace_public,
+    argMax(t.bookmarked, o.event_ts) as trace_bookmarked,
+    argMax(t.tags, o.event_ts) as trace_tags,
+    argMax(t.input, o.event_ts) as trace_input,
+    argMax(t.output, o.event_ts) as trace_output,
+    argMax(t.session_id, o.event_ts) as trace_session_id,
+    argMax(t.event_ts, o.event_ts) as trace_event_ts,
+    o.id as id,
+    argMax(o.trace_id, o.event_ts) as trace_id,
+    argMax(o.name, o.event_ts) as name,
+    o.project_id as project_id,
+    argMax(o.metadata, o.event_ts) as metadata,
+    argMax(o.type, o.event_ts) as type,
+    argMax(o.parent_observation_id, o.event_ts) as parent_observation_id,
+    argMax(o.start_time, o.event_ts) as start_time,
+    argMax(o.end_time, o.event_ts) as end_time,
+    argMax(o.level, o.event_ts) as level,
+    argMax(o.status_message, o.event_ts) as status_message,
+    argMax(o.provided_model_name, o.event_ts) as provided_model_name,
+    argMax(o.internal_model_id, o.event_ts) as internal_model_id,
+    argMax(o.model_parameters, o.event_ts) as model_parameters,
+    argMax(o.provided_input_usage_units, o.event_ts) as provided_input_usage_units,
+    argMax(o.provided_output_usage_units, o.event_ts) as provided_output_usage_units,
+    argMax(o.provided_total_usage_units, o.event_ts) as provided_total_usage_units,
+    argMax(o.input_usage_units, o.event_ts) as input_usage_units,
+    argMax(o.output_usage_units, o.event_ts) as output_usage_units,
+    argMax(o.total_usage_units, o.event_ts) as total_usage_units,
+    argMax(o.unit, o.event_ts) as unit,
+    argMax(o.provided_input_cost, o.event_ts) as provided_input_cost,
+    argMax(o.provided_output_cost, o.event_ts) as provided_output_cost,
+    argMax(o.provided_total_cost, o.event_ts) as provided_total_cost,
+    argMax(o.input_cost, o.event_ts) as input_cost,
+    argMax(o.output_cost, o.event_ts) as output_cost,
+    argMax(o.total_cost, o.event_ts) as total_cost,
+    argMax(o.completion_start_time, o.event_ts) as completion_start_time,
+    argMax(o.prompt_id, o.event_ts) as prompt_id,
+    argMax(o.prompt_name, o.event_ts) as prompt_name,
+    argMax(o.prompt_version, o.event_ts) as prompt_version,
+    argMax(o.created_at, o.event_ts) as created_at,
+    argMax(o.updated_at, o.event_ts) as updated_at,
+    argMax(o.event_ts, o.event_ts) as event_ts
+FROM observations o
+INNER JOIN traces t ON t.id = o.trace_id
+WHERE t.id IS NOT NULL
+GROUP BY o.id, o.project_id;

packages/shared/clickhouse/scripts/seed.ts

@@ -0,0 +1,28 @@
+import { clickhouseClient } from "@langfuse/shared/src/server";
+import { prisma } from "../../src/db";
+import { redis } from "@langfuse/shared/src/server";
+import { prepareClickhouse } from "../../scripts/prepareClickhouse";
+
+async function main() {
+  try {
+    const projectIds = [
+      "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a",
+      "239ad00f-562f-411d-af14-831c75ddd875",
+    ]; // Example project IDs
+    await prepareClickhouse(projectIds, {
+      numberOfDays: 3,
+      totalObservations: 1000,
+    });
+
+    console.log("Clickhouse preparation completed successfully.");
+  } catch (error) {
+    console.error("Error during Clickhouse preparation:", error);
+  } finally {
+    await clickhouseClient.close();
+    await prisma.$disconnect();
+    redis?.disconnect();
+    console.log("Disconnected from Clickhouse.");
+  }
+}
+
+main();

packages/shared/package.json

@@ -21,6 +21,10 @@
       "import": "./dist/src/server/index.js",
       "require": "./dist/src/server/index.js"
     },
+    "./src/server/auth/apiKeys": {
+      "import": "./dist/src/server/auth/apiKeys.js",
+      "require": "./dist/src/server/auth/apiKeys.js"
+    },
     "./encryption": {
       "import": "./dist/src/encryption/index.js",
       "require": "./dist/src/encryption/index.js"
@@ -43,67 +47,79 @@
     "ch:up": "bash clickhouse/scripts/up.sh",
     "ch:down": "bash clickhouse/scripts/down.sh",
     "ch:drop": "bash clickhouse/scripts/drop.sh",
-    "ch:reset": "pnpm run ch:down && pnpm run ch:up"
+    "ch:reset": "pnpm run ch:down && pnpm run ch:up && pnpm run ch:seed",
+    "ch:seed": "dotenv -e ../../.env -- tsx clickhouse/scripts/seed.ts",
+    "load:setup": "dotenv -e ../../.env -- tsx scripts/load-seed.ts"
   },
   "prisma": {
     "seed": "ts-node -r tsconfig-paths/register -r dotenv/config --compiler-options {\"module\":\"CommonJS\"} prisma/seed.ts"
   },
   "dependencies": {
     "@anthropic-ai/tokenizer": "^0.0.4",
-    "@aws-sdk/client-s3": "^3.627.0",
-    "@aws-sdk/lib-storage": "^3.568.0",
-    "@aws-sdk/s3-request-presigner": "^3.554.0",
+    "@aws-sdk/client-cloudwatch": "^3.675.0",
+    "@aws-sdk/client-s3": "^3.675.0",
+    "@aws-sdk/lib-storage": "^3.675.0",
+    "@aws-sdk/s3-request-presigner": "^3.675.0",
     "@clickhouse/client": "^1.4.0",
-    "@langchain/anthropic": "^0.1.21",
-    "@langchain/core": "^0.1.61",
-    "@langchain/openai": "^0.0.33",
-    "@opentelemetry/api": ">=1.0.0 <1.9.0",
-    "@prisma/client": "^5.17.0",
+    "@langchain/anthropic": "^0.3.1",
+    "@langchain/aws": "^0.1.0",
+    "@langchain/core": "^0.3.9",
+    "@langchain/openai": "^0.3.0",
+    "@opentelemetry/api": ">=1.0.0 <1.10.0",
+    "@prisma/client": "^5.20.0",
     "@react-email/components": "^0.0.19",
     "@react-email/render": "^0.0.15",
     "@types/bcryptjs": "^2.4.6",
+    "axios": "^1.7.7",
     "bcryptjs": "^2.4.3",
     "bullmq": "^5.12.10",
-    "dd-trace": "^5.19.0",
+    "dd-trace": "^5.23.1",
     "decimal.js": "^10.4.3",
     "exponential-backoff": "^3.1.1",
     "ioredis": "^5.4.1",
     "kysely": "^0.27.4",
-    "langchain": "^0.2.6",
+    "langchain": "^0.3.2",
     "lodash": "^4.17.21",
     "next-auth": "^4.24.7",
-    "nodemailer": "^6.9.13",
+    "nodemailer": "^6.9.15",
     "prisma-extension-kysely": "^2.1.0",
     "uuid": "^9.0.1",
+    "winston": "^3.14.2",
     "zod": "^3.23.8",
     "zod-to-json-schema": "^3.23.2"
   },
   "devDependencies": {
     "@repo/eslint-config": "workspace:*",
     "@repo/typescript-config": "workspace:*",
-    "@types/lodash": "^4.17.7",
+    "@types/lodash": "^4.17.10",
     "@types/node": "^20.11.29",
-    "@types/nodemailer": "^6.4.15",
-    "@types/pg": "^8.11.6",
+    "@types/nodemailer": "^6.4.16",
+    "@types/pg": "^8.11.10",
     "@types/uuid": "^9.0.8",
     "@typescript-eslint/parser": "^7.12.0",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-config-standard": "^17.1.0",
     "eslint-plugin-prettier": "^5.1.3",
-    "kysely-codegen": "^0.11.0",
-    "nodemon": "^3.1.3",
-    "prettier": "^3.2.5",
-    "prisma": "^5.17.0",
+    "kysely-codegen": "^0.16.8",
+    "nodemon": "^3.1.7",
+    "prettier": "^3.3.3",
+    "prisma": "^5.20.0",
     "prisma-erd-generator": "^1.11.2",
     "prisma-kysely": "^1.8.0",
     "ts-node": "^10.9.2",
     "tsc-watch": "^6.2.0",
+    "tsx": "^4.19.1",
     "typescript": "^5.4.5",
-    "vitest": "^1.5.3"
+    "vitest": "^2.1.2"
   },
   "peerDependencies": {
-    "@types/react": "^18.2.79",
-    "react": "^18.0.0"
+    "@types/react": "~18.2.79",
+    "react": "~18.2.0"
+  },
+  "pnpm": {
+    "overrides": {
+      "jsonpath-plus": "10.0.0"
+    }
   }
 }

packages/shared/prettierrc.json

@@ -1,4 +0,0 @@
-{
-  "trailingComma": "es5",
-  "printWidth": 120
-}

packages/shared/prisma/generated/types.ts

@@ -37,6 +37,16 @@ export const ScoreDataType = {
     BOOLEAN: "BOOLEAN"
 } as const;
 export type ScoreDataType = (typeof ScoreDataType)[keyof typeof ScoreDataType];
+export const AnnotationQueueStatus = {
+    PENDING: "PENDING",
+    COMPLETED: "COMPLETED"
+} as const;
+export type AnnotationQueueStatus = (typeof AnnotationQueueStatus)[keyof typeof AnnotationQueueStatus];
+export const AnnotationQueueObjectType = {
+    TRACE: "TRACE",
+    OBSERVATION: "OBSERVATION"
+} as const;
+export type AnnotationQueueObjectType = (typeof AnnotationQueueObjectType)[keyof typeof AnnotationQueueObjectType];
 export const DatasetStatus = {
     ACTIVE: "ACTIVE",
     ARCHIVED: "ARCHIVED"
@@ -80,6 +90,31 @@ export type Account = {
     scope: string | null;
     id_token: string | null;
     session_state: string | null;
+    refresh_token_expires_in: number | null;
+    created_at: number | null;
+};
+export type AnnotationQueue = {
+    id: string;
+    name: string;
+    description: string | null;
+    score_config_ids: Generated<string[]>;
+    project_id: string;
+    created_at: Generated<Timestamp>;
+    updated_at: Generated<Timestamp>;
+};
+export type AnnotationQueueItem = {
+    id: string;
+    queue_id: string;
+    object_id: string;
+    object_type: AnnotationQueueObjectType;
+    status: Generated<AnnotationQueueStatus>;
+    locked_at: Timestamp | null;
+    locked_by_user_id: string | null;
+    annotator_user_id: string | null;
+    completed_at: Timestamp | null;
+    project_id: string;
+    created_at: Generated<Timestamp>;
+    updated_at: Generated<Timestamp>;
 };
 export type ApiKey = {
     id: string;
@@ -244,6 +279,7 @@ export type LlmApiKeys = {
     base_url: string | null;
     custom_models: Generated<string[]>;
     with_default_models: Generated<boolean>;
+    config: unknown | null;
     project_id: string;
 };
 export type MembershipInvitation = {
@@ -409,6 +445,7 @@ export type Score = {
     observation_id: string | null;
     config_id: string | null;
     string_value: string | null;
+    queue_id: string | null;
     created_at: Generated<Timestamp>;
     updated_at: Generated<Timestamp>;
     data_type: Generated<ScoreDataType>;
@@ -505,6 +542,8 @@ export type VerificationToken = {
 };
 export type DB = {
     Account: Account;
+    annotation_queue_items: AnnotationQueueItem;
+    annotation_queues: AnnotationQueue;
     api_keys: ApiKey;
     audit_logs: AuditLog;
     batch_exports: BatchExport;

packages/shared/prisma/migrations/20240913095558_models_add_openai_o1_2024-09-12/migration.sql

@@ -0,0 +1,30 @@
+-- For OpenAI reasoning models, manually tokenizing output string does not account for reasoning tokens, thus would lead to incorrect cost
+-- So no manual tokenizer config is provided
+-- Reference: https://platform.openai.com/docs/guides/reasoning/how-reasoning-works
+
+INSERT INTO models (
+  id,
+  project_id,
+  model_name,
+  match_pattern,
+  start_date,
+  input_price,
+  output_price,
+  total_price,
+  unit,
+  tokenizer_id,
+  tokenizer_config
+)
+VALUES
+  -- o1-preview
+  ('cm10ivcdp0000gix7lelmbw80', NULL, 'o1-preview', '(?i)^(o1-preview)$', NULL, 0.000015, 0.00006, NULL, 'TOKENS', NULL, NULL), 
+
+  -- o1-preview-2024-09-12
+  ('cm10ivo130000n8x7qopcjjcg', NULL, 'o1-preview-2024-09-12', '(?i)^(o1-preview-2024-09-12)$', NULL, 0.000015, 0.00006, NULL, 'TOKENS', NULL, NULL), 
+
+  -- o1-mini
+  ('cm10ivwo40000r1x7gg3syjq0', NULL, 'o1-mini', '(?i)^(o1-mini)$', NULL, 0.000003, 0.000012, NULL, 'TOKENS', NULL, NULL), 
+
+  -- o1-mini-2024-09-12
+  ('cm10iw6p20000wgx7it1hlb22', NULL, 'o1-mini-2024-09-12', '(?i)^(o1-mini-2024-09-12)$', NULL, 0.000003, 0.000012, NULL, 'TOKENS', NULL, NULL) 
+

packages/shared/prisma/migrations/20240913185822_account_add_refresh_token_expires_in/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "Account" ADD COLUMN     "refresh_token_expires_in" INTEGER;

packages/shared/prisma/migrations/20240917183001_remove_covered_indexes_01/migration.sql

@@ -0,0 +1,3 @@
+-- DropIndex
+-- Removes indexes that are covered by other indexes on the same table, e.g. (project_id) if (project_id, timestamp) exists.
+DROP INDEX CONCURRENTLY IF EXISTS "traces_project_id_idx"; -- covered by traces_project_id_timestamp_idx

packages/shared/prisma/migrations/20240917183002_remove_covered_indexes_02/migration.sql

@@ -0,0 +1,3 @@
+-- DropIndex
+-- Removes indexes that are covered by other indexes on the same table, e.g. (project_id) if (project_id, timestamp) exists.
+DROP INDEX CONCURRENTLY IF EXISTS "datasets_project_id_idx"; -- covered by datasets_project_id_name_key (unique)

packages/shared/prisma/migrations/20240917183003_remove_covered_indexes_03/migration.sql

@@ -0,0 +1,3 @@
+-- DropIndex
+-- Removes indexes that are covered by other indexes on the same table, e.g. (project_id) if (project_id, timestamp) exists.
+DROP INDEX CONCURRENTLY IF EXISTS "eval_templates_project_id_idx"; -- covered by eval_templates_project_id_id_idx

packages/shared/prisma/migrations/20240917183004_remove_covered_indexes_04/migration.sql

@@ -0,0 +1,3 @@
+-- DropIndex
+-- Removes indexes that are covered by other indexes on the same table, e.g. (project_id) if (project_id, timestamp) exists.
+DROP INDEX CONCURRENTLY IF EXISTS "job_configurations_project_id_idx"; -- covered by job_configurations_project_id_id_idx

packages/shared/prisma/migrations/20240917183005_remove_covered_indexes_05/migration.sql

@@ -0,0 +1,3 @@
+-- DropIndex
+-- Removes indexes that are covered by other indexes on the same table, e.g. (project_id) if (project_id, timestamp) exists.
+DROP INDEX CONCURRENTLY IF EXISTS "job_executions_project_id_idx"; -- covered by job_executions_project_id_id_idx

packages/shared/prisma/migrations/20240917183006_remove_covered_indexes_06/migration.sql

@@ -0,0 +1,3 @@
+-- DropIndex
+-- Removes indexes that are covered by other indexes on the same table, e.g. (project_id) if (project_id, timestamp) exists.
+DROP INDEX CONCURRENTLY IF EXISTS "llm_api_keys_project_id_provider_idx"; -- covered by llm_api_keys_project_id_provider_key (unique)

packages/shared/prisma/migrations/20240917183007_remove_covered_indexes_07/migration.sql

@@ -0,0 +1,3 @@
+-- DropIndex
+-- Removes indexes that are covered by other indexes on the same table, e.g. (project_id) if (project_id, timestamp) exists.
+DROP INDEX CONCURRENTLY IF EXISTS "models_project_id_model_name_idx"; -- covered by models_project_id_model_name_start_date_unit_key (unique)

packages/shared/prisma/migrations/20240917183008_remove_covered_indexes_08/migration.sql

@@ -0,0 +1,3 @@
+-- DropIndex
+-- Removes indexes that are covered by other indexes on the same table, e.g. (project_id) if (project_id, timestamp) exists.
+DROP INDEX CONCURRENTLY IF EXISTS "models_project_id_model_name_start_date_unit_idx"; -- covered by models_project_id_model_name_start_date_unit_key (unique)

packages/shared/prisma/migrations/20240917183009_remove_covered_indexes_09/migration.sql

@@ -0,0 +1,3 @@
+-- DropIndex
+-- Removes indexes that are covered by other indexes on the same table, e.g. (project_id) if (project_id, timestamp) exists.
+DROP INDEX CONCURRENTLY IF EXISTS "observations_project_id_idx"; -- covered by observations_project_id_start_time_type_idx

packages/shared/prisma/migrations/20240917183010_remove_covered_indexes_10/migration.sql

@@ -0,0 +1,3 @@
+-- DropIndex
+-- Removes indexes that are covered by other indexes on the same table, e.g. (project_id) if (project_id, timestamp) exists.
+DROP INDEX CONCURRENTLY IF EXISTS "observations_trace_id_idx"; -- covered by observations_trace_id_project_id_start_time_idx

packages/shared/prisma/migrations/20240917183011_remove_covered_indexes_11/migration.sql

@@ -0,0 +1,3 @@
+-- DropIndex
+-- Removes indexes that are covered by other indexes on the same table, e.g. (project_id) if (project_id, timestamp) exists.
+DROP INDEX CONCURRENTLY IF EXISTS "observations_trace_id_project_id_idx"; -- covered by observations_trace_id_project_id_start_time_idx

packages/shared/prisma/migrations/20240917183012_remove_covered_indexes_12/migration.sql

@@ -0,0 +1,3 @@
+-- DropIndex
+-- Removes indexes that are covered by other indexes on the same table, e.g. (project_id) if (project_id, timestamp) exists.
+DROP INDEX CONCURRENTLY IF EXISTS "organization_memberships_org_id_idx"; -- covered by organization_memberships_org_id_user_id_key (unique)

packages/shared/prisma/migrations/20240917183013_remove_covered_indexes_13/migration.sql

@@ -0,0 +1,3 @@
+-- DropIndex
+-- Removes indexes that are covered by other indexes on the same table, e.g. (project_id) if (project_id, timestamp) exists.
+DROP INDEX CONCURRENTLY IF EXISTS "posthog_integrations_project_id_idx"; -- covered by posthog_integrations_pkey (unique)

packages/shared/prisma/migrations/20240917183014_remove_covered_indexes_14/migration.sql

@@ -0,0 +1,3 @@
+-- DropIndex
+-- Removes indexes that are covered by other indexes on the same table, e.g. (project_id) if (project_id, timestamp) exists.
+DROP INDEX CONCURRENTLY IF EXISTS "prompts_project_id_idx"; -- covered by prompts_project_id_name_version_key (unique)

packages/shared/prisma/migrations/20240917183015_remove_covered_indexes_15/migration.sql

@@ -0,0 +1,3 @@
+-- DropIndex
+-- Removes indexes that are covered by other indexes on the same table, e.g. (project_id) if (project_id, timestamp) exists.
+DROP INDEX CONCURRENTLY IF EXISTS "prompts_project_id_name_version_idx"; -- covered by prompts_project_id_name_version_key (unique)

packages/shared/prisma/migrations/20240917183016_remove_covered_indexes_16/migration.sql

@@ -0,0 +1,3 @@
+-- DropIndex
+-- Removes indexes that are covered by other indexes on the same table, e.g. (project_id) if (project_id, timestamp) exists.
+DROP INDEX CONCURRENTLY IF EXISTS "scores_project_id_idx"; -- covered by scores_project_id_name_idx

packages/shared/prisma/migrations/20241009042557_auth_add_created_at_for_gitlab/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "Account" ADD COLUMN     "created_at" INTEGER;

packages/shared/prisma/migrations/20241009110720_scores_add_nullable_queue_id_column/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "scores" ADD COLUMN     "queue_id" TEXT;

packages/shared/prisma/migrations/20241009113245_add_annotation_queue/migration.sql

@@ -0,0 +1,75 @@
+-- CreateEnum
+CREATE TYPE "AnnotationQueueStatus" AS ENUM ('PENDING', 'COMPLETED');
+
+-- CreateEnum
+CREATE TYPE "AnnotationQueueObjectType" AS ENUM ('TRACE', 'OBSERVATION');
+
+-- CreateTable
+CREATE TABLE "annotation_queues" (
+    "id" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "description" TEXT,
+    "score_config_ids" TEXT[] DEFAULT ARRAY[]::TEXT[],
+    "project_id" TEXT NOT NULL,
+    "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updated_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "annotation_queues_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "annotation_queue_items" (
+    "id" TEXT NOT NULL,
+    "queue_id" TEXT NOT NULL,
+    "object_id" TEXT NOT NULL,
+    "object_type" "AnnotationQueueObjectType" NOT NULL,
+    "status" "AnnotationQueueStatus" NOT NULL DEFAULT 'PENDING',
+    "locked_at" TIMESTAMP(3),
+    "locked_by_user_id" TEXT,
+    "annotator_user_id" TEXT,
+    "completed_at" TIMESTAMP(3),
+    "project_id" TEXT NOT NULL,
+    "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updated_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "annotation_queue_items_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "annotation_queues_id_project_id_idx" ON "annotation_queues"("id", "project_id");
+
+-- CreateIndex
+CREATE INDEX "annotation_queues_project_id_created_at_idx" ON "annotation_queues"("project_id", "created_at");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "annotation_queues_project_id_name_key" ON "annotation_queues"("project_id", "name");
+
+-- CreateIndex
+CREATE INDEX "annotation_queue_items_id_project_id_idx" ON "annotation_queue_items"("id", "project_id");
+
+-- CreateIndex
+CREATE INDEX "annotation_queue_items_project_id_queue_id_status_idx" ON "annotation_queue_items"("project_id", "queue_id", "status");
+
+-- CreateIndex
+CREATE INDEX "annotation_queue_items_object_id_object_type_project_id_que_idx" ON "annotation_queue_items"("object_id", "object_type", "project_id", "queue_id");
+
+-- CreateIndex
+CREATE INDEX "annotation_queue_items_annotator_user_id_idx" ON "annotation_queue_items"("annotator_user_id");
+
+-- CreateIndex
+CREATE INDEX "annotation_queue_items_created_at_idx" ON "annotation_queue_items"("created_at");
+
+-- AddForeignKey
+ALTER TABLE "annotation_queues" ADD CONSTRAINT "annotation_queues_project_id_fkey" FOREIGN KEY ("project_id") REFERENCES "projects"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "annotation_queue_items" ADD CONSTRAINT "annotation_queue_items_queue_id_fkey" FOREIGN KEY ("queue_id") REFERENCES "annotation_queues"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "annotation_queue_items" ADD CONSTRAINT "annotation_queue_items_locked_by_user_id_fkey" FOREIGN KEY ("locked_by_user_id") REFERENCES "users"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "annotation_queue_items" ADD CONSTRAINT "annotation_queue_items_annotator_user_id_fkey" FOREIGN KEY ("annotator_user_id") REFERENCES "users"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "annotation_queue_items" ADD CONSTRAINT "annotation_queue_items_project_id_fkey" FOREIGN KEY ("project_id") REFERENCES "projects"("id") ON DELETE CASCADE ON UPDATE CASCADE;

packages/shared/prisma/migrations/20241010120245_llm_keys_add_config/migration.sql

@@ -0,0 +1 @@
+ALTER TABLE "llm_api_keys" ADD COLUMN "config" JSONB;

packages/shared/prisma/migrations/20241015110145_prompts_config_to_JSON/migration.sql

@@ -0,0 +1,107 @@
+-- Temporarily drop observations_view as prompts.config is a calculated column in the view and we need to update it to a JSON type
+DROP VIEW IF EXISTS "observations_view"; -- Drop view as column was added in 20240705154048_observation_view_add_created_at_updated_at and update view must have same columns
+
+-- Update prompts.config to JSON type. Use JSON as JSONB is reordering keys for optimization, which is undesired
+ALTER TABLE prompts ALTER COLUMN config TYPE JSON USING config::JSON;
+ALTER TABLE prompts ALTER COLUMN config SET DEFAULT '{}'::JSON;
+
+-- Recreate the view with the updated prompts.config column
+CREATE VIEW "observations_view" AS -- Specify the columns that should be returned in the view, as calculated columns are added but exist in the observations table already
+SELECT
+    o.id,
+    o.name,
+    o.start_time,
+    o.end_time,
+    o.parent_observation_id,
+    o.type,
+    o.trace_id,
+    o.metadata,
+    o.model,
+    o."modelParameters",
+    o.input,
+    o.output,
+    o.level,
+    o.status_message,
+    o.completion_start_time,
+    o.completion_tokens,
+    o.prompt_tokens,
+    o.total_tokens,
+    o.version,
+    o.project_id,
+    o.created_at,
+    o.updated_at,
+    o.unit,
+    o.prompt_id,
+    p.name as prompt_name,         -- added in this change
+    p.version as prompt_version,   -- added in this change
+    o.input_cost,
+    o.output_cost,
+    o.total_cost,
+    o.internal_model,
+    m.id AS "model_id",
+    m.start_date AS "model_start_date",
+    m.input_price,
+    m.output_price,
+    m.total_price,
+    m.tokenizer_config AS "tokenizer_config",
+    CASE 
+        WHEN o.calculated_input_cost IS NULL AND o.input_cost IS NULL AND o.output_cost IS NULL AND o.total_cost IS NULL THEN
+            o.prompt_tokens::decimal * m.input_price
+        ELSE
+            COALESCE(o.calculated_input_cost, o.input_cost)
+    END AS "calculated_input_cost",
+    CASE 
+        WHEN o.calculated_output_cost IS NULL AND o.input_cost IS NULL AND o.output_cost IS NULL AND o.total_cost IS NULL THEN
+            o.completion_tokens::decimal * m.output_price
+        ELSE
+            COALESCE(o.calculated_output_cost, o.output_cost)
+    END AS "calculated_output_cost",
+    CASE 
+        WHEN o.calculated_total_cost IS NULL AND o.input_cost IS NULL AND o.output_cost IS NULL AND o.total_cost IS NULL THEN
+            CASE 
+                WHEN m.total_price IS NOT NULL AND o.total_tokens IS NOT NULL THEN
+                    m.total_price * o.total_tokens
+                ELSE
+                    o.prompt_tokens::decimal * m.input_price + 
+                    o.completion_tokens::decimal * m.output_price
+            END
+        ELSE
+            COALESCE(o.calculated_total_cost, o.total_cost)
+    END AS "calculated_total_cost",
+    CASE WHEN o.end_time IS NULL THEN NULL ELSE (EXTRACT(EPOCH FROM o."end_time") - EXTRACT(EPOCH FROM o."start_time"))::double precision END AS "latency",
+    CASE WHEN o.completion_start_time IS NOT NULL AND o.start_time IS NOT NULL THEN EXTRACT(EPOCH FROM (completion_start_time - start_time))::double precision ELSE NULL END as "time_to_first_token"
+    
+FROM
+    observations o
+LEFT JOIN LATERAL (
+    SELECT
+        models.*
+    FROM
+        models
+    WHERE (models.project_id = o.project_id OR models.project_id IS NULL)
+    AND models.model_name = o.internal_model
+    AND (models.start_date < o.start_time OR models.start_date IS NULL)
+    AND o.unit::TEXT = models.unit
+    ORDER BY
+        models.project_id ASC, -- in postgres, NULLs are sorted last when ordering ASC
+        models.start_date DESC NULLS LAST -- now, NULLs are sorted last when ordering DESC as well
+    LIMIT 1
+) m ON TRUE
+LEFT JOIN LATERAL (
+    SELECT
+        prompts.*
+    FROM
+        prompts
+    WHERE prompts.id = o.prompt_id
+    AND prompts.project_id = o.project_id
+    LIMIT 1
+) p ON TRUE
+
+
+-- requirements:
+-- 1. The view should return all columns from the observations table
+-- 2. The view should match with only one model for each observation if:
+--     a. The model has the same project_id as the observation, otherwise the model without project_id. 
+--     b. The model has the same model_name as the observation
+--     c. The model has a start_date that is less than the observation start_time, otherwise the model without start_date
+--     d. The model has the same unit as the observation

packages/shared/prisma/migrations/20241022110145_add_claude_sonnet_35/migration.sql

@@ -0,0 +1,18 @@
+INSERT INTO models (
+  id,
+  project_id,
+  model_name,
+  match_pattern,
+  start_date,
+  input_price,
+  output_price,
+  total_price,
+  unit,
+  tokenizer_id,
+  tokenizer_config
+)
+VALUES
+  -- https://docs.anthropic.com/en/docs/about-claude/models#model-comparison-table
+  ('cm2krz1uf000208jjg5653iud', NULL, 'claude-3.5-haiku-20241022', '(?i)^(claude-3-5-sonnet-20241022|anthropic\.claude-3-5-sonnet-20241022-v2:0|claude-3-5-sonnet-V2@20241022)$', NULL, 0.000003, 0.000015, NULL, 'TOKENS', 'claude', NULL),
+  ('cm2ks2vzn000308jjh4ze1w7q', NULL, 'claude-3.5-haiku-latest', '(?i)^(claude-3-5-sonnet-latest)$', NULL, 0.000003, 0.000015, NULL, 'TOKENS', 'claude', NULL)
+

packages/shared/prisma/schema.prisma

@@ -34,21 +34,23 @@ generator kysely {
 
 // Necessary for Next auth
 model Account {
-    id                String  @id @default(cuid())
-    userId            String  @map("user_id")
-    type              String
-    provider          String
-    providerAccountId String
-    refresh_token     String? // @db.Text
-    access_token      String? // @db.Text
-    expires_at        Int?
-    expires_in        Int?
-    ext_expires_in    Int?
-    token_type        String?
-    scope             String?
-    id_token          String? // @db.Text
-    session_state     String?
-    user              User    @relation(fields: [userId], references: [id], onDelete: Cascade)
+    id                       String  @id @default(cuid())
+    userId                   String  @map("user_id")
+    type                     String
+    provider                 String
+    providerAccountId        String
+    refresh_token            String? // @db.Text
+    access_token             String? // @db.Text
+    expires_at               Int?
+    expires_in               Int?
+    ext_expires_in           Int?
+    token_type               String?
+    scope                    String?
+    id_token                 String? // @db.Text
+    session_state            String?
+    refresh_token_expires_in Int?
+    created_at               Int? // GitLab
+    user                     User    @relation(fields: [userId], references: [id], onDelete: Cascade)
 
     @@unique([provider, providerAccountId])
     @@index([userId])
@@ -78,6 +80,8 @@ model User {
     createdAt               DateTime                 @default(now()) @map("created_at")
     updatedAt               DateTime                 @default(now()) @updatedAt @map("updated_at")
     featureFlags            String[]                 @default([]) @map("feature_flags")
+    annotatedLockedItem     AnnotationQueueItem[]    @relation("LockedByUser")
+    annotatedCompletedItem  AnnotationQueueItem[]    @relation("AnnotatorUser")
 
     @@map("users")
 }
@@ -105,31 +109,33 @@ model Organization {
 }
 
 model Project {
-    id                 String                 @id @default(cuid())
-    orgId              String                 @map("org_id")
-    createdAt          DateTime               @default(now()) @map("created_at")
-    updatedAt          DateTime               @default(now()) @updatedAt @map("updated_at")
-    name               String
-    projectMembers     ProjectMembership[]
-    organization       Organization           @relation(fields: [orgId], references: [id], onUpdate: Cascade, onDelete: Cascade)
-    traces             Trace[]
-    observations       Observation[]
-    apiKeys            ApiKey[]
-    dataset            Dataset[]
-    RawEvents          Events[]
-    invitations        MembershipInvitation[]
-    sessions           TraceSession[]
-    Prompt             Prompt[]
-    Model              Model[]
-    EvalTemplate       EvalTemplate[]
-    JobConfiguration   JobConfiguration[]
-    JobExecution       JobExecution[]
-    LlmApiKeys         LlmApiKeys[]
-    PosthogIntegration PosthogIntegration[]
-    Score              Score[]
-    scoreConfig        ScoreConfig[]
-    BatchExport        BatchExport[]
-    comment            Comment[]
+    id                  String                 @id @default(cuid())
+    orgId               String                 @map("org_id")
+    createdAt           DateTime               @default(now()) @map("created_at")
+    updatedAt           DateTime               @default(now()) @updatedAt @map("updated_at")
+    name                String
+    projectMembers      ProjectMembership[]
+    organization        Organization           @relation(fields: [orgId], references: [id], onUpdate: Cascade, onDelete: Cascade)
+    traces              Trace[]
+    observations        Observation[]
+    apiKeys             ApiKey[]
+    dataset             Dataset[]
+    RawEvents           Events[]
+    invitations         MembershipInvitation[]
+    sessions            TraceSession[]
+    Prompt              Prompt[]
+    Model               Model[]
+    EvalTemplate        EvalTemplate[]
+    JobConfiguration    JobConfiguration[]
+    JobExecution        JobExecution[]
+    LlmApiKeys          LlmApiKeys[]
+    PosthogIntegration  PosthogIntegration[]
+    Score               Score[]
+    scoreConfig         ScoreConfig[]
+    BatchExport         BatchExport[]
+    comment             Comment[]
+    annotationQueue     AnnotationQueue[]
+    annotationQueueItem AnnotationQueueItem[]
 
     @@index([orgId])
     @@map("projects")
@@ -167,12 +173,12 @@ model LlmApiKeys {
     baseURL           String?  @map("base_url")
     customModels      String[] @default([]) @map("custom_models")
     withDefaultModels Boolean  @default(true) @map("with_default_models")
+    config            Json?
 
     projectId String  @map("project_id")
     project   Project @relation(fields: [projectId], references: [id], onDelete: Cascade)
 
     @@unique([projectId, provider])
-    @@index([projectId, provider])
     @@map("llm_api_keys")
 }
 
@@ -189,7 +195,6 @@ model OrganizationMembership {
 
     @@unique([orgId, userId])
     @@index([userId])
-    @@index([orgId])
     @@map("organization_memberships")
 }
 
@@ -282,7 +287,6 @@ model Trace {
 
     JobExecution JobExecution[]
 
-    @@index([projectId])
     @@index([projectId, timestamp])
     @@index([sessionId])
     @@index([name])
@@ -373,12 +377,9 @@ model Observation {
     @@index([projectId, internalModel, startTime, unit])
     @@index([traceId, projectId, type, startTime])
     @@index([traceId, projectId, startTime])
-    @@index([traceId, projectId])
-    @@index([traceId])
     @@index([type])
     @@index(startTime)
     @@index(createdAt)
-    @@index(projectId)
     @@index(model)
     @@index(internalModel)
     @@index([projectId, promptId])
@@ -464,6 +465,7 @@ model Score {
     observationId String?        @map("observation_id")
     configId      String?        @map("config_id")
     stringValue   String?        @map("string_value") // always defined if data type is CATEGORICAL or BOOLEAN, null for NUMERIC
+    queueId       String?        @map("queue_id")
     createdAt     DateTime       @default(now()) @map("created_at")
     updatedAt     DateTime       @default(now()) @updatedAt @map("updated_at")
     dataType      ScoreDataType  @default(NUMERIC) @map("data_type")
@@ -473,7 +475,6 @@ model Score {
     @@unique([id, projectId]) // used for upserts via prisma
     @@index(timestamp)
     @@index([value])
-    @@index([projectId])
     @@index([projectId, name])
     @@index([authorUserId])
     @@index([configId])
@@ -521,6 +522,59 @@ enum ScoreDataType {
     BOOLEAN
 }
 
+model AnnotationQueue {
+    id                  String                @id @default(cuid())
+    name                String
+    description         String?
+    scoreConfigIds      String[]              @default([]) @map("score_config_ids")
+    projectId           String                @map("project_id")
+    project             Project               @relation(fields: [projectId], references: [id], onDelete: Cascade)
+    createdAt           DateTime              @default(now()) @map("created_at")
+    updatedAt           DateTime              @default(now()) @updatedAt @map("updated_at")
+    annotationQueueItem AnnotationQueueItem[]
+
+    @@unique([projectId, name])
+    @@index([id, projectId])
+    @@index([projectId, createdAt])
+    @@map("annotation_queues")
+}
+
+model AnnotationQueueItem {
+    id              String                    @id @default(cuid())
+    queueId         String                    @map("queue_id")
+    queue           AnnotationQueue           @relation(fields: [queueId], references: [id], onDelete: Cascade)
+    objectId        String                    @map("object_id")
+    objectType      AnnotationQueueObjectType @map("object_type")
+    status          AnnotationQueueStatus     @default(PENDING)
+    lockedAt        DateTime?                 @map("locked_at")
+    lockedByUserId  String?                   @map("locked_by_user_id")
+    lockedByUser    User?                     @relation("LockedByUser", fields: [lockedByUserId], references: [id], onDelete: SetNull)
+    annotatorUserId String?                   @map("annotator_user_id")
+    annotatorUser   User?                     @relation("AnnotatorUser", fields: [annotatorUserId], references: [id], onDelete: SetNull)
+    completedAt     DateTime?                 @map("completed_at")
+    projectId       String                    @map("project_id")
+    project         Project                   @relation(fields: [projectId], references: [id], onDelete: Cascade)
+    createdAt       DateTime                  @default(now()) @map("created_at")
+    updatedAt       DateTime                  @default(now()) @updatedAt @map("updated_at")
+
+    @@index([id, projectId])
+    @@index([projectId, queueId, status])
+    @@index([objectId, objectType, projectId, queueId])
+    @@index([annotatorUserId])
+    @@index([createdAt])
+    @@map("annotation_queue_items")
+}
+
+enum AnnotationQueueStatus {
+    PENDING
+    COMPLETED
+}
+
+enum AnnotationQueueObjectType {
+    TRACE
+    OBSERVATION
+}
+
 model CronJobs {
     name         String    @id
     lastRun      DateTime? @map("last_run")
@@ -544,7 +598,6 @@ model Dataset {
 
     @@id([id, projectId])
     @@unique([projectId, name])
-    @@index([projectId], type: Hash)
     @@index([createdAt])
     @@index([updatedAt])
     @@map("datasets")
@@ -673,14 +726,12 @@ model Prompt {
     version  Int
     type     String   @default("text")
     isActive Boolean? @map("is_active") // Deprecated. To be removed once 'production' labels work as expected.
-    config   Json     @default("{}")
+    config   Json     @default("{}") @db.Json
     tags     String[] @default([])
     labels   String[] @default([])
 
     @@unique([projectId, name, version])
-    @@index([projectId, name, version])
     @@index([projectId, id])
-    @@index([projectId])
     @@index([createdAt])
     @@index([updatedAt])
     @@index([tags(ops: ArrayOps)], type: Gin)
@@ -707,8 +758,6 @@ model Model {
     tokenizerConfig Json?     @map("tokenizer_config")
 
     @@unique([projectId, modelName, startDate, unit])
-    @@index([projectId, modelName, startDate, unit])
-    @@index([projectId, modelName])
     @@index(modelName)
     @@map("models")
 }
@@ -757,7 +806,6 @@ model EvalTemplate {
 
     @@unique([projectId, name, version])
     @@index([projectId, id])
-    @@index([projectId])
     @@map("eval_templates")
 }
 
@@ -792,7 +840,6 @@ model JobConfiguration {
     JobExecution    JobExecution[]
 
     @@index([projectId, id])
-    @@index([projectId])
     @@map("job_configurations")
 }
 
@@ -827,7 +874,6 @@ model JobExecution {
 
     @@index([projectId, status])
     @@index([projectId, id])
-    @@index([projectId])
     @@index([jobConfigurationId])
     @@index([jobOutputScoreId])
     @@index([jobInputTraceId])
@@ -860,7 +906,6 @@ model PosthogIntegration {
     enabled                Boolean
     createdAt              DateTime  @default(now()) @map("created_at")
 
-    @@index([projectId])
     @@map("posthog_integrations")
 }
 

packages/shared/prisma/seed.ts

@@ -5,6 +5,7 @@ import {
   ObservationType,
   ScoreSource,
   ScoreDataType,
+  AnnotationQueueObjectType,
 } from "../src/index";
 import { hash } from "bcryptjs";
 import { parseArgs } from "node:util";
@@ -12,7 +13,7 @@ import { parseArgs } from "node:util";
 import { chunk } from "lodash";
 import { v4 } from "uuid";
 import { ModelUsageUnit } from "../src";
-import { getDisplaySecretKey, hashSecretKey } from "../src/server";
+import { getDisplaySecretKey, hashSecretKey, logger } from "../src/server";
 import { encrypt } from "../src/encryption";
 import { redis } from "../src/server/redis/redis";
 
@@ -77,6 +78,9 @@ async function main() {
     create: {
       id: seedOrgId,
       name: "Seed Org",
+      cloudConfig: {
+        plan: "Team",
+      },
     },
   });
 
@@ -250,6 +254,11 @@ async function main() {
       project2,
     ]);
 
+    const queueIds = await generateQueuesForProject(
+      [project1, project2],
+      configIdsAndNames
+    );
+
     const promptIds = await generatePromptsForProject([project1, project2]);
 
     const envTags = [null, "development", "staging", "production"];
@@ -257,18 +266,26 @@ async function main() {
 
     const traceVolume = environment === "load" ? LOAD_TRACE_VOLUME : 100;
 
-    const { traces, observations, scores, sessions, events, comments } =
-      createObjects(
-        traceVolume,
-        envTags,
-        colorTags,
-        project1,
-        project2,
-        promptIds,
-        configIdsAndNames
-      );
+    const {
+      traces,
+      observations,
+      scores,
+      sessions,
+      events,
+      comments,
+      queueItems,
+    } = createObjects(
+      traceVolume,
+      envTags,
+      colorTags,
+      project1,
+      project2,
+      promptIds,
+      queueIds,
+      configIdsAndNames
+    );
 
-    console.log(
+    logger.info(
       `Seeding ${traces.length} traces, ${observations.length} observations, and ${scores.length} scores`
     );
 
@@ -278,7 +295,8 @@ async function main() {
       scores,
       sessions,
       events,
-      comments
+      comments,
+      queueItems
     );
 
     // If openai key is in environment, add it to the projects LLM API keys
@@ -295,7 +313,7 @@ async function main() {
         },
       });
     } else {
-      console.warn(
+      logger.warn(
         "No OPENAI_API_KEY found in environment. Skipping seeding LLM API key."
       );
     }
@@ -457,13 +475,13 @@ main()
   .then(async () => {
     await prisma.$disconnect();
     redis?.disconnect();
-    console.log("Disconnected from postgres and redis");
+    logger.info("Disconnected from postgres and redis");
   })
   .catch(async (e) => {
-    console.error(e);
+    logger.error(e);
     await prisma.$disconnect();
     redis?.disconnect();
-    console.log("Disconnected from postgres and redis");
+    logger.info("Disconnected from postgres and redis");
     process.exit(1);
   });
 
@@ -473,7 +491,8 @@ async function uploadObjects(
   scores: Prisma.ScoreCreateManyInput[],
   sessions: Prisma.TraceSessionCreateManyInput[],
   events: Prisma.ObservationCreateManyInput[],
-  comments: Prisma.CommentCreateManyInput[]
+  comments: Prisma.CommentCreateManyInput[],
+  queueItems: Prisma.AnnotationQueueItemCreateManyInput[]
 ) {
   let promises: Prisma.PrismaPromise<unknown>[] = [];
 
@@ -493,7 +512,7 @@ async function uploadObjects(
 
   for (let i = 0; i < promises.length; i++) {
     if (i + 1 >= promises.length || i % Math.ceil(promises.length / 10) === 0)
-      console.log(
+      logger.info(
         `Seeding of Sessions ${((i + 1) / promises.length) * 100}% complete`
       );
     await promises[i];
@@ -510,7 +529,7 @@ async function uploadObjects(
   });
   for (let i = 0; i < promises.length; i++) {
     if (i + 1 >= promises.length || i % Math.ceil(promises.length / 10) === 0)
-      console.log(
+      logger.info(
         `Seeding of Traces ${((i + 1) / promises.length) * 100}% complete`
       );
     await promises[i];
@@ -527,7 +546,7 @@ async function uploadObjects(
 
   for (let i = 0; i < promises.length; i++) {
     if (i + 1 >= promises.length || i % Math.ceil(promises.length / 10) === 0)
-      console.log(
+      logger.info(
         `Seeding of Observations ${((i + 1) / promises.length) * 100}% complete`
       );
     await promises[i];
@@ -544,7 +563,7 @@ async function uploadObjects(
 
   for (let i = 0; i < promises.length; i++) {
     if (i + 1 >= promises.length || i % Math.ceil(promises.length / 10) === 0)
-      console.log(
+      logger.info(
         `Seeding of Events ${((i + 1) / promises.length) * 100}% complete`
       );
     await promises[i];
@@ -560,7 +579,7 @@ async function uploadObjects(
   });
   for (let i = 0; i < promises.length; i++) {
     if (i + 1 >= promises.length || i % Math.ceil(promises.length / 10) === 0)
-      console.log(
+      logger.info(
         `Seeding of Scores ${((i + 1) / promises.length) * 100}% complete`
       );
     await promises[i];
@@ -576,11 +595,27 @@ async function uploadObjects(
   });
   for (let i = 0; i < promises.length; i++) {
     if (i + 1 >= promises.length || i % Math.ceil(promises.length / 10) === 0)
-      console.log(
+      logger.info(
         `Seeding of Comments ${((i + 1) / promises.length) * 100}% complete`
       );
     await promises[i];
   }
+
+  promises = [];
+  chunk(queueItems, chunkSize).forEach((chunk) => {
+    promises.push(
+      prisma.annotationQueueItem.createMany({
+        data: chunk,
+      })
+    );
+  });
+  for (let i = 0; i < promises.length; i++) {
+    if (i + 1 >= promises.length || i % Math.ceil(promises.length / 10) === 0)
+      logger.info(
+        `Seeding of Annotation Queue Items ${((i + 1) / promises.length) * 100}% complete`
+      );
+    await promises[i];
+  }
 }
 
 function createObjects(
@@ -590,6 +625,7 @@ function createObjects(
   project1: Project,
   project2: Project,
   promptIds: Map<string, string[]>,
+  queueIds: Map<string, string[]>,
   configParams: Map<
     string,
     {
@@ -607,6 +643,7 @@ function createObjects(
   const events: Prisma.ObservationCreateManyInput[] = [];
   const configs: Prisma.ScoreConfigCreateManyInput[] = [];
   const comments: Prisma.CommentCreateManyInput[] = [];
+  const queueItems: Prisma.AnnotationQueueItemCreateManyInput[] = [];
 
   for (let i = 0; i < traceVolume; i++) {
     // print progress to console with a progress bar that refreshes every 10 iterations
@@ -689,6 +726,21 @@ function createObjects(
       }),
     };
 
+    const queueItem = [
+      ...(Math.random() > 0.9 && queueIds.get(projectId)?.[0]
+        ? [
+            {
+              queueId: queueIds.get(projectId)?.[0] as string,
+              objectId: trace.id,
+              objectType: AnnotationQueueObjectType.TRACE,
+              projectId,
+            },
+          ]
+        : []),
+    ];
+
+    queueItems.push(...queueItem);
+
     const traceScores = [
       ...(Math.random() > 0.5
         ? [
@@ -941,6 +993,7 @@ function createObjects(
     observations,
     scores,
     configs,
+    queueItems,
     sessions: uniqueSessions,
     events,
     comments,
@@ -1218,6 +1271,7 @@ async function generateConfigs(project: Project) {
 
   return configNameAndId;
 }
+
 function getGenerationInputOutput(): {
   input: Prisma.InputJsonValue;
   output: Prisma.InputJsonValue;
@@ -1278,3 +1332,64 @@ function getGenerationInputOutput(): {
 
   return { input, output };
 }
+
+async function generateQueuesForProject(
+  projects: Project[],
+  configIdsAndNames: Map<
+    string,
+    {
+      name: string;
+      id: string;
+      dataType: ScoreDataType;
+      categories: ConfigCategory[] | null;
+    }[]
+  >
+) {
+  const projectIdsToQueues: Map<string, string[]> = new Map();
+
+  await Promise.all(
+    projects.map(async (project) => {
+      const queueIds = await generateQueues(
+        project,
+        configIdsAndNames.get(project.id) ?? []
+      );
+      projectIdsToQueues.set(project.id, queueIds);
+    })
+  );
+  return projectIdsToQueues;
+}
+
+async function generateQueues(
+  project: Project,
+  configIdsAndNames: {
+    name: string;
+    id: string;
+    dataType: ScoreDataType;
+    categories: ConfigCategory[] | null;
+  }[]
+) {
+  const queue = {
+    id: `queue-${v4()}`,
+    name: "Default",
+    description: "Default queue",
+    scoreConfigIds: configIdsAndNames.map((config) => config.id),
+    projectId: project.id,
+  };
+
+  await prisma.annotationQueue.upsert({
+    where: {
+      projectId_name: {
+        projectId: queue.projectId,
+        name: queue.name,
+      },
+    },
+    create: {
+      ...queue,
+    },
+    update: {
+      id: queue.id,
+    },
+  });
+
+  return [queue.id];
+}

packages/shared/scripts/load-seed.ts

@@ -0,0 +1,133 @@
+import { randomUUID } from "crypto";
+import { prisma } from "../src/db";
+import {
+  clickhouseClient,
+  getDisplaySecretKey,
+  hashSecretKey,
+  logger,
+} from "../src/server";
+import { prepareClickhouse } from "./prepareClickhouse";
+import { redis } from "@langfuse/shared/src/server";
+
+const createRandomProjectId = () => randomUUID().toString();
+
+const prepareProjectsAndApiKeys = async (
+  numOfProjects: number,
+  opts: { requiredProjectIds: string[] }
+) => {
+  const { requiredProjectIds } = opts;
+  const projectsToCreate = numOfProjects - requiredProjectIds.length;
+  const projectIds = [...requiredProjectIds];
+
+  for (let i = 0; i < projectsToCreate; i++) {
+    projectIds.push(createRandomProjectId());
+  }
+
+  const operations = projectIds.map(async (projectId) => {
+    const orgId = `org-${projectId}`;
+
+    await prisma.organization.upsert({
+      where: { id: orgId },
+      update: {},
+      create: {
+        id: orgId,
+        name: `Organization for ${projectId}`,
+      },
+    });
+
+    await prisma.project.upsert({
+      where: { id: projectId },
+      update: {},
+      create: {
+        id: projectId,
+        name: `Project ${projectId}`,
+        orgId: orgId,
+      },
+    });
+
+    const apiKeyId = `api-key-${projectId}`;
+    const apiKeyExists = await prisma.apiKey.findUnique({
+      where: { id: apiKeyId },
+    });
+    if (!apiKeyExists) {
+      const sk = await hashSecretKey(
+        `sk-${Math.random().toString(36).substr(2, 9)}`
+      );
+      await prisma.apiKey.create({
+        data: {
+          id: apiKeyId,
+          note: `API Key for ${projectId}`,
+          publicKey: `pk-${Math.random().toString(36).substr(2, 9)}`,
+          hashedSecretKey: sk,
+          displaySecretKey: getDisplaySecretKey(sk),
+          project: {
+            connect: {
+              id: projectId,
+            },
+          },
+        },
+      });
+    }
+  });
+
+  await Promise.all(operations);
+  return projectIds;
+};
+
+async function main() {
+  let numOfProjects = parseInt(process.argv[3], 10);
+  let numberOfDays = parseInt(process.argv[4], 10);
+  let totalObservations = parseInt(process.argv[5], 10);
+
+  if (isNaN(totalObservations)) {
+    logger.warn(
+      "Total observations not provided or invalid. Defaulting to 1000 observations."
+    );
+    totalObservations = 1000;
+  }
+
+  if (isNaN(numOfProjects)) {
+    logger.warn(
+      "Number of projects not provided or invalid. Defaulting to 10 projects."
+    );
+    numOfProjects = 10;
+  }
+
+  if (isNaN(numberOfDays)) {
+    logger.warn(
+      "Number of days not provided or invalid. Defaulting to 3 days."
+    );
+    numberOfDays = 3;
+  }
+
+  logger.info(
+    `Preparing Clickhouse for ${numOfProjects} projects and ${numberOfDays} days with max Observations ${totalObservations}.`
+  );
+
+  try {
+    const projectIds = [
+      "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a",
+      "239ad00f-562f-411d-af14-831c75ddd875",
+    ];
+
+    const createdProjectIds = await prepareProjectsAndApiKeys(numOfProjects, {
+      requiredProjectIds: projectIds,
+    });
+
+    await prepareClickhouse(createdProjectIds, {
+      numberOfDays,
+      totalObservations: totalObservations ?? 1000,
+    });
+
+    logger.info("Clickhouse preparation completed successfully.");
+  } catch (error) {
+    logger.error("Error during Clickhouse preparation:", error);
+  } finally {
+    await clickhouseClient.close();
+    await prisma.$disconnect();
+    redis?.disconnect();
+    logger.info("Disconnected from Clickhouse.");
+  }
+}
+
+main();

packages/shared/scripts/prepareClickhouse.ts

@@ -0,0 +1,222 @@
+import { clickhouseClient, logger } from "../src/server";
+
+function randn_bm(min: number, max: number, skew: number) {
+  let u = 0,
+    v = 0;
+  while (u === 0) u = Math.random(); //Converting [0,1) to (0,1)
+  while (v === 0) v = Math.random();
+  let num = Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
+
+  num = num / 10.0 + 0.5; // Translate to 0 -> 1
+  if (num > 1 || num < 0)
+    num = randn_bm(min, max, skew); // resample between 0 and 1 if out of range
+  else {
+    num = Math.pow(num, skew); // Skew
+    num *= max - min; // Stretch to fill range
+    num += min; // offset to min
+  }
+  return num;
+}
+
+export const prepareClickhouse = async (
+  projectIds: string[],
+  opts: {
+    numberOfDays: number;
+    totalObservations: number;
+  }
+) => {
+  logger.info(
+    `Preparing Clickhouse for ${projectIds.length} projects and ${opts.numberOfDays} days.`
+  );
+
+  const projectData = projectIds.map((projectId) => {
+    const observationsPerProject = Math.ceil(
+      randn_bm(0, opts.totalObservations, 2)
+    ); // Skew the number of observations
+
+    const tracesPerProject = Math.floor(observationsPerProject / 6); // On average, one trace should have 6 observations
+    const scoresPerProject = tracesPerProject * 10; // On average, one trace should have 10 scores
+    return {
+      projectId,
+      observationsPerProject,
+      tracesPerProject,
+      scoresPerProject,
+    };
+  });
+
+  for (const data of projectData) {
+    const {
+      projectId,
+      tracesPerProject,
+      observationsPerProject,
+      scoresPerProject,
+    } = data;
+    logger.info(
+      `Preparing Clickhouse for ${projectId}: Traces: ${tracesPerProject}, Scores: ${scoresPerProject}, Observations: ${observationsPerProject}`
+    );
+
+    const tracesQuery = `
+    INSERT INTO traces
+    SELECT toString(number) AS id,
+      toDateTime(now() - randUniform(0, ${opts.numberOfDays} * 24 * 60 * 60)) AS timestamp,
+      concat('name_', toString(rand() % 100)) AS name,
+      concat('user_id_', toString(randUniform(0, 100))) AS user_id,
+      map('key', 'value') AS metadata,
+      concat('release_', toString(randUniform(0, 100))) AS release,
+      concat('version_', toString(randUniform(0, 100))) AS version,
+      '${projectId}' AS project_id,
+      if(rand() < 0.8, true, false) as public,
+      if(rand() < 0.8, true, false) as bookmarked,
+      array('tag1', 'tag2') as tags,
+      repeat('input', toInt64(randExponential(1 / 100))) AS input,
+      repeat('output', toInt64(randExponential(1 / 100))) AS output,
+      concat('session_', toString(rand() % 100)) AS session_id,
+      timestamp AS created_at,
+      timestamp AS updated_at,
+      timestamp AS event_ts
+    FROM numbers(${tracesPerProject});
+  `;
+
+    const observationsQuery = `
+    INSERT INTO observations
+    SELECT toString(number) AS id,
+      toString(floor(randUniform(0, ${tracesPerProject}))) AS trace_id,
+      '${projectId}' AS project_id,
+      if(rand() < 0.47, 'GENERATION', if(rand() < 0.94, 'SPAN', 'EVENT')) AS type,
+      toString(rand()) AS parent_observation_id,
+      toDateTime(now() - randUniform(0, ${opts.numberOfDays} * 24 * 60 * 60)) AS start_time,
+      addSeconds(start_time, if(rand() < 0.6, floor(randUniform(0, 20)), floor(randUniform(0, 3600)))) AS end_time,
+      concat('name', toString(rand() % 100)) AS name,
+      map('key', 'value') AS metadata,
+      if(rand() < 0.9, 'DEFAULT', if(rand() < 0.5, 'ERROR', if(rand() < 0.5, 'DEBUG', 'WANING'))) AS level,
+      'status_message' AS status_message,
+      'version' AS version,
+      repeat('input', toInt64(randExponential(1 / 100))) AS input,
+      repeat('output', toInt64(randExponential(1 / 100))) AS output,
+      case
+        when number % 2 = 0 then 'claude-3-haiku-20240307'
+        else 'gpt-4'
+      end as provided_model_name,
+      case
+        when number % 2 = 0 then 'cltr0w45b000008k1407o9qv1'
+        else 'clrntkjgy000f08jx79v9g1xj'
+      end as internal_model_id,
+      'model_parameters' AS model_parameters,
+      toInt32(randUniform(0, 1000)) AS provided_input_usage_units,
+      toInt32(randUniform(0, 1000)) AS provided_output_usage_units,
+      toInt32(randUniform(0, 1000)) AS provided_total_usage_units,
+      toInt32(randUniform(0, 1000)) AS input_usage_units,
+      toInt32(randUniform(0, 1000)) AS output_usage_units,
+      toInt32(randUniform(0, 1000)) AS total_usage_units,
+      toInt32(randUniform(0, 1000)) AS provided_input_cost,
+      toInt32(randUniform(0, 1000)) AS provided_output_cost,
+      toInt32(randUniform(0, 1000)) AS provided_total_cost,
+      'TOKENS' AS unit,
+      toInt32(randUniform(0, 1000)) AS input_cost,
+      toInt32(randUniform(0, 1000)) AS output_cost,
+      toInt32(randUniform(0, 1000)) AS total_cost,
+      start_time AS completion_start_time,
+      toString(rand()) AS prompt_id,
+      toString(rand()) AS prompt_name,
+      1000 AS prompt_version,
+      start_time AS created_at,
+      start_time AS updated_at,
+      start_time AS event_ts
+    FROM numbers(${observationsPerProject});
+  `;
+
+    const scoresQuery = `
+    INSERT INTO scores
+    SELECT toString(floor(randUniform(0, 100))) AS id,
+      toDateTime(now() - randUniform(0, ${opts.numberOfDays} * 24 * 60 * 60)) AS timestamp,
+      '${projectId}' AS project_id,
+      toString(floor(randUniform(0, ${tracesPerProject}))) AS trace_id,
+      if(
+        rand() > 0.9,
+        toString(floor(randUniform(0, ${observationsPerProject}))),
+        NULL
+      ) AS observation_id,
+      concat('name_', toString(rand() % 100)) AS name,
+      randUniform(0, 100) as value,
+      'API' as source,
+      'comment' as comment,
+      toString(rand() % 100) as author_user_id,
+      toString(rand() % 100) as config_id,
+      toString(rand() % 100) as data_type,
+      toString(rand() % 100) as string_value,
+      timestamp AS created_at,
+      timestamp AS updated_at,
+      timestamp AS event_ts
+    FROM numbers(${scoresPerProject});
+  `;
+
+    const queries = [tracesQuery, scoresQuery, observationsQuery];
+
+    for (const query of queries) {
+      logger.info(`Executing query: ${query}`);
+      await clickhouseClient.command({
+        query,
+        clickhouse_settings: {
+          wait_end_of_query: 1,
+        },
+      });
+    }
+  }
+
+  const tables = ["traces", "scores", "observations"];
+  for (const table of tables) {
+    const query = `
+            SELECT
+            project_id,
+            count() AS per_project_count,
+            bar(per_project_count, 0, (
+                SELECT count(*)
+                FROM ${table}
+            ), 50) AS bar_representation
+          FROM ${table}
+          GROUP BY project_id
+          ORDER BY count() desc
+          `;
+
+    const result = await clickhouseClient.query({
+      query,
+      format: "TabSeparated",
+    });
+
+    logger.info(
+      `${table.charAt(0).toUpperCase() + table.slice(1)} per Project: \n` +
+        (await result.text())
+    );
+  }
+
+  const tablesWithDateColumns = [
+    { name: "traces", dateColumn: "timestamp" },
+    { name: "scores", dateColumn: "timestamp" },
+    { name: "observations", dateColumn: "start_time" },
+  ];
+
+  for (const { name: table, dateColumn } of tablesWithDateColumns) {
+    const query = `
+            SELECT
+            toDate(${dateColumn}) AS event_date,
+            count() AS per_date_count,
+            bar(per_date_count, 0, (
+                SELECT count(*)
+                FROM ${table}
+            ), 50) AS bar_representation
+          FROM ${table}
+          GROUP BY event_date
+          ORDER BY event_date desc
+          `;
+
+    const result = await clickhouseClient.query({
+      query,
+      format: "TabSeparated",
+    });
+
+    logger.info(
+      `${table.charAt(0).toUpperCase() + table.slice(1)} per Date: \n` +
+        (await result.text())
+    );
+  }
+};

packages/shared/src/db.ts

@@ -1,7 +1,7 @@
 // This file exports the prisma db connection, the Prisma Object, and the Typescript types.
 // This is not imported in the index.ts file of this package, as we must not import this into FE code.
 
-import { PrismaClient } from "@prisma/client";
+import { Prisma, PrismaClient } from "@prisma/client";
 import { env } from "process";
 import kyselyExtension from "prisma-extension-kysely";
 import {
@@ -11,21 +11,86 @@ import {
   PostgresQueryCompiler,
 } from "kysely";
 import { DB } from ".";
+import { logger } from "./server";
 
-// Instantiated according to the Prisma documentation
-// https://www.prisma.io/docs/orm/more/help-and-troubleshooting/help-articles/nextjs-prisma-client-dev-practices
+export class PrismaClientSingleton {
+  private static instance: PrismaClient;
 
-const prismaClientSingleton = () => {
-  return new PrismaClient({
-    log:
-      env.NODE_ENV === "development"
-        ? ["query", "error", "warn"]
-        : ["error", "warn"],
+  public static getInstance(): PrismaClient {
+    if (PrismaClientSingleton.instance) {
+      return PrismaClientSingleton.instance;
+    }
+
+    PrismaClientSingleton.instance = createPrismaInstance();
+
+    return PrismaClientSingleton.instance;
+  }
+}
+
+const createPrismaInstance = () => {
+  const client = new PrismaClient<
+    Prisma.PrismaClientOptions,
+    "warn" | "error" | "query"
+  >({
+    log: [
+      { emit: "event", level: "query" },
+      { emit: "event", level: "error" },
+      { emit: "event", level: "warn" },
+    ],
   });
+
+  if (env.NODE_ENV === "development") {
+    client.$on("query", (event) => {
+      logger.info(`prisma:query ${event.query}, ${event.duration}ms`);
+    });
+  }
+
+  client.$on("warn", (event) => {
+    logger.warn(`prisma:warn ${event.message}`);
+  });
+
+  client.$on("error", (event) => {
+    logger.error(`prisma:error ${event.message}`);
+  });
+  return client;
 };
 
-const kyselySingleton = (prismaClient: PrismaClient) => {
-  return prismaClient.$extends(
+export class KyselySingleton {
+  private static instance: { $kysely: Kysely<DB> };
+
+  public static getInstance() {
+    if (KyselySingleton.instance) {
+      return KyselySingleton.instance;
+    }
+
+    KyselySingleton.instance = PrismaClientSingleton.getInstance().$extends(
+      kyselyExtension({
+        kysely: (driver) =>
+          new Kysely<DB>({
+            dialect: {
+              // This is where the magic happens!
+              createDriver: () => driver,
+              // Don't forget to customize these to match your database!
+              createAdapter: () => new PostgresAdapter(),
+              createIntrospector: (db) => new PostgresIntrospector(db),
+              createQueryCompiler: () => new PostgresQueryCompiler(),
+            },
+          }),
+      })
+    );
+
+    return KyselySingleton.instance;
+  }
+}
+
+declare const globalThis: {
+  prismaGlobal: PrismaClient | undefined;
+  kyselyPrismaGlobal: { $kysely: Kysely<DB> } | undefined;
+} & typeof global;
+
+if (process.env.NODE_ENV === "development") {
+  globalThis.prismaGlobal ??= createPrismaInstance(); // regular instantiation
+  globalThis.kyselyPrismaGlobal ??= globalThis.prismaGlobal.$extends(
     kyselyExtension({
       kysely: (driver) =>
         new Kysely<DB>({
@@ -40,16 +105,11 @@ const kyselySingleton = (prismaClient: PrismaClient) => {
         }),
     })
   );
-};
-declare global {
-  // eslint-disable-next-line no-var
-  var prisma: undefined | ReturnType<typeof prismaClientSingleton>;
-  var kyselyPrisma: undefined | ReturnType<typeof kyselySingleton>;
 }
 
-export const prisma = globalThis.prisma ?? prismaClientSingleton();
-export const kyselyPrisma = globalThis.kyselyPrisma ?? kyselySingleton(prisma);
+export const prisma =
+  globalThis.prismaGlobal ?? PrismaClientSingleton.getInstance();
+export const kyselyPrisma =
+  globalThis.kyselyPrismaGlobal ?? KyselySingleton.getInstance();
 
 export * from "@prisma/client";
-
-if (process.env.NODE_ENV !== "production") globalThis.prisma = prisma;

packages/shared/src/env.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { removeEmptyEnvVariables } from "./utils/environment";
 
 const EnvSchema = z.object({
   NODE_ENV: z
@@ -21,7 +22,7 @@ const EnvSchema = z.object({
     .string()
     .length(
       64,
-      "ENCRYPTION_KEY must be 256 bits, 64 string characters in hex format, generate via: openssl rand -hex 32"
+      "ENCRYPTION_KEY must be 256 bits, 64 string characters in hex format, generate via: openssl rand -hex 32",
     )
     .optional(),
   LANGFUSE_CACHE_PROMPT_ENABLED: z.enum(["true", "false"]).default("false"),
@@ -29,15 +30,14 @@ const EnvSchema = z.object({
   CLICKHOUSE_URL: z.string().url().optional(),
   CLICKHOUSE_USER: z.string().optional(),
   CLICKHOUSE_PASSWORD: z.string().optional(),
-  LANGFUSE_INGESTION_FLUSH_DELAY_MS: z.coerce
-    .number()
-    .nonnegative()
-    .default(10000),
-  LANGFUSE_INGESTION_FLUSH_ATTEMPTS: z.coerce.number().positive().default(3),
-  LANGFUSE_INGESTION_BUFFER_TTL_SECONDS: z.coerce
-    .number()
-    .positive()
-    .default(60 * 10),
+  SALT: z.string().optional(), // used by components imported by web package
+  LANGFUSE_LOG_LEVEL: z
+    .enum(["trace", "debug", "info", "warn", "error", "fatal"])
+    .optional(),
+  LANGFUSE_LOG_FORMAT: z.enum(["text", "json"]).default("text"),
+  ENABLE_AWS_CLOUDWATCH_METRIC_PUBLISHING: z
+    .enum(["true", "false"])
+    .default("false"),
 });
 
-export const env = EnvSchema.parse(process.env);
+export const env = EnvSchema.parse(removeEmptyEnvVariables(process.env));

packages/shared/src/features/annotation/types.ts

@@ -32,6 +32,7 @@ const CreateAnnotationScoreBase = z.object({
   configId: z.string().optional(),
   observationId: z.string().optional(),
   comment: z.string().nullish(),
+  queueId: z.string().nullish(),
 });
 
 const UpdateAnnotationScoreBase = CreateAnnotationScoreBase.extend({
@@ -57,3 +58,15 @@ export const UpdateAnnotationScoreData = z.discriminatedUnion("dataType", [
   UpdateAnnotationScoreBase.merge(CategoricalData),
   UpdateAnnotationScoreBase.merge(BooleanData),
 ]);
+
+// annotation queues
+
+export const CreateQueueData = z.object({
+  name: z.string().min(1).max(35),
+  description: z.string().max(1000).optional(),
+  scoreConfigIds: z.array(z.string()).min(1, {
+    message: "At least 1 score config must be selected",
+  }),
+});
+
+export type CreateQueue = z.infer<typeof CreateQueueData>;

packages/shared/src/features/batchExport/types.ts

@@ -19,6 +19,8 @@ export enum BatchExportFileFormat {
 
 export enum BatchExportTableName {
   Sessions = "sessions",
+  Traces = "traces",
+  Generations = "generations",
 }
 
 export const exportOptions: Record<

packages/shared/src/features/evals/types.ts

@@ -1,5 +1,4 @@
 import z from "zod";
-import { LLMAdapter } from "../..";
 
 export const langfuseObjects = [
   "trace",
@@ -77,18 +76,6 @@ export const availableEvalVariables = [
   },
 ];
 
-export const evalModelsByAdapter: Record<LLMAdapter, string[]> = {
-  [LLMAdapter.OpenAI]: [
-    "gpt-4o",
-    "gpt-4o-mini",
-    "gpt-4o-2024-08-06", // cheaper than gpt-4o
-    "gpt-4-turbo-preview",
-    "gpt-3.5-turbo",
-  ] as const,
-  [LLMAdapter.Anthropic]: [] as const,
-  [LLMAdapter.Azure]: [] as const,
-};
-
 export const OutputSchema = z.object({
   reasoning: z.string(),
   score: z.string(),

packages/shared/src/features/scores/scoreTypes.ts

@@ -55,6 +55,7 @@ const ScoreBase = z.object({
   configId: z.string().nullish(),
   createdAt: z.coerce.date(),
   updatedAt: z.coerce.date(),
+  queueId: z.string().nullish(),
 });
 
 const BaseScoreBody = z.object({
@@ -234,6 +235,8 @@ export const GetScoresQuery = z.object({
   userId: z.string().nullish(),
   dataType: z.enum(ScoreDataType).nullish(),
   configId: z.string().nullish(),
+  queueId: z.string().nullish(),
+  traceTags: z.union([z.array(z.string()), z.string()]).nullish(),
   name: z.string().nullish(),
   fromTimestamp: stringDateTime,
   toTimestamp: stringDateTime,
@@ -255,6 +258,7 @@ const LegacyGetScoreResponseDataV1 = z.intersection(
   z.object({
     trace: z.object({
       userId: z.string().nullish(),
+      tags: z.array(z.string()).nullish(),
     }),
   })
 );

packages/shared/src/index.ts

@@ -1,15 +1,13 @@
 export * from "./constants";
-export * from "./queries";
 export * from "./interfaces/filters";
 export * from "./interfaces/orderBy";
 export * from "./interfaces/cloudConfigSchema";
 export * from "./interfaces/parseDbOrg";
+export * from "./interfaces/customLLMProviderConfigSchemas";
 export * from "./tableDefinitions";
 export * from "./types";
-export * from "./filterToPrisma";
-export * from "./orderByToPrisma";
 export * from "./tracesTable";
-export * from "./server/auth/auth";
+export * from "./server/auth/apiKeys";
 export * from "./observationsTable";
 export * from "./utils/zod";
 export * from "./utils/json";
@@ -21,7 +19,6 @@ export { env } from "./env";
 
 // llm api
 export * from "./server/llm/types";
-export * from "./server/llm/fetchLLMCompletion";
 
 // evals
 export * from "./features/evals/types";
@@ -43,3 +40,5 @@ export { type DB } from "../prisma/generated/types";
 
 // errors
 export * from "./errors/index";
+
+export * from "./utils/environment";

packages/shared/src/interfaces/customLLMProviderConfigSchemas.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+
+export const BedrockConfigSchema = z.object({ region: z.string() });
+export type BedrockConfig = z.infer<typeof BedrockConfigSchema>;
+
+export const BedrockCredentialSchema = z
+  .object({
+    accessKeyId: z.string(),
+    secretAccessKey: z.string(),
+  })
+  .optional();
+export type BedrockCredential = z.infer<typeof BedrockCredentialSchema>;

packages/shared/src/interfaces/rate-limits.ts

@@ -6,6 +6,7 @@ export const RateLimitResource = z.enum([
   "public-api",
   "public-api-metrics",
   "prompts",
+  "legacy-ingestion",
 ]);
 
 // result of the rate limit check.

packages/shared/src/observationsTable.ts

@@ -52,7 +52,8 @@ export const observationsTableCols: ColumnDefinition[] = [
     name: "Time To First Token (s)",
     id: "timeToFirstToken",
     type: "number",
-    internal: 'o."completion_start_time" - o."start_time"',
+    internal:
+      'EXTRACT(EPOCH FROM (o."completion_start_time" - o."start_time"))',
     nullable: true,
   },
   {
@@ -62,10 +63,10 @@ export const observationsTableCols: ColumnDefinition[] = [
     internal: '"latency"',
   },
   {
-    name: "Time Per Output Token (s)",
-    id: "timePerOutputToken",
+    name: "Tokens per second",
+    id: "tokensPerSecond",
     type: "number",
-    internal: '"latency" / o."completion_tokens"',
+    internal: 'o."completion_tokens" / "latency"',
     nullable: true,
   },
   {

packages/shared/src/queries/index.ts

@@ -1 +0,0 @@
-export { createSessionsAllQuery } from "./createSessionsAllQuery";

packages/shared/src/server/auth/apiKeys.ts

@@ -0,0 +1,81 @@
+import { PrismaClient } from "@prisma/client";
+import { compare, hash } from "bcryptjs";
+import { randomUUID } from "crypto";
+import * as crypto from "crypto";
+import { env } from "../../env";
+
+export function getDisplaySecretKey(secretKey: string) {
+  return secretKey.slice(0, 6) + "..." + secretKey.slice(-4);
+}
+
+export async function hashSecretKey(key: string) {
+  // legacy, uses bcrypt, transformed into hashed key upon first use
+  const hashedKey = await hash(key, 11);
+  return hashedKey;
+}
+
+async function generateKeySet() {
+  return {
+    pk: `pk-lf-${randomUUID()}`,
+    sk: `sk-lf-${randomUUID()}`,
+  };
+}
+
+export async function verifySecretKey(key: string, hashedKey: string) {
+  const isValid = await compare(key, hashedKey);
+  return isValid;
+}
+
+export function createShaHash(privateKey: string, salt: string): string {
+  const hash = crypto
+    .createHash("sha256")
+    .update(privateKey)
+    .update(crypto.createHash("sha256").update(salt, "utf8").digest("hex"))
+    .digest("hex");
+
+  return hash;
+}
+
+export async function createAndAddApiKeysToDb(p: {
+  prisma: PrismaClient;
+  projectId: string;
+  note?: string;
+  predefinedKeys?: {
+    secretKey: string;
+    publicKey: string;
+  };
+}) {
+  const salt = env.SALT;
+  if (!salt) {
+    throw new Error("SALT is not set");
+  }
+
+  const { pk, sk } = p.predefinedKeys
+    ? { pk: p.predefinedKeys.publicKey, sk: p.predefinedKeys.secretKey }
+    : await generateKeySet();
+
+  const hashedSk = await hashSecretKey(sk);
+  const displaySk = getDisplaySecretKey(sk);
+
+  const hashFromProvidedKey = createShaHash(sk, salt);
+
+  const apiKey = await p.prisma.apiKey.create({
+    data: {
+      projectId: p.projectId,
+      publicKey: pk,
+      hashedSecretKey: hashedSk,
+      displaySecretKey: displaySk,
+      fastHashedSecretKey: hashFromProvidedKey,
+      note: p.note,
+    },
+  });
+
+  return {
+    id: apiKey.id,
+    createdAt: apiKey.createdAt,
+    note: apiKey.note,
+    publicKey: apiKey.publicKey,
+    secretKey: sk,
+    displaySecretKey: displaySk,
+  };
+}

packages/shared/src/server/auth/auth.ts

@@ -1,81 +0,0 @@
-import { compare, hash } from "bcryptjs";
-import { randomUUID } from "crypto";
-import * as crypto from "crypto";
-import type { OAuthConfig, OAuthUserConfig } from "next-auth/providers/oauth";
-
-export function generateSecretKey() {
-  return `sk-lf-${randomUUID()}`;
-}
-
-export function generatePublicKey() {
-  return `pk-lf-${randomUUID()}`;
-}
-
-export function getDisplaySecretKey(secretKey: string) {
-  return secretKey.slice(0, 6) + "..." + secretKey.slice(-4);
-}
-
-export async function hashSecretKey(key: string) {
-  // legacy, uses bcrypt, transformed into hashed key upon first use
-  const hashedKey = await hash(key, 11);
-  return hashedKey;
-}
-
-export async function generateKeySet() {
-  const pk = generatePublicKey();
-  const sk = generateSecretKey();
-  const hashedSk = await hashSecretKey(sk);
-  const displaySk = getDisplaySecretKey(sk);
-
-  return {
-    pk,
-    sk,
-    hashedSk,
-    displaySk,
-  };
-}
-
-export async function verifySecretKey(key: string, hashedKey: string) {
-  const isValid = await compare(key, hashedKey);
-  return isValid;
-}
-
-export function createShaHash(privateKey: string, salt: string): string {
-  const hash = crypto
-    .createHash("sha256")
-    .update(privateKey)
-    .update(crypto.createHash("sha256").update(salt, "utf8").digest("hex"))
-    .digest("hex");
-
-  return hash;
-}
-
-export interface CustomSSOUser extends Record<string, any> {
-  email: string;
-  id: string;
-  name: string;
-  verified: boolean;
-}
-
-export function CustomSSOProvider<P extends CustomSSOUser>(
-  options: OAuthUserConfig<P>
-): OAuthConfig<P> {
-  return {
-    id: "custom",
-    name: "CustomSSOProvider",
-    type: "oauth",
-    wellKnown: `${options.issuer}/.well-known/openid-configuration`,
-    authorization: { params: { scope: "openid email profile" } }, // overridden by options.authorization to be able to set custom scopes, deep merged with this default
-    checks: ["pkce", "state"],
-    idToken: true,
-    profile(profile) {
-      return {
-        id: profile.sub,
-        name: profile.name,
-        email: profile.email,
-        image: null,
-      };
-    },
-    options,
-  };
-}

packages/shared/src/server/auth/customSsoProvider.ts

@@ -0,0 +1,31 @@
+import type { OAuthConfig, OAuthUserConfig } from "next-auth/providers/oauth";
+
+interface CustomSSOUser extends Record<string, any> {
+  email: string;
+  id: string;
+  name: string;
+  verified: boolean;
+}
+
+export function CustomSSOProvider<P extends CustomSSOUser>(
+  options: OAuthUserConfig<P>
+): OAuthConfig<P> {
+  return {
+    id: "custom",
+    name: "CustomSSOProvider",
+    type: "oauth",
+    wellKnown: `${options.issuer}/.well-known/openid-configuration`,
+    authorization: { params: { scope: "openid email profile" } }, // overridden by options.authorization to be able to set custom scopes, deep merged with this default
+    checks: ["pkce", "state"],
+    idToken: true,
+    profile(profile) {
+      return {
+        id: profile.sub,
+        name: profile.name,
+        email: profile.email,
+        image: null,
+      };
+    },
+    options,
+  };
+}

packages/shared/src/server/clickhouse.ts

@@ -1,6 +1,38 @@
 import { createClient } from "@clickhouse/client";
 
 import { env } from "../env";
+import { eventTypes } from "./ingestion/types";
+import { LangfuseNotFoundError } from "../errors";
+
+export enum ClickhouseEntityType {
+  Trace = "trace",
+  Score = "score",
+  Observation = "observation",
+  SdkLog = "sdk-log",
+}
+
+export function getClickhouseEntityType(
+  eventType: string,
+): ClickhouseEntityType {
+  switch (eventType) {
+    case eventTypes.TRACE_CREATE:
+      return ClickhouseEntityType.Trace;
+    case eventTypes.OBSERVATION_CREATE:
+    case eventTypes.OBSERVATION_UPDATE:
+    case eventTypes.EVENT_CREATE:
+    case eventTypes.SPAN_CREATE:
+    case eventTypes.SPAN_UPDATE:
+    case eventTypes.GENERATION_CREATE:
+    case eventTypes.GENERATION_UPDATE:
+      return ClickhouseEntityType.Observation;
+    case eventTypes.SCORE_CREATE:
+      return ClickhouseEntityType.Score;
+    case eventTypes.SDK_LOG:
+      return ClickhouseEntityType.SdkLog;
+    default:
+      throw new LangfuseNotFoundError(`Unknown event type: ${eventType}`);
+  }
+}
 
 export type ClickhouseClientType = ReturnType<typeof createClient>;
 

packages/shared/src/server/definitions.ts

@@ -50,6 +50,7 @@ export const observationRecordReadSchema = observationRecordBaseSchema.extend({
   start_time: clickhouseStringDateSchema,
   end_time: clickhouseStringDateSchema.nullish(),
   completion_start_time: clickhouseStringDateSchema.nullish(),
+  event_ts: clickhouseStringDateSchema,
 });
 export type ObservationRecordReadType = z.infer<
   typeof observationRecordReadSchema
@@ -62,6 +63,7 @@ export const observationRecordInsertSchema = observationRecordBaseSchema.extend(
     start_time: z.number(),
     end_time: z.number().nullish(),
     completion_start_time: z.number().nullish(),
+    event_ts: z.number(),
   }
 );
 export type ObservationRecordInsertType = z.infer<
@@ -89,6 +91,7 @@ export const traceRecordReadSchema = traceRecordBaseSchema.extend({
   timestamp: clickhouseStringDateSchema,
   created_at: clickhouseStringDateSchema,
   updated_at: clickhouseStringDateSchema,
+  event_ts: clickhouseStringDateSchema,
 });
 export type TraceRecordReadType = z.infer<typeof traceRecordReadSchema>;
 
@@ -96,6 +99,7 @@ export const traceRecordInsertSchema = traceRecordBaseSchema.extend({
   timestamp: z.number(),
   created_at: z.number(),
   updated_at: z.number(),
+  event_ts: z.number(),
 });
 export type TraceRecordInsertType = z.infer<typeof traceRecordInsertSchema>;
 
@@ -119,6 +123,7 @@ export const scoreRecordReadSchema = scoreRecordBaseSchema.extend({
   created_at: clickhouseStringDateSchema,
   updated_at: clickhouseStringDateSchema,
   timestamp: clickhouseStringDateSchema,
+  event_ts: clickhouseStringDateSchema,
 });
 export type ScoreRecordReadType = z.infer<typeof scoreRecordReadSchema>;
 
@@ -126,6 +131,7 @@ export const scoreRecordInsertSchema = scoreRecordBaseSchema.extend({
   created_at: z.number(),
   updated_at: z.number(),
   timestamp: z.number(),
+  event_ts: z.number(),
 });
 export type ScoreRecordInsertType = z.infer<typeof scoreRecordInsertSchema>;
 
@@ -137,6 +143,7 @@ export const convertTraceReadToInsert = (
     created_at: new Date(record.created_at).getTime(),
     updated_at: new Date(record.created_at).getTime(),
     timestamp: new Date(record.timestamp).getTime(),
+    event_ts: new Date(record.event_ts).getTime(),
   };
 };
 
@@ -152,6 +159,7 @@ export const convertObservationReadToInsert = (
     completion_start_time: record.completion_start_time
       ? new Date(record.completion_start_time).getTime()
       : undefined,
+    event_ts: new Date(record.event_ts).getTime(),
   };
 };
 
@@ -163,5 +171,6 @@ export const convertScoreReadToInsert = (
     created_at: new Date(record.created_at).getTime(),
     updated_at: new Date(record.updated_at).getTime(),
     timestamp: new Date(record.timestamp).getTime(),
+    event_ts: new Date(record.event_ts).getTime(),
   };
 };

packages/shared/src/server/filterToPrisma.ts

@@ -1,8 +1,9 @@
 import { Prisma } from "@prisma/client";
-import { ColumnDefinition, type TableNames } from "./tableDefinitions";
-import { FilterState } from "./types";
-import { filterOperators, timeFilter } from "./interfaces/filters";
+import { ColumnDefinition, type TableNames } from "../tableDefinitions";
+import { FilterState } from "../types";
+import { filterOperators, timeFilter } from "../interfaces/filters";
 import { z } from "zod";
+import { logger } from "./index";
 
 const operatorReplacements = {
   "any of": "IN",
@@ -51,7 +52,7 @@ export function tableColumnsToSqlFilter(
         c.name === filter.column || c.id === filter.column
     );
     if (!col) {
-      console.error("Invalid filter column", filter.column);
+      logger.error("Invalid filter column", filter.column);
       throw new Error("Invalid filter column: " + filter.column);
     }
     const colPrisma = Prisma.raw(col.internal);

packages/shared/src/server/index.ts

@@ -3,25 +3,29 @@ export * from "./services/email/organizationInvitation/sendMembershipInvitationE
 export * from "./services/email/batchExportSuccess/sendBatchExportSuccessEmail";
 export * from "./services/email/passwordReset/sendResetPasswordVerificationRequest";
 export * from "./services/PromptService";
-export * from "./auth/auth";
+export * from "./auth/apiKeys";
+export * from "./auth/customSsoProvider";
 export * from "./llm/fetchLLMCompletion";
 export * from "./llm/types";
 export * from "./utils/DatabaseReadStream";
 export * from "./utils/transforms";
 export * from "./clickhouse";
 export * from "../server/definitions";
-export * from "../server/ingestion/IngestionUtils";
 export * from "../server/ingestion/types";
-export * from "../server/ingestion/model-match";
+export * from "./ingestion/modelMatch";
 export * from "../server/ingestion/types";
 export * from "../server/ingestion/validateAndInflateScore";
 export * from "./redis/redis";
-export * from "./redis/trace-upsert";
-export * from "./redis/batch-export";
-export * from "./redis/ingestionFlushQueue";
-export * from "./redis/legacy-ingestion";
+export * from "./redis/traceUpsert";
+export * from "./redis/batchExport";
+export * from "./redis/legacyIngestion";
+export * from "./redis/ingestionQueue";
 export * from "./auth/types";
 export * from "./ingestion/legacy/index";
 export * from "./queues";
 export * from "./ingestion/legacy/EventProcessor";
+export * from "./orderByToPrisma";
+export * from "./filterToPrisma";
 export * from "./instrumentation";
+export * from "./logger";
+export * from "./queries";

packages/shared/src/server/ingestion/IngestionUtils.ts

@@ -1,86 +0,0 @@
-import { eventTypes, IngestionEventType } from "./types";
-
-const reservedCharsEscapeMap = [
-  { reserved: ":", escape: "|%|" },
-  { reserved: "_", escape: "|#|" },
-];
-
-export enum ClickhouseEntityType {
-  Trace = "trace",
-  Score = "score",
-  Observation = "observation",
-  SDK_LOG = "sdk-log",
-}
-
-export class IngestionUtils {
-  public static getBufferKey(flushKey: string): string {
-    const { projectId, eventType, entityId } =
-      IngestionUtils.parseFlushKey(flushKey);
-
-    const sanitizedEntityId = IngestionUtils.escapeReservedChars(entityId);
-
-    return (
-      "ingestionBuffer:" + `${projectId}_${eventType}_${sanitizedEntityId}`
-    );
-  }
-
-  public static getFlushKey(params: {
-    projectId: string;
-    eventType: ClickhouseEntityType;
-    entityId: string;
-    batchTimestamp: string;
-  }): string {
-    const { projectId, eventType, entityId, batchTimestamp } = params;
-    const sanitizedEntityId = IngestionUtils.escapeReservedChars(entityId);
-
-    return `${projectId}_${eventType}_${sanitizedEntityId}_${batchTimestamp}`;
-  }
-
-  public static parseFlushKey(projectEntityKey: string) {
-    const split = projectEntityKey.split("_");
-
-    if (split.length < 3) {
-      throw new Error(
-        `Invalid project entity key format ${projectEntityKey}, expected 3 or 4 parts`
-      );
-    }
-
-    const [projectId, eventType, escapedEntityId, batchTimestamp] = split;
-    const entityId = IngestionUtils.unescapeReservedChars(escapedEntityId);
-
-    return { projectId, eventType, entityId, batchTimestamp };
-  }
-
-  private static escapeReservedChars(string: string): string {
-    return reservedCharsEscapeMap.reduce(
-      (acc, { reserved, escape }) => acc.replaceAll(reserved, escape),
-      string
-    );
-  }
-
-  private static unescapeReservedChars(escapedString: string): string {
-    return reservedCharsEscapeMap.reduce(
-      (acc, { reserved, escape }) => acc.replaceAll(escape, reserved),
-      escapedString
-    );
-  }
-
-  public static getEventType(event: IngestionEventType): ClickhouseEntityType {
-    switch (event.type) {
-      case eventTypes.TRACE_CREATE:
-        return ClickhouseEntityType.Trace;
-      case eventTypes.OBSERVATION_CREATE:
-      case eventTypes.OBSERVATION_UPDATE:
-      case eventTypes.EVENT_CREATE:
-      case eventTypes.SPAN_CREATE:
-      case eventTypes.SPAN_UPDATE:
-      case eventTypes.GENERATION_CREATE:
-      case eventTypes.GENERATION_UPDATE:
-        return ClickhouseEntityType.Observation;
-      case eventTypes.SCORE_CREATE:
-        return ClickhouseEntityType.Score;
-      case eventTypes.SDK_LOG:
-        return ClickhouseEntityType.SDK_LOG;
-    }
-  }
-}

packages/shared/src/server/ingestion/legacy/EventProcessor.ts

@@ -1,7 +1,7 @@
 import { v4 } from "uuid";
 import { type z } from "zod";
 import Decimal from "decimal.js";
-import { findModel } from "../model-match";
+import { findModel } from "../modelMatch";
 import {
   ObservationEvent,
   eventTypes,
@@ -10,6 +10,7 @@ import {
   traceEvent,
   scoreEvent,
   sdkLogEvent,
+  ingestionEvent,
 } from "../types";
 import { validateAndInflateScore } from "../validateAndInflateScore";
 import { Trace, Observation, Score, Prisma, Model } from "@prisma/client";
@@ -18,15 +19,42 @@ import { mergeJson } from "../../../utils/json";
 import { jsonSchema } from "../../../utils/zod";
 import { prisma } from "../../../db";
 import { LegacyIngestionAccessScope } from ".";
+import { logger } from "../../logger";
 
 export interface EventProcessor {
   auth(apiScope: LegacyIngestionAccessScope): void;
 
   process(
-    apiScope: LegacyIngestionAccessScope
+    apiScope: LegacyIngestionAccessScope,
   ): Promise<Trace | Observation | Score> | undefined;
 }
 
+export const getProcessorForEvent = (
+  event: z.infer<typeof ingestionEvent>,
+  calculateTokenDelegate: (p: {
+    model: Model;
+    text: unknown;
+  }) => number | undefined,
+): EventProcessor => {
+  switch (event.type) {
+    case eventTypes.TRACE_CREATE:
+      return new TraceProcessor(event);
+    case eventTypes.OBSERVATION_CREATE:
+    case eventTypes.OBSERVATION_UPDATE:
+    case eventTypes.EVENT_CREATE:
+    case eventTypes.SPAN_CREATE:
+    case eventTypes.SPAN_UPDATE:
+    case eventTypes.GENERATION_CREATE:
+    case eventTypes.GENERATION_UPDATE:
+      return new ObservationProcessor(event, calculateTokenDelegate);
+    case eventTypes.SCORE_CREATE: {
+      return new ScoreProcessor(event);
+    }
+    case eventTypes.SDK_LOG:
+      return new SdkLogProcessor(event);
+  }
+};
+
 export class ObservationProcessor implements EventProcessor {
   event: ObservationEvent;
   calculateTokenDelegate: (p: {
@@ -39,7 +67,7 @@ export class ObservationProcessor implements EventProcessor {
     calculateTokenDelegate: (p: {
       model: Model;
       text: unknown;
-    }) => number | undefined
+    }) => number | undefined,
   ) {
     this.event = event;
     this.calculateTokenDelegate = calculateTokenDelegate;
@@ -47,7 +75,7 @@ export class ObservationProcessor implements EventProcessor {
 
   async convertToObservation(
     apiScope: LegacyIngestionAccessScope,
-    existingObservation: Observation | null
+    existingObservation: Omit<Observation, "input" | "output"> | null,
   ): Promise<{
     id: string;
     create: Prisma.ObservationUncheckedCreateInput;
@@ -77,7 +105,7 @@ export class ObservationProcessor implements EventProcessor {
       !existingObservation
     ) {
       throw new LangfuseNotFoundError(
-        `Observation with id ${this.event.id} not found`
+        `Observation with id ${this.event.id} not found`,
       );
     }
 
@@ -89,11 +117,11 @@ export class ObservationProcessor implements EventProcessor {
               projectId: apiScope.projectId,
               model:
                 "model" in this.event.body
-                  ? this.event.body.model ?? undefined
+                  ? (this.event.body.model ?? undefined)
                   : undefined,
               unit:
                 "usage" in this.event.body
-                  ? this.event.body.usage?.unit ?? undefined
+                  ? (this.event.body.usage?.unit ?? undefined)
                   : undefined,
               startTime: this.event.body.startTime
                 ? new Date(this.event.body.startTime)
@@ -119,20 +147,21 @@ export class ObservationProcessor implements EventProcessor {
     // Token counts
     const [newInputCount, newOutputCount] =
       "usage" in this.event.body
-        ? this.calculateTokenCounts(
+        ? await this.calculateTokenCounts(
+            apiScope.projectId,
             this.event.body,
             this.calculateTokenDelegate,
             internalModel ?? undefined,
-            existingObservation ?? undefined
+            existingObservation ?? undefined,
           )
         : [undefined, undefined];
 
     const newTotalCount =
       "usage" in this.event.body
-        ? this.event.body.usage?.total ??
+        ? (this.event.body.usage?.total ??
           (newInputCount != null || newOutputCount != null
             ? (newInputCount ?? 0) + (newOutputCount ?? 0)
-            : undefined)
+            : undefined))
         : undefined;
 
     const userProvidedTokenCosts = {
@@ -159,7 +188,7 @@ export class ObservationProcessor implements EventProcessor {
     const calculatedCosts = ObservationProcessor.calculateTokenCosts(
       internalModel,
       userProvidedTokenCosts,
-      tokenCounts
+      tokenCounts,
     );
 
     // merge metadata from existingObservation.metadata and metadata
@@ -167,7 +196,7 @@ export class ObservationProcessor implements EventProcessor {
       existingObservation?.metadata
         ? jsonSchema.parse(existingObservation.metadata)
         : undefined,
-      this.event.body.metadata ?? undefined
+      this.event.body.metadata ?? undefined,
     );
 
     const prompt =
@@ -187,8 +216,9 @@ export class ObservationProcessor implements EventProcessor {
         : undefined;
 
     // Only null if promptName and promptVersion are set but prompt is not found
-    if (prompt === null)
-      console.warn("Prompt not found for observation", this.event.body);
+    if (prompt === null) {
+      logger.warn("Prompt not found for observation", this.event.body);
+    }
 
     const observationId = this.event.body.id ?? v4();
 
@@ -215,7 +245,7 @@ export class ObservationProcessor implements EventProcessor {
         model: "model" in this.event.body ? this.event.body.model : undefined,
         modelParameters:
           "modelParameters" in this.event.body
-            ? this.event.body.modelParameters ?? undefined
+            ? (this.event.body.modelParameters ?? undefined)
             : undefined,
         input: this.event.body.input ?? undefined,
         output: this.event.body.output ?? undefined,
@@ -224,7 +254,7 @@ export class ObservationProcessor implements EventProcessor {
         totalTokens: newTotalCount,
         unit:
           "usage" in this.event.body
-            ? this.event.body.usage?.unit ?? internalModel?.unit
+            ? (this.event.body.usage?.unit ?? internalModel?.unit)
             : internalModel?.unit,
         level: this.event.body.level ?? undefined,
         statusMessage: this.event.body.statusMessage ?? undefined,
@@ -270,7 +300,7 @@ export class ObservationProcessor implements EventProcessor {
         model: "model" in this.event.body ? this.event.body.model : undefined,
         modelParameters:
           "modelParameters" in this.event.body
-            ? this.event.body.modelParameters ?? undefined
+            ? (this.event.body.modelParameters ?? undefined)
             : undefined,
         input: this.event.body.input ?? undefined,
         output: this.event.body.output ?? undefined,
@@ -279,7 +309,7 @@ export class ObservationProcessor implements EventProcessor {
         totalTokens: newTotalCount,
         unit:
           "usage" in this.event.body
-            ? this.event.body.usage?.unit ?? internalModel?.unit
+            ? (this.event.body.usage?.unit ?? internalModel?.unit)
             : internalModel?.unit,
         level: this.event.body.level ?? undefined,
         statusMessage: this.event.body.statusMessage ?? undefined,
@@ -309,7 +339,8 @@ export class ObservationProcessor implements EventProcessor {
     };
   }
 
-  calculateTokenCounts(
+  async calculateTokenCounts(
+    projectId: string,
     body:
       | z.infer<typeof legacyObservationCreateEvent>["body"]
       | z.infer<typeof generationCreateEvent>["body"],
@@ -318,29 +349,59 @@ export class ObservationProcessor implements EventProcessor {
       text: unknown;
     }) => number | undefined,
     model?: Model,
-    existingObservation?: Observation
+    existingObservation?: Omit<Observation, "input" | "output">,
   ) {
-    const newPromptTokens =
-      body.usage?.input ??
-      ((body.input || existingObservation?.input) && model && model.tokenizerId
-        ? calculateTokenDelegate({
-            model: model,
-            text: body.input ?? existingObservation?.input,
-          })
-        : undefined);
+    let newPromptTokens = body.usage?.input;
+    if (newPromptTokens === undefined && model && model.tokenizerId) {
+      if (body.input) {
+        newPromptTokens = calculateTokenDelegate({
+          model: model,
+          text: body.input,
+        });
+      } else {
+        logger.info(
+          `No input provided, trying to calculate for id: ${existingObservation?.id}`,
+        );
+        const observationInput = await prisma.observation.findFirst({
+          where: { id: existingObservation?.id, projectId: projectId },
+          select: {
+            input: true,
+          },
+        });
 
-    const newCompletionTokens =
-      body.usage?.output ??
-      ((body.output || existingObservation?.output) &&
-      model &&
-      model.tokenizerId
-        ? calculateTokenDelegate({
-            model: model,
-            text: body.output ?? existingObservation?.output,
-          })
-        : undefined);
+        newPromptTokens = calculateTokenDelegate({
+          model: model,
+          text: observationInput?.input,
+        });
+      }
+    }
 
-    return [newPromptTokens, newCompletionTokens];
+    let newCompletionTokens = body.usage?.output;
+
+    if (newCompletionTokens === undefined && model && model.tokenizerId) {
+      if (body.output) {
+        newCompletionTokens = calculateTokenDelegate({
+          model: model,
+          text: body.output,
+        });
+      } else {
+        logger.info(
+          `No output provided, trying to calculate for id: ${existingObservation?.id}`,
+        );
+        const observationOutput = await prisma.observation.findFirst({
+          where: { id: existingObservation?.id, projectId: projectId },
+          select: {
+            output: true,
+          },
+        });
+        newCompletionTokens = calculateTokenDelegate({
+          model: model,
+          text: observationOutput?.output,
+        });
+      }
+    }
+
+    return [newPromptTokens ?? undefined, newCompletionTokens ?? undefined];
   }
 
   static calculateTokenCosts(
@@ -350,7 +411,7 @@ export class ObservationProcessor implements EventProcessor {
       outputCost?: Decimal | null;
       totalCost?: Decimal | null;
     },
-    tokenCounts: { input?: number; output?: number; total?: number }
+    tokenCounts: { input?: number; output?: number; total?: number },
   ): {
     inputCost?: Decimal | null;
     outputCost?: Decimal | null;
@@ -367,7 +428,7 @@ export class ObservationProcessor implements EventProcessor {
         totalCost:
           userProvidedCosts.totalCost ??
           (userProvidedCosts.inputCost ?? new Decimal(0)).add(
-            userProvidedCosts.outputCost ?? new Decimal(0)
+            userProvidedCosts.outputCost ?? new Decimal(0),
           ),
       };
     }
@@ -387,7 +448,7 @@ export class ObservationProcessor implements EventProcessor {
     const finalTotalCost =
       tokenCounts.total !== undefined && model?.totalPrice
         ? model.totalPrice.mul(tokenCounts.total)
-        : finalInputCost ?? finalOutputCost
+        : (finalInputCost ?? finalOutputCost)
           ? new Decimal(finalInputCost ?? 0).add(finalOutputCost ?? 0)
           : undefined;
 
@@ -408,7 +469,43 @@ export class ObservationProcessor implements EventProcessor {
 
     const existingObservation = this.event.body.id
       ? await prisma.observation.findFirst({
-          where: { id: this.event.body.id },
+          select: {
+            // do not select I/O to spare our db
+            input: false,
+            output: false,
+
+            id: true,
+            traceId: true,
+            projectId: true,
+            type: true,
+            startTime: true,
+            endTime: true,
+            name: true,
+            metadata: true,
+            parentObservationId: true,
+            level: true,
+            statusMessage: true,
+            version: true,
+            createdAt: true,
+            updatedAt: true,
+            model: true,
+            internalModelId: true,
+            modelParameters: true,
+            promptTokens: true,
+            completionTokens: true,
+            totalTokens: true,
+            unit: true,
+            inputCost: true,
+            outputCost: true,
+            totalCost: true,
+            calculatedInputCost: true,
+            calculatedOutputCost: true,
+            calculatedTotalCost: true,
+            completionStartTime: true,
+            promptId: true,
+            internalModel: true,
+          },
+          where: { id: this.event.body.id, projectId: apiScope.projectId },
         })
       : null;
 
@@ -417,7 +514,7 @@ export class ObservationProcessor implements EventProcessor {
       existingObservation.projectId !== apiScope.projectId
     ) {
       throw new ForbiddenError(
-        `Access denied for observation creation ${existingObservation.projectId} `
+        `Access denied for observation creation ${existingObservation.projectId} `,
       );
     }
 
@@ -434,6 +531,7 @@ export class ObservationProcessor implements EventProcessor {
     });
   }
 }
+
 export class TraceProcessor implements EventProcessor {
   event: z.infer<typeof traceEvent>;
 
@@ -447,7 +545,7 @@ export class TraceProcessor implements EventProcessor {
   }
 
   async process(
-    apiScope: LegacyIngestionAccessScope
+    apiScope: LegacyIngestionAccessScope,
   ): Promise<Trace | Observation | Score> {
     const { body } = this.event;
 
@@ -455,11 +553,8 @@ export class TraceProcessor implements EventProcessor {
 
     const internalId = body.id ?? v4();
 
-    console.log(
-      "Trying to create trace, project ",
-      apiScope.projectId,
-      ", id:",
-      internalId
+    logger.debug(
+      `Trying to create trace, project ${apiScope.projectId}, id: ${internalId}`,
     );
 
     const existingTrace = await prisma.trace.findFirst({
@@ -470,7 +565,7 @@ export class TraceProcessor implements EventProcessor {
 
     if (existingTrace && existingTrace.projectId !== apiScope.projectId) {
       throw new ForbiddenError(
-        `Access denied for trace creation ${existingTrace.projectId}`
+        `Access denied for trace creation ${existingTrace.projectId}`,
       );
     }
 
@@ -478,7 +573,7 @@ export class TraceProcessor implements EventProcessor {
       existingTrace?.metadata
         ? jsonSchema.parse(existingTrace.metadata)
         : undefined,
-      body.metadata ?? undefined
+      body.metadata ?? undefined,
     );
 
     const mergedTags =
@@ -546,6 +641,7 @@ export class TraceProcessor implements EventProcessor {
     return upsertedTrace;
   }
 }
+
 export class ScoreProcessor implements EventProcessor {
   event: z.infer<typeof scoreEvent>;
 
@@ -556,12 +652,12 @@ export class ScoreProcessor implements EventProcessor {
   auth(apiScope: LegacyIngestionAccessScope) {
     if (apiScope.accessLevel !== "scores" && apiScope.accessLevel !== "all")
       throw new ForbiddenError(
-        `Access denied for score creation, ${apiScope.accessLevel}`
+        `Access denied for score creation, ${apiScope.accessLevel}`,
       );
   }
 
   async process(
-    apiScope: LegacyIngestionAccessScope
+    apiScope: LegacyIngestionAccessScope,
   ): Promise<Trace | Observation | Score> {
     const { body } = this.event;
 
@@ -579,7 +675,7 @@ export class ScoreProcessor implements EventProcessor {
     });
     if (existingScore && existingScore.projectId !== apiScope.projectId) {
       throw new ForbiddenError(
-        `Access denied for score creation ${existingScore.projectId}`
+        `Access denied for score creation ${existingScore.projectId}`,
       );
     }
 
@@ -619,7 +715,7 @@ export class SdkLogProcessor implements EventProcessor {
 
   process() {
     try {
-      console.log("SDK Log", this.event);
+      logger.info("SDK Log", this.event);
       return undefined;
     } catch (error) {
       return undefined;

packages/shared/src/server/ingestion/legacy/enqueueIngestionEvents.ts

@@ -1,71 +0,0 @@
-import { type Redis } from "ioredis";
-import { QueueJobs } from "../../queues";
-import {
-  getIngestionFlushQueue,
-  IngestionFlushQueue,
-} from "../../redis/ingestionFlushQueue";
-import { IngestionUtils } from "../IngestionUtils";
-import { IngestionEventType } from "../types";
-import { redis } from "../../redis/redis";
-import { env } from "../../../env";
-
-export async function enqueueIngestionEvents(
-  projectId: string,
-  events: IngestionEventType[]
-) {
-  const ingestionFlushQueue = getIngestionFlushQueue();
-
-  if (!ingestionFlushQueue) {
-    throw Error("IngestionFlushQueue not initialized");
-  }
-  if (!redis) throw Error("Redis connection not available");
-
-  const queuedEventPromises: Promise<void>[] = [];
-  const batchTimestamp = Date.now().toString();
-
-  // Use for loop as TS does not narrow redis type in map function
-  for (const event of events) {
-    queuedEventPromises.push(
-      enqueueSingleIngestionEvent(
-        projectId,
-        event,
-        redis,
-        ingestionFlushQueue,
-        batchTimestamp
-      )
-    );
-  }
-
-  await Promise.all(queuedEventPromises);
-}
-
-async function enqueueSingleIngestionEvent(
-  projectId: string,
-  event: IngestionEventType,
-  redis: Redis,
-  ingestionFlushQueue: IngestionFlushQueue,
-  batchTimestamp: string
-): Promise<void> {
-  if (!("id" in event.body && event.body.id)) {
-    console.warn(
-      `Received ingestion event without id: ${JSON.stringify(event)}`
-    );
-
-    return;
-  }
-
-  const flushKey = IngestionUtils.getFlushKey({
-    entityId: event.body.id,
-    eventType: IngestionUtils.getEventType(event),
-    projectId,
-    batchTimestamp,
-  });
-  const bufferKey = IngestionUtils.getBufferKey(flushKey);
-  const serializedEventData = JSON.stringify({ ...event, projectId });
-
-  await redis.lpush(bufferKey, serializedEventData);
-  await redis.expire(bufferKey, env.LANGFUSE_INGESTION_BUFFER_TTL_SECONDS);
-  await ingestionFlushQueue.add(QueueJobs.FlushIngestionEntity, null, {
-    jobId: flushKey,
-  });
-}

packages/shared/src/server/ingestion/legacy/index.ts

@@ -2,23 +2,17 @@ import { env } from "node:process";
 import z from "zod";
 import { ForbiddenError, UnauthorizedError } from "../../../errors";
 import { eventTypes, ingestionApiSchema, ingestionEvent } from "../types";
-import {
-  EventProcessor,
-  TraceProcessor,
-  ObservationProcessor,
-  ScoreProcessor,
-  SdkLogProcessor,
-} from "./EventProcessor";
-import { EventBodyType, EventName, TraceUpsertEventType } from "../../queues";
+import { getProcessorForEvent } from "./EventProcessor";
+import { TraceUpsertEventType } from "../../queues";
 import {
   convertTraceUpsertEventsToRedisEvents,
-  getTraceUpsertQueue,
-} from "../../redis/trace-upsert";
+  TraceUpsertQueue,
+} from "../../redis/traceUpsert";
 import { ApiAccessScope } from "../../auth/types";
 import { redis } from "../../redis/redis";
 import { backOff } from "exponential-backoff";
 import { Model } from "../../..";
-import { enqueueIngestionEvents } from "./enqueueIngestionEvents";
+import { logger } from "../../logger";
 
 export type BatchResult = {
   result: unknown;
@@ -49,9 +43,9 @@ type LegacyIngestionAuthHeaderVerificationResult =
 export const handleBatch = async (
   events: z.infer<typeof ingestionApiSchema>["batch"],
   authCheck: LegacyIngestionAuthHeaderVerificationResult,
-  calculateTokenDelegate: (p: TokenCountInput) => number | undefined
+  calculateTokenDelegate: (p: TokenCountInput) => number | undefined,
 ) => {
-  console.log(`handling ingestion ${events.length} events`);
+  logger.debug(`handling ingestion ${events.length} events`);
 
   if (!authCheck.validKey) throw new UnauthorizedError(authCheck.error);
 
@@ -69,7 +63,7 @@ export const handleBatch = async (
         return await handleSingleEvent(
           singleEvent,
           authCheck.scope,
-          calculateTokenDelegate
+          calculateTokenDelegate,
         );
       });
       results.push({
@@ -79,7 +73,7 @@ export const handleBatch = async (
       }); // Push each result into the array
     } catch (error) {
       // Handle or log the error if `handleSingleEvent` fails
-      console.error("Error handling event:", error);
+      logger.error("Error handling event:", error);
       // Decide how to handle the error: rethrow, continue, or push an error object to results
       // For example, push an error object:
       errors.push({
@@ -90,15 +84,6 @@ export const handleBatch = async (
     }
   }
 
-  if (env.CLICKHOUSE_URL) {
-    try {
-      await enqueueIngestionEvents(authCheck.scope.projectId, events);
-      console.log(`Added ${events.length} ingestion events to queue`);
-    } catch (err) {
-      console.error("Error adding ingestion events to queue", err);
-    }
-  }
-
   return { results, errors };
 };
 
@@ -107,10 +92,10 @@ async function retry<T>(request: () => Promise<T>): Promise<T> {
     numOfAttempts: env.LANGFUSE_ASYNC_INGESTION_PROCESSING === "true" ? 5 : 3,
     retry: (e: Error, attemptNumber: number) => {
       if (e instanceof UnauthorizedError || e instanceof ForbiddenError) {
-        console.log("not retrying auth error");
+        logger.info("not retrying auth error");
         return false;
       }
-      console.log(`retrying processing events ${attemptNumber}`);
+      logger.info(`retrying processing events ${attemptNumber}`);
       return true;
     },
   });
@@ -122,7 +107,7 @@ const handleSingleEvent = async (
   calculateTokenDelegate: (p: {
     model: Model;
     text: unknown;
-  }) => number | undefined
+  }) => number | undefined,
 ) => {
   const { body } = event;
   let restEvent = body;
@@ -137,46 +122,24 @@ const handleSingleEvent = async (
     restEvent = rest;
   }
 
-  console.log(
-    `handling single event ${event.id} of type ${event.type}:  ${JSON.stringify({ body: restEvent })}`
+  logger.info(
+    `handling single event ${event.id} of type ${event.type}:  ${JSON.stringify({ body: restEvent })}`,
   );
 
   const cleanedEvent = ingestionEvent.parse(cleanEvent(event));
 
-  const { type } = cleanedEvent;
-
-  let processor: EventProcessor;
-  switch (type) {
-    case eventTypes.TRACE_CREATE:
-      processor = new TraceProcessor(cleanedEvent);
-      break;
-    case eventTypes.OBSERVATION_CREATE:
-    case eventTypes.OBSERVATION_UPDATE:
-    case eventTypes.EVENT_CREATE:
-    case eventTypes.SPAN_CREATE:
-    case eventTypes.SPAN_UPDATE:
-    case eventTypes.GENERATION_CREATE:
-    case eventTypes.GENERATION_UPDATE:
-      processor = new ObservationProcessor(
-        cleanedEvent,
-        calculateTokenDelegate
-      );
-      break;
-    case eventTypes.SCORE_CREATE: {
-      processor = new ScoreProcessor(cleanedEvent);
-      break;
-    }
-    case eventTypes.SDK_LOG:
-      processor = new SdkLogProcessor(cleanedEvent);
-  }
-
   // Deny access to non-score events if the access level is not "all"
   // This is an additional safeguard to auth checks in EventProcessor
-  if (apiScope.accessLevel !== "all" && type !== eventTypes.SCORE_CREATE) {
+  if (
+    apiScope.accessLevel !== "all" &&
+    cleanedEvent.type !== eventTypes.SCORE_CREATE
+  ) {
     throw new ForbiddenError("Access denied. Event type not allowed.");
   }
 
-  return await processor.process(apiScope);
+  return getProcessorForEvent(cleanedEvent, calculateTokenDelegate).process(
+    apiScope,
+  );
 };
 
 // cleans NULL characters from the event
@@ -201,15 +164,15 @@ export function cleanEvent(obj: unknown): unknown {
 }
 
 export const isNotNullOrUndefined = <T>(
-  val?: T | null
+  val?: T | null,
 ): val is Exclude<T, null | undefined> => !isUndefinedOrNull(val);
 
 export const isUndefinedOrNull = <T>(val?: T | null): val is undefined | null =>
   val === undefined || val === null;
 
-export const sendToWorkerIfEnvironmentConfigured = async (
+export const addTracesToTraceUpsertQueue = async (
   batchResults: BatchResult[],
-  projectId: string
+  projectId: string,
 ): Promise<void> => {
   const traceEvents: TraceUpsertEventType[] = batchResults
     .filter((result) => result.type === eventTypes.TRACE_CREATE) // we only have create, no update.
@@ -219,49 +182,23 @@ export const sendToWorkerIfEnvironmentConfigured = async (
       "id" in result.result
         ? // ingestion API only gets traces for one projectId
           { traceId: result.result.id as string, projectId }
-        : null
+        : null,
     )
     .filter(isNotNullOrUndefined);
 
   try {
     if (env.NEXT_PUBLIC_LANGFUSE_CLOUD_REGION && redis) {
-      console.log(`Sending ${traceEvents.length} events to worker via Redis`);
+      logger.info(`Sending ${traceEvents.length} events to worker via Redis`);
 
-      const queue = getTraceUpsertQueue();
+      const queue = TraceUpsertQueue.getInstance();
       if (!queue) {
-        console.error("TraceUpsertQueue not initialized");
+        logger.error("TraceUpsertQueue not initialized");
         return;
       }
 
       await queue.addBulk(convertTraceUpsertEventsToRedisEvents(traceEvents));
-    } else if (
-      env.LANGFUSE_WORKER_HOST &&
-      env.LANGFUSE_WORKER_PASSWORD &&
-      env.NEXT_PUBLIC_LANGFUSE_CLOUD_REGION
-    ) {
-      console.log(`Sending ${traceEvents.length} events to worker via HTTP`);
-      const body: EventBodyType = {
-        name: EventName.TraceUpsert,
-        payload: traceEvents,
-      };
-
-      if (traceEvents.length > 0) {
-        await fetch(`${env.LANGFUSE_WORKER_HOST}/api/events`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization:
-              "Basic " +
-              Buffer.from(
-                "admin" + ":" + env.LANGFUSE_WORKER_PASSWORD
-              ).toString("base64"),
-          },
-          body: JSON.stringify(body),
-          signal: AbortSignal.timeout(8 * 1000),
-        });
-      }
     }
   } catch (error) {
-    console.error("Error sending events to worker", error);
+    logger.error("Error sending events to worker", error);
   }
 };

packages/shared/src/server/ingestion/modelMatch.ts

@@ -8,7 +8,7 @@ export async function findModel(p: {
     unit?: string;
     startTime?: Date;
   };
-  existingDbObservation?: Observation;
+  existingDbObservation?: Omit<Observation, "input" | "output">;
 }): Promise<Model | null> {
   const { event, existingDbObservation } = p;
   // either get the model from the existing observation

packages/shared/src/server/ingestion/types.ts

@@ -115,7 +115,7 @@ export const CreateGenerationBody = CreateSpanBody.extend({
           z.array(z.string()),
           z.record(z.string()),
         ])
-        .nullish()
+        .nullish(),
     )
     .nullish(),
   usage: usage,
@@ -143,7 +143,7 @@ export const UpdateGenerationBody = UpdateSpanBody.extend({
           z.array(z.string()),
           z.record(z.string()),
         ])
-        .nullish()
+        .nullish(),
     )
     .nullish(),
   usage: usage,
@@ -174,14 +174,14 @@ export const ScoreBody = z.discriminatedUnion("dataType", [
       value: z.number(),
       dataType: z.literal("NUMERIC"),
       configId: z.string().nullish(),
-    })
+    }),
   ),
   BaseScoreBody.merge(
     z.object({
       value: z.string(),
       dataType: z.literal("CATEGORICAL"),
       configId: z.string().nullish(),
-    })
+    }),
   ),
   BaseScoreBody.merge(
     z.object({
@@ -191,14 +191,14 @@ export const ScoreBody = z.discriminatedUnion("dataType", [
       }),
       dataType: z.literal("BOOLEAN"),
       configId: z.string().nullish(),
-    })
+    }),
   ),
   BaseScoreBody.merge(
     z.object({
       value: z.union([z.string(), z.number()]),
       dataType: z.undefined(),
       configId: z.string().nullish(),
-    })
+    }),
   ),
 ]);
 
@@ -243,7 +243,7 @@ export const LegacyGenerationsCreateSchema = z.object({
   modelParameters: z
     .record(
       z.string(),
-      z.union([z.string(), z.number(), z.boolean()]).nullish()
+      z.union([z.string(), z.number(), z.boolean()]).nullish(),
     )
     .nullish(),
   prompt: jsonSchema.nullish(),
@@ -267,7 +267,7 @@ export const LegacyGenerationPatchSchema = z.object({
   modelParameters: z
     .record(
       z.string(),
-      z.union([z.string(), z.number(), z.boolean()]).nullish()
+      z.union([z.string(), z.number(), z.boolean()]).nullish(),
     )
     .nullish(),
   prompt: jsonSchema.nullish(),
@@ -291,7 +291,7 @@ export const LegacyObservationBody = z.object({
   modelParameters: z
     .record(
       z.string(),
-      z.union([z.string(), z.number(), z.boolean()]).nullish()
+      z.union([z.string(), z.number(), z.boolean()]).nullish(),
     )
     .nullish(),
   input: jsonSchema.nullish(),
@@ -306,6 +306,7 @@ export const LegacyObservationBody = z.object({
 
 export const SdkLogEvent = z.object({
   log: jsonSchema,
+  id: z.string().nullish(), // Not used, but makes downstream processing easier.
 });
 
 // definitions for the ingestion API
@@ -402,7 +403,7 @@ export const ingestionBatchEvent = z.array(ingestionEvent);
 export type IngestionBatchEventType = z.infer<typeof ingestionBatchEvent>;
 
 export const ingestionEventWithProjectId = ingestionEvent.and(
-  z.object({ projectId: z.string() })
+  z.object({ projectId: z.string() }),
 );
 export type IngestionEventWithProjectIdType = z.infer<
   typeof ingestionEventWithProjectId

packages/shared/src/server/ingestion/validateAndInflateScore.ts

@@ -15,7 +15,7 @@ type ValidateAndInflateScoreParams = {
 };
 
 export async function validateAndInflateScore(
-  params: ValidateAndInflateScoreParams
+  params: ValidateAndInflateScoreParams,
 ): Promise<Score> {
   const { body, projectId } = params;
 
@@ -29,7 +29,7 @@ export async function validateAndInflateScore(
 
     if (!config || !validateDbScoreConfigSafe(config).success)
       throw new LangfuseNotFoundError(
-        "The configId you provided does not match a valid config in this project"
+        "The configId you provided does not match a valid config in this project",
       );
 
     validateConfigAgainstBody(body, config as ValidatedScoreConfig);
@@ -47,7 +47,7 @@ export async function validateAndInflateScore(
 
   if (!validation.success) {
     throw new InvalidRequestError(
-      `Ingested score value type not valid against provided data type. Provide numeric values for numeric and boolean scores, and string values for categorical scores.`
+      `Ingested score value type not valid against provided data type. Provide numeric values for numeric and boolean scores, and string values for categorical scores.`,
     );
   }
 
@@ -62,7 +62,7 @@ function inferDataType(value: string | number): ScoreDataType {
 
 function mapStringValueToNumericValue(
   config: ValidatedScoreConfig,
-  label: string
+  label: string,
 ): number | null {
   return (
     config.categories?.find((category) => category.label === label)?.value ??
@@ -71,7 +71,7 @@ function mapStringValueToNumericValue(
 }
 
 function inflateScoreBody(
-  params: ValidateAndInflateScoreParams & { config?: ValidatedScoreConfig }
+  params: ValidateAndInflateScoreParams & { config?: ValidatedScoreConfig },
 ): Score {
   const { body, projectId, scoreId, config } = params;
 
@@ -105,25 +105,25 @@ function inflateScoreBody(
 
 function validateConfigAgainstBody(
   body: any,
-  config: ValidatedScoreConfig
+  config: ValidatedScoreConfig,
 ): void {
   const { maxValue, minValue, categories, dataType: configDataType } = config;
 
   if (body.dataType && body.dataType !== configDataType) {
     throw new InvalidRequestError(
-      `Data type mismatch based on config: expected ${configDataType}, got ${body.dataType}`
+      `Data type mismatch based on config: expected ${configDataType}, got ${body.dataType}`,
     );
   }
 
   if (config.isArchived) {
     throw new InvalidRequestError(
-      "Config is archived and cannot be used to create new scores. Please restore the config first."
+      "Config is archived and cannot be used to create new scores. Please restore the config first.",
     );
   }
 
   if (config.name !== body.name) {
     throw new InvalidRequestError(
-      `Name mismatch based on config: expected ${config.name}, got ${body.name}`
+      `Name mismatch based on config: expected ${config.name}, got ${body.name}`,
     );
   }
 
@@ -136,7 +136,7 @@ function validateConfigAgainstBody(
 
   if (!dataTypeValidation.success) {
     throw new InvalidRequestError(
-      `Ingested score body not valid against provided config data type.`
+      `Ingested score body not valid against provided config data type.`,
     );
   }
 
@@ -154,7 +154,7 @@ function validateConfigAgainstBody(
       .join(", ");
 
     throw new InvalidRequestError(
-      `Ingested score body not valid against provided config: ${errorDetails}`
+      `Ingested score body not valid against provided config: ${errorDetails}`,
     );
   }
 }

packages/shared/src/server/instrumentation/Readme.md

@@ -12,13 +12,3 @@ Throughout our applications we want to use as much Otel as possible. This helps
 - `web` and `worker` have an instrumentation.ts file, which configures otel for the application.
 - For trpc, we use `@baselime/trpc-opentelemetry-middleware` to enrich spans with trpc inputs and outputs.
 - When building adding new infrastructure, we should search for auto instumentations for our code base.
-
-## Library support
-
-- `dd-trace` has a direct dependency of `@opentelemetry/api` version < `1.9` [GH](https://github.com/DataDog/dd-trace-js/blob/ed9b0b30f7b0283579a9bf8c18e1f9deab18fecf/package.json#L81).
-- `@prisma/instrumentation` requires at least `@opentelemetry/api` version `1.8` [GH](https://github.com/prisma/prisma/blob/d780290b13754420abcfa5d7592f02049c6cc005/packages/instrumentation/package.json#L25)
-- We need to ensure that all other libraries we use are compatible with `@opentelemetry/api` version `1.8`. If we have a package using a later version, this will break the instrumentation and crash the container. We can check the versions with the following command:
-
-```bash
-pnpm --filter=web why @opentelemetry/api
-```

packages/shared/src/server/instrumentation/index.ts

@@ -1,56 +1,50 @@
 import * as opentelemetry from "@opentelemetry/api";
 import * as dd from "dd-trace";
+import { env } from "../../env";
+import {
+  CloudWatchClient,
+  PutMetricDataCommand,
+} from "@aws-sdk/client-cloudwatch";
+import { logger } from "../logger";
 
 // type CallbackFn<T> = () => T;
 
+export type TCarrier = {
+  traceparent?: string;
+  tracestate?: string;
+};
+
 export type SpanCtx = {
   name: string;
   spanKind?: opentelemetry.SpanKind; // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/api.md#spankind
   rootSpan?: boolean; // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/overview.md#traces
   traceScope?: string;
+  traceContext?: TCarrier;
 };
 
-type AsyncCallbackFn<T> = () => Promise<T>;
+type AsyncCallbackFn<T> = (span: opentelemetry.Span) => Promise<T>;
 
 export async function instrumentAsync<T>(
   ctx: SpanCtx,
-  callback: AsyncCallbackFn<T>
+  callback: AsyncCallbackFn<T>,
 ): Promise<T> {
-  return await getTracer(ctx.traceScope ?? callback.name).startActiveSpan(
-    ctx.name,
-    {
-      root: ctx.rootSpan,
-      kind: ctx.spanKind,
-    },
-    async (span) => {
-      try {
-        const result = await callback();
-        span.end();
-        return result;
-      } catch (ex) {
-        traceException(ex as opentelemetry.Exception, span);
-        span.end();
-        throw ex;
-      }
-    }
-  );
-}
+  const activeContext = ctx.traceContext
+    ? opentelemetry.propagation.extract(
+        opentelemetry.context.active(),
+        ctx.traceContext,
+      )
+    : opentelemetry.context.active();
 
-type SyncCallbackFn<T> = () => T;
-
-export function instrumentSync<T>(
-  ctx: SpanCtx,
-  callback: SyncCallbackFn<T>
-): T {
   return getTracer(ctx.traceScope ?? callback.name).startActiveSpan(
     ctx.name,
     {
-      root: ctx.rootSpan,
+      root: !Boolean(ctx.traceContext) && ctx.rootSpan,
       kind: ctx.spanKind,
     },
-    (span) => {
+    activeContext,
+    async (span) => {
       try {
-        const result = callback();
+        const result = await callback(span);
         span.end();
         return result;
       } catch (ex) {
@@ -58,7 +52,41 @@ export function instrumentSync<T>(
         span.end();
         throw ex;
       }
-    }
+    },
+  );
+}
+
+type SyncCallbackFn<T> = (span: opentelemetry.Span) => T;
+
+export function instrumentSync<T>(
+  ctx: SpanCtx,
+  callback: SyncCallbackFn<T>,
+): T {
+  const activeContext = ctx.traceContext
+    ? opentelemetry.propagation.extract(
+        opentelemetry.context.active(),
+        ctx.traceContext,
+      )
+    : opentelemetry.context.active();
+
+  return getTracer(ctx.traceScope ?? callback.name).startActiveSpan(
+    ctx.name,
+    {
+      root: !Boolean(ctx.traceContext) && ctx.rootSpan,
+      kind: ctx.spanKind,
+    },
+    activeContext,
+    (span) => {
+      try {
+        const result = callback(span);
+        span.end();
+        return result;
+      } catch (ex) {
+        traceException(ex as opentelemetry.Exception, span);
+        span.end();
+        throw ex;
+      }
+    },
   );
 }
 
@@ -67,7 +95,7 @@ export const getCurrentSpan = () => opentelemetry.trace.getActiveSpan();
 export const traceException = (
   ex: unknown,
   span?: opentelemetry.Span,
-  code?: string
+  code?: string,
 ) => {
   const activeSpan = span ?? getCurrentSpan();
 
@@ -115,7 +143,7 @@ export const traceException = (
 
 export const addUserToSpan = (
   attributes: { userId?: string; projectId?: string; email?: string },
-  span?: opentelemetry.Span
+  span?: opentelemetry.Span,
 ) => {
   const activeSpan = span ?? getCurrentSpan();
 
@@ -131,6 +159,36 @@ export const addUserToSpan = (
 
 export const getTracer = (name: string) => opentelemetry.trace.getTracer(name);
 
+const cloudWatchClient = new CloudWatchClient();
+const cloudWatchLastSubmitted: Record<string, number> = {};
+const sendCloudWatchMetric = (key: string, value: number | undefined) => {
+  const currentTime = Date.now();
+  const interval = 30 * 1000;
+
+  // Check if the function has been executed in the last 30s for this key
+  if (
+    !cloudWatchLastSubmitted[key] ||
+    currentTime - cloudWatchLastSubmitted[key] >= interval
+  ) {
+    cloudWatchLastSubmitted[key] = currentTime;
+    cloudWatchClient
+      .send(
+        new PutMetricDataCommand({
+          Namespace: "Langfuse",
+          MetricData: [
+            {
+              MetricName: key,
+              Value: value ?? 0,
+            },
+          ],
+        }),
+      )
+      .catch((error) => {
+        logger.warn("Failed to send metric to CloudWatch", error);
+      });
+  }
+};
+
 export const recordGauge = (
   stat: string,
   value?: number | undefined,
@@ -138,23 +196,44 @@ export const recordGauge = (
     | {
         [tag: string]: string | number;
       }
-    | undefined
+    | undefined,
 ) => {
+  if (env.ENABLE_AWS_CLOUDWATCH_METRIC_PUBLISHING === "true") {
+    sendCloudWatchMetric(stat, value);
+  }
   dd.dogstatsd.gauge(stat, value, tags);
 };
 
 export const recordIncrement = (
   stat: string,
   value?: number | undefined,
-  tags?: { [tag: string]: string | number } | undefined
+  tags?: { [tag: string]: string | number } | undefined,
 ) => {
+  if (env.ENABLE_AWS_CLOUDWATCH_METRIC_PUBLISHING === "true") {
+    sendCloudWatchMetric(stat, value);
+  }
   dd.dogstatsd.increment(stat, value, tags);
 };
 
 export const recordHistogram = (
   stat: string,
   value?: number | undefined,
-  tags?: { [tag: string]: string | number } | undefined
+  tags?: { [tag: string]: string | number } | undefined,
 ) => {
+  if (env.ENABLE_AWS_CLOUDWATCH_METRIC_PUBLISHING === "true") {
+    sendCloudWatchMetric(stat, value);
+  }
   dd.dogstatsd.histogram(stat, value, tags);
 };
+
+/**
+ * Converts a queue name to the matching datadog metric name.
+ * Consumer only needs to append the relevant suffix.
+ *
+ * Example: `legacy-ingestion-queue` -> `langfuse.queue.legacy_ingestion`
+ */
+export const convertQueueNameToMetricName = (queueName: string): string => {
+  return (
+    "langfuse.queue." + queueName.replace(/-/g, "_").replace(/_queue$/, "")
+  );
+};