diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 138eedbcc..c66484907 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -4,4 +4,6 @@ repos: hooks: - id: ruff args: [--fix, --exit-non-zero-on-fix] + exclude: ^app/ - id: ruff-format + exclude: ^app/ diff --git a/README.md b/README.md index f6b85deff..7eccb1289 100644 --- a/README.md +++ b/README.md @@ -109,6 +109,13 @@ agentops.end_session('Success') All your sessions can be viewed on the [AgentOps dashboard](https://app.agentops.ai?ref=gh)
+## Run the App and API locally + +Looking to run the full AgentOps app (Dashboard + API backend) on your machine? Follow the setup guide in `app/README.md`: + +- [Run the App and Backend (Dashboard + API)](app/README.md) + +
Agent Debugging diff --git a/app/.eslintrc.json b/app/.eslintrc.json new file mode 100644 index 000000000..0e1853970 --- /dev/null +++ b/app/.eslintrc.json @@ -0,0 +1,56 @@ +{ + "root": true, + "extends": [ + "eslint:recommended", + "plugin:@typescript-eslint/recommended", + "next/core-web-vitals", + "prettier" + ], + "plugins": [], + "parser": "@typescript-eslint/parser", + "parserOptions": { + "ecmaVersion": "latest", + "sourceType": "module" + }, + "rules": { + "@typescript-eslint/no-unused-vars": [ + "warn", + { + "argsIgnorePattern": "^_", + "varsIgnorePattern": "^_", + "caughtErrorsIgnorePattern": "^_" + } + ], + "@typescript-eslint/no-explicit-any": "warn", + "no-unused-vars": "off", + "import/no-unused-modules": [ + "off" + ], + "no-console": [ + "warn", + { + "allow": [ + "warn", + "error" + ] + } + ] + }, + "ignorePatterns": [ + "node_modules/", + ".next/", + "dist/", + "build/" + ], + "overrides": [ + { + "files": [ + "*.js", + "*.jsx" + ], + "rules": { + "@typescript-eslint/no-var-requires": "off" + } + } + ] +} \ No newline at end of file diff --git a/app/.github/ISSUE_TEMPLATE/bug_report.yml b/app/.github/ISSUE_TEMPLATE/bug_report.yml new file mode 100644 index 000000000..ed37ce7df --- /dev/null +++ b/app/.github/ISSUE_TEMPLATE/bug_report.yml @@ -0,0 +1,91 @@ +name: Bug Report +description: Report a bug to help us improve AgentOps +title: "[Bug]: " +labels: ["bug"] +body: + - type: markdown + attributes: + value: | + Thanks for taking the time to report a bug! Please fill out the form below to help us understand and fix the issue. + + - type: textarea + id: description + attributes: + label: Bug Description + description: A clear and concise description of what the bug is. + placeholder: Describe the bug you encountered... + validations: + required: true + + - type: textarea + id: reproduction + attributes: + label: Steps to Reproduce + description: Steps to reproduce the behavior + placeholder: | + 1. Go to '...' + 2. Click on '...' + 3. Scroll down to '...' + 4. See error + validations: + required: true + + - type: textarea + id: expected + attributes: + label: Expected Behavior + description: A clear description of what you expected to happen. + placeholder: What should have happened instead? + validations: + required: true + + - type: textarea + id: actual + attributes: + label: Actual Behavior + description: What actually happened instead? + placeholder: What actually happened? + validations: + required: true + + - type: dropdown + id: component + attributes: + label: Component + description: Which component is affected? + options: + - API Server + - Dashboard (Frontend) + - Docker Setup + - Documentation + - Other + validations: + required: true + + - type: textarea + id: environment + attributes: + label: Environment + description: Please provide your environment details + placeholder: | + - OS: (e.g., macOS 14.0, Ubuntu 20.04, Windows 11) + - Node.js version: (e.g., 18.17.0) + - Python version: (e.g., 3.12.0) + - Browser: (e.g., Chrome 119, Safari 17) + - AgentOps version: (e.g., commit hash or branch) + validations: + required: true + + - type: textarea + id: logs + attributes: + label: Logs and Screenshots + description: If applicable, add logs or screenshots to help explain the problem. + placeholder: Paste any relevant logs or drag & drop screenshots here + + - type: textarea + id: additional + attributes: + label: Additional Context + description: Add any other context about the problem here. + placeholder: Any additional information that might be helpful... \ No newline at end of file diff --git a/app/.github/ISSUE_TEMPLATE/config.yml b/app/.github/ISSUE_TEMPLATE/config.yml new file mode 100644 index 000000000..0655f3644 --- /dev/null +++ b/app/.github/ISSUE_TEMPLATE/config.yml @@ -0,0 +1,11 @@ +blank_issues_enabled: false +contact_links: + - name: šŸ’¬ GitHub Discussions + url: https://github.com/AgentOps-AI/AgentOps.Next/discussions + about: Ask questions and discuss ideas with the community + - name: šŸ“š Documentation + url: https://github.com/AgentOps-AI/AgentOps.Next/blob/main/README.md + about: Check our comprehensive setup and usage documentation + - name: šŸ”’ Security Vulnerability + url: https://github.com/AgentOps-AI/AgentOps.Next/blob/main/SECURITY.md + about: Report security vulnerabilities privately \ No newline at end of file diff --git a/app/.github/ISSUE_TEMPLATE/feature_request.yml b/app/.github/ISSUE_TEMPLATE/feature_request.yml new file mode 100644 index 000000000..fc0e67ee5 --- /dev/null +++ b/app/.github/ISSUE_TEMPLATE/feature_request.yml @@ -0,0 +1,89 @@ +name: Feature Request +description: Suggest a new feature or improvement for AgentOps +title: "[Feature]: " +labels: ["enhancement"] +body: + - type: markdown + attributes: + value: | + Thanks for suggesting a new feature! Please fill out the form below to help us understand your request. + + - type: textarea + id: summary + attributes: + label: Feature Summary + description: A clear and concise description of the feature you'd like to see. + placeholder: What feature would you like to see added? + validations: + required: true + + - type: textarea + id: problem + attributes: + label: Problem Statement + description: What problem does this feature solve? + placeholder: | + Is your feature request related to a problem? Please describe. + Example: I'm always frustrated when [...] + validations: + required: true + + - type: textarea + id: solution + attributes: + label: Proposed Solution + description: Describe the solution you'd like to see. + placeholder: A clear description of what you want to happen. + validations: + required: true + + - type: dropdown + id: component + attributes: + label: Component + description: Which component would this feature affect? + options: + - API Server + - Dashboard (Frontend) + - Docker Setup + - Documentation + - Other + validations: + required: true + + - type: textarea + id: alternatives + attributes: + label: Alternatives Considered + description: Describe any alternative solutions or features you've considered. + placeholder: What other approaches have you considered? + + - type: dropdown + id: priority + attributes: + label: Priority + description: How important is this feature to you? + options: + - Low - Nice to have + - Medium - Would be helpful + - High - Important for my use case + - Critical - Blocking my adoption + validations: + required: true + + - type: checkboxes + id: contribution + attributes: + label: Contribution + description: Are you willing to help implement this feature? + options: + - label: I'm willing to submit a PR for this feature + - label: I can help with testing + - label: I can help with documentation + + - type: textarea + id: additional + attributes: + label: Additional Context + description: Add any other context, mockups, or examples about the feature request. + placeholder: Any additional information, mockups, or examples that might be helpful... \ No newline at end of file diff --git a/app/.github/ISSUE_TEMPLATE/question.yml b/app/.github/ISSUE_TEMPLATE/question.yml new file mode 100644 index 000000000..a9f6964b1 --- /dev/null +++ b/app/.github/ISSUE_TEMPLATE/question.yml @@ -0,0 +1,56 @@ +name: Question / Help +description: Ask a question or get help with AgentOps +title: "[Question]: " +labels: ["question"] +body: + - type: markdown + attributes: + value: | + Have a question or need help? We're here to assist! + + **Before asking:** Please check if your question has already been answered in: + - [Documentation](https://github.com/AgentOps-AI/AgentOps.Next/blob/main/README.md) + - [Existing Issues](https://github.com/AgentOps-AI/AgentOps.Next/issues) + - [Discussions](https://github.com/AgentOps-AI/AgentOps.Next/discussions) + + - type: textarea + id: question + attributes: + label: Your Question + description: What would you like to know? + placeholder: Ask your question here... + validations: + required: true + + - type: dropdown + id: category + attributes: + label: Category + description: What category does your question fall into? + options: + - Setup / Installation + - Configuration + - Usage / How-to + - API / Integration + - Performance + - Deployment + - Other + validations: + required: true + + - type: textarea + id: context + attributes: + label: Context + description: Provide any relevant context about your setup or use case. + placeholder: | + - What are you trying to achieve? + - What have you already tried? + - Any relevant environment details? + + - type: textarea + id: additional + attributes: + label: Additional Information + description: Any additional information that might help us answer your question. + placeholder: Code snippets, error messages, screenshots, etc. \ No newline at end of file diff --git a/app/.github/pull_request_template.md b/app/.github/pull_request_template.md new file mode 100644 index 000000000..3de5bdfef --- /dev/null +++ b/app/.github/pull_request_template.md @@ -0,0 +1,45 @@ +## Description + +Brief description of changes made in this PR. + +## Type of Change + +- [ ] Bug fix (non-breaking change which fixes an issue) +- [ ] New feature (non-breaking change which adds functionality) +- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected) +- [ ] Documentation update +- [ ] Code refactoring (no functional changes) +- [ ] Performance improvement +- [ ] Other (please describe): + +## Related Issues + +- Fixes #(issue number) +- Relates to #(issue number) + +## Testing + +- [ ] Tests pass locally (`just test`) +- [ ] Added tests for new functionality +- [ ] Manual testing completed +- [ ] No new warnings introduced + +**Test Instructions:** + + +## Screenshots (if applicable) + + + +## Checklist + +- [ ] Code follows project style guidelines (`just lint`) +- [ ] Self-review completed +- [ ] Code is commented where necessary +- [ ] Documentation updated (if needed) +- [ ] Environment variables documented (if added) +- [ ] Changelog updated (for significant changes) + +## Additional Notes + + \ No newline at end of file diff --git a/app/.github/workflows/cypress-tests.yml b/app/.github/workflows/cypress-tests.yml new file mode 100644 index 000000000..c74efeca3 --- /dev/null +++ b/app/.github/workflows/cypress-tests.yml @@ -0,0 +1,200 @@ +name: E2E Tests + +# Temporarily disabled while working out bugs +on: + workflow_dispatch: {} + # pull_request: + # types: [opened, synchronize, reopened] + # branches: + # - main + +permissions: + contents: read + +jobs: + e2e-testing: + name: Cypress E2E Testing + runs-on: ubuntu-latest + env: + # Supabase Application Environment Variables + NEXT_PUBLIC_SUPABASE_URL: ${{ secrets.SUPABASE_URL }} + NEXT_PUBLIC_SUPABASE_ANON_KEY: ${{ secrets.SUPABASE_ANON_KEY }} + + # Cypress Environment Variables + CYPRESS_USER: ${{ secrets.CYPRESS_USER }} + CYPRESS_PASSWORD: ${{ secrets.CYPRESS_PASSWORD }} + + # Bun Cache Configuration + BUN_INSTALL_CACHE_DIR: "~/.bun/install/cache" + + # Supabase CLI Environment Variables + SUPABASE_ACCESS_TOKEN: ${{ secrets.SUPABASE_ACCESS_TOKEN }} + SUPABASE_PROJECT_REF: ${{ secrets.SUPABASE_PROJECT_REF }} + SUPABASE_BUCKET_NAME: ${{ secrets.SUPABASE_BUCKET_NAME }} + + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Setup Bun + uses: oven-sh/setup-bun@v2 + + - name: Install Dependencies + run: bun install + working-directory: ./dashboard + + # Cypress only works with NPM but we want to test with the bun dependency resolutions + - name: Convert bun.lock to package-lock.json for Cypress + run: | + cd dashboard + + if [ ! -f bun.lock ]; then + echo "Error: bun.lock file not found" + exit 1 + fi + + bun install + + # create package-lock.json using Bun's built-in compatibility feature + # this guarantees using Bun's exact dependency resolution + bun run --bun npm install --package-lock-only + + if ! jq empty package-lock.json 2>/dev/null; then + echo "Error: Generated package-lock.json is not valid JSON" + exit 1 + fi + + if [ -f package-lock.json ]; then + echo "Successfully converted bun.lock to package-lock.json" + ls -lh package-lock.json + else + echo "Error: Failed to create package-lock.json" + exit 1 + fi + + - name: Upload package-lock.json as artifact + uses: actions/upload-artifact@v4 + with: + name: package-lock-json + path: dashboard/package-lock.json + + - name: Cache Next.js build + id: next-cache # Optional: Give the cache step an ID + uses: actions/cache@v4 + with: + # Cache the Next.js build directory within the dashboard workspace + path: ./dashboard/.next/cache + # Generate a new cache whenever the lockfile or source files change. + key: ${{ runner.os }}-nextjs-${{ hashFiles('**/bun.lockb') }}-${{ hashFiles('dashboard/**.[jt]s', 'dashboard/**.[jt]sx') }} + # Fallback restore keys + restore-keys: | + ${{ runner.os }}-nextjs-${{ hashFiles('**/bun.lockb') }}- + + - name: Build Application + run: bun next telemetry disable && bun run build + working-directory: ./dashboard + + - name: Run Cypress Tests + uses: cypress-io/github-action@v6 + with: + working-directory: ./dashboard + start: bun start + wait-on: 'http://localhost:3000' + wait-on-timeout: 60 + + - name: Set Dynamic Artifact Paths + if: always() + id: set_paths + run: | + PR_OR_RUN_ID="${{ github.event.pull_request.number || github.run_id }}" + COMMIT_SHA="${{ github.sha }}" + # Base path example for artifacts: pr-123/commit-abc123 + ARTIFACT_BASE_PATH="pr-${PR_OR_RUN_ID}/commit-${COMMIT_SHA}" + + # Set the artifact base path as an environment variable + echo "ARTIFACT_BASE_PATH=${ARTIFACT_BASE_PATH}" >> $GITHUB_ENV + echo "Base Path in Bucket: ${ARTIFACT_BASE_PATH}" + + - name: Setup Supabase CLI + if: always() + uses: supabase/setup-cli@v1 + + # This step is critical to the working of Supabase CLI + # It does not require the same project id as the application so it can be used to debug easily + - name: Link Supabase Project + if: always() + env: + SUPABASE_DB_PASSWORD: ${{ secrets.SUPABASE_DB_PASSWORD }} + run: | + supabase link --project-ref ${{ env.SUPABASE_PROJECT_REF }} + + - name: Upload Mochawesome Report to Supabase + if: always() + run: | + REPORT_PATH="./dashboard/cypress/reports/html/index.html" + DESTINATION="ss://${{ env.SUPABASE_PROJECT_REF }}/${{ env.SUPABASE_BUCKET_NAME }}/${{ env.ARTIFACT_BASE_PATH }}/report.html" + + if [ -f "$REPORT_PATH" ]; then + echo "Uploading Mochawesome report from $REPORT_PATH to $DESTINATION..." + supabase storage cp --experimental "$REPORT_PATH" "$DESTINATION" + if [ $? -ne 0 ]; then echo "::error::Failed to upload Mochawesome report."; exit 1; fi + else + echo "::warning::Mochawesome report not found at $REPORT_PATH. Skipping upload." + fi + + - name: Upload Coverage Report to Supabase + if: always() + run: | + COVERAGE_DIR="./dashboard/coverage/" + DESTINATION="ss://${{ env.SUPABASE_PROJECT_REF }}/${{ env.SUPABASE_BUCKET_NAME }}/${{ env.ARTIFACT_BASE_PATH }}/coverage-report/" + + if [ -d "$COVERAGE_DIR" ]; then + echo "Uploading Coverage report from $COVERAGE_DIR to $DESTINATION..." + supabase storage cp --experimental --recursive "$COVERAGE_DIR" "$DESTINATION" + if [ $? -ne 0 ]; then echo "::error::Failed to upload Coverage report."; exit 1; fi + else + echo "::warning::Coverage report directory not found at $COVERAGE_DIR. Skipping upload." + fi + + - name: Upload Screenshots to Supabase + if: always() + run: | + SCREENSHOT_DIR="./dashboard/cypress/screenshots" + DESTINATION="ss://${{ env.SUPABASE_PROJECT_REF }}/${{ env.SUPABASE_BUCKET_NAME }}/${{ env.ARTIFACT_BASE_PATH }}/screenshots/" + + if [ -d "$SCREENSHOT_DIR" ]; then + echo "Uploading screenshots from $SCREENSHOT_DIR to $DESTINATION..." + supabase storage cp --experimental --recursive "$SCREENSHOT_DIR" "$DESTINATION" + if [ $? -ne 0 ]; then echo "::error::Failed to upload screenshots."; exit 1; fi + else + echo "Screenshots directory not found at $SCREENSHOT_DIR. Skipping upload." + fi + + - name: Upload Videos to Supabase + if: always() + run: | + VIDEO_DIR="./dashboard/cypress/reports/html/videos" + DESTINATION="ss://${{ env.SUPABASE_PROJECT_REF }}/${{ env.SUPABASE_BUCKET_NAME }}/${{ env.ARTIFACT_BASE_PATH }}/videos/" + + if [ -d "$VIDEO_DIR" ]; then + echo "Uploading videos from $VIDEO_DIR to $DESTINATION..." + supabase storage cp --experimental --recursive "$VIDEO_DIR" "$DESTINATION" + if [ $? -ne 0 ]; then echo "::error::Failed to upload videos."; exit 1; fi + else + echo "Videos directory not found at $VIDEO_DIR. Skipping upload." + fi + + - name: Echo Artifact URLs + if: always() + run: | + # Constructs the public URLs for the uploaded artifacts to show in the logs + SUPABASE_PUBLIC_URL_BASE="https://${{ env.SUPABASE_PROJECT_REF }}.supabase.co/storage/v1/object/public/${{ env.SUPABASE_BUCKET_NAME }}" + BUCKET_BASE_PATH="${{ env.ARTIFACT_BASE_PATH }}" + + echo "" + echo "-------------------- Supabase Artifact URLs --------------------" + echo "Test Report URL: ${SUPABASE_PUBLIC_URL_BASE}/${BUCKET_BASE_PATH}/test-report.html" + echo "Coverage Report URL: ${SUPABASE_PUBLIC_URL_BASE}/${BUCKET_BASE_PATH}/coverage-report/index.html" + echo "Screenshots Directory URL: ${SUPABASE_PUBLIC_URL_BASE}/${BUCKET_BASE_PATH}/screenshots/" + echo "Videos Directory URL: ${SUPABASE_PUBLIC_URL_BASE}/${BUCKET_BASE_PATH}/videos/" + echo "------------------------------------------------------------------" diff --git a/app/.github/workflows/fly-deploy.yml b/app/.github/workflows/fly-deploy.yml new file mode 100644 index 000000000..5f692530b --- /dev/null +++ b/app/.github/workflows/fly-deploy.yml @@ -0,0 +1,23 @@ +name: Deploy API Server to Fly.io + +on: + push: + branches: + - main + paths: + - 'api/**' + +permissions: + contents: read + +jobs: + deploy: + name: Deploy API Server + runs-on: ubuntu-latest + concurrency: deploy-group # optional: ensure only one action runs at a time + steps: + - uses: actions/checkout@v4 + - uses: superfly/flyctl-actions/setup-flyctl@master + - run: cd api && flyctl deploy -c fly.toml --remote-only + env: + FLY_API_TOKEN: ${{ secrets.FLY_API_TOKEN_NEXT }} diff --git a/app/.github/workflows/prettier-check.yml b/app/.github/workflows/prettier-check.yml new file mode 100644 index 000000000..35f4dcf6a --- /dev/null +++ b/app/.github/workflows/prettier-check.yml @@ -0,0 +1,36 @@ +name: Prettier Check + +on: + pull_request: + branches: + - main + +jobs: + prettier: + runs-on: ubuntu-latest + steps: + - name: Checkout code + uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Set up Node.js + uses: oven-sh/setup-bun@v2 + + - name: Install Root Dependencies + run: bun install + + - name: Install Dashboard Dependencies + run: bun install + working-directory: ./dashboard + + - name: Run Prettier Check on Changed Files + run: | + CHANGED_FILES=$(git diff --name-only --diff-filter=ACMR ${{ github.event.pull_request.base.sha }}..${{ github.event.pull_request.head.sha }}) + if [ -z "$CHANGED_FILES" ]; then + echo "No files require Prettier checks." + else + echo "Checking formatting for the following files:" + echo "$CHANGED_FILES" + echo "$CHANGED_FILES" | xargs npx prettier --check --ignore-unknown || true + fi diff --git a/app/.github/workflows/ruff-formatter.yml b/app/.github/workflows/ruff-formatter.yml new file mode 100644 index 000000000..87371bcde --- /dev/null +++ b/app/.github/workflows/ruff-formatter.yml @@ -0,0 +1,36 @@ +name: Ruff Code Formatter Check + +on: + pull_request: + branches: + - main + paths: + - 'api/**' + +jobs: + ruff-check: + runs-on: ubuntu-latest + + steps: + - name: Checkout code + uses: actions/checkout@v2 + + - name: Set up Python + uses: actions/setup-python@v2 + with: + python-version: '3.11' # Specify the version of Python you need + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install ruff + + - name: Update Ruff Configuration + run: | + echo "lint.select = ['E', 'F', 'I']" >> ruff.toml + + - name: Run Ruff + uses: astral-sh/ruff-action@v3 + with: + args: "check --diff" + src: ${{ github.event.pull_request.base.sha }}..${{ github.event.pull_request.head.sha }} \ No newline at end of file diff --git a/app/.github/workflows/supabase-migrations.yml b/app/.github/workflows/supabase-migrations.yml new file mode 100644 index 000000000..1a6fcdb38 --- /dev/null +++ b/app/.github/workflows/supabase-migrations.yml @@ -0,0 +1,89 @@ +name: Supabase Migrations + +on: + push: + branches: + - main + - dev + paths: + - 'supabase/migrations/**' + workflow_dispatch: + +jobs: + migrate-production: + name: Run Migrations on Production + runs-on: ubuntu-latest + if: github.ref == 'refs/heads/main' + + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Setup Node.js + uses: actions/setup-node@v4 + with: + node-version: '18' + + - name: Install Supabase CLI + run: | + cd /tmp + curl -sL https://github.com/supabase/cli/releases/latest/download/supabase_linux_amd64.tar.gz | tar -xz + sudo mv supabase /usr/local/bin/ + cd - + + - name: Link to Supabase project + run: | + cd supabase + supabase link --project-ref ${{ secrets.SUPABASE_PROJECT_ID }} --debug + env: + SUPABASE_ACCESS_TOKEN: ${{ secrets.SUPABASE_ACCESS_TOKEN }} + + - name: Run migrations + run: | + cd supabase + supabase db push + env: + SUPABASE_ACCESS_TOKEN: ${{ secrets.SUPABASE_ACCESS_TOKEN }} + SUPABASE_URL: ${{ secrets.SUPABASE_URL }} + SUPABASE_ANON_KEY: ${{ secrets.SUPABASE_ANON_KEY }} + SUPABASE_SERVICE_ROLE_KEY: ${{ secrets.SUPABASE_SERVICE_ROLE_KEY }} + SUPABASE_PROJECT_ID: ${{ secrets.SUPABASE_PROJECT_ID }} + + migrate-development: + name: Run Migrations on Development + runs-on: ubuntu-latest + if: github.ref == 'refs/heads/dev' + + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Setup Node.js + uses: actions/setup-node@v4 + with: + node-version: '18' + + - name: Install Supabase CLI + run: | + cd /tmp + curl -sL https://github.com/supabase/cli/releases/latest/download/supabase_linux_amd64.tar.gz | tar -xz + sudo mv supabase /usr/local/bin/ + cd - + + - name: Link to Supabase project + run: | + cd supabase + supabase link --project-ref ${{ secrets.__DEV__SUPABASE_PROJECT_ID }} --debug + env: + SUPABASE_ACCESS_TOKEN: ${{ secrets.SUPABASE_ACCESS_TOKEN }} + + - name: Run migrations + run: | + cd supabase + supabase db push + env: + SUPABASE_ACCESS_TOKEN: ${{ secrets.SUPABASE_ACCESS_TOKEN }} + SUPABASE_URL: ${{ secrets.__DEV__SUPABASE_URL }} + SUPABASE_ANON_KEY: ${{ secrets.__DEV__SUPABASE_ANON_KEY }} + SUPABASE_SERVICE_ROLE_KEY: ${{ secrets.__DEV__SUPABASE_SERVICE_ROLE_KEY }} + SUPABASE_PROJECT_ID: ${{ secrets.__DEV__SUPABASE_PROJECT_ID }} diff --git a/app/.github/workflows/test-api.yaml b/app/.github/workflows/test-api.yaml new file mode 100644 index 000000000..81c428044 --- /dev/null +++ b/app/.github/workflows/test-api.yaml @@ -0,0 +1,92 @@ +name: API Python Tests +on: + workflow_dispatch: {} + push: + branches: + - main + paths: + - '.github/workflows/test-api.yaml' + - 'api/**/*.py' + - 'api/**/*.ipynb' + - 'api/pyproject.toml' + pull_request: + paths: + - '.github/workflows/test-api.yaml' + - 'api/**/*.py' + - 'api/**/*.ipynb' + - 'api/pyproject.toml' + +jobs: + unit-tests: + runs-on: ubuntu-latest + + services: + postgres: + image: supabase/postgres:15.1.0.103 + env: + POSTGRES_USER: postgres + POSTGRES_PASSWORD: postgres + POSTGRES_DB: test_db + ports: + - 5432:5432 + options: >- + --health-cmd pg_isready + --health-interval 5s + --health-timeout 5s + --health-retries 5 + clickhouse: + image: clickhouse:24.12 + env: + CLICKHOUSE_USER: default + CLICKHOUSE_PASSWORD: clickhouse + CLICKHOUSE_DB: otel_2 + ports: + - 8123:8123 + - 9000:9000 + options: >- + --ulimit nofile=262144:262144 + --health-cmd "wget --no-verbose --tries=1 --spider http://localhost:8123/ping || exit 1" + --health-interval 10s + --health-timeout 5s + --health-retries 5 + + env: + PYTHONUNBUFFERED: '1' + SUPABASE_URL: ${{ secrets.__DEV__SUPABASE_URL }} + SUPABASE_ANON_KEY: ${{ secrets.__DEV__SUPABASE_ANON_KEY }} + SUPABASE_PROJECT_ID: ${{ secrets.__DEV__SUPABASE_PROJECT_ID }} + SUPABASE_KEY: ${{ secrets.__DEV__SUPABASE_SERVICE_ROLE_KEY }} + SUPABASE_S3_BUCKET: "user-uploads" + SUPABASE_S3_LOGS_BUCKET: "agentops-logs" + JWT_SECRET_KEY: 'test-secret-key' + AGENTOPS_API_KEY: ${{ secrets.__DEV__AGENTOPS_API_KEY }} + JOCKEY_PATH: "${{ github.workspace }}/api/jockey" + + defaults: + run: + working-directory: ./api + strategy: + matrix: + python-version: ['3.12'] + fail-fast: false + + steps: + - uses: actions/checkout@v4 + + - name: Setup UV + uses: astral-sh/setup-uv@v5 + continue-on-error: true + with: + python-version: ${{ matrix.python-version }} + enable-cache: true + cache-suffix: uv-${{ matrix.python-version }} + cache-dependency-glob: '**/pyproject.toml' + + - name: Install dependencies + run: | + uv sync --group dev + + - name: Run unit tests with coverage + timeout-minutes: 5 + run: | + uv run -m pytest tests/ -v diff --git a/app/.github/workflows/test-deploy.yml b/app/.github/workflows/test-deploy.yml new file mode 100644 index 000000000..9f194b12c --- /dev/null +++ b/app/.github/workflows/test-deploy.yml @@ -0,0 +1,70 @@ +name: Deploy Tests +on: + workflow_dispatch: {} + push: + branches: + - main + paths: + - '.github/workflows/test-deploy.yml' + - 'deploy/**/*.py' + - 'deploy/**/pyproject.toml' + - 'deploy/pytest.ini' + pull_request: + paths: + - '.github/workflows/test-deploy.yml' + - 'deploy/**/*.py' + - 'deploy/**/pyproject.toml' + - 'deploy/pytest.ini' + +jobs: + unit-tests: + runs-on: ubuntu-latest + + services: + redis: + image: redis:8.0 + ports: + - 6379:6379 + options: >- + --health-cmd "redis-cli ping" + --health-interval 5s + --health-timeout 5s + --health-retries 5 + + env: + PYTHONUNBUFFERED: '1' + REDIS_HOST: 'localhost' + REDIS_PORT: '6379' + REDIS_DB: '0' + + defaults: + run: + working-directory: ./deploy/jockey + + strategy: + matrix: + python-version: ['3.12'] + fail-fast: false + + steps: + - uses: actions/checkout@v4 + + - name: Setup UV + uses: astral-sh/setup-uv@v5 + continue-on-error: true + with: + python-version: ${{ matrix.python-version }} + enable-cache: true + cache-suffix: deploy-${{ matrix.python-version }} + cache-dependency-glob: 'deploy/**/pyproject.toml' + + - name: Install dependencies + run: | + uv sync --group dev + + - name: Run all deploy tests + timeout-minutes: 5 + run: | + uv run -m pytest tests/ -v + env: + DOCKER_BUILDKIT: 1 \ No newline at end of file diff --git a/app/.github/workflows/test-otel-collector.yml b/app/.github/workflows/test-otel-collector.yml new file mode 100644 index 000000000..c86111a1d --- /dev/null +++ b/app/.github/workflows/test-otel-collector.yml @@ -0,0 +1,92 @@ +name: OpenTelemetry Collector Tests + +on: + workflow_dispatch: {} + push: + branches: + - main + paths: + - '.github/workflows/test-otel-collector.yml' + - 'opentelemetry-collector/**/*.py' + - 'opentelemetry-collector/**/pyproject.toml' + - 'opentelemetry-collector/**/uv.lock' + - 'opentelemetry-collector/compose.yaml' + - 'opentelemetry-collector/Dockerfile' + - 'opentelemetry-collector/config/**' + pull_request: + paths: + - '.github/workflows/test-otel-collector.yml' + - 'opentelemetry-collector/**/*.py' + - 'opentelemetry-collector/**/pyproject.toml' + - 'opentelemetry-collector/**/uv.lock' + - 'opentelemetry-collector/compose.yaml' + - 'opentelemetry-collector/Dockerfile' + - 'opentelemetry-collector/config/**' + +jobs: + collector-tests: + name: OpenTelemetry Collector Tests + runs-on: ubuntu-latest + + defaults: + run: + working-directory: ./opentelemetry-collector + + env: + PYTHONUNBUFFERED: '1' + + steps: + - uses: actions/checkout@v4 + + - name: Setup UV + uses: astral-sh/setup-uv@v5 + with: + python-version: '3.12' + enable-cache: true + cache-suffix: otel-collector + cache-dependency-glob: '**/pyproject.toml' + + - name: Install dependencies + run: | + cd builder && uv pip install -e ".[dev]" + + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@v3 + + - name: Install Docker Compose + run: | + sudo curl -L "https://github.com/docker/compose/releases/download/v2.24.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose + sudo chmod +x /usr/local/bin/docker-compose + docker-compose --version + + - name: Build collector image + run: | + docker build -t otel-collector:test . + + - name: Run all tests with coverage + timeout-minutes: 15 + run: | + cd builder + source $VIRTUAL_ENV/bin/activate + python -m pytest tests/ -v -s --cov=. --cov-report=xml + + - name: Upload coverage to Codecov + uses: codecov/codecov-action@v4 + with: + file: ./opentelemetry-collector/builder/coverage.xml + flags: otel-collector + name: otel-collector-tests + + - name: Show docker logs on failure + if: failure() + run: | + echo "=== Docker Compose Logs ===" + docker-compose logs || true + echo "=== All Running Containers ===" + docker ps -a || true + + - name: Clean up Docker resources + if: always() + run: | + docker-compose down --volumes --remove-orphans || true + docker system prune -f || true \ No newline at end of file diff --git a/app/.github/workflows/update-otel-collector-tokencost.yml b/app/.github/workflows/update-otel-collector-tokencost.yml new file mode 100644 index 000000000..2e9bc121c --- /dev/null +++ b/app/.github/workflows/update-otel-collector-tokencost.yml @@ -0,0 +1,151 @@ +name: Update otel-collector tokencost dependency + +on: + schedule: + # Run every night at 1 AM UTC + - cron: '0 1 * * *' + workflow_dispatch: # Allow manual triggering + +jobs: + check-tokencost-update: + runs-on: ubuntu-latest + permissions: + contents: write + pull-requests: write + + steps: + - name: Checkout repository + uses: actions/checkout@v4 + with: + token: ${{ secrets.GITHUB_TOKEN }} + + - name: Setup Python + uses: actions/setup-python@v5 + with: + python-version: '3.12' + + - name: Setup UV + uses: astral-sh/setup-uv@v5 + with: + enable-cache: true + + - name: Create virtual environment + run: | + cd opentelemetry-collector/builder + uv venv + + - name: Get current tokencost version + id: current-version + run: | + cd opentelemetry-collector/builder + CURRENT=$(grep -E "tokencost>=" pyproject.toml | sed 's/.*tokencost>=\([^"]*\).*/\1/') + echo "current=$CURRENT" >> $GITHUB_OUTPUT + echo "Current tokencost version: $CURRENT" + + - name: Get latest tokencost version from PyPI + id: latest-version + run: | + LATEST=$(curl -s https://pypi.org/pypi/tokencost/json | python3 -c "import sys, json; print(json.load(sys.stdin)['info']['version'])") + echo "latest=$LATEST" >> $GITHUB_OUTPUT + echo "Latest tokencost version: $LATEST" + + - name: Compare versions + id: compare + run: | + if [ "${{ steps.current-version.outputs.current }}" != "${{ steps.latest-version.outputs.latest }}" ]; then + echo "needs_update=true" >> $GITHUB_OUTPUT + echo "Version update needed: ${{ steps.current-version.outputs.current }} -> ${{ steps.latest-version.outputs.latest }}" + else + echo "needs_update=false" >> $GITHUB_OUTPUT + echo "No update needed. Current version is latest." + fi + + - name: Create branch for update + if: steps.compare.outputs.needs_update == 'true' + run: | + git config --global user.name 'github-actions[bot]' + git config --global user.email 'github-actions[bot]@users.noreply.github.com' + git checkout -b update-tokencost-${{ steps.latest-version.outputs.latest }} + + - name: Update tokencost version in pyproject.toml + if: steps.compare.outputs.needs_update == 'true' + run: | + cd opentelemetry-collector/builder + sed -i 's/tokencost>=[^"]*/tokencost>=${{ steps.latest-version.outputs.latest }}/' pyproject.toml + echo "Updated pyproject.toml with tokencost>=${{ steps.latest-version.outputs.latest }}" + + - name: Update UV lock file + if: steps.compare.outputs.needs_update == 'true' + run: | + cd opentelemetry-collector/builder + uv lock --upgrade-package tokencost + echo "Updated uv.lock file" + + - name: Verify installation works + if: steps.compare.outputs.needs_update == 'true' + run: | + cd opentelemetry-collector/builder + source .venv/bin/activate + uv pip install -e ".[dev]" + python -c "import importlib.metadata; print(f'tokencost version: {importlib.metadata.version(\"tokencost\")}')" + + - name: Run tests to ensure compatibility + if: steps.compare.outputs.needs_update == 'true' + timeout-minutes: 10 + run: | + cd opentelemetry-collector/builder + source .venv/bin/activate + python -m pytest tests/test_model_cost.py -v + echo "Unit tests passed successfully" + + - name: Commit changes + if: steps.compare.outputs.needs_update == 'true' + run: | + git add opentelemetry-collector/builder/pyproject.toml opentelemetry-collector/builder/uv.lock + git commit -m "chore: update tokencost to ${{ steps.latest-version.outputs.latest }} + + - Updates tokencost dependency from ${{ steps.current-version.outputs.current }} to ${{ steps.latest-version.outputs.latest }} + - Refreshes uv.lock with latest package versions + - Verified compatibility with existing unit tests" + + - name: Push branch + if: steps.compare.outputs.needs_update == 'true' + run: | + git push origin update-tokencost-${{ steps.latest-version.outputs.latest }} + + - name: Create Pull Request + if: steps.compare.outputs.needs_update == 'true' + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: | + gh pr create \ + --title "chore: update tokencost to ${{ steps.latest-version.outputs.latest }}" \ + --body "$(cat <<'EOF' + ## Summary + - Updates tokencost dependency from ${{ steps.current-version.outputs.current }} to ${{ steps.latest-version.outputs.latest }} + - Automatically detected and applied the latest version available on PyPI + + ## Changes + - Updated `opentelemetry-collector/builder/pyproject.toml` with new tokencost version + - Refreshed `opentelemetry-collector/builder/uv.lock` with updated dependencies + - Verified compatibility by running unit tests + + ## Testing + - āœ… Unit tests pass with new tokencost version + - āœ… Package installation verified + - āœ… No breaking changes detected + + ## Additional Notes + This PR was automatically created by the tokencost update workflow. The changes have been tested for basic compatibility but please review for any potential impacts on model cost calculations. + EOF + )" \ + --head update-tokencost-${{ steps.latest-version.outputs.latest }} \ + --base main + + - name: Summary + run: | + if [ "${{ steps.compare.outputs.needs_update }}" == "true" ]; then + echo "āœ… Successfully created PR to update tokencost from ${{ steps.current-version.outputs.current }} to ${{ steps.latest-version.outputs.latest }}" + else + echo "ā„¹ļø No update needed. tokencost is already at the latest version (${{ steps.current-version.outputs.current }})" + fi \ No newline at end of file diff --git a/app/.gitignore b/app/.gitignore new file mode 100644 index 000000000..7e51b5d61 --- /dev/null +++ b/app/.gitignore @@ -0,0 +1,241 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# cursor +.cursor/* +.cursorrules + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env* +.venv* +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ + +# Output files shouldn't be pushed to git +output/ + +# Supabase +.branches +.temp +.env + +# dependencies +node_modules/ +/.pnp +.pnp.js + +# testing +/coverage + +# next.js +.next/ +/out/ + +# production +/build + +# misc +.DS_Store +*.pem + +# debug +npm-debug.log* +yarn-debug.log* +yarn-error.log* + +# local env files +.env*.local +.env*.prod + +# vercel +.vercel + +# typescript +*.tsbuildinfo +next-env.d.ts + +# IDE +.idea +.vscode + +# Sentry Config File +.sentryclirc +dashboard/bun.lockb +.aider* + +# Bundle Analytics +dashboard/bundle_analytics/* +!dashboard/bundle_analytics/README.md + +# Cypress +dashboard/cypress/screenshots/* +dashboard/cypress/videos/* +dashboard/cypress/downloads/* +dashboard/.nyc_output +dashboard/coverage/* +dashboard/cypress/screenshots/* +dashboard/cypress/videos/* +dashboard/cypress/reports/* + +# Opsboard +opsboard/bun.lockb +opsboard/.env +opsboard/node_modules +opsboard/dist +opsboard/build + +# NPM Lockfiles +dashboard/package-lock.json +landing/package-lock.json +package-lock.json \ No newline at end of file diff --git a/app/.husky/pre-commit b/app/.husky/pre-commit new file mode 100644 index 000000000..7d523f645 --- /dev/null +++ b/app/.husky/pre-commit @@ -0,0 +1,215 @@ +#!/usr/bin/env bash + +# Function to get status emoji +get_status_emoji() { + local status=$1 + case $status in + 0) echo "āœ…";; # Success + 1) echo "āŒ";; # Failure + 2) echo "āš ļø";; # Warning + 3) echo "šŸ™ˆ";; # Skipped + *) echo "ā“";; # Unknown + esac +} + +# Export the function so it's available to sourced scripts +export -f get_status_emoji + +echo "šŸ” Running pre-commit hook..." + +# Get the repository root directory +REPO_ROOT="$(git rev-parse --show-toplevel)" + +# Function to get staged Python files +get_python_files() { + git diff --cached --name-only --diff-filter=ACMR | grep '\.py$' || echo "" +} + +# Function to get staged JS/TS files +get_js_ts_files() { + git diff --cached --name-only --diff-filter=ACMR | grep -E '\.(js|jsx|ts|tsx)$' || echo "" +} + +# 1. Create Temp Directory +TEMP_DIR=$(mktemp -d -t precommit-checks-XXXXXXXXXX) +trap 'rm -rf "$TEMP_DIR"' EXIT +if [ ! -d "$TEMP_DIR" ]; then echo "āŒ Error: Could not create temp dir." >&2; exit 1; fi + +# --- 2. Conditionally Run Checks --- +STAGED_PYTHON_FILES=$(get_python_files) +STAGED_JS_TS_FILES=$(get_js_ts_files) + +if [ ! -z "$STAGED_PYTHON_FILES" ]; then + bash "$REPO_ROOT/scripts/git-hooks/check-python-deps.sh" "$TEMP_DIR" + bash "$REPO_ROOT/scripts/git-hooks/python-checks.sh" "$TEMP_DIR" +fi + +if [ ! -z "$STAGED_JS_TS_FILES" ]; then + bash "$REPO_ROOT/scripts/git-hooks/check-js-deps.sh" "$TEMP_DIR" + bash "$REPO_ROOT/scripts/git-hooks/js-checks.sh" "$TEMP_DIR" +fi + +bash "$REPO_ROOT/scripts/git-hooks/check-unstaged.sh" "$TEMP_DIR" + +# --- 3. Read and Aggregate Results --- +declare -A RESULTS + +# Function to safely read file content +read_file_content() { + local file_path="$1" + local default_value="$2" + if [[ -f "$file_path" ]]; then + # Use process substitution to handle potential final newline issues + read -r -d '' content < <(cat "$file_path" && printf '\0') || true + echo "$content" + else + echo "$default_value" + fi +} + +# Read all potential results +RESULTS[python_deps_status]=$(read_file_content "$TEMP_DIR/python_deps_status.txt" "3") # Default to skipped +RESULTS[python_deps_message]=$(read_file_content "$TEMP_DIR/python_deps_message.txt" "") +RESULTS[python_run_status]=$(read_file_content "$TEMP_DIR/python_run_status.txt" "3") # Default to skipped +RESULTS[python_run_message]=$(read_file_content "$TEMP_DIR/python_run_message.txt" "") + +RESULTS[js_deps_status]=$(read_file_content "$TEMP_DIR/js_deps_status.txt" "3") # Default to skipped +RESULTS[js_deps_message]=$(read_file_content "$TEMP_DIR/js_deps_message.txt" "") +RESULTS[js_run_status]=$(read_file_content "$TEMP_DIR/js_run_status.txt" "3") # Default to skipped +RESULTS[js_run_message]=$(read_file_content "$TEMP_DIR/js_run_message.txt" "") + +RESULTS[unstaged_status]=$(read_file_content "$TEMP_DIR/unstaged_status.txt" "-1") +RESULTS[unstaged_message]=$(read_file_content "$TEMP_DIR/unstaged_message.txt" "Error reading message") + +# Aggregate language results +get_combined_status() { + local deps_status=$1 + local run_status=$2 + # Prioritize errors, then failure, then warnings, then run status, then deps status + if [ "$deps_status" = "-1" ] || [ "$run_status" = "-1" ]; then echo "-1"; # File read error + elif [ "$deps_status" = "1" ] || [ "$run_status" = "1" ]; then echo "1"; # Failure + elif [ "$deps_status" = "2" ]; then echo "2"; # Dep Warning + elif [ "$run_status" = "2" ]; then echo "2"; # Run Warning (if any) + elif [ "$run_status" = "0" ]; then echo "0"; # Run Success + # If checks weren't run (deps=3, run=3), overall is skipped (3) + elif [ "$deps_status" = "3" ] && [ "$run_status" = "3" ]; then echo "3"; + else echo "3"; # Fallback to skipped if something unexpected happened + fi +} + +get_combined_message() { + local deps_status=$1 + local run_status=$2 + local deps_msg=$3 + local run_msg=$4 + # Show dep warning message first if it exists + if [ "$deps_status" = "2" ]; then echo "$deps_msg"; + # Then show run message if it exists and wasn't skipped + elif [ -n "$run_msg" ] && [ "$run_status" != "3" ]; then echo "$run_msg"; + # Fallback to dep message if it exists and wasn't skipped + elif [ -n "$deps_msg" ] && [ "$deps_status" != "3" ]; then echo "$deps_msg"; + # If both were skipped, show nothing + elif [ "$run_status" = "3" ] && [ "$deps_status" = "3" ]; then echo ""; + else echo "Check skipped or no message"; # Fallback + fi +} + +RESULTS[python_combined_status]=$(get_combined_status ${RESULTS[python_deps_status]} ${RESULTS[python_run_status]}) +RESULTS[python_combined_message]=$(get_combined_message ${RESULTS[python_deps_status]} ${RESULTS[python_run_status]} "${RESULTS[python_deps_message]}" "${RESULTS[python_run_message]}") + +RESULTS[js_combined_status]=$(get_combined_status ${RESULTS[js_deps_status]} ${RESULTS[js_run_status]}) +RESULTS[js_combined_message]=$(get_combined_message ${RESULTS[js_deps_status]} ${RESULTS[js_run_status]} "${RESULTS[js_deps_message]}" "${RESULTS[js_run_message]}") + +# --- 4. Assemble and Print Summary Table (Reduced) --- +echo -e "\nšŸ“Š Pre-commit Hook Status:" + +declare -A data + +data[1,0]="Python" +data[1,1]="$(get_status_emoji ${RESULTS[python_combined_status]})" +data[1,2]="${RESULTS[python_combined_message]}" + +data[2,0]="JS/TS" +data[2,1]="$(get_status_emoji ${RESULTS[js_combined_status]})" +data[2,2]="${RESULTS[js_combined_message]}" + +data[3,0]="Unstaged" +data[3,1]="$(get_status_emoji ${RESULTS[unstaged_status]})" +data[3,2]="${RESULTS[unstaged_message]}" + +# Array of generic success/skip messages to potentially hide +declare -a HIDDEN_MESSAGES=( + "Python dependencies (ruff) found." + "JS/TS dependencies (prettier, eslint) found." + "JS/TS files formatted and linted successfully" + "Python files formatted and linted successfully" + "No unstaged changes detected" + # Keep "No staged ... files found to check." visible +) + +# Function to check if a message should be hidden +should_hide_message() { + local msg="$1" + for hidden in "${HIDDEN_MESSAGES[@]}"; do + if [[ "$msg" == "$hidden" ]]; then + return 0 + fi + done + return 1 +} + +# Print data rows (now only 3 rows) +for ((i=1; i<4; i++)); do + check_label="${data[$i,0]}" + status_emoji="${data[$i,1]}" + message="${data[$i,2]}" + status_val=-1 + if [ "$check_label" == "Python" ]; then status_val=${RESULTS[python_combined_status]}; + elif [ "$check_label" == "JS/TS" ]; then status_val=${RESULTS[js_combined_status]}; + elif [ "$check_label" == "Unstaged" ]; then status_val=${RESULTS[unstaged_status]}; + fi + + # Always print the row (removed status != 3 check) + # or if it's the Unstaged check which always runs + # if [[ "$status_val" != "3" ]] || [[ "$check_label" == "Unstaged" ]]; then + echo -n "${check_label}: ${status_emoji}" + if [[ "$status_val" != "-1" && -n "$message" ]] && ! should_hide_message "$message"; then + echo # Newline before message + echo "$message" | sed 's/^/ /' + else + echo # Just a newline after the status + fi + # fi # Removed corresponding closing fi +done + +# --- 5. Final Exit Status --- +FINAL_EXIT_CODE=0 +FAILURE_MESSAGE="" + +# Check combined statuses for failure (1) or read error (-1) +if [ ${RESULTS[python_combined_status]} -eq 1 ] || [ ${RESULTS[js_combined_status]} -eq 1 ] || [ ${RESULTS[unstaged_status]} -eq 1 ]; then + FAILURE_MESSAGE="\nāŒ Pre-commit hook failed. Please fix the issues reported." + FINAL_EXIT_CODE=1 +elif [ ${RESULTS[python_combined_status]} -eq -1 ] || [ ${RESULTS[js_combined_status]} -eq -1 ] || [ ${RESULTS[unstaged_status]} -eq -1 ]; then + FAILURE_MESSAGE="\nāŒ Pre-commit hook encountered an internal error (missing result files)." + FINAL_EXIT_CODE=1 +fi + +if [ $FINAL_EXIT_CODE -ne 0 ]; then + echo -e "$FAILURE_MESSAGE" +else + # Check for warnings (status 2) + HAS_WARNINGS=0 + if [ ${RESULTS[python_combined_status]} -eq 2 ] || [ ${RESULTS[js_combined_status]} -eq 2 ] || [ ${RESULTS[unstaged_status]} -eq 2 ]; then + HAS_WARNINGS=1 + fi + + if [ $HAS_WARNINGS -eq 1 ]; then + echo -e "\nāš ļø Pre-commit hook completed with warnings." + else + echo -e "\nāœ… Pre-commit hook completed successfully." + fi +fi + +# Cleanup is handled by trap +exit $FINAL_EXIT_CODE diff --git a/app/.todo/01_clickhouse_client.md b/app/.todo/01_clickhouse_client.md new file mode 100644 index 000000000..4c2f24f24 --- /dev/null +++ b/app/.todo/01_clickhouse_client.md @@ -0,0 +1,43 @@ +# Task: Implement Clickhouse Client + +## Description + +Create a Clickhouse client implementation for connecting to the Clickhouse database. This client will be used by the v4 endpoints to query trace, log, and metric data. + +## Requirements + +1. Implement an async Clickhouse client using the `clickhouse-driver` package +2. Create connection pooling to efficiently manage database connections +3. Implement error handling and retry mechanisms +4. Create utility functions for common query patterns +5. Ensure proper configuration from environment variables + +## Implementation Details + +- Create a new file at `agentops/api/db/clickhouse_client.py` +- Use environment variables for connection details (host, port, username, password, database) +- Implement connection pooling to efficiently manage connections +- Create utility functions for common query patterns (e.g., querying traces, logs, metrics) +- Implement error handling and retry mechanisms + +## Environment Variables + +- `CLICKHOUSE_HOST`: Clickhouse server hostname +- `CLICKHOUSE_PORT`: Clickhouse server port +- `CLICKHOUSE_USER`: Clickhouse username +- `CLICKHOUSE_PASSWORD`: Clickhouse password +- `CLICKHOUSE_DATABASE`: Clickhouse database name (default: otel) + +## Dependencies + +- Add `clickhouse-driver` to the project dependencies in `pyproject.toml` + +## Testing + +- Create unit tests for the client implementation +- Test connection to the Clickhouse database +- Test query execution and result parsing + +## Estimated Time + +4-6 hours diff --git a/app/.todo/02_authentication_middleware.md b/app/.todo/02_authentication_middleware.md new file mode 100644 index 000000000..7f3acc48e --- /dev/null +++ b/app/.todo/02_authentication_middleware.md @@ -0,0 +1,46 @@ +# Task: Implement Authentication Middleware for v4 Endpoints + +## Description + +Create authentication middleware for the v4 endpoints that verifies JWT tokens obtained from the v3 authentication endpoint. This middleware will ensure that only authenticated users can access the v4 endpoints. + +## Requirements + +1. Implement middleware that verifies JWT tokens +2. Extract project information from the token +3. Handle error cases (missing token, invalid token, expired token) +4. Ensure compatibility with the existing v3 authentication endpoint + +## Implementation Details + +- Create a new file at `agentops/api/middleware/auth.py` +- Implement a FastAPI dependency that verifies JWT tokens +- Extract project information from the token +- Handle error cases (missing token, invalid token, expired token) +- Ensure compatibility with the existing v3 authentication endpoint + +## Integration with v4 Endpoints + +- All v4 endpoints should use this middleware to verify authentication +- The middleware should extract project information from the token and make it available to the endpoint handlers + +## Error Handling + +- Return appropriate HTTP status codes for authentication errors: + - 401 Unauthorized: Missing or invalid token + - 403 Forbidden: Token does not have permission to access the requested resource + +## Testing + +- Create unit tests for the middleware +- Test with valid and invalid tokens +- Test with expired tokens +- Test with tokens that do not have permission to access the requested resource + +## Dependencies + +- Use the existing JWT verification function from `agentops/api/routes/v3.py` + +## Estimated Time + +2-3 hours diff --git a/app/.todo/03_trace_endpoints.md b/app/.todo/03_trace_endpoints.md new file mode 100644 index 000000000..717d74894 --- /dev/null +++ b/app/.todo/03_trace_endpoints.md @@ -0,0 +1,68 @@ +# Task: Implement Trace Endpoints for v4 API + +## Description + +Create endpoints for querying trace data from Clickhouse. These endpoints will replace the existing v2 endpoints that query trace data from Supabase. + +## Requirements + +1. Implement endpoints for querying trace data +2. Ensure compatibility with the existing v2 endpoints +3. Optimize queries for performance +4. Implement filtering, sorting, and pagination +5. Handle error cases + +## Endpoints to Implement + +1. `GET /v4/traces`: Get a list of traces +2. `GET /v4/traces/{trace_id}`: Get a specific trace by ID +3. `GET /v4/traces/{trace_id}/spans`: Get spans for a specific trace +4. `GET /v4/traces/search`: Search for traces based on criteria + +## Implementation Details + +- Create a new file at `agentops/api/routes/v4/traces.py` +- Use the Clickhouse client to query trace data +- Implement filtering, sorting, and pagination +- Handle error cases +- Ensure compatibility with the existing v2 endpoints + +## Query Parameters + +- `project_id`: Filter by project ID +- `start_time`: Filter by start time +- `end_time`: Filter by end time +- `service_name`: Filter by service name +- `span_name`: Filter by span name +- `status_code`: Filter by status code +- `limit`: Limit the number of results +- `offset`: Offset for pagination + +## Response Format + +- Return JSON responses with trace data +- Include metadata for pagination +- Include links to related resources + +## Computed Fields Migration + +- Identify computed fields in v2 endpoints (e.g., LLM calls, tool calls) +- Implement equivalent queries in Clickhouse +- Use span attributes and events to extract the required data +- Ensure backward compatibility with existing clients + +## Testing + +- Create unit tests for the endpoints +- Test with real data in Clickhouse +- Test performance with large datasets +- Test error handling + +## Dependencies + +- Clickhouse client implementation +- Authentication middleware + +## Estimated Time + +8-10 hours diff --git a/app/.todo/04_log_endpoints.md b/app/.todo/04_log_endpoints.md new file mode 100644 index 000000000..d62ac2c88 --- /dev/null +++ b/app/.todo/04_log_endpoints.md @@ -0,0 +1,62 @@ +# Task: Implement Log Endpoints for v4 API + +## Description + +Create endpoints for querying log data from Clickhouse. These endpoints will replace the existing v2 endpoints that query log data from Supabase. + +## Requirements + +1. Implement endpoints for querying log data +2. Ensure compatibility with the existing v2 endpoints +3. Optimize queries for performance +4. Implement filtering, sorting, and pagination +5. Handle error cases + +## Endpoints to Implement + +1. `GET /v4/logs`: Get a list of logs +2. `GET /v4/logs/{trace_id}`: Get logs for a specific trace +3. `GET /v4/logs/search`: Search for logs based on criteria + +## Implementation Details + +- Create a new file at `agentops/api/routes/v4/logs.py` +- Use the Clickhouse client to query log data +- Implement filtering, sorting, and pagination +- Handle error cases +- Ensure compatibility with the existing v2 endpoints + +## Query Parameters + +- `project_id`: Filter by project ID +- `trace_id`: Filter by trace ID +- `start_time`: Filter by start time +- `end_time`: Filter by end time +- `service_name`: Filter by service name +- `severity_text`: Filter by severity text +- `severity_number`: Filter by severity number +- `body_contains`: Filter by log body content +- `limit`: Limit the number of results +- `offset`: Offset for pagination + +## Response Format + +- Return JSON responses with log data +- Include metadata for pagination +- Include links to related resources + +## Testing + +- Create unit tests for the endpoints +- Test with real data in Clickhouse +- Test performance with large datasets +- Test error handling + +## Dependencies + +- Clickhouse client implementation +- Authentication middleware + +## Estimated Time + +6-8 hours diff --git a/app/.todo/05_metric_endpoints.md b/app/.todo/05_metric_endpoints.md new file mode 100644 index 000000000..c60d6c87b --- /dev/null +++ b/app/.todo/05_metric_endpoints.md @@ -0,0 +1,79 @@ +# Task: Implement Metric Endpoints for v4 API + +## Description + +Create endpoints for querying metric data from Clickhouse. These endpoints will replace the existing v2 endpoints that query metric data from Supabase. + +## Requirements + +1. Implement endpoints for querying metric data +2. Ensure compatibility with the existing v2 endpoints +3. Optimize queries for performance +4. Implement filtering, sorting, and pagination +5. Handle error cases + +## Endpoints to Implement + +1. `GET /v4/metrics`: Get a list of metrics +2. `GET /v4/metrics/{metric_name}`: Get a specific metric by name +3. `GET /v4/metrics/search`: Search for metrics based on criteria +4. `GET /v4/metrics/aggregate`: Aggregate metrics based on criteria + +## Implementation Details + +- Create a new file at `agentops/api/routes/v4/metrics.py` +- Use the Clickhouse client to query metric data +- Implement filtering, sorting, and pagination +- Handle error cases +- Ensure compatibility with the existing v2 endpoints + +## Query Parameters + +- `project_id`: Filter by project ID +- `metric_name`: Filter by metric name +- `start_time`: Filter by start time +- `end_time`: Filter by end time +- `service_name`: Filter by service name +- `attributes`: Filter by attributes +- `aggregation`: Specify aggregation function (sum, avg, min, max, count) +- `interval`: Specify time interval for aggregation +- `limit`: Limit the number of results +- `offset`: Offset for pagination + +## Response Format + +- Return JSON responses with metric data +- Include metadata for pagination +- Include links to related resources + +## Metric Types + +- Implement support for different metric types: + - Gauge metrics (from `otel_metrics_gauge`) + - Sum metrics (from `otel_metrics_sum`) + - Histogram metrics (from `otel_metrics_histogram`) + - Summary metrics (from `otel_metrics_summary`) + - Exponential histogram metrics (from `otel_metrics_exponential_histogram`) + +## Computed Fields Migration + +- Identify computed metrics in v2 endpoints +- Implement equivalent queries in Clickhouse +- Use metric attributes to extract the required data +- Ensure backward compatibility with existing clients + +## Testing + +- Create unit tests for the endpoints +- Test with real data in Clickhouse +- Test performance with large datasets +- Test error handling + +## Dependencies + +- Clickhouse client implementation +- Authentication middleware + +## Estimated Time + +8-10 hours diff --git a/app/.todo/06_session_endpoints.md b/app/.todo/06_session_endpoints.md new file mode 100644 index 000000000..808ed673d --- /dev/null +++ b/app/.todo/06_session_endpoints.md @@ -0,0 +1,77 @@ +# Task: Implement Session Endpoints for v4 API + +## Description + +Create endpoints for querying session data from Clickhouse. These endpoints will replace the existing v2 endpoints that query session data from Supabase. + +## Requirements + +1. Implement endpoints for querying session data +2. Ensure compatibility with the existing v2 endpoints +3. Optimize queries for performance +4. Implement filtering, sorting, and pagination +5. Handle error cases + +## Endpoints to Implement + +1. `GET /v4/sessions`: Get a list of sessions +2. `GET /v4/sessions/{session_id}`: Get a specific session by ID +3. `GET /v4/sessions/{session_id}/traces`: Get traces for a specific session +4. `GET /v4/sessions/{session_id}/logs`: Get logs for a specific session +5. `GET /v4/sessions/{session_id}/metrics`: Get metrics for a specific session +6. `GET /v4/sessions/{session_id}/stats`: Get statistics for a specific session +7. `GET /v4/sessions/search`: Search for sessions based on criteria + +## Implementation Details + +- Create a new file at `agentops/api/routes/v4/sessions.py` +- Use the Clickhouse client to query session data +- Implement filtering, sorting, and pagination +- Handle error cases +- Ensure compatibility with the existing v2 endpoints + +## Query Parameters + +- `project_id`: Filter by project ID +- `start_time`: Filter by start time +- `end_time`: Filter by end time +- `tags`: Filter by tags +- `end_state`: Filter by end state +- `limit`: Limit the number of results +- `offset`: Offset for pagination + +## Response Format + +- Return JSON responses with session data +- Include metadata for pagination +- Include links to related resources + +## Session Identification + +- Sessions are identified by the `session_id` attribute in trace resource attributes +- Implement logic to extract session information from trace data +- Create views or materialized views in Clickhouse to optimize session queries + +## Computed Fields Migration + +- Identify computed fields in v2 endpoints (e.g., session statistics) +- Implement equivalent queries in Clickhouse +- Use trace attributes and events to extract the required data +- Ensure backward compatibility with existing clients + +## Testing + +- Create unit tests for the endpoints +- Test with real data in Clickhouse +- Test performance with large datasets +- Test error handling + +## Dependencies + +- Clickhouse client implementation +- Authentication middleware +- Trace endpoints implementation + +## Estimated Time + +10-12 hours diff --git a/app/.todo/07_computed_fields_migration.md b/app/.todo/07_computed_fields_migration.md new file mode 100644 index 000000000..0c37771bb --- /dev/null +++ b/app/.todo/07_computed_fields_migration.md @@ -0,0 +1,61 @@ +# Task: Migrate Computed Fields from v2 to v4 API + +## Description + +Develop a strategy and implementation for migrating computed fields from v2 to v4 API. In v2, these fields were computed by "meters", but in v4, they need to be computed from OpenTelemetry data in Clickhouse. + +## Requirements + +1. Identify all computed fields in v2 endpoints +2. Develop a strategy for computing these fields from OpenTelemetry data +3. Implement the computation logic +4. Ensure backward compatibility with existing clients +5. Optimize queries for performance + +## Computed Fields to Migrate + +1. LLM calls (count, tokens, cost) +2. Tool calls (count, types) +3. Session duration +4. Session cost +5. Session statistics (success rate, error rate) +6. Agent performance metrics + +## Implementation Details + +- Create a new file at `agentops/api/utils/computed_fields.py` +- Implement functions for computing each field from OpenTelemetry data +- Use span attributes and events to extract the required data +- Optimize queries for performance +- Ensure backward compatibility with existing clients + +## OpenTelemetry Data Mapping + +- Map v2 computed fields to OpenTelemetry concepts: + - LLM calls: Spans with `span.kind=client` and `ai.model.name` attribute + - Tool calls: Spans with `span.kind=client` and specific attributes + - Session duration: Difference between first and last span timestamp in a trace + - Session cost: Sum of costs from LLM call spans + - Session statistics: Derived from span status codes and attributes + +## Query Optimization + +- Create materialized views in Clickhouse to precompute common aggregations +- Use efficient query patterns to minimize data transfer +- Implement caching for frequently accessed data + +## Testing + +- Create unit tests for the computation logic +- Test with real data in Clickhouse +- Test performance with large datasets +- Test backward compatibility with existing clients + +## Dependencies + +- Clickhouse client implementation +- Trace, log, and metric endpoints implementation + +## Estimated Time + +12-16 hours diff --git a/app/.todo/08_api_documentation.md b/app/.todo/08_api_documentation.md new file mode 100644 index 000000000..825ef057f --- /dev/null +++ b/app/.todo/08_api_documentation.md @@ -0,0 +1,73 @@ +# Task: Create API Documentation for v4 Endpoints + +## Description + +Create comprehensive API documentation for the v4 endpoints. This documentation should include endpoint descriptions, request/response formats, authentication requirements, and examples. + +## Requirements + +1. Document all v4 endpoints +2. Include request/response formats +3. Include authentication requirements +4. Include examples +5. Create OpenAPI specification + +## Documentation to Create + +1. API reference documentation +2. OpenAPI specification (v3) +3. Migration guide from v2 to v4 +4. Examples for common use cases + +## Implementation Details + +- Create a new file at `openapi-spec-v4.yaml` +- Document all v4 endpoints in the OpenAPI specification +- Create a migration guide from v2 to v4 +- Create examples for common use cases + +## API Reference Documentation + +- Document each endpoint with: + - Description + - Request format + - Response format + - Authentication requirements + - Query parameters + - Path parameters + - Examples + +## OpenAPI Specification + +- Create an OpenAPI specification (v3) for the v4 endpoints +- Include all endpoints, request/response formats, and authentication requirements +- Ensure the specification is valid and can be used to generate client libraries + +## Migration Guide + +- Create a guide for migrating from v2 to v4 +- Document changes in authentication +- Document changes in endpoint paths +- Document changes in request/response formats +- Document changes in computed fields + +## Examples + +- Create examples for common use cases +- Include code snippets in multiple languages (Python, JavaScript, Go) +- Include examples for authentication +- Include examples for querying traces, logs, and metrics + +## Testing + +- Validate the OpenAPI specification +- Test examples with real data +- Ensure documentation is clear and comprehensive + +## Dependencies + +- All v4 endpoint implementations + +## Estimated Time + +6-8 hours diff --git a/app/.todo/09_testing_and_validation.md b/app/.todo/09_testing_and_validation.md new file mode 100644 index 000000000..5e13a0e0a --- /dev/null +++ b/app/.todo/09_testing_and_validation.md @@ -0,0 +1,73 @@ +# Task: Testing and Validation of v4 API + +## Description + +Create comprehensive tests for the v4 API endpoints. These tests should validate the functionality, performance, and reliability of the endpoints. + +## Requirements + +1. Create unit tests for all v4 endpoints +2. Create integration tests for the v4 API +3. Create performance tests for the v4 API +4. Create validation tests for the v4 API +5. Create a test environment with sample data + +## Test Types to Create + +1. Unit tests for individual endpoint functions +2. Integration tests for the entire API +3. Performance tests for high-load scenarios +4. Validation tests for data consistency +5. Authentication tests for security + +## Implementation Details + +- Create test files in the `tests/api/v4` directory +- Use pytest for unit and integration tests +- Use locust or k6 for performance tests +- Create a test environment with sample data in Clickhouse + +## Unit Tests + +- Test each endpoint function in isolation +- Mock dependencies (Clickhouse client, authentication) +- Test error handling +- Test edge cases + +## Integration Tests + +- Test the entire API flow +- Test authentication +- Test data consistency across endpoints +- Test error handling + +## Performance Tests + +- Test endpoint performance under load +- Test query performance with large datasets +- Test concurrent requests +- Identify bottlenecks + +## Validation Tests + +- Validate data consistency between v2 and v4 endpoints +- Validate computed fields +- Validate response formats +- Validate error handling + +## Test Environment + +- Create a test environment with sample data in Clickhouse +- Create scripts to populate the test environment +- Create scripts to validate the test environment +- Document the test environment setup + +## Dependencies + +- All v4 endpoint implementations +- Clickhouse client implementation +- Authentication middleware + +## Estimated Time + +10-12 hours diff --git a/app/.todo/10_deployment_and_monitoring.md b/app/.todo/10_deployment_and_monitoring.md new file mode 100644 index 000000000..2954b0fc6 --- /dev/null +++ b/app/.todo/10_deployment_and_monitoring.md @@ -0,0 +1,73 @@ +# Task: Deployment and Monitoring of v4 API + +## Description + +Create a deployment and monitoring strategy for the v4 API. This strategy should include deployment procedures, monitoring tools, and alerting mechanisms. + +## Requirements + +1. Create a deployment strategy for the v4 API +2. Set up monitoring for the v4 API +3. Set up alerting for the v4 API +4. Create a rollback strategy +5. Document the deployment and monitoring procedures + +## Implementation Details + +- Update the Dockerfile to include the v4 API +- Create deployment scripts +- Set up monitoring tools (Prometheus, Grafana) +- Set up alerting mechanisms (PagerDuty, Slack) +- Document the deployment and monitoring procedures + +## Deployment Strategy + +- Update the Dockerfile to include the v4 API +- Create deployment scripts for different environments (dev, staging, prod) +- Set up CI/CD pipelines for automated deployment +- Create a rollback strategy for failed deployments +- Document the deployment procedures + +## Monitoring + +- Set up Prometheus for metrics collection +- Set up Grafana for metrics visualization +- Create dashboards for key metrics: + - Request rate + - Error rate + - Response time + - Resource usage +- Document the monitoring procedures + +## Alerting + +- Set up alerting mechanisms (PagerDuty, Slack) +- Create alert rules for key metrics: + - High error rate + - Slow response time + - Resource exhaustion +- Document the alerting procedures + +## Performance Optimization + +- Identify performance bottlenecks +- Optimize query performance +- Implement caching where appropriate +- Scale resources as needed + +## Documentation + +- Document the deployment procedures +- Document the monitoring procedures +- Document the alerting procedures +- Document the rollback procedures +- Create runbooks for common issues + +## Dependencies + +- All v4 endpoint implementations +- Testing and validation + +## Estimated Time + +8-10 hours diff --git a/app/.todo/README.md b/app/.todo/README.md new file mode 100644 index 000000000..7b5452ddc --- /dev/null +++ b/app/.todo/README.md @@ -0,0 +1,53 @@ +# v4 API Implementation Tasks + +This directory contains tasks for implementing the v4 API endpoints that query Clickhouse data as part of the transition to OpenTelemetry. + +## Overview + +The v4 API will replace the existing v2 API endpoints that query data from Supabase. The new endpoints will query data from Clickhouse, which stores OpenTelemetry trace, log, and metric data. + +## Task Structure + +Each task is defined in a separate Markdown file with the following structure: + +1. Task name and description +2. Requirements +3. Implementation details +4. Testing requirements +5. Dependencies +6. Estimated time + +## Task Dependencies + +The tasks are ordered by dependency, with earlier tasks being dependencies for later tasks: + +1. **Clickhouse Client**: Implement a client for connecting to Clickhouse +2. **Authentication Middleware**: Implement middleware for authenticating requests +3. **Trace Endpoints**: Implement endpoints for querying trace data +4. **Log Endpoints**: Implement endpoints for querying log data +5. **Metric Endpoints**: Implement endpoints for querying metric data +6. **Session Endpoints**: Implement endpoints for querying session data +7. **Computed Fields Migration**: Migrate computed fields from v2 to v4 +8. **API Documentation**: Create documentation for the v4 API +9. **Testing and Validation**: Create tests for the v4 API +10. **Deployment and Monitoring**: Create a deployment and monitoring strategy + +## Implementation Strategy + +The implementation strategy is to create a new set of v4 endpoints that query data from Clickhouse, while maintaining backward compatibility with the existing v2 endpoints. This will allow for a gradual migration from v2 to v4. + +## Computed Fields Migration + +A key challenge in this implementation is migrating the computed fields from v2 to v4. In v2, these fields were computed by "meters", but in v4, they need to be computed from OpenTelemetry data in Clickhouse. Task 7 focuses on this migration. + +## Authentication + +The v4 endpoints will use the same authentication mechanism as the v3 endpoints, which exchange an API key for a JWT token. The token is then used to authenticate requests to the v4 endpoints. + +## Testing + +Each task includes testing requirements to ensure that the implementation is correct and performs well. Task 9 focuses on comprehensive testing of the entire v4 API. + +## Deployment + +Task 10 focuses on creating a deployment and monitoring strategy for the v4 API, including procedures for deploying, monitoring, and alerting. diff --git a/app/CONTRIBUTING.md b/app/CONTRIBUTING.md new file mode 100644 index 000000000..876293a99 --- /dev/null +++ b/app/CONTRIBUTING.md @@ -0,0 +1,490 @@ +# Contributing to AgentOps + +Thank you for your interest in contributing to AgentOps! We welcome contributions from the community and are excited to see what you'll build. + +## šŸ“‹ Table of Contents + +- [Code of Conduct](#code-of-conduct) +- [Getting Started](#getting-started) +- [Development Setup](#development-setup) +- [Making Changes](#making-changes) +- [Submitting Changes](#submitting-changes) +- [Code Style](#code-style) +- [Testing](#testing) +- [Documentation](#documentation) +- [Community](#community) + +## šŸ¤ Code of Conduct + +This project and everyone participating in it is governed by our Code of Conduct. By participating, you are expected to uphold this code. Please report unacceptable behavior to [conduct@agentops.ai](mailto:conduct@agentops.ai). + +### Our Standards + +- **Be respectful** and inclusive in your language and actions +- **Be collaborative** and help others learn and grow +- **Be constructive** when giving feedback +- **Focus on what's best** for the community and project + +## šŸš€ Getting Started + +### Ways to Contribute + +There are many ways to contribute to AgentOps: + +- **šŸ› Bug Reports**: Help us identify and fix issues +- **āœØ Feature Requests**: Suggest new features or improvements +- **šŸ“ Documentation**: Improve our docs, guides, and examples +- **šŸ’» Code**: Fix bugs, implement features, or improve performance +- **šŸŽØ Design**: Improve UI/UX, create graphics, or design assets +- **šŸ§Ŗ Testing**: Help test new features and report issues +- **šŸ’¬ Community**: Help answer questions and support other users + +### Before You Start + +1. **Check existing issues** to see if your bug/feature is already being worked on +2. **Join our Discord** to discuss your ideas with the community +3. **Read this guide** to understand our development process +4. **Set up your development environment** following the instructions below + +## šŸ› ļø Development Setup + +### Prerequisites + +Make sure you have the following installed: + +- **Node.js** 18+ ([Download](https://nodejs.org/)) +- **Python** 3.12+ ([Download](https://www.python.org/downloads/)) +- **Docker & Docker Compose** ([Download](https://www.docker.com/get-started)) +- **Bun** (recommended) or npm ([Install Bun](https://bun.sh/)) +- **uv** (recommended for Python) ([Install uv](https://github.com/astral-sh/uv)) +- **Git** ([Download](https://git-scm.com/downloads)) + +### Fork and Clone + +1. **Fork the repository** on GitHub +2. **Clone your fork**: + ```bash + git clone https://github.com/YOUR_USERNAME/agentops.git + cd agentops + ``` +3. **Add the upstream remote**: + ```bash + git remote add upstream https://github.com/AgentOps-AI/agentops.git + ``` + +### Environment Setup + +1. **Copy environment files**: + ```bash + cp .env.example .env + cp api/.env.example api/.env + cp dashboard/.env.example dashboard/.env.local + ``` + +2. **Set up external services** (see [External Services](#external-services) below) + +3. **Install dependencies**: + ```bash + # Root dependencies (linting, formatting) + bun install + + # Python dev dependencies + uv pip install -r requirements-dev.txt + + # API dependencies + cd api && uv pip install -e . && cd .. + + # Dashboard dependencies + cd dashboard && bun install && cd .. + ``` + +4. **Start development environment**: + ```bash + # Option 1: Use just commands (recommended) + just api-run # Start API server + just fe-run # Start frontend (in another terminal) + + # Option 2: Manual startup + cd api && uv run python run.py & + cd dashboard && bun dev & + ``` + +### External Services + +For development, you'll need to set up these external services: + +#### Supabase (Required) +1. Create a project at [supabase.com](https://supabase.com) +2. Get your project URL and anon key from Settings ā†’ API +3. Update `.env` files with your credentials + +#### ClickHouse (Required) +1. Sign up for [ClickHouse Cloud](https://clickhouse.com/cloud) (free tier available) +2. Create a database and get connection details +3. Update `.env` files with your credentials + +#### PostgreSQL (Required) +Configure direct PostgreSQL connection for the API: +1. Use your Supabase PostgreSQL connection details +2. Update `.env` files with `POSTGRES_*` variables + +#### Redis (Optional) +For caching (will fallback to SQLite for local development): +1. Set up Redis instance (local or cloud) +2. Update `.env` files with Redis connection details + +#### Stripe (Optional - for billing features) +1. Create a [Stripe](https://stripe.com) account +2. Get test API keys from the dashboard +3. Update `.env` files with your credentials + +## šŸ”„ Making Changes + +### Branch Naming + +Use descriptive branch names that follow this pattern: +- `feature/add-user-analytics` - New features +- `fix/dashboard-loading-issue` - Bug fixes +- `docs/update-api-guide` - Documentation updates +- `refactor/optimize-queries` - Code refactoring +- `test/add-integration-tests` - Test additions + +### Development Workflow + +1. **Create a new branch**: + ```bash + git checkout -b feature/your-feature-name + ``` + +2. **Make your changes** following our [code style guidelines](#code-style) + +3. **Test your changes**: + ```bash + # Run tests + cd api && pytest && ruff format + cd dashboard && bun test + + # Run linting + bun run lint + ``` + +4. **Commit your changes**: + ```bash + git add . + git commit -m "feat: add user analytics dashboard" + ``` + +### Commit Message Format + +We use [Conventional Commits](https://www.conventionalcommits.org/) for consistent commit messages: + +``` +(): + +[optional body] + +[optional footer(s)] +``` + +**Types:** +- `feat`: New feature +- `fix`: Bug fix +- `docs`: Documentation changes +- `style`: Code style changes (formatting, etc.) +- `refactor`: Code refactoring +- `test`: Adding or updating tests +- `chore`: Maintenance tasks + +**Examples:** +```bash +feat(dashboard): add real-time trace visualization +fix(api): resolve authentication token expiration +docs(readme): update installation instructions +test(api): add integration tests for billing endpoints +``` + +## šŸ“¤ Submitting Changes + +### Pull Request Process + +1. **Update your branch** with the latest changes: + ```bash + git fetch upstream + git rebase upstream/main + ``` + +2. **Push your changes**: + ```bash + git push origin your-branch-name + ``` + +3. **Create a Pull Request** on GitHub with: + - **Clear title** describing the change + - **Detailed description** explaining what and why + - **Screenshots** for UI changes + - **Testing instructions** for reviewers + - **Issue references** (e.g., "Closes #123") + +### Pull Request Template + +```markdown +## Description +Brief description of changes made. + +## Type of Change +- [ ] Bug fix (non-breaking change which fixes an issue) +- [ ] New feature (non-breaking change which adds functionality) +- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected) +- [ ] Documentation update + +## Testing +- [ ] Tests pass locally +- [ ] Added/updated tests for changes +- [ ] Manual testing completed + +## Screenshots (if applicable) +Add screenshots to help explain your changes. + +## Checklist +- [ ] Code follows project style guidelines +- [ ] Self-review completed +- [ ] Code is commented where necessary +- [ ] Documentation updated +- [ ] No new warnings introduced +``` + +### Review Process + +1. **Automated checks** must pass (linting, tests, build) +2. **Code review** by maintainers and community members +3. **Address feedback** and update your PR as needed +4. **Final approval** and merge by maintainers + +## šŸŽØ Code Style + +### JavaScript/TypeScript + +We use **ESLint** and **Prettier** for consistent formatting: + +```bash +# Check linting +bun run lint:js + +# Fix linting issues +bun run lint:js --fix + +# Format code +bun run format:js +``` + +**Key conventions:** +- Use **TypeScript** for type safety +- Prefer **const** and **let** over **var** +- Use **arrow functions** for short functions +- Use **async/await** over promises when possible +- Follow **React Hooks** best practices + +### Python + +We use **Ruff** for linting and formatting: + +```bash +# Check linting +bun run lint:py + +# Format code (runs 'ruff format') +bun run format:py +``` + +**Key conventions:** +- Follow **PEP 8** style guide +- Use **type hints** for function parameters and returns +- Prefer **f-strings** for string formatting +- Use **dataclasses** or **Pydantic** models for structured data +- Follow **FastAPI** best practices + +### General Guidelines + +- **Write clear, self-documenting code** +- **Add comments for complex logic** +- **Use meaningful variable and function names** +- **Keep functions small and focused** +- **Follow existing patterns in the codebase** + +## šŸ§Ŗ Testing + +**Docker is required** to run tests since they create PostgreSQL & ClickHouse instances. + +### Running Tests + +```bash +# API tests (requires Docker) +cd api && pytest + +# Frontend tests +cd dashboard && bun test + +# Integration tests (requires Docker) +cd api && pytest tests/integration/ + +# End-to-end tests +cd dashboard && bun run test:e2e +``` + +### Writing Tests + +#### API Tests (Python) +- Use **pytest** for test framework +- Use **fixtures** for test data setup +- Test **happy paths** and **error cases** +- Mock **external services** in unit tests + +```python +def test_create_user_success(client, db_session): + """Test successful user creation.""" + user_data = {"email": "test@example.com", "name": "Test User"} + response = client.post("/users", json=user_data) + assert response.status_code == 201 + assert response.json()["email"] == user_data["email"] +``` + +#### Frontend Tests (TypeScript) +- Use **Jest** and **React Testing Library** +- Test **user interactions** and **component behavior** +- Mock **API calls** and **external dependencies** + +```typescript +test('displays user dashboard correctly', async () => { + render(); + expect(screen.getByText('Welcome, Test User')).toBeInTheDocument(); + expect(screen.getByRole('button', { name: 'View Analytics' })).toBeInTheDocument(); +}); +``` + +### Test Coverage + +- Aim for **80%+ code coverage** +- Focus on **critical paths** and **business logic** +- Include **edge cases** and **error scenarios** + +## šŸ“š Documentation + +### Types of Documentation + +1. **Code Comments**: Explain complex logic and decisions +2. **API Documentation**: Auto-generated from code annotations +3. **User Guides**: Step-by-step instructions for users +4. **Developer Docs**: Technical implementation details + +### Writing Guidelines + +- **Be clear and concise** +- **Use examples** to illustrate concepts +- **Keep docs up-to-date** with code changes +- **Include screenshots** for UI features +- **Test instructions** to ensure they work + +### Documentation Structure + +``` +docs/ +ā”œā”€ā”€ api/ # API reference +ā”œā”€ā”€ guides/ # User guides +ā”œā”€ā”€ development/ # Developer documentation +ā”œā”€ā”€ deployment/ # Deployment guides +ā””ā”€ā”€ examples/ # Code examples +``` + +## šŸ‘„ Community + +### Getting Help + +- **GitHub Issues**: For bugs and feature requests +- **GitHub Discussions**: For questions and general discussion +- **Discord**: For real-time chat and community support +- **Email**: [support@agentops.ai](mailto:support@agentops.ai) for private matters + +### Helping Others + +- **Answer questions** in issues and discussions +- **Review pull requests** from other contributors +- **Share examples** and use cases +- **Write tutorials** and blog posts + +### Recognition + +We recognize contributors in several ways: +- **Contributors list** in README +- **Release notes** mention significant contributions +- **Swag and rewards** for major contributions +- **Maintainer status** for consistent, high-quality contributions + +## šŸ·ļø Issue Labels + +We use labels to categorize and prioritize issues: + +- **`good first issue`**: Great for new contributors +- **`help wanted`**: Community contributions welcome +- **`bug`**: Something isn't working +- **`enhancement`**: New feature or improvement +- **`documentation`**: Documentation needs +- **`question`**: Further information requested +- **`priority: high`**: Urgent issues +- **`priority: low`**: Nice-to-have improvements + +## šŸŽÆ Roadmap + +Check out our [public roadmap](https://github.com/AgentOps-AI/agentops/projects) to see what we're working on and where you can help. + +### Current Focus Areas + +- **Performance optimization** for large-scale deployments +- **Enhanced visualization** features +- **Integration ecosystem** expansion +- **Developer experience** improvements +- **Documentation** and **examples** + +## ā“ FAQ + +### How do I get started as a new contributor? + +1. Look for issues labeled `good first issue` +2. Join our Discord to introduce yourself +3. Set up your development environment +4. Start with documentation or small bug fixes +5. Ask questions - we're here to help! + +### What if I want to work on a big feature? + +1. Open an issue to discuss your idea first +2. Get feedback from maintainers and community +3. Create a design document for complex features +4. Break the work into smaller, reviewable PRs +5. Keep the community updated on your progress + +### How long does it take to get a PR reviewed? + +- **Simple fixes**: Usually within 1-2 days +- **New features**: May take 3-7 days for thorough review +- **Complex changes**: Could take 1-2 weeks with multiple review rounds + +We aim to provide initial feedback quickly and will let you know if we need more time. + +### Can I contribute if I'm not a developer? + +Absolutely! We welcome contributions in many forms: +- **Documentation** improvements +- **Design** and **UX** feedback +- **Testing** and **bug reports** +- **Community support** and **advocacy** +- **Content creation** (blogs, tutorials, videos) + +--- + +## šŸ™ Thank You + +Thank you for taking the time to contribute to AgentOps! Every contribution, no matter how small, helps make the project better for everyone. + +If you have any questions or need help getting started, don't hesitate to reach out. We're excited to see what you'll build with us! + +Happy coding! šŸš€ \ No newline at end of file diff --git a/app/LICENSE b/app/LICENSE new file mode 100644 index 000000000..abb28c71b --- /dev/null +++ b/app/LICENSE @@ -0,0 +1,55 @@ +Elastic License 2.0 + +URL: https://www.elastic.co/licensing/elastic-license + +## Acceptance + +By using the software, you agree to all of the terms and conditions below. + +## Copyright License + +The licensor grants you a non-exclusive, royalty-free, worldwide, non-sublicensable, non-transferable license to use, copy, distribute, make available, and prepare derivative works of the software, in each case subject to the limitations and conditions below. + +## Limitations + +You may not provide the software to third parties as a hosted or managed service, where the service provides users with access to any substantial set of the features or functionality of the software. + +You may not move, change, disable, or circumvent the license key functionality in the software, and you may not remove or obscure any functionality in the software that is protected by the license key. + +You may not alter, remove, or obscure any licensing, copyright, or other notices of the licensor in the software. Any use of the licensor's trademarks is subject to applicable law. + +## Patents + +The licensor grants you a license, under any patent claims the licensor can license, or becomes able to license, to make, have made, use, sell, offer for sale, import and have imported the software, in each case subject to the limitations and conditions in this license. This license does not cover any patent claims that you cause to be infringed by modifications or additions to the software. If you or your company make any written claim that the software infringes or contributes to infringement of any patent, your patent license for the software granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company. + +## Notices + +You must ensure that anyone who gets a copy of any part of the software from you also gets a copy of these terms. + +If you modify the software, you must include in any modified copies of the software prominent notices stating that you have modified the software. + +## No Other Rights + +These terms do not imply any licenses other than those expressly granted in these terms. + +## Termination + +If you use the software in violation of these terms, such use is not licensed, and your licenses will automatically terminate. If the licensor provides you with a notice of your violation, and you cease all violation of this license no later than 30 days after you receive that notice, your licenses will be reinstated retroactively. However, if you violate these terms after such reinstatement, any additional violation of these terms will cause your licenses to terminate automatically and permanently. + +## No Liability + +*As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the software, under any kind of legal claim.* + +## Definitions + +The **licensor** is the entity offering these terms, and the **software** is the software the licensor makes available under these terms, including any portion of it. + +**you** refers to the individual or entity agreeing to these terms. + +**your company** is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization. **control** means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise. Control can be direct or indirect. + +**your licenses** are all the licenses granted to you for the software under these terms. + +**use** means anything you do with the software requiring one of your licenses. + +**trademark** means trademarks, service marks, and similar rights. \ No newline at end of file diff --git a/app/README.md b/app/README.md new file mode 100644 index 000000000..37ef869a8 --- /dev/null +++ b/app/README.md @@ -0,0 +1,394 @@ +# AgentOps + +[![License: ELv2](https://img.shields.io/badge/License-ELv2-blue.svg)](https://www.elastic.co/licensing/elastic-license) +[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/) +[![Node.js 18+](https://img.shields.io/badge/node.js-18+-green.svg)](https://nodejs.org/) + +AgentOps is a comprehensive observability platform for AI agents and applications. Monitor, debug, and optimize your AI systems with real-time tracing, metrics, and analytics. + +## šŸš€ Features + +- **Real-time Monitoring**: Track AI agent performance and behavior in real-time +- **Distributed Tracing**: Full visibility into multi-step AI workflows +- **Cost Analytics**: Monitor and optimize AI model costs across providers +- **Error Tracking**: Comprehensive error monitoring and alerting +- **Team Collaboration**: Multi-user dashboard with role-based access +- **Billing Management**: Integrated subscription and usage-based billing + +## šŸ—ļø Architecture + +This monorepo contains: + +- **API Server** (`api/`) - FastAPI backend with authentication, billing, and data processing +- **Dashboard** (`dashboard/`) - Next.js frontend for visualization and management +- **Landing Page** (`landing/`) - Marketing website +- **ClickHouse** - Analytics database for traces and metrics +- **Supabase** - Authentication and primary database +- **Docker Compose** - Local development environment + +## šŸ“‹ Prerequisites + +Before you begin, ensure you have the following installed: + +- **Node.js** 18+ ([Download](https://nodejs.org/)) +- **Python** 3.12+ ([Download](https://www.python.org/downloads/)) +- **Docker & Docker Compose** ([Download](https://www.docker.com/get-started)) +- **Bun** (recommended) or npm ([Install Bun](https://bun.sh/)) +- **uv** (recommended for Python) ([Install uv](https://github.com/astral-sh/uv)) + +## šŸ› ļø Quick Start + +### 1. Clone the Repository + +```bash +git clone https://github.com/AgentOps-AI/AgentOps.Next.git +cd agentops +``` + +### 2. Set Up Environment Variables + +Copy the environment example files and fill in your values: + +```bash +# Root environment (for Docker Compose) +cp .env.example .env + +# API environment +cp api/.env.example api/.env + +# Dashboard environment +cp dashboard/.env.example dashboard/.env.local +``` + +**Important**: You'll need to set up external services first. See [External Services Setup](#external-services-setup) below. + +### 3. Install Dependencies + +```bash +# Install root dependencies (linting, formatting tools) +bun install + +# Install Python dev dependencies +uv pip install -r requirements-dev.txt + +# Install API dependencies +cd api && uv pip install -e . && cd .. + +# Install Dashboard dependencies +cd dashboard && bun install && cd .. +``` + +### 4. Start Development Environment + +```bash +# Start all services with Docker Compose +docker-compose up -d + +# Or use the convenience script +just api-run # Start API server +just fe-run # Start frontend in another terminal +``` + +Visit: +- Dashboard: http://localhost:3000 +- API Docs: http://localhost:8000/redoc + +## šŸ”§ External Services Setup + +AgentOps requires several external services. Here's how to set them up: + +### Supabase (Required) + +1. Create a new project at [supabase.com](https://supabase.com) +2. Go to Settings ā†’ API to get your keys +3. Update your `.env` files with: + ``` + SUPABASE_URL=https://your-project-id.supabase.co + SUPABASE_KEY=your-anon-key + ``` + +### ClickHouse (Required) + +1. Sign up for [ClickHouse Cloud](https://clickhouse.com/cloud) or self-host +2. Create a database and get connection details +3. Update your `.env` files with: + ``` + CLICKHOUSE_HOST=your-host.clickhouse.cloud + CLICKHOUSE_USER=default + CLICKHOUSE_PASSWORD=your-password + CLICKHOUSE_DATABASE=your-database + ``` + +### PostgreSQL (Required) + +Configure direct PostgreSQL connection: +1. Use your Supabase PostgreSQL connection details +2. Update your `.env` files with: + ``` + POSTGRES_HOST=your-supabase-host + POSTGRES_PORT=5432 + POSTGRES_USER=postgres.your-project-id + POSTGRES_PASSWORD=your-password + POSTGRES_DATABASE=postgres + ``` + +### Stripe (Optional - for billing) + +1. Create a [Stripe](https://stripe.com) account +2. Get your API keys from the dashboard +3. Update your `.env` files with: + ``` + STRIPE_SECRET_KEY=sk_test_... + STRIPE_PUBLISHABLE_KEY=pk_test_... + ``` + +### Additional Services (Optional) + +- **Sentry**: Error monitoring - [sentry.io](https://sentry.io) +- **PostHog**: Analytics - [posthog.com](https://posthog.com) +- **GitHub OAuth**: Social login - [GitHub Apps](https://github.com/settings/applications/new) + +## šŸƒā€ā™‚ļø Development Workflow + +### Using Just Commands (Recommended) + +```bash +# API Development +just api-native # Run API natively (faster for development) +just api-docker-build # Build API Docker image +just api-docker-run # Run API in Docker + +# Frontend Development +just fe-run # Run dashboard development server + +# View all available commands +just +``` + +### Manual Development + +```bash +# Start API server +cd api && uv run python run.py + +# Start dashboard (in another terminal) +cd dashboard && bun dev + +# Start landing page (in another terminal) +cd landing && bun dev +``` + +## šŸ§Ŗ Testing + +```bash +# Run API tests +cd api && pytest + +# Run frontend tests +cd dashboard && bun test + +# Run linting +bun run lint + +# Run formatting +bun run format +``` + +## šŸ“¦ Production Deployment + +### Using Docker Compose + +```bash +# Build and start production services +docker-compose -f compose.yaml up -d +``` + +### Environment Variables for Production + +Update your `.env` files with production values: + +```bash +# Core settings +PROTOCOL="https" +API_DOMAIN="api.yourdomain.com" +APP_DOMAIN="yourdomain.com" + +# Security +DEBUG="false" +LOGGING_LEVEL="WARNING" + +# Frontend +NEXT_PUBLIC_ENVIRONMENT_TYPE="production" +NEXT_PUBLIC_PLAYGROUND="false" +``` + +### Deployment Platforms + +AgentOps can be deployed on: + +- **Docker Compose** (recommended for self-hosting) +- **Kubernetes** (helm charts available) +- **Cloud platforms** (AWS, GCP, Azure) +- **Vercel** (frontend) + **Railway/Fly.io** (backend) + +## šŸ¤ Contributing + +We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details. + +### Development Setup + +1. Fork the repository +2. Create a feature branch: `git checkout -b feature/amazing-feature` +3. Make your changes and add tests +4. Run linting and tests: `bun run lint && bun run test` +5. Commit your changes: `git commit -m 'Add amazing feature'` +6. Push to the branch: `git push origin feature/amazing-feature` +7. Open a Pull Request + +### Code Style + +This project uses: +- **ESLint + Prettier** for JavaScript/TypeScript +- **Ruff** for Python +- **Pre-commit hooks** for automatic formatting + +## šŸ“š Documentation + +- [API Documentation](api/README.md) +- [Dashboard Documentation](dashboard/README.md) +- [Deployment Guide](docs/deployment.md) +- [Contributing Guide](CONTRIBUTING.md) + +## šŸ“„ License + +This project is licensed under the Elastic License 2.0 - see the [LICENSE](LICENSE) file for details. + +**Key License Points:** +- āœ… Free to use, modify, and distribute +- āœ… Commercial use allowed +- āŒ Cannot provide as a hosted/managed service to third parties +- āŒ Cannot circumvent license key functionality +- āŒ Cannot remove licensing notices + +For more information, visit [elastic.co/licensing/elastic-license](https://www.elastic.co/licensing/elastic-license). + +## šŸ†˜ Support + +- **Documentation**: Check our [docs](docs/) +- **Issues**: [GitHub Issues](https://github.com/AgentOps-AI/AgentOps.Next/issues) +- **Discussions**: [GitHub Discussions](https://github.com/AgentOps-AI/AgentOps.Next/discussions) +- **Email**: support@agentops.ai + +## šŸ™ Acknowledgments + +- Built with [FastAPI](https://fastapi.tiangolo.com/), [Next.js](https://nextjs.org/), [Supabase](https://supabase.com/), and [ClickHouse](https://clickhouse.com/) +- Inspired by the open source community +- Special thanks to all our contributors + +--- + +## Development Setup (Detailed) + +This monorepo uses centralized configurations for linting and formatting to ensure consistency across projects. + +**Prerequisites:** + +- Node.js (Version specified in root `package.json` -> engines) +- bun (usually comes with Node.js) +- Python (Version specified in `api/pyproject.toml` -> requires-python, used by Ruff) +- pip or uv (uv recommended for faster Python dependency management) + +**Installation:** + +1. **Install Root Node.js Dev Dependencies:** + ```bash + # From the repository root + bun install + ``` + + This installs ESLint, Prettier, TypeScript, Husky, and other shared tools defined in the root `package.json`. + +2. **Install Root Python Dev Dependencies:** + + ```bash + # From the repository root + # Using uv (recommended): + uv pip install -r requirements-dev.txt + + # Or using pip: + pip install -r requirements-dev.txt + ``` + This installs Ruff, defined in the root `requirements-dev.txt`. The `uv.lock` file ensures consistent versions across the monorepo. + +3. **Install Project-Specific Dependencies:** Navigate to the specific project directory (e.g., `dashboard/`, `api/`, `landing/`) and follow their respective setup instructions (e.g., `bun install`, `pip install -e .` or `uv pip install -e .`). + +**Linting & Formatting:** + +- **Configuration:** + - **JavaScript/TypeScript:** ESLint (`.eslintrc.json`) and Prettier (`prettier.config.js`) configurations are located at the repository root. + - **Python:** Ruff (`ruff.toml`) configuration is located at the repository root. + - Specific projects (like `dashboard/`) may have their own `.eslintrc.json` that _extends_ the root configuration for project-specific overrides. +- **Pre-commit Hook:** Husky is set up (`.husky/pre-commit`) to automatically format and lint staged files (JS/TS/Python) using the root configurations before you commit. +- **Manual Checks:** You can run checks manually from the root directory using scripts defined in the root `package.json`: + + ```bash + # Lint JS/TS files + bun run lint:js + + # Lint Python files + bun run lint:py + + # Format JS/TS files + bun run format:js + + # Format Python files + bun run format:py + + # Run all linting + bun run lint + + # Run all formatting + bun run format + ``` + +- **IDE Integration:** For the best experience, configure your IDE (e.g., VS Code) with the appropriate extensions (ESLint, Prettier, Ruff) to get real-time feedback and auto-formatting on save. + +### Running Services (Convenience) + +A `justfile` is provided at the root for convenience in running the primary services from the project root directory. After completing the setup and installation steps within each service directory (`api/`, `dashboard/`), you can use: + +- `just api-native`: Runs the backend API server natively. +- `just api-docker-build`: Builds the backend API Docker image. +- `just api-docker-run`: Runs the backend API server in Docker. +- `just dash`: Runs the frontend dashboard development server. + +Refer to the README files in `api/` and `dashboard/` for detailed setup instructions (environment variables, dependencies) before using these commands. + +## Procedure + +### Feature branch workflow + +1. Choose a ticket or feature to build +2. Create a new branch with a descriptive name +3. Complete the feature with this branch +4. Once the feature is finished, create a Pull Request with a brief explanation of the changes +5. With at least one review, merge the feature branch into main + +### PR's + +- No squash commit (green square maxxing) +- At least one review before merge +- `Main` is protected +- Emergency `Main` merges without reviews need to be justified in the PR +- The PR description should fit the PR template. +- Linear tickets closed should be referenced (i.e. `Closes ENG-123`) + +### Commit Formatting + +`type(service): description` + +_Examples_: + +- feat(supabase): added user table +- fix(app): spacing issue on dashboard +- test(app): login component testing diff --git a/app/SECURITY.md b/app/SECURITY.md new file mode 100644 index 000000000..8205be2b1 --- /dev/null +++ b/app/SECURITY.md @@ -0,0 +1,69 @@ +# Security Policy + +## Supported Versions + +We currently support the following versions with security updates: + +| Version | Supported | +| ------- | ------------------ | +| main | :white_check_mark: | + +## Reporting a Vulnerability + +We take security vulnerabilities seriously. If you discover a security vulnerability in AgentOps, please report it responsibly. + +### How to Report + +1. **Do NOT create a public GitHub issue** for security vulnerabilities +2. **Email us directly** at security@agentops.ai +3. **Include the following information:** + - Description of the vulnerability + - Steps to reproduce the issue + - Potential impact + - Suggested fix (if you have one) + +### What to Expect + +- **Acknowledgment**: We'll acknowledge receipt of your report within 24 hours +- **Investigation**: We'll investigate and validate the vulnerability +- **Timeline**: We aim to provide an initial response within 72 hours +- **Resolution**: Critical vulnerabilities will be patched within 7 days +- **Credit**: We'll credit you in our security advisories (unless you prefer to remain anonymous) + +### Security Best Practices + +When deploying AgentOps: + +1. **Environment Variables**: Never commit sensitive environment variables to version control +2. **HTTPS**: Always use HTTPS in production +3. **Authentication**: Use strong, unique passwords and enable 2FA where possible +4. **Updates**: Keep dependencies and the platform updated +5. **Access Control**: Follow the principle of least privilege +6. **Monitoring**: Enable logging and monitoring for suspicious activity + +### Security Features + +AgentOps includes several security features: + +- **JWT Authentication**: Secure token-based authentication +- **Role-based Access Control**: Granular permissions system +- **Input Validation**: Comprehensive input sanitization +- **Rate Limiting**: Protection against abuse +- **Audit Logging**: Track all user actions +- **Secure Headers**: HTTPS enforcement and security headers + +## Vulnerability Disclosure Timeline + +1. **Day 0**: Vulnerability reported +2. **Day 1**: Acknowledgment sent +3. **Days 1-3**: Investigation and validation +4. **Days 3-7**: Patch development and testing +5. **Day 7**: Security release (for critical issues) +6. **Day 14**: Public disclosure (after users have time to update) + +## Security Contacts + +- **Security Team**: security@agentops.ai +- **General Contact**: support@agentops.ai + +Thank you for helping keep AgentOps secure! diff --git a/app/api/.dockerignore b/app/api/.dockerignore new file mode 100644 index 000000000..2f36eea93 --- /dev/null +++ b/app/api/.dockerignore @@ -0,0 +1,3 @@ +fly.toml +.pytest_cache +.github diff --git a/app/api/Dockerfile b/app/api/Dockerfile new file mode 100644 index 000000000..f980093a1 --- /dev/null +++ b/app/api/Dockerfile @@ -0,0 +1,26 @@ +# To run this Dockerfile, do so from the AgentOps.Next directory +# docker build -f api/Dockerfile -t agentops-api . + +FROM python:3.12-slim-bookworm + +ENV PYTHONDONTWRITEBYTECODE=1 +ENV PYTHONUNBUFFERED=1 + +WORKDIR /app + +RUN apt-get update && apt-get install -y --no-install-recommends \ + build-essential \ + git \ + && rm -rf /var/lib/apt/lists/* + +COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/ + +COPY api/pyproject.toml /app/ + +COPY api/agentops /app/agentops +COPY deploy/jockey /app/jockey + +RUN uv sync + +EXPOSE 8000 +CMD ["uv", "run", "uvicorn", "agentops.app:app", "--host", "0.0.0.0", "--port", "8000"] diff --git a/app/api/README.md b/app/api/README.md new file mode 100644 index 000000000..b5073f279 --- /dev/null +++ b/app/api/README.md @@ -0,0 +1,319 @@ +# AgentOps Next API Server + +> **Note:** This project uses shared development configurations (linting, formatting) defined in the repository root. Please see the [root README.md](../../README.md#development-setup) for initial setup instructions and tooling details (Ruff). + +## Authentication + +Requests to protected endpoints (primarily `/opsboard/*` and `/v4/*`) require a valid Supabase JWT passed in the `Authorization: Bearer ` header. The API server validates this token using the `Depends(get_current_user)` dependency before processing the request. + +## Billing & Subscription Management šŸ’³ + +The API server integrates with Stripe to handle subscription billing, payment processing, and organization upgrades. This section covers the billing architecture, setup requirements, and available endpoints. + +### Billing Architecture + +The billing system follows this flow: +1. **Frontend** initiates billing actions (upgrade, cancel, reactivate) via API calls +2. **API Server** creates Stripe checkout sessions and manages subscription state +3. **Stripe Webhooks** notify the API of payment events and subscription changes +4. **Database** stores subscription status and organization premium status + +### Stripe Integration Setup + +#### Required Environment Variables + +```bash +# Stripe API Configuration +STRIPE_SECRET_KEY=sk_test_... # or sk_live_... for production +STRIPE_WEBHOOK_SECRET=whsec_... # Webhook signing secret +STRIPE_SUBSCRIPTION_PRICE_ID=price_... # Your subscription plan price ID +APP_URL=http://localhost:3000 # Frontend URL for redirects +``` + +#### Webhook Configuration + +Configure a Stripe webhook endpoint pointing to your API server: + +**Production:** +- Endpoint URL: `https://your-api-domain.com/v4/stripe-webhook` +- Events to send: `checkout.session.completed`, `customer.subscription.updated`, `customer.subscription.deleted`, `charge.dispute.created` + +**Local Development:** +Use the Stripe CLI to forward webhooks to your local server: +```bash +stripe listen --forward-to http://localhost:8000/v4/stripe-webhook +``` + +### Billing Endpoints + +#### Organization Billing (`/opsboard/orgs/{org_id}/`) + +- **`POST /create-checkout-session`**: Create a Stripe Checkout Session for upgrading to Pro + - **Body**: `{ "price_id": "price_...", "discount_code": "optional_code" }` + - **Returns**: `{ "clientSecret": "cs_..." }` for Stripe Elements + - **Features**: + - Double-payment prevention (checks existing active subscriptions) + - Discount code validation (promotion codes and coupons) + - Idempotency keys for retry safety + +- **`POST /cancel-subscription`**: Cancel an active subscription + - **Body**: `{ "subscription_id": "sub_..." }` + - **Action**: Sets `cancel_at_period_end=true` (subscription remains active until period end) + - **Features**: Idempotency protection, validation checks + +- **`POST /reactivate-subscription`**: Reactivate a cancelled subscription + - **Action**: Sets `cancel_at_period_end=false` (continues billing) + - **Features**: Idempotency protection, state validation + +- **`POST /validate-discount-code`**: Validate promotion codes before checkout + - **Body**: `{ "discount_code": "PROMO20" }` + - **Returns**: Discount details and validity status + +#### Webhook Handling (`/v4/stripe-webhook`) + +The webhook endpoint processes these Stripe events: + +- **`checkout.session.completed`**: Updates organization to Pro status after successful payment +- **`customer.subscription.updated`**: Handles subscription status changes (active, past_due, etc.) +- **`customer.subscription.deleted`**: Downgrades organization to free tier +- **`charge.dispute.created`**: Handles payment disputes and chargebacks + +### Billing Data Model + +Organizations store billing-related fields: + +```python +class OrgModel: + prem_status: PremStatus # 'free' or 'pro' + subscription_id: str # Stripe subscription ID + subscription_end_date: int # Unix timestamp + subscription_cancel_at_period_end: bool +``` + +### Error Handling & Monitoring + +The billing system includes comprehensive error handling: + +- **Structured Logging**: All billing operations log with structured data for monitoring +- **Webhook Replay Protection**: Events are processed idempotently +- **Database Transaction Safety**: Rollback on failures with detailed error logging +- **Stripe API Error Handling**: Graceful handling of Stripe API failures + +### Security Features + +- **Double-Payment Prevention**: Checks for existing active subscriptions before creating checkout sessions +- **Idempotency Keys**: All Stripe operations use unique idempotency keys to prevent duplicates +- **Webhook Signature Verification**: All webhook events are cryptographically verified +- **Permission Validation**: Only org admins/owners can manage billing + +### Testing Billing Features + +For local development: +1. Use Stripe test mode keys (`sk_test_...`, `price_test_...`) +2. Use test card numbers (e.g., `4242424242424242`) +3. Forward webhooks using `stripe listen` +4. Monitor webhook events in Stripe Dashboard + +## API Endpoints + +The API is divided into two main sections: `/opsboard` for user, organization, and project management, and `/v4` for trace and metric data retrieval. All endpoints listed below require JWT authentication. + +### OpsBoard (`/opsboard`) + +Handles core entity management. + +* **Users (`/opsboard/users`)** + * `GET /me`: Get details of the currently authenticated user. + * `PUT /me`: Update details of the currently authenticated user. + * `PUT /me/survey-complete`: Mark the authenticated user's survey as complete. +* **Projects (`/opsboard/projects`)** + * `GET /`: Get all projects the user has access to (excludes Demo Org). + * `GET /{project_id}`: Get details for a specific project. + * `POST /`: Create a new project (Requires Admin/Owner role in the org). + * `PUT /{project_id}`: Update project name or environment (Requires Admin/Owner role in the org). + * `DELETE /{project_id}`: Delete a project (Requires Owner role in the org). + * `POST /{project_id}/regenerate-key`: Regenerate the API key for a project (Requires Admin/Owner role in the org). +* **Organizations (`/opsboard/orgs`)** + * `GET /`: Get all organizations the user belongs to (excludes Demo Org). + * `GET /invites`: Get pending invitations *for* the authenticated user. + * `GET /{org_id}`: Get detailed information for a specific organization, including members. + * `POST /`: Create a new organization (user becomes Owner). + * `PUT /{org_id}`: Update organization name (Requires Admin/Owner role). + * `POST /{org_id}/invite`: Invite a user (by email) to the organization (Requires Admin/Owner role). + * `POST /{org_id}/accept-invite`: Accept a pending invitation for the authenticated user. + * `POST /{org_id}/remove-member`: Remove a specified user from the organization (Requires Admin/Owner role; cannot remove self or last Owner). + * `POST /{org_id}/change-role`: Change the role of a specified member (Requires Admin/Owner role; cannot change self or demote last Owner). + * `POST /{org_id}/create-checkout-session`: Create a Stripe Checkout Session for an organization to upgrade their plan. + * `POST /{org_id}/cancel-subscription`: Cancel the active Stripe subscription for an organization. + +### V4 (`/v4`) + +Handles trace and metrics data retrieval, primarily sourced from Clickhouse. These endpoints typically require a `project_id` query parameter. + +* **Traces (`/v4/traces`)** + * `GET /?project_id=&...`: Get a list of traces for the specified `project_id`. Supports filtering by time range, span name, pagination (`limit`, `offset`), and sorting (`order_by`, `sort_order`). + * `GET /{trace_id}?project_id=`: Get detailed information (including spans) for a specific `trace_id` belonging to the specified `project_id`. +* **Metrics (`/v4/meterics`)** *(Note: Prefix is intentionally `meterics`)* + * `GET /project?project_id=&...`: Get aggregated metrics (span counts, token usage, costs, durations, etc.) for the specified `project_id`. Supports filtering by time range (`start_time`, `end_time`). +* **Webhooks (`/v4`)** + * `POST /stripe-webhook`: Handles incoming Stripe events (e.g., `checkout.session.completed`, subscription updates) to manage subscription statuses. Requires specific Stripe webhook configuration in your Stripe dashboard to point to this endpoint. + +## Local Development Setup āš™ļø + +Install requirements using `uv` (recommended) or `pip`: + +This API server powers the AgentOps dashboard frontend. You'll need to run this server locally to develop or test frontend features that interact with the API. + +### 1. Environment Variables + +First, set up your environment variables. Copy the example file: + +```bash +cp .env.example .env +``` + +Then, **edit `.env`** and fill in the required values. **This step is crucial for both native and Docker setups.** + +#### Required Environment Variables + +The following variables are **required** for the API to function: + +**Supabase Configuration:** +```bash +SUPABASE_URL="https://your-project-id.supabase.co" +SUPABASE_KEY="your-supabase-service-role-key" +JWT_SECRET_KEY="your-jwt-secret-key" +``` + +**ClickHouse Configuration:** +```bash +CLICKHOUSE_HOST="your-clickhouse-host.com" +CLICKHOUSE_USER="default" +CLICKHOUSE_PASSWORD="your-clickhouse-password" +CLICKHOUSE_DATABASE="otel_2" +``` + +#### Optional Environment Variables + +**Stripe (for billing features):** +```bash +STRIPE_SECRET_KEY="sk_test_your_stripe_secret_key" +STRIPE_WEBHOOK_SECRET="whsec_your_webhook_secret" +STRIPE_SUBSCRIPTION_PRICE_ID="price_your_subscription_price_id" +``` + +**Monitoring:** +```bash +SENTRY_DSN="your-sentry-dsn" +DEBUG="true" # Set to false in production +LOGGING_LEVEL="INFO" +``` + +See the `.env.example` file for the complete list of available configuration options. + +Key environment variables include: +* `SUPABASE_URL`, `SUPABASE_KEY`, `SUPABASE_JWT_SECRET`: For Supabase connection and JWT validation. +* `DATABASE_URL`: For direct PostgreSQL connection (used by SQLAlchemy). +* `STRIPE_SECRET_KEY`: Your Stripe secret API key. + * **Production**: Use your *live* mode secret key (e.g., `sk_live_...`) from the Stripe Dashboard. + * **Local/Development**: Use your *test* mode secret key (e.g., `sk_test_...`) from the Stripe Dashboard. +* `STRIPE_WEBHOOK_SECRET`: Secret used to verify signatures of incoming webhooks from Stripe. + * **Production**: The signing secret for your *production* webhook endpoint, obtained from the Stripe Dashboard when you configure the endpoint. + * **Local/Development (using `stripe listen`)**: When using the Stripe CLI command `stripe listen --forward-to `, the CLI will output a *temporary, local-only* webhook signing secret (e.g., `whsec_...`). You **must** use this specific secret in your local `.env` file for the API server to correctly verify events forwarded by `stripe listen`. This is different from your production webhook secret. If you use just api-build -s and just api run -s it will handle this secret for you, and you MUST delete it from your .env file if you hard coded it in the past. +* `STRIPE_SUBSCRIPTION_PRICE_ID`: The specific Stripe Price ID for your primary subscription plan. + * **Production**: The ID of your *live* mode price (e.g., `price_...`) from the Stripe Dashboard. + * **Local/Development**: The ID of your *test* mode price (e.g., `price_...`) from the Stripe Dashboard, used for testing subscriptions. +* `APP_URL`: The base URL of your frontend application (e.g., `http://localhost:3000`), used for constructing return URLs for Stripe. +* `SQLALCHEMY_LOG_LEVEL`: (Optional) Set the logging level for SQLAlchemy. Can be "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL". Defaults to "INFO". +* `DEBUG`: Set to `true` for detailed request logging. +* `PROFILING_ENABLED`, `PROFILE_OUTPUT_DIR`, `PROFILING_FORMAT`: For request profiling. + +### 2. Choose Your Setup Method: + +#### Option A: Running Natively (Python) šŸ + +Use this method if you want to run the server directly using your local Python environment. + +1. **Install Dependencies:** + Use `uv` (recommended) or `pip`: + + ```bash + # Using uv (faster): + uv pip install -r requirements.txt + + # Or using pip: + pip install -r requirements.txt + ``` + +2. **Run the Server:** + + ```bash + python run.py + ``` + + The API should now be running, typically at `http://localhost:8000`. + +#### Option B: Running with Docker šŸ³ + +Use this method if you prefer using containers to manage dependencies and the runtime environment. + +1. **Build the Docker Image:** + Make sure you're in the `api/` directory. + + ```bash + docker build -t agentops-api . + ``` + +2. **Run the Docker Container:** + This command maps port 8000, loads environment variables from your `.env` file (make sure you completed Step 1!), automatically removes the container on exit (`--rm`), and names the container. + + ```bash + docker run -p 8000:8000 --env-file .env --rm --name agentops-api-container agentops-api + ``` + + The API should now be accessible at `http://localhost:8000`! šŸŽ‰ + +## Request Logging + +The API logs basic information about all requests by default. To enable detailed request body logging, set the `DEBUG` environment variable to `true`: + +```bash +# In your .env file +DEBUG=true +``` + +This will log the full request body for all POST, PUT, and PATCH requests, which is useful for debugging but may contain sensitive information. + +## Profiling + +The API includes request profiling functionality using [pyinstrument](https://github.com/joerick/pyinstrument). + +### Setup + +1. Enable profiling by setting the environment variable in your .env file: + + ``` + PROFILING_ENABLED=true + ``` + +2. Optionally, set a custom output directory for profile files: + + ``` + PROFILE_OUTPUT_DIR=/path/to/profiles + ``` + +3. Choose between HTML or Speedscope profiles: + ``` + PROFILING_FORMAT=html # default + ``` + or + ``` + PROFILING_FORMAT=speedscope + ``` + +Profile files are saved to the current directory or the configured `PROFILE_OUTPUT_DIR` with a timestamp in the filename. + +### Viewing Profiles + +- Speedscope profiles (.speedscope.json): Upload to [speedscope.app](https://www.speedscope.app/) +- HTML profiles (.html): Open in any browser \ No newline at end of file diff --git a/app/api/agentops/__init__.py b/app/api/agentops/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/api/agentops/agentops.code-workspace b/app/api/agentops/agentops.code-workspace new file mode 100644 index 000000000..9ceb9dd60 --- /dev/null +++ b/app/api/agentops/agentops.code-workspace @@ -0,0 +1,14 @@ +{ + "folders": [ + { + "path": "../../../agentops" + }, + { + "path": "../.." + }, + { + "path": "../../../agentops-ts" + } + ], + "settings": {}, +} diff --git a/app/api/agentops/api/__init__.py b/app/api/agentops/api/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/api/agentops/api/app.py b/app/api/agentops/api/app.py new file mode 100644 index 000000000..36d747b9e --- /dev/null +++ b/app/api/agentops/api/app.py @@ -0,0 +1,47 @@ +import fastapi +from fastapi.middleware.cors import CORSMiddleware + +from agentops.common.middleware import ( + CacheControlMiddleware, + ExceptionMiddleware, + DefaultContentTypeMiddleware, +) +from agentops.api.routes import v1, v2, v3, v4 + + +app = fastapi.FastAPI( + docs_url=None, # Disable docs in the mounted app to avoid conflicts + openapi_url=None, # Disable OpenAPI in the mounted app to avoid conflicts + title="AgentOps API", + description="AgentOps API for managing sessions, agents, and events", +) + +# A number of routes inside this app need to have alow_origins set to all, since they +# communicate with the SDK from client machines directly. Traces and Meterics routes +# should be behind CORS protection, and since they use a cookie for auth, they +# theoretically should require that the origins be restricted, but in practice this +# seems to work. +# We use a decorator to explicitly add CORS headers to the routes that need it. +app.add_middleware( + CORSMiddleware, + allow_origins=['*'], + allow_credentials=True, + allow_methods=["*"], # Allow all methods + allow_headers=["*"], # Allow all headers +) + +app.add_middleware(CacheControlMiddleware) +app.add_middleware(ExceptionMiddleware) +app.add_middleware(DefaultContentTypeMiddleware) + +# Include routers +app.include_router(v1.router) +app.include_router(v2.router) +app.include_router(v3.router) +app.include_router(v4.router) + + +# Health Check +@app.get("/health") +async def health_check(): + return {"message": "Server Up"} diff --git a/app/api/agentops/api/auth.py b/app/api/agentops/api/auth.py new file mode 100644 index 000000000..b775b1c95 --- /dev/null +++ b/app/api/agentops/api/auth.py @@ -0,0 +1,156 @@ +from dataclasses import dataclass +from datetime import datetime, timedelta + +import jwt +from fastapi import Header, HTTPException + +from agentops.api.environment import JWT_SECRET_KEY +from agentops.opsboard.models import ProjectModel + + +JWT_EXPIRATION_DAYS: int = 30 +JWT_ALGO: str = "HS256" + + +def _generate_jwt_timestamp() -> int: + """Generate a timestamp for the JWT token expiration.""" + return int((datetime.now() + timedelta(days=JWT_EXPIRATION_DAYS)).timestamp()) + + +def _assert_jwt_secret() -> None: + """Assert that the JWT secret key is set in the environment.""" + if not JWT_SECRET_KEY: + raise HTTPException(status_code=500, detail="JWT secret not configured") + + +@dataclass +class JWTPayload: + """ + Dataclass to represent the payload of a JWT token. + This is used for type checking and validation of the JWT payload. + """ + + exp: int + aud: str + project_id: str + project_prem_status: str + api_key: str + dev: bool = False + + def asdict(self) -> dict: + """Convert the payload to a dictionary format.""" + properties = { + "exp": self.exp, + "aud": self.aud, + "project_id": self.project_id, + "project_prem_status": self.project_prem_status, + "api_key": self.api_key, + } + + if self.dev: + properties["dev"] = self.dev + + return properties + + @classmethod + def from_project(cls, project: ProjectModel, dev: bool = False) -> "JWTPayload": + """ + Create a new instance of JWTPayload with the given project_id and role. + The expiration time is set to 30 days from now. + """ + return cls( + exp=_generate_jwt_timestamp(), + aud="authenticated", + project_id=str(project.id), + project_prem_status=project.org.prem_status.value, + api_key=str(project.api_key), + dev=dev, + ) + + +def generate_jwt(project: ProjectModel) -> str: + """Generate a JWT token for a project""" + _assert_jwt_secret() + + payload = JWTPayload.from_project(project) + return jwt.encode( + payload.asdict(), + JWT_SECRET_KEY, + algorithm=JWT_ALGO, + ) + + +def verify_jwt(token: str) -> JWTPayload: + """Verify a JWT token""" + _assert_jwt_secret() + + payload_data = jwt.decode( + token, + JWT_SECRET_KEY, + algorithms=[JWT_ALGO], + audience="authenticated", # Verify audience claim + ) + return JWTPayload(**payload_data) + + +async def get_jwt_token(authorization: str = Header(None)) -> JWTPayload: + """ + Dependency to extract and verify JWT token from Authorization header + + Usage: + - Include this as a dependency in route functions + - The JWT payload will be passed to the route function + """ + if not authorization: + raise HTTPException(status_code=401, detail="Authorization header missing") + + try: + # Extract token from "Bearer " format + scheme, token = authorization.split() + if scheme.lower() != "bearer": + raise HTTPException(status_code=401, detail="Invalid authentication scheme") + + return verify_jwt(token) + except ValueError: + raise HTTPException(status_code=401, detail="Invalid token format") + except jwt.ExpiredSignatureError: + raise HTTPException(status_code=401, detail="Token has expired") + except jwt.InvalidAudienceError: + raise HTTPException(status_code=401, detail="Invalid audience") + except jwt.InvalidTokenError: + raise HTTPException(status_code=401, detail="Invalid token") + + +def generate_dev_token(project_id: str) -> str: + """ + Generate a development JWT token for testing with a specific project ID. + This should only be used for development/testing purposes. + + Args: + project_id: The project ID to include in the token + + Returns: + str: The generated JWT token + + Raises: + ValueError: If JWT secret is not configured + """ + if not JWT_SECRET_KEY: + raise ValueError("JWT_SECRET_KEY environment variable is not set") + + # Create a JWT payload for development purposes + payload = JWTPayload( + exp=_generate_jwt_timestamp(), + aud="authenticated", + project_id=project_id, + project_prem_status="premium", # Default to premium for dev tokens + api_key="dev-token", # Placeholder API key for dev tokens + dev=True, # Mark as development token + ) + + # Encode the payload + return jwt.encode( + payload.asdict(), + JWT_SECRET_KEY, + algorithm=JWT_ALGO, + ) diff --git a/app/api/agentops/api/db/__init__.py b/app/api/agentops/api/db/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/api/agentops/api/db/clickhouse/__init__.py b/app/api/agentops/api/db/clickhouse/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/api/agentops/api/db/clickhouse/models.py b/app/api/agentops/api/db/clickhouse/models.py new file mode 100644 index 000000000..4215fea2e --- /dev/null +++ b/app/api/agentops/api/db/clickhouse/models.py @@ -0,0 +1,469 @@ +import asyncio +from typing import TypeVar, ClassVar, Type, Any, Optional, Union, Collection, Tuple, Literal +from datetime import datetime +from uuid import UUID +import abc +import pydantic +from clickhouse_connect.driver.asyncclient import AsyncClient +from agentops.api.db.clickhouse_client import get_async_clickhouse # type: ignore + + +TOperation = TypeVar('TOperation', bound='BaseOperation') +TClickhouseModel = TypeVar('TClickhouseModel', bound='ClickhouseModel') +TClickhouseAggregatedModel = TypeVar('TClickhouseAggregatedModel', bound='ClickhouseAggregatedModel') + +# Defines the filterable fields on a Model. +FilterDict = dict[str, Tuple[Union[str, Type[TOperation]], str]] # {field_name: (operator, db_column)} + +# Types that can be automatically formatted for ClickHouse queries +FormattableValue = Union[datetime, UUID, str, int, float, bool, None] + +# FilterFields is a dictionary of field names to values that can be used in WHERE clauses +FilterFields = dict[str, FormattableValue] # Filter values for queries + +# SelectFields can be a string (like "*"), a list of field names, or a dict mapping +SelectFields = Union[str, Collection[str], dict[str, str]] + +# Fields that can be searched with LIKE/ILIKE pattern matching +SearchFields = dict[str, Tuple[Literal["LIKE", "ILIKE"], str]] # {field_name: (operator, db_column)} +# Search term is simply a string that gets applied to all configured searchable fields + +__all__ = [ + 'ClickhouseModel', + 'TClickhouseModel', + 'ClickhouseAggregatedModel', + 'TClickhouseAggregatedModel', + 'FilterDict', + 'FilterFields', + 'FormattableValue', + 'SelectFields', + 'SearchFields', +] + + +def _format_field_value(value: FormattableValue) -> Any: + """ + Format field values for ClickHouse queries based on their type. + + This method provides a centralized place to handle type conversions + for different Python types to their ClickHouse-compatible formats. + + Args: + value: The value to format (datetime, UUID, or basic types) + + Returns: + The formatted value suitable for ClickHouse queries + """ + if isinstance(value, datetime): + return value.strftime('%Y-%m-%d %H:%M:%S') # ClickHouse format: 'YYYY-MM-DD HH:MM:SS' + + if isinstance(value, UUID): + return str(value) + + return value + + +class BaseOperation(abc.ABC): + """ + Base class for custom Clickhouse filter operations. + """ + + @staticmethod + @abc.abstractmethod + def format(db_field: str, field: str, value: Any) -> tuple[str, dict]: ... + + +class WithinListOperation(BaseOperation): + """ + Operation for filtering within a list of values. + """ + + @staticmethod + def format(db_field: str, field: str, value: list | tuple) -> tuple[str, dict]: + # multiple ORs are faster than a single IN + assert isinstance(value, (list, tuple)), f"Expected list or tuple, got {type(value)}" + + params, conditions = {}, [] + for idx, item in enumerate(value): + conditions.append(f"{db_field} = %({field}_withinlist_{idx})s") + params[f"{field}_withinlist_{idx}"] = _format_field_value(item) + return " OR ".join(conditions), params + + +class ClickhouseModel(abc.ABC, pydantic.BaseModel): + """Base abstract model for Clickhouse database interactions. + + This model provides a standardized interface for querying Clickhouse tables, + with support for filtering, field selection, and result pagination. It handles + parameter binding and query generation automatically based on class attributes. + + Configuration: + - table_name: The Clickhouse table to query + - selectable_fields: Fields to SELECT by default (defaults to "*") This + should be populated as a lookup table for conversion os column names + to your python attribute names. + For example: + selectable_fields = {'Timestamp': 'timestamp'} allows you to refer + to `timestamp` in your python code. + - filterable_fields: Dict mapping Python attribute names to tuples of + (comparison_operator, db_column_name). + For example: + {"project_id": ("=", "ProjectId")} enables filtering by project_id + - searchable_fields: Dict mapping Python attribute names to tuples of + (search_operator, db_column_name) for string search operations. + For example: + {"name": ("ILIKE", "UserName")} enables searching by name + For models using GROUP BY with HAVING clauses, the db_column_name should + reference the column alias created in the query, not the original table column. + + Usage example: + ```python + class UserModel(ClickhouseModel): + table_name = "users" + selectable_fields = { + "Id": "id", + "Age": "age", + "Timestamp": "timestamp", + "ProjectId": "project_id", + "UserName": "name", + } + filterable_fields = { + "user_id": ("=", "Id"), + "min_age": (">=", "Age"), + "max_age": ("<=", "Age"), + } + searchable_fields = { + "name": ("ILIKE", "UserName"), + } + + # Get users between ages 18-30 + users = await UserModel.select(filters={"min_age": 18, "max_age": 30}) + + # Search for users with names containing 'john' + users = await UserModel.select(search="john") + ``` + + This is intended to be used to query a single table. + Override the _get_query method for more complex query customization. + See `ClickhouseAggregatedModel` for handling multiple models in a single query. + """ + + table_name: ClassVar[Optional[str]] = None + selectable_fields: ClassVar[SelectFields] = "*" + filterable_fields: ClassVar[FilterDict] = { + # field_name: (comparison_operator, db_column_name) + "id": ("=", "Id"), + "start_time": (">=", "Timestamp"), + "end_time": ("<=", "Timestamp"), + } + searchable_fields: ClassVar[SearchFields] = { + # "field_name": ("ILIKE", db_column_name) + } + + @classmethod + def _get_select_clause(cls, *, fields: Optional[SelectFields] = None) -> str: + """ + Get the selectable fields for the model. This allows subclasses to customize + the selectable fields dynamically if needed. + Returns: + SelectFields: The selectable fields for the model, which can be a string, list, or dict. + """ + if fields is None: + fields = cls.selectable_fields + + if isinstance(fields, str): # str like "*" or a single db column name + return fields + + if isinstance(fields, (tuple, list)): # list of field names + return ', '.join(fields) + + if isinstance(fields, dict): # dict of field names to db column names + return ', '.join([f"{db_col} as {field}" for db_col, field in fields.items()]) + + raise ValueError(f"Invalid fields type: {type(fields)}. Expected str, list, tuple, or dict.") + + @classmethod + def _get_search_clause(cls, search_term: Optional[str] = None) -> tuple[str, dict]: + """ + Generate search conditions based on the searchable_fields configuration. + + Arguments: + search_term: The search term to apply to all searchable fields + + Returns: + tuple[str, dict]: A tuple containing: + - clause: The search conditions string (joined with OR), empty string if no conditions + - params: Dictionary of parameter values for the conditions + """ + conditions = [] + params = {} + + if search_term is not None: + for field, (op, db_field) in cls.searchable_fields.items(): + param_name = f"search_{field}" # avoid collisions with other params + conditions.append(f"{db_field} {op} %({param_name})s") + params[param_name] = f"%{search_term}%" + + # Join conditions with OR - this is more intuitive for searches across multiple fields + # Users expect to see results where ANY field matches, not where ALL fields match + return " OR ".join(conditions), params + + @classmethod + def _get_where_clause(cls, **filters: FormattableValue) -> tuple[str, dict]: + """ + Generate the WHERE clause for the SQL query based on the provided filterable fields. + + Arguments: + filters: The keyword arguments to filter on. Each key should match a filterable field in the model. + + Returns: + tuple[str, dict]: A tuple containing: + - clause: The WHERE clause string (joined with AND), empty string if no conditions + - params: Dictionary of parameter values for the conditions + + Example: + ( + "ProjectId = %(project_id)s AND Timestamp >= %(start_time)s", + {'project_id': 'my_project', 'start_time': '2023-01-01'} + ) + """ + conditions = [] + params = {} + + for field, (op, db_field) in cls.filterable_fields.items(): + if (value := filters.get(field)) is not None: + if isinstance(op, type) and issubclass(op, BaseOperation): + # dynamic operation + _cond, _params = op.format(db_field, field, value) + conditions.append(_cond) + params.update(_params) + else: + # basic operation + conditions.append(f"{db_field} {op} %({field})s") + params[field] = _format_field_value(value) + + # Join conditions with AND + return " AND ".join(conditions), params + + @classmethod + def _get_select_query( + cls: Type[TClickhouseModel], + *, + fields: Optional[SelectFields] = None, + filters: Optional[FilterFields] = None, + search: Optional[str] = None, + order_by: Optional[str] = None, + offset: Optional[int] = None, + limit: Optional[int] = None, + ) -> tuple[str, dict[str, Any]]: + """Generate SQL query and parameters for this model. + + This internal method builds the SQL query string and parameters dictionary + used by the select method. It's commonly overridden by subclasses to + customize the query logic or structure. + + Args: + fields: Fields to select (defaults to cls.selectable_fields) + filters: Filters to apply in the WHERE clause + search: Search string to apply to all configured searchable fields + order_by: ORDER BY clause (without the "ORDER BY" prefix) + offset: OFFSET value for pagination + limit: LIMIT value to restrict result count + + Returns: + tuple[str, dict]: A tuple containing: + - The SQL query string with parameterized values + - A dictionary of parameter values for safe query execution + """ + assert cls.table_name, f"table_name must be set for {cls.__name__} to generate SQL queries" + + select_clause = cls._get_select_clause(fields=fields) + filter_clause, filter_params = cls._get_where_clause(**(filters or {})) + search_clause, search_params = cls._get_search_clause(search) + params = {**filter_params, **search_params} + + if filter_clause and search_clause: + where_clause = f"({filter_clause}) AND ({search_clause})" + else: + where_clause = filter_clause or search_clause + + query = f""" + SELECT {select_clause} + FROM {cls.table_name} + {f"WHERE {where_clause}" if where_clause else ""} + """ + + if order_by is not None: + query += f" ORDER BY {order_by}" + + if limit is not None: + query += f" LIMIT {limit}" + + if offset is not None: + query += f" OFFSET {offset}" + + return query, params + + @classmethod + async def select( + cls: Type[TClickhouseModel], + *, + fields: Optional[SelectFields] = None, + filters: Optional[FilterFields] = None, + search: Optional[str] = None, + order_by: Optional[str] = None, + offset: Optional[int] = None, + limit: Optional[int] = None, + ) -> list[TClickhouseModel]: + """Query the database and return a list of model instances. + + This method builds and executes a SQL query based on the provided parameters and + class configuration, then converts the query results into model instances. + + Args: + fields: Optional list of fields to select. Defaults to cls.selectable_fields. + Example: ["id", "name", "email"] + filters: Optional dictionary of filters to apply. Keys must be defined in + cls.filterable_fields to be effective. + Example: {"project_id": "123", "start_time": "2023-01-01"} + search: Optional search string to apply to all searchable fields configured in + cls.searchable_fields. For LIKE/ILIKE searches, wildcards (%) + are automatically added if not present. + Example: "authentication" will search all configured fields for "authentication" + order_by: Optional ORDER BY clause (without the "ORDER BY" prefix). + Example: "created_at DESC" + offset: Optional OFFSET value for pagination. + limit: Optional LIMIT value to restrict the number of results. + + Returns: + List[TClickhouseModel]: A list of model instances of the exact calling class type, + with each instance created from a row in the query results. The return type is + properly typed using generics to preserve the concrete subclass type. + + Example: + ```python + # Get last 10 traces for a specific project + traces = await TraceModel.select( + filters={"project_id": "abc123"}, + order_by="timestamp DESC", + limit=10 + ) + + # Search for traces with spans containing "authentication" + traces = await TraceModel.select( + filters={"project_id": "abc123"}, + search="authentication", + limit=10 + ) + + # Access model properties on the results + for trace in traces: + print(f"Trace {trace.trace_id}: {trace.total_tokens} tokens") + ``` + """ + query, params = cls._get_select_query( + fields=fields, + filters=filters, + search=search, + order_by=order_by, + offset=offset, + limit=limit, + ) + client: AsyncClient = await get_async_clickhouse() + result = await client.query(query, parameters=params) + results = list(result.named_results()) + return [cls(**row) for row in results] + + +class ClickhouseAggregatedModel(abc.ABC, pydantic.BaseModel): + """Base model for composing and executing multiple Clickhouse queries in parallel. + + This model allows you to combine results from multiple ClickhouseModel queries + into a single aggregated model. It executes all queries concurrently for better + performance and constructs a model instance with the combined results. + + Configuration: + - aggregated_models: Class variable listing the ClickhouseModel subclasses to query + + How it works: + 1. The select() method takes filters that apply to all underlying models + 2. Queries from each model in aggregated_models are generated and executed in parallel + 3. Results from each query are passed as positional arguments to the constructor + 4. The model can then process and combine data from all queries + + This pattern is useful when you need to: + - Fetch different types of data in a single request + - Create aggregated metrics from multiple tables + - Provide a unified API for related data + """ + + aggregated_models: ClassVar[Collection[Type[ClickhouseModel]]] + + # TODO this can accept all the other query params, too + @classmethod + async def select( + cls: Type[TClickhouseAggregatedModel], + *, + fields: Optional[SelectFields] = None, + filters: Optional[FilterFields] = None, + search: Optional[str] = None, + order_by: Optional[str] = None, + offset: Optional[int] = None, + limit: Optional[int] = None, + ) -> TClickhouseAggregatedModel: + """Execute parallel queries for all aggregated models and return a combined model. + + This method: + 1. Generates a query for each model defined in aggregated_models + 2. Executes all queries concurrently using asyncio.gather + 3. Processes the results into lists of model instances + 4. Passes the processed results to the model's constructor + + When passing arguments: + It is up to the individual model implementations to accept the arguments + in their `select` method and process them accordingly. + + Args: + fields: Optional list of fields to select for each aggregated model. + filters: Optional dictionary of filters to apply to all aggregated models. + This should match the filterable fields in each model. + search: Optional search string to apply to all searchable fields + configured in each model's searchable_fields. + order_by: Optional ORDER BY clause (without the "ORDER BY" prefix) to apply to each query. + offset: Optional OFFSET value for pagination (applies to each query). + limit: Optional LIMIT value to restrict the number of results for each query. + + Returns: + An instance of the calling class, initialized with the results + from all the queries. The exact return type depends on the + implementation of the subclass's __init__ method. Results are passed + as positional arguments corresponding to the order of models in + `aggregated_models`. + """ + assert cls.aggregated_models, f"{cls.__name__} must define `aggregated_models`" + + client: AsyncClient = await get_async_clickhouse() + queries: list[str] = [] + params: list[dict] = [] + + for model_cls in cls.aggregated_models: + _query, _params = model_cls._get_select_query( + fields=fields, + filters=filters, + search=search, + order_by=order_by, + offset=offset, + limit=limit, + ) + queries.append(_query) + params.append(_params) + + responses: list = await asyncio.gather( + *[client.query(q, parameters=p) for q, p in zip(queries, params)] + ) + + results: list = [] + for response in responses: + results.append(list(response.named_results())) + + return cls(*results) diff --git a/app/api/agentops/api/db/clickhouse_client.py b/app/api/agentops/api/db/clickhouse_client.py new file mode 100644 index 000000000..359a76e38 --- /dev/null +++ b/app/api/agentops/api/db/clickhouse_client.py @@ -0,0 +1,130 @@ +import asyncio +import threading +from typing import Annotated + +from clickhouse_connect import get_async_client, get_client +from clickhouse_connect.driver.asyncclient import AsyncClient +from clickhouse_connect.driver.client import Client +from fastapi import Depends + +from agentops.api.environment import ( + CLICKHOUSE_DATABASE, + CLICKHOUSE_HOST, + CLICKHOUSE_PASSWORD, + CLICKHOUSE_PORT, + CLICKHOUSE_USER, +) + +# Global variables to store client instances +clickhouse = None +async_clickhouse = None + + +# Create locks for thread-safe initialization +_clickhouse_lock = threading.Lock() +_async_clickhouse_lock = asyncio.Lock() + + +class ConnectionConfig: + """ + Connection configuration for Supabase. + + This is an intermediary because it allows us to easily modify the vars in tests. + """ + + host: str = CLICKHOUSE_HOST + port: str | int = CLICKHOUSE_PORT + database: str = CLICKHOUSE_DATABASE + username: str = CLICKHOUSE_USER + password: str = CLICKHOUSE_PASSWORD + secure: bool = True + + def __init__(self) -> None: + """Non-instantiable class has a lower chance of being printed.""" + raise NotImplementedError("Cannot instantiate ConnectionConfig.") + + @classmethod + def to_connection_dict(cls) -> dict[str, str | int]: + """ + Convert the connection configuration to a dictionary that can be passed + as kwargs to get_client and get_async_client. + + Returns: + dict[str, str | int]: The connection configuration as a dictionary. + """ + return { + 'host': cls.host, + 'port': cls.port, + 'database': cls.database, + 'username': cls.username, + 'password': cls.password, + 'secure': cls.secure, + } + + +def get_clickhouse(): + """ + FastAPI dependency to get the synchronous ClickHouse client. + This allows for proper dependency injection and easier testing. + + Returns: + Client: The synchronous ClickHouse client instance + """ + global clickhouse + + if clickhouse is None: + with _clickhouse_lock: + # Check again inside the lock to prevent race conditions + if clickhouse is None: + clickhouse = get_client(**ConnectionConfig.to_connection_dict()) + return clickhouse + + +async def get_async_clickhouse(): + """ + FastAPI dependency to get the async ClickHouse client. + This allows for proper dependency injection and easier testing. + + Returns: + AsyncClient: The async ClickHouse client instance + """ + global async_clickhouse + + # Check again inside the lock to prevent race conditions + if async_clickhouse is None: + async with _async_clickhouse_lock: + # Check again inside the lock to prevent race conditions + if async_clickhouse is None: + async_clickhouse = await get_async_client(**ConnectionConfig.to_connection_dict()) + return async_clickhouse + + +# Annotated dependencies for better type hinting +AsyncClickHouseClient = Annotated[AsyncClient, Depends(get_async_clickhouse)] +ClickHouseClient = Annotated[Client, Depends(get_clickhouse)] + + +async def close_clickhouse_clients(): + """ + Close the ClickHouse client connections. + """ + global clickhouse, async_clickhouse + + try: + if clickhouse is not None: + clickhouse.close() + clickhouse = None + except Exception as e: + # Log the error but don't raise - we still want to try closing the async client + import logging + + logging.getLogger(__name__).error(f"Error closing ClickHouse sync client: {e}") + + try: + if async_clickhouse is not None: + await async_clickhouse.close() + async_clickhouse = None + except Exception as e: + import logging + + logging.getLogger(__name__).error(f"Error closing ClickHouse async client: {e}") diff --git a/app/api/agentops/api/db/supabase_client.py b/app/api/agentops/api/db/supabase_client.py new file mode 100644 index 000000000..7d7256d0a --- /dev/null +++ b/app/api/agentops/api/db/supabase_client.py @@ -0,0 +1,77 @@ +import asyncio +import threading +from typing import Annotated + +from fastapi import Depends +from supabase.client import AsyncClient as AsyncSupabase +from supabase.client import Client as Supabase + +# Global variables to store client instances +supabase = None +async_supabase = None + +# Create locks for thread-safe initialization +_supabase_lock = threading.Lock() +_async_supabase_lock = asyncio.Lock() + + +def get_supabase(): + """ + FastAPI dependency to get the synchronous Supabase client. + This allows for proper dependency injection and easier testing. + + Returns: + Supabase: The synchronous Supabase client instance + """ + + from agentops.api.environment import SUPABASE_KEY, SUPABASE_URL + + global supabase + if supabase is None: + with _supabase_lock: + # Check again inside the lock to prevent race conditions + if supabase is None: + supabase = Supabase(SUPABASE_URL, SUPABASE_KEY) + return supabase + + +async def get_async_supabase(): + """ + FastAPI dependency to get the async Supabase client. + This allows for proper dependency injection and easier testing. + + Returns: + AsyncSupabase: The async Supabase client instance + """ + + from agentops.api.environment import SUPABASE_KEY, SUPABASE_URL + + global async_supabase + if async_supabase is None: + async with _async_supabase_lock: + # Check again inside the lock to prevent race conditions + if async_supabase is None: + async_supabase = AsyncSupabase(SUPABASE_URL, SUPABASE_KEY) + return async_supabase + + +# Annotated dependencies for better type hinting +AsyncSupabaseClient = Annotated[AsyncSupabase, Depends(get_async_supabase)] +SupabaseClient = Annotated[Supabase, Depends(get_supabase)] + + +async def close_supabase_clients(): + """ + Close the Supabase client connections. + """ + global supabase, async_supabase + + if supabase is not None: + # Supabase client doesn't have an explicit close method + # but we can set it to None to allow garbage collection + supabase = None + + if async_supabase is not None: + # Async Supabase client doesn't have an explicit close method + # but we can set it to None to allow garbage collection + async_supabase = None diff --git a/app/api/agentops/api/encoders/spans.py b/app/api/agentops/api/encoders/spans.py new file mode 100644 index 000000000..77d7d65f8 --- /dev/null +++ b/app/api/agentops/api/encoders/spans.py @@ -0,0 +1,27 @@ +import base64 +import pickle +from typing import Any, Dict + + +class SpanAttributeEncoder: + @staticmethod + def encode(attributes: Dict[str, Any]) -> bytes: + """Encode span attributes to binary format.""" + return pickle.dumps(attributes) + + @staticmethod + def decode(binary_data: bytes) -> Dict[str, Any]: + """Decode binary data to span attributes.""" + return pickle.loads(binary_data) + + @staticmethod + def encode_to_base64(attributes: Dict[str, Any]) -> str: + """Encode span attributes to base64 string for debugging.""" + binary_data = SpanAttributeEncoder.encode(attributes) + return base64.b64encode(binary_data).decode("utf-8") + + @staticmethod + def decode_from_base64(base64_str: str) -> Dict[str, Any]: + """Decode base64 string to span attributes for debugging.""" + binary_data = base64.b64decode(base64_str) + return SpanAttributeEncoder.decode(binary_data) diff --git a/app/api/agentops/api/environment.py b/app/api/agentops/api/environment.py new file mode 100644 index 000000000..0831a4c6c --- /dev/null +++ b/app/api/agentops/api/environment.py @@ -0,0 +1,75 @@ +import os +import logging + +logger = logging.getLogger(__name__) + +SUPABASE_URL: str = os.getenv("SUPABASE_URL") +SUPABASE_KEY: str = os.getenv("SUPABASE_KEY") + +SUPABASE_S3_BUCKET: str = os.getenv("SUPABASE_S3_BUCKET") +SUPABASE_S3_LOGS_BUCKET: str = os.getenv("SUPABASE_S3_LOGS_BUCKET") +SUPABASE_S3_ACCESS_KEY_ID: str = os.getenv("SUPABASE_S3_ACCESS_KEY_ID") +SUPABASE_S3_SECRET_ACCESS_KEY: str = os.getenv("SUPABASE_S3_SECRET_ACCESS_KEY") + +JWT_SECRET_KEY: str = os.getenv("JWT_SECRET_KEY") + +CLICKHOUSE_HOST: str = os.getenv("CLICKHOUSE_HOST") +CLICKHOUSE_PORT: int = int(os.getenv("CLICKHOUSE_PORT", 0)) +CLICKHOUSE_USER: str = os.getenv("CLICKHOUSE_USER", "") +CLICKHOUSE_PASSWORD: str = os.getenv("CLICKHOUSE_PASSWORD", "") +CLICKHOUSE_DATABASE: str = os.getenv("CLICKHOUSE_DATABASE", "") + + +PROFILING_ENABLED: bool = os.environ.get("PROFILING_ENABLED", "false").lower() == "true" +PROFILING_FORMAT: str = os.environ.get("PROFILING_FORMAT", "html") +if PROFILING_FORMAT not in ["html", "speedscope"]: + PROFILING_FORMAT = "html" +PROFILING_OUTPUT_DIR: str = os.environ.get("PROFILING_OUTPUT_DIR", ".") + +# Stripe Configuration +STRIPE_WEBHOOK_SECRET: str = os.getenv("STRIPE_WEBHOOK_SECRET", "") +STRIPE_SECRET_KEY: str = os.getenv("STRIPE_SECRET_KEY", "") +STRIPE_SUBSCRIPTION_PRICE_ID: str = os.getenv("STRIPE_SUBSCRIPTION_PRICE_ID", "") +STRIPE_TOKEN_PRICE_ID: str = os.getenv("STRIPE_TOKEN_PRICE_ID", "") +STRIPE_SPAN_PRICE_ID: str = os.getenv("STRIPE_SPAN_PRICE_ID", "") + + +# Log Stripe configuration status on module load +def _log_stripe_config(): + """Log the status of Stripe environment variables for debugging""" + stripe_vars = { + "STRIPE_SECRET_KEY": STRIPE_SECRET_KEY, + "STRIPE_WEBHOOK_SECRET": STRIPE_WEBHOOK_SECRET, + "STRIPE_SUBSCRIPTION_PRICE_ID": STRIPE_SUBSCRIPTION_PRICE_ID, + "STRIPE_TOKEN_PRICE_ID": STRIPE_TOKEN_PRICE_ID, + "STRIPE_SPAN_PRICE_ID": STRIPE_SPAN_PRICE_ID, + } + + logger.info("=== Stripe Configuration Status ===") + found_count = 0 + missing_vars = [] + for var_name, var_value in stripe_vars.items(): + if var_value: + # Show first 8 characters for verification without exposing secrets + masked_value = f"{var_value[:8]}..." if len(var_value) > 8 else var_value + logger.info(f"āœ“ {var_name}: {masked_value}") + found_count += 1 + else: + logger.warning(f"āœ— {var_name}: NOT FOUND") + missing_vars.append(var_name) + + logger.info(f"Stripe configuration: {found_count}/{len(stripe_vars)} variables found") + + if missing_vars: + logger.error(f"MISSING STRIPE VARIABLES: {', '.join(missing_vars)}") + logger.error("These variables are required for proper Stripe integration:") + for var in missing_vars: + logger.error(f" - {var}") + else: + logger.info("āœ“ All Stripe environment variables are configured") + + logger.info("==================================") + + +# Call the logging function when module is imported +_log_stripe_config() diff --git a/app/api/agentops/api/event_handlers.py b/app/api/agentops/api/event_handlers.py new file mode 100644 index 000000000..0571ca90b --- /dev/null +++ b/app/api/agentops/api/event_handlers.py @@ -0,0 +1,206 @@ +import base64 +import uuid +import datetime +import json +from decimal import Decimal +from tokencost import TOKEN_COSTS, count_string_tokens, count_message_tokens +from jsonschema import validate +from jsonschema.exceptions import ValidationError + +from agentops.api.promptarmor import get_promptarmor_flag +from agentops.api.log_config import logger +from agentops.api.exceptions import InvalidModelError +from agentops.api.db.supabase_client import AsyncSupabaseClient, get_async_supabase +from agentops.api.environment import SUPABASE_URL + + +async def handle_actions(event, session_id, supabase: AsyncSupabaseClient = None): + if supabase is None: + supabase = await get_async_supabase() + + async def process_screenshot(screenshot, session_id): + if screenshot is None: + return None + + if screenshot.startswith("http://") or screenshot.startswith("https://"): + return screenshot + + # screenshot is a base64 string + base64_img_bytes = screenshot.replace("data:image/png;base64,", "") + base64_img_bytes += "=" * ((4 - len(base64_img_bytes) % 4) % 4) + img_bytes = base64.b64decode(base64_img_bytes) + timestamp_utc = datetime.datetime.now(datetime.timezone.utc).isoformat() + + try: + await supabase.storage.from_("screenshots").upload(f"{session_id}/{timestamp_utc}.png", img_bytes) + except RuntimeError as e: + logger.warning(f"Error posting screenshot: {e}") + return None + + return f"{SUPABASE_URL}/storage/v1/object/screenshots/{session_id}/{timestamp_utc}.png" + + action = { + "id": event.get("id", str(uuid.uuid4())), + "session_id": session_id, + "agent_id": event.get("agent_id", None), + "action_type": event.get("action_type", None), + "logs": event.get("logs", None), + "screenshot": await process_screenshot(event.get("screenshot", None), session_id), + "params": event.get("params", None), + "returns": event.get("returns", None), + "init_timestamp": event["init_timestamp"], + "end_timestamp": event["end_timestamp"], + } + return action + + +async def handle_llms(event, premium, session_id, supabase: AsyncSupabaseClient = None): + if supabase is None: + supabase = await get_async_supabase() + + def count_prompt_tokens(prompt): + try: + if model not in TOKEN_COSTS: + raise InvalidModelError(f'Invalid model "{model}" provided.') + if type(prompt) is str: + return count_string_tokens(prompt, model) + else: + return count_message_tokens(prompt, model) + except Exception as e: + logger.warning(e) + return 0 + + def count_completion_tokens(completion): + try: + if model not in TOKEN_COSTS: + raise InvalidModelError(f'Invalid model "{model}" provided.') + # User may send dict containing the completion content or just the completion content + # completion = {role:"assistant", content:"some message", function_call: ..., tool_calls: ...} + # completion = "some message" + return count_string_tokens(completion.get("content", completion), model) + except Exception as e: + logger.warning(e) + return 0 + + chatml_schema_prompt = { + "$schema": "http://json-schema.org/draft-07/schema#", + "type": "array", + "items": { + "type": "object", + "required": ["role"], + "properties": { + "role": {"type": "string"}, + "name": {"type": "string"}, + "content": { + "oneOf": [ + {"type": ["string", "null"]}, + {"type": "array"}, + {"type": "object"}, + ] + }, + "tool_calls": {"type": ["array", "null"]}, + "tool_call_id": {"type": ["string", "null"]}, + }, + "additionalProperties": True, + }, + } + + chatml_schema_completion = { + "$schema": "http://json-schema.org/draft-07/schema#", + "type": "object", + "required": ["role"], + "properties": { + "role": {"type": "string"}, + "content": {"type": ["string", "null", "object", "array"]}, + "tool_calls": {"type": ["array", "null"]}, + "function_call": {"type": ["object", "null"]}, + }, + "additionalProperties": True, + } + + def coerce_llm_message_to_chatml_schema(message, chatml_schema): + try: + validate(instance=message, schema=chatml_schema) + + wrapped_message = {"type": "chatml", "messages": message} + return wrapped_message + except ValidationError: + # If validation fails, wrap the message as a "string" type + wrapped_message = { + "type": "string", + "string": (json.dumps(message) if not isinstance(message, str) else message), + } + + return wrapped_message + + model = event.get("model", None) + prompt = event.get("prompt", None) + completion = event.get("completion", None) + prompt_tokens = event.get("prompt_tokens") or count_prompt_tokens(prompt) + completion_tokens = event.get("completion_tokens") or count_completion_tokens(completion) + + if premium: + promptarmor_flag = await get_promptarmor_flag(prompt, completion, session_id) + else: + promptarmor_flag = None + + cost = event.get("cost") + if (cost is None) and (model in TOKEN_COSTS): + cost_per_prompt_token = Decimal(str(TOKEN_COSTS[model]["input_cost_per_token"])) + cost_per_completion_token = Decimal(str(TOKEN_COSTS[model]["output_cost_per_token"])) + cost = str((prompt_tokens * cost_per_prompt_token) + (completion_tokens * cost_per_completion_token)) + + llm = { + "id": event.get("id", str(uuid.uuid4())), + "session_id": session_id, + "agent_id": event.get("agent_id", None), + "thread_id": event.get("thread_id", None), + "prompt": coerce_llm_message_to_chatml_schema(prompt, chatml_schema_prompt), + "completion": coerce_llm_message_to_chatml_schema(completion, chatml_schema_completion), + "model": model, + "prompt_tokens": prompt_tokens, + "completion_tokens": completion_tokens, + "cost": cost, + "promptarmor_flag": promptarmor_flag, + "params": event.get("params", None), + "returns": event.get("returns", None), + "init_timestamp": event["init_timestamp"], + "end_timestamp": event["end_timestamp"], + } + + return llm + + +async def handle_tools(event, session_id, supabase: AsyncSupabaseClient = None): + if supabase is None: + supabase = await get_async_supabase() + + tool = { + "id": event.get("id", str(uuid.uuid4())), + "session_id": session_id, + "agent_id": event.get("agent_id", None), + "name": event.get("name", None), + "logs": event.get("logs", None), + "params": event.get("params", None), + "returns": event.get("returns", None), + "init_timestamp": event["init_timestamp"], + "end_timestamp": event["end_timestamp"], + } + return tool + + +async def handle_errors(event, session_id, supabase: AsyncSupabaseClient = None): + if supabase is None: + supabase = await get_async_supabase() + + error = { + "session_id": session_id, + "trigger_event_id": event.get("trigger_event_id", None), + "trigger_event_type": event.get("trigger_event_type", None), + "error_type": event.get("error_type", None), + "code": event.get("code", None), + "details": event.get("details", None), + "logs": event.get("logs", None), + "timestamp": event.get("timestamp", None), + } + return error diff --git a/app/api/agentops/api/exceptions.py b/app/api/agentops/api/exceptions.py new file mode 100644 index 000000000..913e0a96e --- /dev/null +++ b/app/api/agentops/api/exceptions.py @@ -0,0 +1,18 @@ +class InvalidAPIKeyError(RuntimeError): + def __init__(self, code, message): + self.message = message + self.code = code + super().__init__(message) + + +class ExpiredJWTError(RuntimeError): + def __init__(self, code, message): + self.message = message + self.code = code + super().__init__(message) + + +class InvalidModelError(Exception): + def __init__(self, msg): + super().__init__(msg) + pass diff --git a/app/api/agentops/api/interactors/README.md b/app/api/agentops/api/interactors/README.md new file mode 100644 index 000000000..69aec587c --- /dev/null +++ b/app/api/agentops/api/interactors/README.md @@ -0,0 +1,8 @@ +Interactors implement business logic that are used to interact with the database. + +They are responsible for: + +- Formatting data for the database +- Validating data for the database +- Performing database operations +- Returning the results diff --git a/app/api/agentops/api/interactors/spans.py b/app/api/agentops/api/interactors/spans.py new file mode 100644 index 000000000..a2f5b7740 --- /dev/null +++ b/app/api/agentops/api/interactors/spans.py @@ -0,0 +1,177 @@ +from enum import Enum +from typing import Any, Dict + +from opentelemetry.semconv._incubating.attributes.gen_ai_attributes import ( + GEN_AI_OPERATION_NAME, + GEN_AI_REQUEST_MODEL, + GEN_AI_RESPONSE_MODEL, + GEN_AI_SYSTEM, + GenAiOperationNameValues, +) +from opentelemetry.semconv_ai import LLMRequestTypeValues, SpanAttributes +from opentelemetry.trace import SpanKind + +from agentops.api.encoders.spans import SpanAttributeEncoder + + +# ========================================== +# Internal Span Classifications +# ========================================== +class AgentopsSpanType(str, Enum): + """Internal classification of span types for AgentOps processing.""" + + SESSION_UPDATE = "session_update" + GEN_AI = "gen_ai" + LOG = "log" + + +class AgentopsGenAISpanSubtype(str, Enum): + """Internal classification of GenAI span subtypes for AgentOps processing. + + Note: These are NOT OpenTelemetry standard span types, but rather + internal classifications used by AgentOps for processing.""" + + CHAT = "gen_ai_chat" + COMPLETION = "gen_ai_completion" + TOOL = "gen_ai_tool" + EMBEDDING = "gen_ai_embedding" + GENERIC = "gen_ai" # Generic/fallback type + + +# Legacy/alternative attributes (used in some implementations) +LEGACY_SYSTEM = "ai.system" +LEGACY_LLM = "ai.llm" +LEGACY_EMBEDDING = "ai.embedding" + +# Tool attributes - these aren't yet in the standard, so we define them here +GEN_AI_TOOL_NAME = "gen_ai.tool.name" +GEN_AI_TOOL_CALL_ID = "gen_ai.tool.call.id" + +# Log attributes +LOG_SEVERITY = "log.severity" +LOG_MESSAGE = "log.message" + + +async def classify_span(span: Dict[str, Any]) -> str: + """Classify a span based on semantic conventions.""" + # Get span attributes + attributes = span.get("attributes", {}) + + # Check for Gen AI spans using multiple criteria + if ( + LEGACY_SYSTEM in attributes + or LEGACY_LLM in attributes + or LEGACY_EMBEDDING in attributes + or GEN_AI_SYSTEM in attributes + or GEN_AI_OPERATION_NAME in attributes + or GEN_AI_REQUEST_MODEL in attributes + or GEN_AI_RESPONSE_MODEL in attributes + or SpanAttributes.LLM_REQUEST_MODEL in attributes + or SpanAttributes.LLM_RESPONSE_MODEL in attributes + or SpanAttributes.LLM_SYSTEM in attributes + ): + return AgentopsSpanType.GEN_AI + + # Check for Log spans + if LOG_SEVERITY in attributes or LOG_MESSAGE in attributes: + return AgentopsSpanType.LOG + + # Default to Session Update span + return AgentopsSpanType.SESSION_UPDATE + + +async def classify_gen_ai_span_subtype(span: Dict[str, Any]) -> str: + """Further classify a Gen AI span into subtypes based on attributes.""" + attributes = span.get("attributes", {}) + + # Check for tool usage + if GEN_AI_TOOL_NAME in attributes or GEN_AI_TOOL_CALL_ID in attributes: + return AgentopsGenAISpanSubtype.TOOL + + # Check for operation type + operation_name = attributes.get(GEN_AI_OPERATION_NAME) + if operation_name: + if operation_name == GenAiOperationNameValues.CHAT.value: + return AgentopsGenAISpanSubtype.CHAT + elif operation_name == GenAiOperationNameValues.TEXT_COMPLETION.value: + return AgentopsGenAISpanSubtype.COMPLETION + elif operation_name == GenAiOperationNameValues.EMBEDDINGS.value: + return AgentopsGenAISpanSubtype.EMBEDDING + + # Check for request type from LLMRequestTypeValues + request_type = attributes.get(SpanAttributes.LLM_REQUEST_TYPE) + if request_type: + if request_type == LLMRequestTypeValues.CHAT.value: + return AgentopsGenAISpanSubtype.CHAT + elif request_type == LLMRequestTypeValues.COMPLETION.value: + return AgentopsGenAISpanSubtype.COMPLETION + elif request_type == LLMRequestTypeValues.EMBEDDING.value: + return AgentopsGenAISpanSubtype.EMBEDDING + + # Check for embedding-specific attributes + if LEGACY_EMBEDDING in attributes: + return AgentopsGenAISpanSubtype.EMBEDDING + + # Default to general Gen AI span + return AgentopsGenAISpanSubtype.GENERIC + + +async def handle_session_update_span(span: Dict[str, Any], session_id: str) -> Dict[str, Any]: + """Handle a session update span.""" + # Extract span data + span_data = { + "session_id": session_id, + "agent_id": span.get("agent_id"), + "trace_id": span.get("trace_id"), + "span_id": span.get("span_id"), + "parent_span_id": span.get("parent_span_id"), + "name": span.get("name"), + "kind": span.get("kind", SpanKind.INTERNAL), + "start_time": span.get("start_time"), + "end_time": span.get("end_time"), + "attributes": SpanAttributeEncoder.encode(span.get("attributes", {})), + "span_type": AgentopsSpanType.SESSION_UPDATE, + } + return span_data + + +async def handle_gen_ai_span(span: Dict[str, Any], session_id: str) -> Dict[str, Any]: + """Handle a Gen AI span.""" + # Get the Gen AI span subtype + gen_ai_subtype = await classify_gen_ai_span_subtype(span) + + # Extract span data + span_data = { + "session_id": session_id, + "agent_id": span.get("agent_id"), + "trace_id": span.get("trace_id"), + "span_id": span.get("span_id"), + "parent_span_id": span.get("parent_span_id"), + "name": span.get("name"), + "kind": span.get("kind", SpanKind.CLIENT), + "start_time": span.get("start_time"), + "end_time": span.get("end_time"), + "attributes": SpanAttributeEncoder.encode(span.get("attributes", {})), + "span_type": AgentopsSpanType.GEN_AI, + "span_subtype": gen_ai_subtype, + } + return span_data + + +async def handle_log_span(span: Dict[str, Any], session_id: str) -> Dict[str, Any]: + """Handle a log span.""" + # Extract span data + span_data = { + "session_id": session_id, + "agent_id": span.get("agent_id"), + "trace_id": span.get("trace_id"), + "span_id": span.get("span_id"), + "parent_span_id": span.get("parent_span_id"), + "name": span.get("name"), + "kind": span.get("kind", SpanKind.INTERNAL), + "start_time": span.get("start_time"), + "end_time": span.get("end_time"), + "attributes": SpanAttributeEncoder.encode(span.get("attributes", {})), + "span_type": AgentopsSpanType.LOG, + } + return span_data diff --git a/app/api/agentops/api/log_config.py b/app/api/agentops/api/log_config.py new file mode 100644 index 000000000..81b5460c1 --- /dev/null +++ b/app/api/agentops/api/log_config.py @@ -0,0 +1,43 @@ +import logging +import os + +# Simple logging configuration +log_levels = { + "CRITICAL": logging.CRITICAL, + "ERROR": logging.ERROR, + "WARNING": logging.WARNING, + "INFO": logging.INFO, + "DEBUG": logging.DEBUG, +} + + +def setup_logger(name: str = "AgentOpsAPI") -> logging.Logger: + """Set up and configure a logger with the specified name.""" + logging_level: str = os.environ.get("LOGGING_LEVEL", "INFO") + level = log_levels.get(logging_level.upper(), logging.INFO) + + # Create logger + logger = logging.getLogger(name) + logger.setLevel(level) + logger.propagate = False + + # Clear existing handlers to avoid duplicates when reloading in dev + if logger.handlers: + logger.handlers.clear() + + # Create console handler + handler = logging.StreamHandler() + handler.setLevel(level) + + # Create formatter + formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S') + handler.setFormatter(formatter) + + # Add handler to logger + logger.addHandler(handler) + + return logger + + +# Create the main application logger +logger = setup_logger() diff --git a/app/api/agentops/api/models/__init__.py b/app/api/agentops/api/models/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/api/agentops/api/models/metrics.py b/app/api/agentops/api/models/metrics.py new file mode 100644 index 000000000..18ccc24d4 --- /dev/null +++ b/app/api/agentops/api/models/metrics.py @@ -0,0 +1,439 @@ +from typing import Any, Optional +from functools import cached_property +from decimal import Decimal +from datetime import datetime, date +import pydantic + +from agentops.api.db.clickhouse.models import ClickhouseAggregatedModel, SelectFields, FilterFields +from agentops.api.models.traces import BaseTraceModel + +from .span_metrics import SpanMetricsMixin, TraceMetricsMixin + + +class TraceCountsModel(BaseTraceModel): + """ + Model representing the metrics for all of a user's projects. + This model is used to generate aggregated metrics for projects. + """ + + project_id: str + span_count: int + trace_count: int + + @pydantic.model_validator(mode='before') + @classmethod + def fix_project_id(cls, values: dict[str, Any]) -> dict[str, Any]: + """project_id_ comes from the query, but we want to use project_id.""" + values['project_id'] = values.get('project_id_') + return values + + @classmethod + def _get_select_query( + cls, + *, + fields: Optional[SelectFields] = None, + filters: Optional[FilterFields] = None, + search: Optional[str] = None, + order_by: Optional[str] = None, + offset: Optional[int] = None, + limit: Optional[int] = None, + ) -> tuple[str, dict[str, Any]]: + if fields or order_by or offset or limit or search: + raise NotImplementedError("Custom fields, search, order_by, offset or limit are not supported.") + + where_clause, params = cls._get_where_clause(**(filters or {})) + query = f""" + SELECT + any(project_id) as project_id_, -- cannot reassign project_id + count() as span_count, + count(DISTINCT TraceId) as trace_count + FROM {cls.table_name} + {f"WHERE {where_clause}" if where_clause else ""} + GROUP BY project_id + """ + return query, params + + +class ProjectMetricsTraceModel(SpanMetricsMixin, BaseTraceModel): + """ + Model representing a single span in the project metrics. + + This model extends the base TraceModel to include additional properties and methods + for calculating token costs and other trace-related metrics. + + Incorporates SpanMetricsMixin to handle token calculations. + """ + + selectable_fields = { + "TraceId": "trace_id", + "Timestamp": "timestamp", + "StatusCode": "status_code", + } + + trace_id: str + timestamp: datetime + status_code: str + + # Add span count fields for aggregated metrics + span_count: int = 1 # Number of spans in this trace + success_span_count: int = 0 + fail_span_count: int = 0 + indeterminate_span_count: int = 0 + + # Track if we have costs (either stored or calculable via model info) + has_cached_costs: int = 0 + + @pydantic.field_validator( + 'span_count', + 'success_span_count', + 'fail_span_count', + 'indeterminate_span_count', + 'has_cached_costs', + mode='before', + ) + @classmethod + def ensure_span_counts_int(cls, v: Any) -> int: + """Ensure that all counts are always an integer.""" + return int(v or 0) + + @classmethod + def _get_select_query( + cls, + *, + fields: Optional[SelectFields] = None, + filters: Optional[FilterFields] = None, + search: Optional[str] = None, + order_by: Optional[str] = None, + offset: Optional[int] = None, + limit: Optional[int] = None, + ) -> tuple[str, dict[str, Any]]: + """ + Override to aggregate metrics at the database level instead of fetching all rows. + This dramatically reduces data transfer and processing time. + + For costs: Uses stored costs when available, calculates on-the-fly for missing data. + This preserves 100% accurate costs for new data while fixing historical gaps. + """ + where_clause, params = cls._get_where_clause(**(filters or {})) + + # Instead of selecting individual rows, aggregate by trace + # This processes ALL spans matching the filters but returns one row per trace + query = f""" + SELECT + TraceId as trace_id, + max(Timestamp) as timestamp, + argMax(StatusCode, Timestamp) as status_code, + count() as span_count, + countIf(upper(StatusCode) = 'OK') as success_span_count, + countIf(upper(StatusCode) = 'ERROR') as fail_span_count, + countIf(upper(StatusCode) NOT IN ('OK', 'ERROR')) as indeterminate_span_count, + sum(toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.prompt_tokens'], '0'))) as prompt_tokens, + sum(toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.completion_tokens'], '0'))) as completion_tokens, + sum(toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.cache_read_input_tokens'], '0'))) as cache_read_input_tokens, + sum(toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.reasoning_tokens'], '0'))) as reasoning_tokens, + sum( + if( + SpanAttributes['gen_ai.usage.total_tokens'] != '', + toUInt64OrZero(SpanAttributes['gen_ai.usage.total_tokens']), + toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.prompt_tokens'], '0')) + + toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.completion_tokens'], '0')) + + toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.cache_read_input_tokens'], '0')) + + toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.reasoning_tokens'], '0')) + ) + ) as cached_total_tokens, + any(SpanAttributes['gen_ai.request.model']) as request_model, + any(SpanAttributes['gen_ai.response.model']) as response_model, + sum( + if( + SpanAttributes['gen_ai.usage.prompt_cost'] != '', + toDecimal64OrZero(SpanAttributes['gen_ai.usage.prompt_cost'], 9), + toDecimal64( + calculate_prompt_cost( + toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.prompt_tokens'], '0')), + coalesce( + nullIf(SpanAttributes['gen_ai.response.model'], ''), + nullIf(SpanAttributes['gen_ai.request.model'], '') + ) + ), + 9 + ) + ) + ) as cached_prompt_cost, + sum( + if( + SpanAttributes['gen_ai.usage.completion_cost'] != '', + toDecimal64OrZero(SpanAttributes['gen_ai.usage.completion_cost'], 9), + toDecimal64( + calculate_completion_cost( + toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.completion_tokens'], '0')), + coalesce( + nullIf(SpanAttributes['gen_ai.response.model'], ''), + nullIf(SpanAttributes['gen_ai.request.model'], '') + ) + ), + 9 + ) + ) + ) as cached_completion_cost, + cached_prompt_cost + cached_completion_cost as cached_total_cost, + countIf( + SpanAttributes['gen_ai.usage.prompt_cost'] != '' + OR SpanAttributes['gen_ai.usage.completion_cost'] != '' + OR coalesce( + nullIf(SpanAttributes['gen_ai.response.model'], ''), + nullIf(SpanAttributes['gen_ai.request.model'], '') + ) != '' + ) as has_cached_costs + FROM {cls.table_name} + {f"WHERE {where_clause}" if where_clause else ""} + GROUP BY TraceId + ORDER BY timestamp DESC + """ + + return query, params + + +class ProjectMetricsDurationModel(BaseTraceModel): + """ + Model representing the duration metrics for a project. + + This model is used to generate aggregated duration metrics for traces in a project. + """ + + min_duration: int + max_duration: int + avg_duration: int + total_duration: int + span_count: int + trace_count: int + start_time: datetime + end_time: datetime + + @pydantic.field_validator( + 'min_duration', + 'max_duration', + 'avg_duration', + 'total_duration', + 'span_count', + 'trace_count', + mode='before', + ) + @classmethod + def ensure_int(cls, v: Any) -> int: + """Ensure that all token counts are always an integer.""" + return int(v or 0) + + @classmethod + def _get_select_query( + cls, + *, + fields: Optional[SelectFields] = None, + filters: Optional[FilterFields] = None, + search: Optional[str] = None, + order_by: Optional[str] = None, + offset: Optional[int] = None, + limit: Optional[int] = None, + ) -> tuple[str, dict[str, Any]]: + if fields or search or order_by or offset or limit: + raise NotImplementedError("Custom fields, search, order_by, offset or limit are not supported.") + + where_clause, params = cls._get_where_clause(**(filters or {})) + query = f""" + SELECT + min(if(Duration > 0, Duration, null)) as min_duration, + max(if(Duration > 0, Duration, null)) as max_duration, + avg(if(Duration > 0, Duration, null)) as avg_duration, + sum(if(Duration > 0, Duration, null)) as total_duration, + count() as span_count, + count(DISTINCT TraceId) as trace_count, + min(Timestamp) as start_time, + max(Timestamp) as end_time + FROM {cls.table_name} + {f"WHERE {where_clause}" if where_clause else ""} + """ + return query, params + + +class ProjectMetricsTraceDurationsModel(BaseTraceModel): + """ + Model representing the trace durations for a project. + + This is used for generating the graph that shows the duration of each trace. + """ + + trace_id: str + trace_duration: int + + @pydantic.field_validator('trace_duration', mode='before') + @classmethod + def ensure_int(cls, v): + """Ensure that trace_duration is always an integer.""" + return int(v or 0) + + @classmethod + def _get_select_query( + cls, + *, + fields: Optional[SelectFields] = None, + filters: Optional[FilterFields] = None, + search: Optional[str] = None, + order_by: Optional[str] = None, + offset: Optional[int] = None, + limit: Optional[int] = None, + ) -> tuple[str, dict[str, Any]]: + if fields or search or order_by or offset or limit: + raise NotImplementedError("Custom fields, search, order_by, offset or limit are not supported.") + + where_clause, params = cls._get_where_clause(**(filters or {})) + query = f""" + SELECT + TraceId as trace_id, + sum(Duration) as trace_duration + FROM {cls.table_name} + {f"WHERE {where_clause}" if where_clause else ""} + GROUP BY TraceId + ORDER BY trace_duration ASC + """ + return query, params + + +class ProjectMetricsModel(TraceMetricsMixin, ClickhouseAggregatedModel): + """ + Model representing aggregated project metrics, combining multiple Clickhouse models. + + This model aggregates trace metrics, duration metrics, and trace durations into a single + response. It computes various summary statistics and provides properties for easy access to + common metrics like average tokens and cost calculations. + """ + + aggregated_models = ( + ProjectMetricsTraceModel, + ProjectMetricsDurationModel, + ProjectMetricsTraceDurationsModel, + ) + + trace_metrics_field_name = "traces" + + traces: list[ProjectMetricsTraceModel] = pydantic.Field(default_factory=list) + duration: ProjectMetricsDurationModel + trace_durations: list[ProjectMetricsTraceDurationsModel] = pydantic.Field(default_factory=list) + + trace_cost_dates: dict[date, Decimal] = pydantic.Field(default_factory=dict) + success_dates: list[datetime] = pydantic.Field(default_factory=list) + fail_dates: list[datetime] = pydantic.Field(default_factory=list) + indeterminate_dates: list[datetime] = pydantic.Field(default_factory=list) + + # Track if we have any cost data (stored or calculable) for proper display + has_any_cached_costs: bool = False + + # Initialize parent class attributes + span_count: int = 0 + trace_count: int = 0 + success_count: int = 0 + fail_count: int = 0 + indeterminate_count: int = 0 + + total_tokens: int = 0 + success_tokens: int = 0 + fail_tokens: int = 0 + + prompt_tokens: int = 0 + completion_tokens: int = 0 + cache_read_input_tokens: int = 0 + reasoning_tokens: int = 0 + + prompt_cost: Decimal = Decimal(0) + completion_cost: Decimal = Decimal(0) + total_cost: Decimal = Decimal(0) + + def __init__( + self, + traces: list[ProjectMetricsTraceModel], + durations: list[ProjectMetricsDurationModel], + trace_durations: list[ProjectMetricsTraceDurationsModel], + ) -> None: + super().__init__(traces=traces, duration=durations[0], trace_durations=trace_durations) + + def model_post_init(self, __context) -> None: + """Override to properly aggregate span counts from the aggregated trace data""" + traces = getattr(self, self.trace_metrics_field_name) + trace_ids: set[str] = set() + + # Reset counters + self.span_count = 0 + self.success_count = 0 + self.fail_count = 0 + self.indeterminate_count = 0 + + for trace in traces: + if not isinstance(trace, SpanMetricsMixin): + raise ValueError(f"Provided trace object {trace} does not implement SpanMetricsMixin.") + + trace_ids.add(trace.trace_id) + + # Aggregate span counts from the pre-aggregated data + self.span_count += trace.span_count + self.success_count += trace.success_span_count + self.fail_count += trace.fail_span_count + self.indeterminate_count += trace.indeterminate_span_count + + # Check if any trace has cost data (stored or calculable) + if hasattr(trace, 'has_cached_costs') and trace.has_cached_costs > 0: + self.has_any_cached_costs = True + + # Token aggregation remains the same + self.total_tokens += trace.total_tokens + self.success_tokens += trace.success_tokens + self.fail_tokens += trace.fail_tokens + + self.prompt_tokens += trace.prompt_tokens + self.completion_tokens += trace.completion_tokens + self.cache_read_input_tokens += trace.cache_read_input_tokens + self.reasoning_tokens += trace.reasoning_tokens + + self.prompt_cost += trace.prompt_cost + self.completion_cost += trace.completion_cost + self.total_cost += trace.total_cost + + self._trace_metrics_additions(trace) + + self.trace_count = len(trace_ids) + + def _trace_metrics_additions(self, trace: ProjectMetricsTraceModel) -> None: + """Compute additional trace metrics for a single trace instance.""" + if trace.success: + self.success_dates.append(trace.timestamp) + # TODO should trace_cost_dates only be on success? + date_cost = self.trace_cost_dates.get(trace.timestamp.date(), Decimal(0.0)) + self.trace_cost_dates[trace.timestamp.date()] = date_cost + trace.total_cost + elif trace.fail: + self.fail_dates.append(trace.timestamp) + else: + self.indeterminate_dates.append(trace.timestamp) + + @cached_property + def spans_per_trace(self) -> dict[int, int]: + """Returns a distribution of the number of spans per trace.""" + spans_per_trace: dict[int, int] = {} + trace_span_counts: dict[int, int] = {} + + # Use the span_count from each trace + for trace in self.traces: + count = trace.span_count + trace_span_counts[count] = trace_span_counts.get(count, 0) + 1 + + # Find max count for bucket creation + if trace_span_counts: + max_count = max(trace_span_counts.keys()) + increment = max(1, max_count // 10) + + for bucket_start in range(0, max_count + increment, increment): + bucket_count = sum( + count + for span_count, count in trace_span_counts.items() + if bucket_start <= span_count < bucket_start + increment + ) + if bucket_count: + spans_per_trace[bucket_start] = bucket_count + + return spans_per_trace diff --git a/app/api/agentops/api/models/metrics_optimized.py b/app/api/agentops/api/models/metrics_optimized.py new file mode 100644 index 000000000..41dcda6a1 --- /dev/null +++ b/app/api/agentops/api/models/metrics_optimized.py @@ -0,0 +1,266 @@ +from typing import Any, Optional +from functools import cached_property +from decimal import Decimal +from datetime import datetime, date +import pydantic + +from agentops.api.db.clickhouse.models import ClickhouseAggregatedModel, SelectFields, FilterFields +from agentops.api.models.traces import BaseTraceModel +from agentops.api.models.metrics import ( + ProjectMetricsTraceModel, + ProjectMetricsDurationModel, +) + +from .span_metrics import TraceMetricsMixin + + +class TraceDurationWrapper(pydantic.BaseModel): + """Simple wrapper to maintain compatibility with existing code expecting objects with trace_duration attribute""" + + trace_duration: int + + +class ProjectMetricsTraceDurationBucketsModel(BaseTraceModel): + """ + Model representing trace duration histogram buckets for a project. + Returns pre-aggregated histogram data instead of individual trace durations. + """ + + duration_bucket_ns: int + bucket_count: int + + @pydantic.field_validator('duration_bucket_ns', 'bucket_count', mode='before') + @classmethod + def ensure_int(cls, v): + """Ensure that values are always integers.""" + return int(v or 0) + + @classmethod + def _get_select_query( + cls, + *, + fields: Optional[SelectFields] = None, + filters: Optional[FilterFields] = None, + search: Optional[str] = None, + order_by: Optional[str] = None, + offset: Optional[int] = None, + limit: Optional[int] = None, + ) -> tuple[str, dict[str, Any]]: + if fields or search or order_by or offset or limit: + raise NotImplementedError("Custom fields, search, order_by, offset or limit are not supported.") + + where_clause, params = cls._get_where_clause(**(filters or {})) + + # This query creates histogram buckets for trace durations + # We use 20 logarithmic buckets for better distribution visualization + query = f""" + WITH trace_durations AS ( + SELECT + TraceId, + toUInt64(sum(Duration)) as trace_duration + FROM {cls.table_name} + {f"WHERE {where_clause}" if where_clause else ""} + GROUP BY TraceId + ), + duration_stats AS ( + SELECT + toUInt64(min(trace_duration)) as min_duration, + toUInt64(max(trace_duration)) as max_duration, + toUInt64(count()) as total_count + FROM trace_durations + ) + SELECT + CASE + WHEN total_count = 0 THEN toUInt64(0) + WHEN min_duration = max_duration THEN min_duration + ELSE toUInt64(floor( + min_duration + (toFloat64(number) * toFloat64(max_duration - min_duration) / 20.0) + )) + END as duration_bucket_ns, + toUInt64(countIf( + trace_duration >= CASE + WHEN total_count = 0 THEN toUInt64(0) + WHEN min_duration = max_duration THEN min_duration + ELSE toUInt64(floor(min_duration + (toFloat64(number) * toFloat64(max_duration - min_duration) / 20.0))) + END + AND trace_duration < CASE + WHEN total_count = 0 THEN toUInt64(1) + WHEN min_duration = max_duration THEN min_duration + toUInt64(1) + ELSE toUInt64(floor(min_duration + (toFloat64(number + 1) * toFloat64(max_duration - min_duration) / 20.0))) + END + )) as bucket_count + FROM + trace_durations, + duration_stats, + numbers(20) as number + GROUP BY number, min_duration, max_duration, total_count + ORDER BY duration_bucket_ns + """ + return query, params + + +class ProjectMetricsDateAggregatedModel(BaseTraceModel): + """ + Model representing date-aggregated success/fail/indeterminate counts. + Returns counts by date instead of individual timestamps. + """ + + date: date + success_count: int + fail_count: int + indeterminate_count: int + total_cost: Decimal + + @pydantic.field_validator('success_count', 'fail_count', 'indeterminate_count', mode='before') + @classmethod + def ensure_int(cls, v): + """Ensure that counts are always integers.""" + return int(v or 0) + + @pydantic.field_validator('total_cost', mode='before') + @classmethod + def ensure_decimal(cls, v): + """Ensure that cost is always a Decimal.""" + if isinstance(v, str): + return Decimal(v) if v else Decimal(0) + return Decimal(str(v)) if v else Decimal(0) + + @classmethod + def _get_select_query( + cls, + *, + fields: Optional[SelectFields] = None, + filters: Optional[FilterFields] = None, + search: Optional[str] = None, + order_by: Optional[str] = None, + offset: Optional[int] = None, + limit: Optional[int] = None, + ) -> tuple[str, dict[str, Any]]: + if fields or search or order_by or offset or limit: + raise NotImplementedError("Custom fields, search, order_by, offset or limit are not supported.") + + where_clause, params = cls._get_where_clause(**(filters or {})) + + # Aggregate by trace first, then by date + query = f""" + WITH trace_aggregates AS ( + SELECT + TraceId, + toDate(max(Timestamp)) as trace_date, + argMax(StatusCode, Timestamp) as trace_status, + sum(toDecimal64OrZero(ifNull(SpanAttributes['gen_ai.usage.total_cost'], '0'), 9)) as trace_cost + FROM {cls.table_name} + {f"WHERE {where_clause}" if where_clause else ""} + GROUP BY TraceId + ) + SELECT + trace_date as date, + countIf(upper(trace_status) = 'OK') as success_count, + countIf(upper(trace_status) = 'ERROR') as fail_count, + countIf(upper(trace_status) NOT IN ('OK', 'ERROR')) as indeterminate_count, + sum(trace_cost) as total_cost + FROM trace_aggregates + GROUP BY trace_date + ORDER BY trace_date + """ + return query, params + + +class ProjectMetricsOptimizedModel(TraceMetricsMixin, ClickhouseAggregatedModel): + """ + Optimized model for project metrics that reduces data transfer by aggregating at the database level. + """ + + aggregated_models = ( + ProjectMetricsTraceModel, # Keep existing trace model for token metrics + ProjectMetricsDurationModel, # Keep existing duration model + ProjectMetricsTraceDurationBucketsModel, # New: histogram buckets instead of all durations + ProjectMetricsDateAggregatedModel, # New: date aggregated counts instead of timestamps + ) + + trace_metrics_field_name = "traces" + + traces: list[ProjectMetricsTraceModel] = pydantic.Field(default_factory=list) + duration: ProjectMetricsDurationModel + trace_duration_buckets: list[ProjectMetricsTraceDurationBucketsModel] = pydantic.Field( + default_factory=list + ) + date_aggregates: list[ProjectMetricsDateAggregatedModel] = pydantic.Field(default_factory=list) + + # Keep these for compatibility but they'll be populated differently + trace_cost_dates: dict[date, Decimal] = pydantic.Field(default_factory=dict) + success_dates: list[datetime] = pydantic.Field(default_factory=list) + fail_dates: list[datetime] = pydantic.Field(default_factory=list) + indeterminate_dates: list[datetime] = pydantic.Field(default_factory=list) + trace_durations: list[TraceDurationWrapper] = pydantic.Field(default_factory=list) + + def __init__( + self, + traces: list[ProjectMetricsTraceModel], + durations: list[ProjectMetricsDurationModel], + trace_duration_buckets: list[ProjectMetricsTraceDurationBucketsModel], + date_aggregates: list[ProjectMetricsDateAggregatedModel], + ) -> None: + # Call parent with modified signature + super(ClickhouseAggregatedModel, self).__init__( + traces=traces, + duration=durations[0], + trace_duration_buckets=trace_duration_buckets, + date_aggregates=date_aggregates, + ) + + def model_post_init(self, __context) -> None: + """Override to use aggregated data instead of computing from individual traces""" + # Call parent to handle token aggregation from traces + super().model_post_init(__context) + + # Process date aggregates to populate date arrays + for agg in self.date_aggregates: + # Create datetime objects for each occurrence + dt = datetime.combine(agg.date, datetime.min.time()) + + # Add timestamps for each count + for _ in range(agg.success_count): + self.success_dates.append(dt) + for _ in range(agg.fail_count): + self.fail_dates.append(dt) + for _ in range(agg.indeterminate_count): + self.indeterminate_dates.append(dt) + + # Add to trace cost dates + if agg.total_cost > 0: + self.trace_cost_dates[agg.date] = agg.total_cost + + # Convert histogram buckets to trace durations list + # This maintains compatibility with the frontend + for bucket in self.trace_duration_buckets: + # Add representative durations for each bucket + for _ in range(bucket.bucket_count): + self.trace_durations.append(TraceDurationWrapper(trace_duration=bucket.duration_bucket_ns)) + + @cached_property + def spans_per_trace(self) -> dict[int, int]: + """Returns a distribution of the number of spans per trace.""" + # This can be optimized further in a future iteration + # For now, use the existing implementation + spans_per_trace: dict[int, int] = {} + trace_spans: dict[str, int] = {} + + for trace in self.traces: + trace_spans[trace.trace_id] = trace_spans.get(trace.trace_id, 0) + 1 + + trace_counts = trace_spans.values() + max_count = max(trace_counts) if trace_counts else 0 + + if max_count > 0: + increment = max_count // 10 + if increment < 1: + increment = 1 + for index in range(0, max_count + increment, increment): + count = sum( + 1 for count in trace_spans.values() if count >= index and count < index + increment + ) + if count: + spans_per_trace[index] = count + + return spans_per_trace diff --git a/app/api/agentops/api/models/span_metrics.py b/app/api/agentops/api/models/span_metrics.py new file mode 100644 index 000000000..3e3779bc2 --- /dev/null +++ b/app/api/agentops/api/models/span_metrics.py @@ -0,0 +1,426 @@ +from typing import ClassVar, Type, Any, Optional, Literal +from decimal import Decimal +from functools import cached_property +import pydantic +from tokencost import costs # type: ignore +from agentops.api.db.clickhouse.models import ( + ClickhouseModel, + ClickhouseAggregatedModel, + SelectFields, +) + +# from .traces import ( +# TRACE_STATUS_OK, +# TRACE_STATUS_ERROR, +# ) +# TODO circ import +TRACE_STATUS_OK = "OK" +TRACE_STATUS_ERROR = "ERROR" + +# hax to relate model names to their entries in `tokencost` +MODEL_LOOKUP_ALIASES = { + "sonar-pro": "perplexity/sonar-pro", + "sonar": "perplexity/sonar", +} + + +def _format_cost(value: Decimal) -> str: + """Helper function to format a Decimal cost to a string with 7 decimal places.""" + # 7 decimal places has been observed to be adequately precise. + return f"{float(value):.7f}" + + +class SpanMetricsResponse(pydantic.BaseModel): + """ + Shared metrics response type for spans. + """ + + total_tokens: int + + prompt_tokens: int + completion_tokens: int + cache_read_input_tokens: int + reasoning_tokens: int + + success_tokens: int + fail_tokens: int + indeterminate_tokens: int + + prompt_cost: str + completion_cost: str + total_cost: str + + @pydantic.field_validator('prompt_cost', 'completion_cost', 'total_cost', mode='before') + @classmethod + def format_cost(cls, v: Decimal) -> str: + return _format_cost(v) + + @classmethod + def from_span_with_metrics( + cls: Type['SpanMetricsResponse'], + span: 'SpanMetricsMixin', + ) -> 'SpanMetricsResponse': + """ + Create a SpanMetricsResponse from a SpanMetricsMixin instance. + """ + return cls( + total_tokens=span.total_tokens, + prompt_tokens=span.prompt_tokens, + completion_tokens=span.completion_tokens, + cache_read_input_tokens=span.cache_read_input_tokens, + reasoning_tokens=span.reasoning_tokens, + success_tokens=span.success_tokens, + fail_tokens=span.fail_tokens, + indeterminate_tokens=span.indeterminate_tokens, + # ignore these type errors because a conversion happens with field_validator + prompt_cost=span.prompt_cost, # type: ignore + completion_cost=span.completion_cost, # type: ignore + total_cost=span.total_cost, # type: ignore + ) + + +class SpanMetricsMixin(ClickhouseModel): + status_code: str # base models must populate status_code + trace_id: str # required for trace identification + + request_model: Optional[str] + response_model: Optional[str] + + prompt_tokens: int + completion_tokens: int + cache_read_input_tokens: int + reasoning_tokens: int + cached_total_tokens: Optional[int] = None + + cached_prompt_cost: Optional[Decimal] = None + cached_completion_cost: Optional[Decimal] = None + cached_total_cost: Optional[Decimal] = None + + @classmethod + def _get_select_clause( + cls: Type['SpanMetricsMixin'], + *, + fields: Optional[SelectFields] = None, + ) -> str: + """Append additional metrics to the base model's selects.""" + select_clause = super(SpanMetricsMixin, cls)._get_select_clause(fields=fields) + select_clause = f"{select_clause}, " if select_clause else "" + + # NOTE previously we queried `llm.model` and `gent_ai.model` but it didn't + # seems like we had any data that actually contained that so it has been removed. + return f""" + {select_clause} + ifNull(SpanAttributes['gen_ai.usage.prompt_tokens'], 0) as prompt_tokens, + ifNull(SpanAttributes['gen_ai.usage.completion_tokens'], 0) as completion_tokens, + ifNull(SpanAttributes['gen_ai.usage.cache_read_input_tokens'], 0) as cache_read_input_tokens, + ifNull(SpanAttributes['gen_ai.usage.reasoning_tokens'], 0) as reasoning_tokens, + SpanAttributes['gen_ai.usage.total_tokens'] as cached_total_tokens, + SpanAttributes['gen_ai.request.model'] as request_model, + SpanAttributes['gen_ai.response.model'] as response_model, + SpanAttributes['gen_ai.usage.prompt_cost'] as cached_prompt_cost, + SpanAttributes['gen_ai.usage.completion_cost'] as cached_completion_cost, + SpanAttributes['gen_ai.usage.total_cost'] as cached_total_cost + """ + + @pydantic.field_validator( + 'prompt_tokens', + 'completion_tokens', + 'cache_read_input_tokens', + 'reasoning_tokens', + mode='before', + ) + @classmethod + def ensure_int(cls, v: Any) -> int: + """Ensure that all token counts are always an integer.""" + return int(v or 0) + + @pydantic.field_validator('cached_total_tokens', mode='before') + @classmethod + def ensure_int_or_none(cls, v: Any) -> Optional[int]: + """Ensure token counts are int when present.""" + if v is None or v == "": + return None + + return int(v) + + @pydantic.field_validator( + 'cached_prompt_cost', + 'cached_completion_cost', + 'cached_total_cost', + mode='before', + ) + @classmethod + def ensure_decimal(cls, v: Any) -> Optional[Decimal]: + """Ensure that cached costs are always a Decimal.""" + if v is None: + return None + + if isinstance(v, Decimal): + return v # Already a Decimal, return as-is + + if isinstance(v, str) and v: # filter empty strings + return Decimal(v) + + if isinstance(v, (int, float)): + return Decimal(str(v)) # convert to string to avoid float precision issues + + return None + + @pydantic.field_validator('trace_id', 'status_code', mode='before') + @classmethod + def ensure_required(cls, v: Any) -> Any: + """Ensure that the trace_id and status_code are always present.""" + if not v: + raise ValueError(f"Required field cannot be empty: {cls.__name__}.{v}") + return v + + @property + def success(self) -> bool: + """Indicates whether the trace was successful based on its status code.""" + return self.status_code == TRACE_STATUS_OK + + @property + def fail(self) -> bool: + """Indicates whether the trace failed based on its status code.""" + return self.status_code == TRACE_STATUS_ERROR + + @property + def indeterminate(self) -> bool: + """Indicates whether the trace is indeterminate (i.e., not successful or failed).""" + return self.status_code not in (TRACE_STATUS_OK, TRACE_STATUS_ERROR) + + @cached_property # this might actually be slower + def total_tokens(self) -> int: + """ + Returns the total tokens used in the span. This is the sum of all token types. + """ + if self.cached_total_tokens is not None: + # if the SDK has populated this value, assume it's correct. + return self.cached_total_tokens + + return ( + self.prompt_tokens + self.completion_tokens + self.cache_read_input_tokens + self.reasoning_tokens + ) + + @property + def success_tokens(self) -> int: + """Number of successful tokens.""" + return self.total_tokens if self.success else 0 + + @property + def fail_tokens(self) -> int: + """Number of failed tokens.""" + return self.total_tokens if self.fail else 0 + + @property + def indeterminate_tokens(self) -> int: + """Number of indeterminate tokens.""" + return self.total_tokens if self.indeterminate else 0 + + @property + def model_for_cost(self) -> Optional[str]: + """Get the best available model for calculating costs.""" + model_name: Optional[str] = None + + if self.response_model: + # often we have both a request and a response model set, in this case + # the response model will have been converted by the provider SDK to + # include specifics about it's release version. + model_name = self.response_model + else: + # otherwise return the request model which is essentially user input, + # or `None` if there is no model information. + model_name = self.request_model + + # sometimes we have see model names that don't correspond to the records + # in `tokencost` so we convert them here. + if model_name in MODEL_LOOKUP_ALIASES: + model_name = MODEL_LOOKUP_ALIASES[model_name] + + return model_name + + @cached_property + def prompt_cost(self) -> Decimal: + """The cost of the prompt based on the tokens and model used.""" + # TODO we need to incorporate cached tokens where they apply. + if self.cached_prompt_cost is not None: + # precalculated cost from the collector + return self.cached_prompt_cost + + return self._calculate_cost(self.prompt_tokens, "input") + + @cached_property + def completion_cost(self) -> Decimal: + """The cost of the completion based on the tokens and model used.""" + # TODO we need to incorporate reasoning tokens where they apply. + if self.cached_completion_cost is not None: + # precalculated cost from the collector + return self.cached_completion_cost + + return self._calculate_cost(self.completion_tokens, "output") + + @property + def total_cost(self) -> Decimal: + """Returns the total cost of the trace, which is the sum of the prompt and completion costs.""" + if self.cached_total_cost is not None: + # precalculated cost from the SDK + return self.cached_total_cost + + return self.prompt_cost + self.completion_cost + + def _calculate_cost(self, tokens: int, direction: Literal["input", "output"]) -> Decimal: + """Calculate the cost of the input or output tokens for the span's model.""" + if not self.model_for_cost: + return Decimal(0) + + try: + completion_cost = costs.calculate_cost_by_tokens(tokens, self.model_for_cost, direction) + except Exception: + return Decimal(0) + + if not completion_cost: + return Decimal(0) + + return completion_cost + + +class TraceMetricsResponse(pydantic.BaseModel): + """ + Trace metrics response model used in trace detail responses. + """ + + span_count: int + trace_count: int + success_count: int + fail_count: int + indeterminate_count: int + + prompt_tokens: int + completion_tokens: int + cache_read_input_tokens: int + reasoning_tokens: int + total_tokens: int + + prompt_cost: str + completion_cost: str + average_cost_per_trace: str + total_cost: str + + @pydantic.field_validator( + 'prompt_cost', 'completion_cost', 'average_cost_per_trace', 'total_cost', mode='before' + ) + @classmethod + def format_cost(cls, v: Decimal) -> str: + return _format_cost(v) + + @classmethod + def from_trace_with_metrics( + cls: Type['TraceMetricsResponse'], + trace: 'TraceMetricsMixin', + ) -> 'TraceMetricsResponse': + """ + Create a TraceMetricsResponse from a TraceMetricsMixin instance. + """ + return cls( + span_count=trace.span_count, + trace_count=trace.trace_count, + success_count=trace.success_count, + fail_count=trace.fail_count, + indeterminate_count=trace.indeterminate_count, + prompt_tokens=trace.prompt_tokens, + completion_tokens=trace.completion_tokens, + cache_read_input_tokens=trace.cache_read_input_tokens, + reasoning_tokens=trace.reasoning_tokens, + total_tokens=trace.total_tokens, + # ignore these type errors because a conversion happens with field_validator + prompt_cost=trace.prompt_cost, # type: ignore + completion_cost=trace.completion_cost, # type: ignore + average_cost_per_trace=trace.average_cost_per_trace, # type: ignore + total_cost=trace.total_cost, # type: ignore + ) + + +class TraceMetricsMixin(ClickhouseAggregatedModel): + trace_metrics_field_name: ClassVar[str] = "traces" + + span_count: int = 0 + trace_count: int = 0 + success_count: int = 0 + fail_count: int = 0 + indeterminate_count: int = 0 + + total_tokens: int = 0 + success_tokens: int = 0 + fail_tokens: int = 0 + + prompt_tokens: int = 0 + completion_tokens: int = 0 + cache_read_input_tokens: int = 0 + reasoning_tokens: int = 0 + + prompt_cost: Decimal = Decimal(0) + completion_cost: Decimal = Decimal(0) + total_cost: Decimal = Decimal(0) + + def model_post_init(self, __context) -> None: + """Compute all trace metrics once during initialization to avoid repeated loops""" + traces = getattr(self, self.trace_metrics_field_name) + trace_ids: set[str] = set() + + for trace in traces: + if not isinstance(trace, SpanMetricsMixin): + raise ValueError(f"Provided trace object {trace} does not implement SpanMetricsMixin.") + + trace_ids.add(trace.trace_id) + + if trace.success: + self.success_count += 1 + elif trace.fail: + self.fail_count += 1 + else: + self.indeterminate_count += 1 + + self.total_tokens += trace.total_tokens + self.success_tokens += trace.success_tokens + self.fail_tokens += trace.fail_tokens + + self.prompt_tokens += trace.prompt_tokens + self.completion_tokens += trace.completion_tokens + self.cache_read_input_tokens += trace.cache_read_input_tokens + self.reasoning_tokens += trace.reasoning_tokens + + self.prompt_cost += trace.prompt_cost + self.completion_cost += trace.completion_cost + self.total_cost += trace.total_cost + + self._trace_metrics_additions(trace) + + self.span_count = len(traces) + self.trace_count = len(trace_ids) + + def _trace_metrics_additions(self, trace: Any) -> None: + """ + Helper method to add a single trace's metrics to the current instance. + This prevents us from having to repeat the loop. + """ + pass + + @property + def avg_tokens(self) -> float: + """Returns the average tokens per trace""" + return self.total_tokens / self.span_count if self.span_count > 0 else 0.0 + + @property + def avg_success_tokens(self) -> float: + """Returns the average tokens for successful traces""" + return self.success_tokens / self.success_count if self.success_count > 0 else 0.0 + + @property + def avg_fail_tokens(self) -> float: + """Returns the average tokens for failed traces""" + return self.fail_tokens / self.fail_count if self.fail_count > 0 else 0.0 + + @property + def average_cost_per_trace(self) -> Decimal: + """Returns the average cost per trace""" + return self.total_cost / self.trace_count if self.trace_count > 0 else Decimal(0) diff --git a/app/api/agentops/api/models/traces.py b/app/api/agentops/api/models/traces.py new file mode 100644 index 000000000..856a0995a --- /dev/null +++ b/app/api/agentops/api/models/traces.py @@ -0,0 +1,475 @@ +from typing import Any, Optional, Type +from datetime import datetime, timedelta, timezone +import json +import pydantic +from decimal import Decimal + +from agentops.api.db.clickhouse.models import ( + ClickhouseModel, + TClickhouseModel, + ClickhouseAggregatedModel, + SelectFields, + FilterFields, + WithinListOperation, +) + +from .span_metrics import SpanMetricsMixin, TraceMetricsMixin + + +TRACE_STATUS_OK = "OK" +TRACE_STATUS_ERROR = "ERROR" + + +def nanosecond_timedelta(ns: int) -> timedelta: + """Return a timedelta object from nanoseconds.""" + seconds = ns // 1_000_000_000 + microseconds = (ns % 1_000_000_000) // 1000 # Convert remaining ns to Ī¼s + return timedelta(seconds=seconds, microseconds=microseconds) + + +class BaseTraceModel(ClickhouseModel): + """ + BaseTraceModel is a base model for the trace data in Clickhouse. + + This model defines the structure of the trace data and is used to interact with + the `otel_traces` table in Clickhouse. + + This class is inherited from by other models that interact with the `otel_traces` + table, so it is kept free of attributes to allow them to be defined for each use case. + + Field lookups and filters are common to all models that interact with this table, + so they are shared here in this base class. + """ + + table_name = "otel_traces" + selectable_fields = { + 'Timestamp': "timestamp", + 'project_id': "project_id", + 'TraceId': "trace_id", + 'SpanId': "span_id", + 'ParentSpanId': "parent_span_id", + 'TraceState': "trace_state", + 'SpanName': "span_name", + 'SpanKind': "span_kind", + 'ServiceName': "service_name", + 'ResourceAttributes': "resource_attributes", + 'ScopeName': "scope_name", + 'ScopeVersion': "scope_version", + 'SpanAttributes': "span_attributes", + "SpanAttributes['agentops.tags']": "tags", + 'Duration': "duration", + 'StatusCode': "status_code", + 'StatusMessage': "status_message", + 'Events.Timestamp': "event_timestamps", + 'Events.Name': "event_names", + 'Events.Attributes': "event_attributes", + 'Links.TraceId': "link_trace_ids", + 'Links.SpanId': "link_span_ids", + 'Links.TraceState': "link_trace_states", + 'Links.Attributes': "link_attributes", + } + filterable_fields = { + "trace_id": ("=", "TraceId"), + "span_id": ("=", "SpanId"), + "parent_span_id": ("=", "ParentSpanId"), + "project_id": ("=", "project_id"), + "project_ids": (WithinListOperation, "project_id"), + "start_time": (">=", "Timestamp"), + "end_time": ("<=", "Timestamp"), + } + + @pydantic.field_validator('status_code', check_fields=False, mode='before') + @classmethod + def uppercase_status(cls, v: str) -> str: + """Ensure status_code is always uppercase (if it is present).""" + return v.upper() + + @pydantic.field_validator('tags', check_fields=False, mode='before') + @classmethod + def parse_tags_json(cls, value: str) -> list[str]: + """Parse the tags JSON string into a list of tags.""" + try: + return json.loads(value) + except json.JSONDecodeError: + return [] + + +class SpanModel(SpanMetricsMixin, BaseTraceModel): + """ + SpanModel represents a single span within a trace. This model is used to retrieve + span data from the `otel_traces` table in Clickhouse. + + Incorporates `SpanMetricsMixin` to handle token calculations. + """ + + project_id: str + trace_id: str + span_id: str + parent_span_id: Optional[str] = None + + timestamp: datetime + duration: int + status_code: str + status_message: Optional[str] = None + + trace_state: Optional[str] = None + span_name: Optional[str] = None + span_kind: Optional[str] = None + service_name: Optional[str] = None + scope_name: Optional[str] = None + scope_version: Optional[str] = None + tags: Optional[list[str]] = pydantic.Field(default_factory=list) + + resource_attributes: dict[str, Any] + span_attributes: dict[str, Any] + + event_timestamps: list[datetime] = pydantic.Field(default_factory=list) + event_names: list[str] = pydantic.Field(default_factory=list) + event_attributes: list[Any] = pydantic.Field(default_factory=list) + + link_trace_ids: list[str] = pydantic.Field(default_factory=list) + link_span_ids: list[str] = pydantic.Field(default_factory=list) + link_trace_states: list[str] = pydantic.Field(default_factory=list) + link_attributes: list[Any] = pydantic.Field(default_factory=list) + + @property + def start_time(self) -> datetime: + """start_time property returns the timestamp of the span.""" + return self.timestamp.astimezone(timezone.utc) + + @property + def end_time(self) -> datetime: + """Determine the end time of the span based on the start time and duration.""" + return self.start_time + nanosecond_timedelta(self.duration) + + +class TraceModel(TraceMetricsMixin, ClickhouseAggregatedModel): + """ + TraceModel is an aggregate model that actually only queries one model, but + having the aggregate as a parent gives us a place to store the trace metrics. + """ + + aggregated_models = (SpanModel,) + + trace_metrics_field_name = "spans" + + spans: list[SpanModel] = pydantic.Field(default_factory=list) + + def __init__(self, spans: list[SpanModel]) -> None: + super().__init__( + spans=spans, + ) + + @property + def trace_id(self) -> str: + """ + Get the trace ID for this group of spans. + Validates that all spans in the trace have the same trace ID (they always + should) and returns it. + """ + trace_ids = {span.trace_id for span in self.spans} + assert len(trace_ids) == 1, "All spans in a trace are expected to have the same trace_id" + return trace_ids.pop() + + @property + def project_id(self) -> str: + """ + Get the project ID for this group of spans. + + Validates that all spans in the trace have the same project ID (they + always should) and returns it. + """ + project_ids = {span.project_id for span in self.spans} + assert len(project_ids) == 1, "All spans in a trace are expected to have the same project_id" + return project_ids.pop() + + @property + def start_time(self) -> datetime: + """Get the start time of the trace from the first span.""" + return min(span.start_time for span in self.spans) + + @property + def end_time(self) -> datetime: + """Get the end time of the trace from the last span.""" + return max(span.end_time for span in self.spans) + + @property + def tags(self) -> list[str]: + """Get tags from the root span.""" + # the SDK currently only sets tags on the root span and we always have at least one span + return self.spans[0].tags + + +class TraceSummaryModel(BaseTraceModel): + """ + TraceListModel represents a summary of traces in Clickhouse grouped by `trace_id`. + + This model is used to interact with the `otel_traces` table in Clickhouse to retrieve + a list of traces with summary information suitable for use in a list view. + """ + + filterable_fields = { + "project_id": ("=", "project_id"), + "start_time": (">=", "Timestamp"), + "end_time": ("<=", "Timestamp"), + } + searchable_fields = { + # searchable field should reference the alias we create in the sub-select + "trace_id": ("ILIKE", "trace_id"), + "span_name": ("ILIKE", "span_name"), + "tags": ("ILIKE", "tags"), + } + + trace_id: str + service_name: Optional[str] = None + span_name: Optional[str] = None + start_time: datetime + duration: int + span_count: int + error_count: int + tags: Optional[list[str]] = pydantic.Field(default_factory=list) + total_cost: Optional[float] = None + + @pydantic.field_validator('start_time', mode='before') + def datetime_with_timezone(cls, v: datetime) -> datetime: + """Ensure the start_time is formatted as ISO strings.""" + return v.astimezone(timezone.utc) + + @property + def end_time(self) -> datetime: + """Determine the end time of the span based on the start time and duration.""" + return self.start_time + nanosecond_timedelta(self.duration) + + @classmethod + def _get_select_query( + cls: Type[TClickhouseModel], + *, + fields: Optional[SelectFields] = None, + filters: Optional[FilterFields] = None, + search: Optional[str] = None, + order_by: str = "start_time ASC", + offset: int = 0, + limit: int = 20, + ) -> tuple[str, dict[str, Any]]: + if fields: + raise NotImplementedError("`TraceListModel.select` does not support `fields`") + + where_clause, where_params = cls._get_where_clause(**(filters or {})) + having_clause, having_params = cls._get_search_clause(search) + params = {**where_params, **having_params} + + # we use `argMin` on the aggregation because we can assume that the oldest + # span is the root span + query = f""" + WITH traces AS + ( + SELECT + TraceId as trace_id, + any(ServiceName) AS service_name, + argMin(SpanName, Timestamp) AS span_name, + argMin(SpanAttributes['agentops.tags'], Timestamp) AS tags, + -- Calculate wall-clock duration instead of summing individual span durations + min(Timestamp) AS start_time, + -- Use the difference between the earliest span start and the latest span start to approximate total elapsed time in nanoseconds + dateDiff('nanosecond', min(Timestamp), max(Timestamp)) AS duration, + count() AS span_count, + countIf(upper(StatusCode) = '{TRACE_STATUS_ERROR}') AS error_count, + -- Sum up total cost from all spans in the trace + -- Use hybrid approach: stored costs when available, calculated costs otherwise + sum( + if( + SpanAttributes['gen_ai.usage.total_cost'] != '', + toFloat64OrZero(SpanAttributes['gen_ai.usage.total_cost']), + toFloat64( + calculate_prompt_cost( + toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.prompt_tokens'], '0')), + coalesce( + nullIf(SpanAttributes['gen_ai.response.model'], ''), + nullIf(SpanAttributes['gen_ai.request.model'], '') + ) + ) + calculate_completion_cost( + toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.completion_tokens'], '0')), + coalesce( + nullIf(SpanAttributes['gen_ai.response.model'], ''), + nullIf(SpanAttributes['gen_ai.request.model'], '') + ) + ) + ) + ) + ) AS total_cost + FROM {cls.table_name} + {f"WHERE {where_clause}" if where_clause else ""} + GROUP BY trace_id + ) + SELECT * + FROM traces + {f"HAVING {having_clause}" if having_clause else ""} + ORDER BY {order_by} + LIMIT {limit} + OFFSET {offset} + """ + return query, params + + +class TraceListMetricsModel(SpanMetricsMixin, BaseTraceModel): + """ + Returns statistics related to trace counts for a given project. This model is used to + interact with the `otel_traces` table in Clickhouse to retrieve aggregate trace counts + for use in supporting a trace list view. + + Note that while the `TraceSummaryModel` this is paired with returns a subset of the + available traces, this model references all applicable traces (based on the shared + filters) and can be used to display the metrics for the entire dataset. + + Implements hybrid cost calculation: uses stored costs when available, calculates + on-the-fly for historical data. This approach was inspired by FoxyAI's needs. + """ + + selectable_fields = { + "TraceId": "trace_id", + 'StatusCode': "status_code", + } + filterable_fields = { + "project_id": ("=", "project_id"), + "start_time": (">=", "Timestamp"), + "end_time": ("<=", "Timestamp"), + "span_name": ("ILIKE", "SpanName"), + } + searchable_fields = { + # searchable field should reference the columns in the table + "trace_id": ("ILIKE", "TraceId"), + "span_name": ("ILIKE", "SpanName"), + "tags": ("ILIKE", "SpanAttributes['agentops.tags']"), + } + + # Add aggregated fields + trace_id: str + status_code: str + span_count: int = 1 + prompt_tokens: int = 0 + completion_tokens: int = 0 + cache_read_input_tokens: int = 0 + reasoning_tokens: int = 0 + cached_total_cost: Decimal = Decimal(0) + + @pydantic.field_validator( + 'span_count', + 'prompt_tokens', + 'completion_tokens', + 'cache_read_input_tokens', + 'reasoning_tokens', + mode='before', + ) + @classmethod + def ensure_int(cls, v: Any) -> int: + """Ensure that all counts are always an integer.""" + return int(v or 0) + + @pydantic.field_validator('cached_total_cost', mode='before') + @classmethod + def ensure_decimal(cls, v: Any) -> Decimal: + """Ensure that cost is always a Decimal.""" + if isinstance(v, str): + return Decimal(v) if v else Decimal(0) + return Decimal(str(v)) if v else Decimal(0) + + @classmethod + def _get_select_query( + cls: Type[TClickhouseModel], + *, + fields: Optional[SelectFields] = None, + filters: Optional[FilterFields] = None, + search: Optional[str] = None, + order_by: str = "start_time ASC", + offset: int = 0, + limit: int = 20, + ) -> tuple[str, dict[str, Any]]: + """ + Aggregate trace metrics at the database level for performance. + + For costs: Uses stored total_cost when available, calculates on-the-fly for missing data. + This preserves 100% accurate costs for new data while fixing historical gaps. + """ + if fields: + raise NotImplementedError("`TraceListMetricsModel.select` does not support `fields`") + + # Get the where clause from parent + where_clause, params = cls._get_where_clause(**(filters or {})) + + # Apply search conditions if provided + if search: + search_conditions = [] + search_value = f"%{search}%" + for field, (operator, column) in cls.searchable_fields.items(): + if operator == "ILIKE": + search_conditions.append(f"{column} ILIKE %(search_{field})s") + params[f"search_{field}"] = search_value + + if search_conditions: + search_clause = f"({' OR '.join(search_conditions)})" + where_clause = f"{where_clause} AND {search_clause}" if where_clause else search_clause + + # Aggregate by trace at the database level - this is the key optimization + query = f""" + SELECT + TraceId as trace_id, + argMax(StatusCode, Timestamp) as status_code, + count() as span_count, + sum(toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.prompt_tokens'], '0'))) as prompt_tokens, + sum(toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.completion_tokens'], '0'))) as completion_tokens, + sum(toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.cache_read_input_tokens'], '0'))) as cache_read_input_tokens, + sum(toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.reasoning_tokens'], '0'))) as reasoning_tokens, + any(SpanAttributes['gen_ai.request.model']) as request_model, + any(SpanAttributes['gen_ai.response.model']) as response_model, + sum( + if( + SpanAttributes['gen_ai.usage.total_cost'] != '', + toDecimal64OrZero(SpanAttributes['gen_ai.usage.total_cost'], 9), + toDecimal64( + calculate_prompt_cost( + toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.prompt_tokens'], '0')), + coalesce( + nullIf(SpanAttributes['gen_ai.response.model'], ''), + nullIf(SpanAttributes['gen_ai.request.model'], '') + ) + ) + calculate_completion_cost( + toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.completion_tokens'], '0')), + coalesce( + nullIf(SpanAttributes['gen_ai.response.model'], ''), + nullIf(SpanAttributes['gen_ai.request.model'], '') + ) + ), + 9 + ) + ) + ) as cached_total_cost + FROM {cls.table_name} + {f"WHERE {where_clause}" if where_clause else ""} + GROUP BY TraceId + """ + + return query, params + + +class TraceListModel(TraceMetricsMixin, ClickhouseAggregatedModel): + """ + TraceListModel is an aggregate model that combines the results of `TraceSummaryModel` + and `TraceListMetricsModel` to provide a list of traces matching the user query + for a subset of traces, along with aggregate metrics for the entire trace set. + """ + + aggregated_models = ( + TraceSummaryModel, + TraceListMetricsModel, + ) + + trace_metrics_field_name = "metrics_traces" + + traces: list[TraceSummaryModel] = pydantic.Field(default_factory=list) + metrics_traces: list[TraceListMetricsModel] = pydantic.Field(default_factory=list) + + def __init__(self, traces: list[TraceSummaryModel], metrics_traces: list[TraceListMetricsModel]) -> None: + super().__init__( + traces=traces, + metrics_traces=metrics_traces, + ) diff --git a/app/api/agentops/api/promptarmor.py b/app/api/agentops/api/promptarmor.py new file mode 100644 index 000000000..321d63f82 --- /dev/null +++ b/app/api/agentops/api/promptarmor.py @@ -0,0 +1,55 @@ +import httpx +import os +import asyncio + +from .log_config import logger + +API_KEY = os.environ.get("PROMPTARMOR_API_KEY") + + +async def evaluate(prompt, session_id: str, mode: str, source=None, destination=None) -> bool: + """ + Evaluate a prompt with the PromptArmor API. + Args: + prompt: the content that you are sending to an LLM + session_id: the session id for set of calls to the LLM + mode: the mode of the evaluation. Either "input" or "output" + source(optional) : the source of this content that you are sending to the LLM + destination (optional) : the destination of this output that will come from the LLM + Returns (bool): + The response from the API. {"containsInjection":true} + """ + if mode not in ["input", "output"]: + raise ValueError("mode must be either 'input' or 'output'") + + if mode == "input": + url = "https://api.aidr.promptarmor.com/v1/analyze/input" + else: + url = "https://api.aidr.promptarmor.com/v1/analyze/output" + + promptarmor_headers = { + "PromptArmor-Auth": f"Bearer {API_KEY}", + # The session ID is unique to each user session(e.g. a workflow or conversation) + "PromptArmor-Session-ID": session_id, + "Content-Type": "application/json", + } + + data = {"content": prompt, "source": source, "destination": destination} + + async with httpx.AsyncClient() as async_client: + response = await async_client.post(url, headers=promptarmor_headers, json=data) + + return response.json().get("detection", None) + + +async def get_promptarmor_flag(prompt, completion, session_id) -> bool | None: + "TODO: Implement other specific flags https://promptarmor.readme.io/reference/v1analyzeinput" + try: + input_check, output_check = await asyncio.gather( + evaluate(prompt, session_id, mode="input"), + evaluate(completion, session_id, mode="output"), + ) + return input_check or output_check + except Exception as e: + logger.warning(f"Unable to get Promptarmor Flag: {e}") + return None diff --git a/app/api/agentops/api/routes/v1.py b/app/api/agentops/api/routes/v1.py new file mode 100644 index 000000000..7cd1c5d05 --- /dev/null +++ b/app/api/agentops/api/routes/v1.py @@ -0,0 +1,338 @@ +import asyncio +from decimal import Decimal + +from fastapi import APIRouter, Request +from fastapi.responses import JSONResponse + +import agentops.api.event_handlers as event_handlers +import agentops.api.interactors.spans as span_handlers +from agentops.api.db.supabase_client import AsyncSupabaseClient +from agentops.api.exceptions import InvalidModelError +from agentops.api.log_config import logger +from agentops.api.utils import update_stats + +# Create a router for v1 endpoints +router = APIRouter(prefix="/v1") + + +@router.post("/sessions") +async def create_session(request: Request, supabase: AsyncSupabaseClient): + """Create a new session""" + try: + api_key = request.headers.get("X-Agentops-Auth") + parent_key = request.headers.get("X-Agentops-Parent-Key") + + tasks = [ + supabase.table("projects").select("id").eq("api_key", api_key).limit(1).single().execute(), + request.json(), + ] + + if parent_key: + tasks.append( + supabase.table("projects").select("id").eq("api_key", parent_key).limit(1).single().execute() + ) + project, data, project_secondary = await asyncio.gather(*tasks) + else: + project, data = await asyncio.gather(*tasks) + project_secondary = None + + logger.debug(data) + + if project is None: + raise RuntimeError("Invalid API Key") + + except RuntimeError as e: + message = {"message": f"/sessions: Error posting session: {e}"} + logger.error(message) + return JSONResponse(message, status_code=401) + + try: + session = { + "id": data["session"]["session_id"], + "project_id": project["id"], + "init_timestamp": data["session"]["init_timestamp"], + "end_timestamp": data["session"].get("end_timestamp", None), + "tags": data["session"].get("tags", None), + "end_state": data["session"].get("end_state", None), + "end_state_reason": data["session"].get("end_state_reason", None), + "video": data["session"].get("video", None), + "host_env": data["session"].get("host_env", None), + } + + if project_secondary: + session["project_id_secondary"] = project_secondary["id"] + + await supabase.table("sessions").upsert(session).execute() + await supabase.table("stats").upsert({"session_id": session["id"]}).execute() + + cost = await ( + supabase.table("stats").select("cost").eq("session_id", session["id"]).limit(1).single().execute() + ) + + logger.info(f"/session: Completed POST request for {session['id']}") + if cost is not None: + return JSONResponse( + { + "status": "success", + "token_cost": cost.get("cost", "0.00") or "0.00", + } + ) + return JSONResponse({"status": "success"}) + except RuntimeError as e: + message = {"message": f"/sessions: Error posting session: {e}"} + logger.error(message) + return JSONResponse(message, status_code=400) + + +@router.post("/agents") +async def agents(request: Request, supabase: AsyncSupabaseClient): + try: + api_key = request.headers.get("X-Agentops-Auth") + + sessions, data = await asyncio.gather( + supabase.table("sessions").select("id").eq("api_key", api_key).limit(1).single().execute(), + request.json(), + ) + + session_ids = [session["id"] for session in sessions] + if data["session_id"] not in session_ids: + raise RuntimeError("Invalid API Key for Session") + + logger.debug(data) + + except RuntimeError as e: + message = {"message": f"/agents: Error creating agent: {e}"} + logger.error(message) + return JSONResponse(message, status_code=401) + + try: + agent = { + "id": data["id"], + "session_id": data["session_id"], + "name": data.get("name", None), + "logs": data.get("logs", None), + } + + await supabase.table("agents").upsert(agent).execute() + + logger.info(f"/agents: Completed POST request for {agent['id']}") + return JSONResponse("Success") + except RuntimeError as e: + message = {"message": f"/agents: Error creating agent: {e}"} + logger.error(message) + return JSONResponse(message, status_code=400) + + +@router.post("/threads") +async def threads(request: Request, supabase: AsyncSupabaseClient): + try: + api_key = request.headers.get("X-Agentops-Auth") + + sessions, data = await asyncio.gather( + supabase.table("sessions").select("id").eq("api_key", api_key).limit(1).single().execute(), + request.json(), + ) + + session_ids = [session["id"] for session in sessions] + if data["threads"]["session_id"] not in session_ids: + raise RuntimeError("Invalid API Key for Session") + + logger.debug(data) + + except RuntimeError as e: + message = {"message": f"/threads: Error creating thread: {e}"} + logger.error(message) + return JSONResponse(message, status_code=401) + + try: + thread = { + "id": data["threads"]["id"], + "session_id": data["threads"]["session_id"], + "agent_id": data["threads"].get("agent_id", None), + } + + await supabase.table("threads").upsert(thread).execute() + + logger.info(f"/threads: Completed POST request for {thread['id']}") + return JSONResponse("Success") + except RuntimeError as e: + message = {"message": f"/threads: Error creating agent: {e}"} + logger.error(message) + return JSONResponse(message, status_code=400) + + +@router.post("/events") +async def events(request: Request, supabase: AsyncSupabaseClient): + try: + api_key = request.headers.get("X-Agentops-Auth") + + sessions, data = await asyncio.gather( + supabase.table("sessions").select("id").eq("api_key", api_key).limit(1).single().execute(), + request.json(), + ) + # premium_status = await get_premium_status(supabase, sessions['id']) + premium_status = False + + session_id = data.get("session_id") + session_ids_for_project = [session["id"] for session in sessions] + if session_id not in session_ids_for_project: + raise RuntimeError("Invalid API Key for session") + + except RuntimeError as e: + message = {"message": f"/events: Error posting event: {e}"} + logger.error(message) + return JSONResponse(message, status_code=401) + + except InvalidModelError as e: + message = {"message": f"/events: Invalid model while posting event: {e}"} + return JSONResponse(message, status_code=401) + + try: + actions = [] + llms = [] + tools = [] + errors = [] + additional_cost: Decimal | None = Decimal(0) + additional_events = 0 + additional_prompt_tokens = 0 + additional_completion_tokens = 0 + for event in data.get("events"): + additional_events += 1 + if event["event_type"] == "llms": + llm = await event_handlers.handle_llms(event, premium_status, session_id) + cost = llm.get("cost") + if cost is not None: + additional_cost += Decimal(cost) + additional_prompt_tokens += llm["prompt_tokens"] + additional_completion_tokens += llm["completion_tokens"] + llms.append(llm) + elif event["event_type"] == "tools": + tools.append(await event_handlers.handle_tools(event, session_id)) + # TODO: move into an /errors endpoint? + elif event["event_type"] == "errors": + errors.append(await event_handlers.handle_errors(event, session_id)) + else: + actions.append(await event_handlers.handle_actions(event, session_id)) + + if additional_cost == Decimal(0): + additional_cost = None + + inserts = [] + if len(actions) != 0: + inserts.append(supabase.table("actions").upsert(actions).execute()) + if len(llms) != 0: + inserts.append(supabase.table("llms").upsert(llms).execute()) + if len(tools) != 0: + inserts.append(supabase.table("tools").upsert(tools).execute()) + if len(errors) != 0: + inserts.append(supabase.table("errors").upsert(errors).execute()) + + inserts.append( + update_stats( + supabase=supabase, + session_id=session_id, + cost=additional_cost, + events=additional_events, + prompt_tokens=additional_prompt_tokens, + completion_tokens=additional_completion_tokens, + errors=len(errors), + ) + ) + if inserts: + results = await asyncio.gather(*inserts, return_exceptions=True) + runtime_errors = [result for result in results if isinstance(result, Exception)] + if len(runtime_errors) > 0: + raise RuntimeError(runtime_errors[0]) + + logger.info(f"/events: Completed POST request for {api_key}") + return JSONResponse("Success") + except RuntimeError as e: + message = {"message": f"/events: Error posting event: {e}"} + logger.error(message) + return JSONResponse(message, status_code=400) + + +@router.post("/developer_errors") +async def developer_errors(request: Request, supabase: AsyncSupabaseClient): + try: + data = await request.json() + logger.debug(data) + + developer_error = { + "api_key": request.headers.get("X-Agentops-Auth"), + "session_id": data.get("session_id", None), + "sdk_version": data.get("sdk_version", None), + "type": data.get("type", None), + "message": data.get("message", None), + "stack_trace": data.get("stack_trace", None), + "host_env": data.get("host_env", None), + } + + await supabase.table("developer_errors").upsert(developer_error).execute() + logger.info(f"/developer_errors: Completed POST request for {request.headers.get('X-Agentops-Auth')}") + return JSONResponse("", status_code=204) + except RuntimeError as e: + message = {"message": f"/developer_errors: Error posting developer_error: {e}"} + logger.error(message) + return JSONResponse(message, status_code=400) + + +@router.post("/traces") +async def traces(request: Request, supabase: AsyncSupabaseClient): + """Ingest OpenTelemetry spans""" + try: + api_key = request.headers.get("X-Agentops-Auth") + + sessions, data = await asyncio.gather( + supabase.table("sessions").select("id").eq("api_key", api_key).limit(1).single().execute(), + request.json(), + ) + + session_id = data.get("session_id") + session_ids_for_project = [session["id"] for session in sessions] + if session_id not in session_ids_for_project: + raise RuntimeError("Invalid API Key for session") + + logger.debug(data) + + except RuntimeError as e: + message = {"message": f"/traces: Error processing spans: {e}"} + logger.error(message) + return JSONResponse(message, status_code=401) + + try: + spans_data = [] + for span in data.get("spans", []): + # Classify the span + span_type = await span_handlers.classify_span(span) + + # Route to the appropriate handler + if span_type == span_handlers.SESSION_UPDATE_SPAN: + span_data = await span_handlers.handle_session_update_span(span, session_id) + elif span_type == span_handlers.GEN_AI_SPAN: + span_data = await span_handlers.handle_gen_ai_span(span, session_id) + elif span_type == span_handlers.LOG_SPAN: + span_data = await span_handlers.handle_log_span(span, session_id) + else: + # Default to session update handler + span_data = await span_handlers.handle_session_update_span(span, session_id) + + spans_data.append(span_data) + + # Insert spans into the database + if spans_data: + await supabase.table("spans").upsert(spans_data).execute() + + logger.info(f"/traces: Completed POST request for {api_key}") + return JSONResponse({"status": "success"}) + except RuntimeError as e: + message = {"message": f"/traces: Error processing spans: {e}"} + logger.error(message) + return JSONResponse(message, status_code=400) + + +# @router.get("/openapi.yaml") +# async def openapi_yaml(request: Request): +# with open("openapi-spec.yaml", "r") as f: +# content = f.read() +# return Response(content=content, media_type="text/yaml") diff --git a/app/api/agentops/api/routes/v2.py b/app/api/agentops/api/routes/v2.py new file mode 100644 index 000000000..62cca9f38 --- /dev/null +++ b/app/api/agentops/api/routes/v2.py @@ -0,0 +1,785 @@ +import asyncio +import os +from datetime import datetime, timezone +from decimal import Decimal + +from fastapi import APIRouter, Request +from fastapi.responses import JSONResponse +from termcolor import colored + +from agentops.common.environment import APP_URL +import agentops.api.event_handlers as event_handlers +from agentops.api.db.supabase_client import AsyncSupabaseClient +from agentops.api.exceptions import ExpiredJWTError, InvalidModelError +from agentops.api.log_config import logger +from agentops.api.utils import generate_jwt, update_stats, validate_uuid, verify_jwt + +from agentops.exporter import export + +# Create a router for v2 endpoints +router = APIRouter(prefix="/v2") + +jwt_secret = os.environ["JWT_SECRET_KEY"] +app_url = APP_URL + + +@router.post("/sessions") +async def create_session(request: Request, supabase: AsyncSupabaseClient): + """Create a new session""" + try: + api_key = request.headers.get("X-Agentops-Api-Key") + parent_key = request.headers.get("X-Agentops-Parent-Key") + + validate_uuid(api_key) + tasks = [ + supabase.table("projects").select("*").eq("api_key", api_key).limit(1).single().execute(), + request.json(), + ] + + if parent_key: + tasks.append( + supabase.table("projects").select("*").eq("api_key", parent_key).limit(1).single().execute() + ) + project, data, project_secondary = await asyncio.gather(*tasks) + else: + project, data = await asyncio.gather(*tasks) + project_secondary = None + + logger.debug(data) + + if project is None: + raise RuntimeError("Invalid API Key") + + session = { + "id": data["session"]["session_id"], + "project_id": project["id"], + "init_timestamp": data["session"]["init_timestamp"], + "end_timestamp": data["session"].get("end_timestamp", None), + "tags": data["session"].get("tags", None), + "end_state": data["session"].get("end_state", None), + "end_state_reason": data["session"].get("end_state_reason", None), + "video": data["session"].get("video", None), + "host_env": data["session"].get("host_env", None), + } + + if project_secondary: + session["project_id_secondary"] = project_secondary["id"] + + await supabase.table("sessions").insert(session).execute() + await supabase.table("stats").insert({"session_id": session["id"]}).execute() + await export.create_session(session) + + token = generate_jwt(session["id"], jwt_secret) + logger.info(colored(f"Completed request for {session['id']}", "yellow")) + return JSONResponse( + { + "status": "Success", + "jwt": token, + "session_url": f'{app_url}/drilldown?session_id={data["session"]["session_id"]}', + }, + status_code=200, + ) + except ExpiredJWTError: + logger.warning("Expired JWT") + return JSONResponse({"path": request.url.path, "message": "Expired Token"}, status_code=401) + except RuntimeError as e: + try: + data = await request.json() + logger.error( + f"{request.url.path}: Error creating session with id {data['session']['session_id']}: {e} Data received: {data}" + ) + except Exception as log_error: + logger.error(f"{request.url.path}: Error creating session: {e} Could not read data: {log_error}") + + return JSONResponse( + { + "path": request.url.path, + "message": f"Error creating session: {e}", + }, + status_code=400, + ) + + +@router.post("/reauthorize_jwt") +async def v2_reauthorize_jwt(request: Request, supabase: AsyncSupabaseClient): + try: + api_key = request.headers.get("X-Agentops-Api-Key") + + validate_uuid(api_key) + + tasks = [ + supabase.table("projects").select("id").eq("api_key", api_key).execute(), + request.json(), + ] + project_response, data = await asyncio.gather(*tasks) + + project = project_response.data[0] if project_response.data else None + + if project is None: + raise RuntimeError("Invalid API Key") + + session_response = ( + await supabase.table("sessions").select("project_id").eq("id", data["session_id"]).execute() + ) + session = session_response.data[0] if session_response.data else None + + if session is None: + raise RuntimeError("Invalid Session Id") + + if session["project_id"] != project["id"]: + raise RuntimeError("Invalid Session Id") + + token = generate_jwt(data["session_id"], jwt_secret) + logger.info(colored(f"Completed request for session: {data['session_id']}", "yellow")) + return JSONResponse({"status": "Success", "jwt": token}) + + except RuntimeError as e: + try: + data = await request.json() + logger.error(f"{request.url.path}: Error reauthorizing Api Key: {e} Data received: {data}") + except Exception as log_error: + logger.error( + f"{request.url.path}: Error reauthorizing Api Key: {e} Could not read data: {log_error}" + ) + + return JSONResponse( + { + "path": request.url.path, + "message": f" Error reauthorizing Api Key: {e}", + }, + status_code=400, + ) + + +@router.post("/create_session") +async def v2_create_session(request: Request, supabase: AsyncSupabaseClient): + try: + api_key = request.headers.get("X-Agentops-Api-Key") + parent_key = request.headers.get("X-Agentops-Parent-Key") + + validate_uuid(api_key) + + tasks = [ + supabase.table("projects").select("id").eq("api_key", api_key).execute(), + request.json(), + ] + + if parent_key: + tasks.append(supabase.table("projects").select("id").eq("api_key", parent_key).execute()) + project_response, data, project_secondary_response = await asyncio.gather(*tasks) + project_secondary = ( + project_secondary_response.data[0] if project_secondary_response.data else None + ) + else: + project_response, data = await asyncio.gather(*tasks) + project_secondary = None + + project = project_response.data[0] if project_response.data else None + + logger.debug(data) + + if project is None: + raise RuntimeError("Invalid API Key") + + session = { + "id": data["session"]["session_id"], + "project_id": project["id"], + "init_timestamp": data["session"].get("init_timestamp", None) + or datetime.now(timezone.utc).isoformat(), + "end_timestamp": data["session"].get("end_timestamp", None), + "tags": data["session"].get("tags", None), + "end_state": data["session"].get("end_state", None), + "end_state_reason": data["session"].get("end_state_reason", None), + "video": data["session"].get("video", None), + "host_env": data["session"].get("host_env", None), + } + + if project_secondary: + session["project_id_secondary"] = project_secondary["id"] + + await supabase.table("sessions").insert(session).execute() + await supabase.table("stats").insert({"session_id": session["id"]}).execute() + await export.create_session(session) + + token = generate_jwt(session["id"], jwt_secret) + logger.info(colored(f"Completed request for {session['id']}", "yellow")) + return JSONResponse( + { + "status": "Success", + "jwt": token, + "session_url": f'{app_url}/drilldown?session_id={data["session"]["session_id"]}', + } + ) + except ExpiredJWTError: + logger.warning("Expired JWT") + return JSONResponse({"path": str(request.url.path), "message": "Expired Token"}, status_code=401) + except RuntimeError as e: + try: + data = await request.json() + logger.error( + f"{request.url.path}: Error creating session with id {data['session']['session_id']}: {e} Data received: {data}" + ) + except Exception as log_error: + logger.error(f"{request.url.path}: Error creating session: {e} Could not read data: {log_error}") + + return JSONResponse( + { + "path": str(request.url.path), + "message": f"Error creating session: {e}", + }, + status_code=400, + ) + + +@router.post("/update_session") +async def v2_update_session(request: Request, supabase: AsyncSupabaseClient): + try: + authorization_header = request.headers.get("Authorization") + if authorization_header is None: + raise RuntimeError("Bearer Token is Missing") + + token = authorization_header.split(" ")[1] + session_id = verify_jwt(token, jwt_secret) + data = await request.json() + + logger.debug(data) + + session = { + "id": session_id, + "init_timestamp": data["session"]["init_timestamp"], + "end_timestamp": data["session"].get("end_timestamp", None), + "tags": data["session"].get("tags", None), + "end_state": data["session"].get("end_state", None), + "end_state_reason": data["session"].get("end_state_reason", None), + "video": data["session"].get("video", None), + "host_env": data["session"].get("host_env", None), + } + + await supabase.table("sessions").update(session).eq("id", session_id).execute() + await export.update_session(session) + + cost_response = await supabase.table("stats").select("cost").eq("session_id", session_id).execute() + cost = cost_response.data[0] if cost_response.data else None + + logger.info(colored(f"Completed request for session: {session_id}", "yellow")) + if cost is not None: + return JSONResponse( + { + "status": "success", + "token_cost": cost.get("cost", "0.00") or "0.00", + "session_url": f"{app_url}/drilldown?session_id={session_id}", + } + ) + return JSONResponse({"status": "success"}) + except ExpiredJWTError: + logger.warning("Expired JWT") + return JSONResponse({"path": str(request.url.path), "message": "Expired Token"}, status_code=401) + except RuntimeError as e: + try: + data = await request.json() + logger.error(f"{request.url.path}: Error posting session: {e} Data received: {data}") + except Exception as log_error: + logger.error(f"{request.url.path}: Error posting session: {e} Could not read data: {log_error}") + + return JSONResponse( + { + "path": str(request.url.path), + "message": f"Error posting session: {e}", + }, + status_code=400, + ) + + +@router.post("/create_agent") +async def v2_create_agent(request: Request, supabase: AsyncSupabaseClient): + try: + authorization_header = request.headers.get("Authorization") + if authorization_header is None: + raise RuntimeError("Bearer Token is Missing") + + token = authorization_header.split(" ")[1] + session_id = verify_jwt(token, jwt_secret) + data = await request.json() + + logger.debug(data) + + agent = { + "id": data["id"], + "session_id": session_id, + "name": data.get("name", None), + "logs": data.get("logs", None), + } + + await supabase.table("agents").upsert(agent).execute() + await export.create_agent(agent) + + logger.info( + colored( + f"Completed request request for agent {agent['id']} and session {session_id}", + "yellow", + ) + ) + return JSONResponse("Success") + except ExpiredJWTError: + logger.warning("Expired JWT") + return JSONResponse({"path": request.url.path, "message": "Expired Token"}, status_code=401) + except RuntimeError as e: + try: + data = await request.json() + logger.error(f"{request.url.path}: Error creating agent: {e} Data received: {data}") + except Exception as log_error: + logger.error(f"{request.url.path}: Error creating agent: {e} Could not read data: {log_error}") + + return JSONResponse( + { + "path": request.url.path, + "message": f"Error creating agent: {e}", + }, + status_code=400, + ) + + +@router.post("/create_thread") +async def v2_create_thread(request: Request, supabase: AsyncSupabaseClient): + try: + authorization_header = request.headers.get("Authorization") + if authorization_header is None: + raise RuntimeError("Bearer Token is Missing") + + token = authorization_header.split(" ")[1] + session_id = verify_jwt(token, jwt_secret) + data = await request.json() + + logger.debug(data) + + thread = { + "id": data["id"], + "session_id": session_id, + "agent_id": data.get("agent_id", None), + } + + await supabase.table("threads").upsert(thread).execute() + + logger.info(colored(f"Completed request request for thread: {thread['id']}", "yellow")) + return JSONResponse("Success") + except ExpiredJWTError: + logger.warning("Expired JWT") + return JSONResponse({"path": request.url.path, "message": "Expired Token"}, status_code=401) + except RuntimeError as e: + try: + data = await request.json() + logger.error(f"{request.url.path}: Error creating agent: {e} Data received: {data}") + except Exception as log_error: + logger.error(f"{request.url.path}: Error creating agent: {e} Could not read data: {log_error}") + + return JSONResponse( + { + "path": request.url.path, + "message": f"Error creating agent: {e}", + }, + status_code=400, + ) + + +@router.post("/create_events") +async def v2_create_events(request: Request, supabase: AsyncSupabaseClient): + try: + authorization_header = request.headers.get("Authorization") + if authorization_header is None: + raise RuntimeError("Bearer Token is Missing") + + token = authorization_header.split(" ")[1] + session_id = verify_jwt(token, jwt_secret) + data = await request.json() + + # premium_status = await get_premium_status(supabase, sessions['id']) + premium_status = False + + actions = [] + llms = [] + tools = [] + errors = [] + additional_cost: Decimal | None = Decimal(0) + additional_events = 0 + additional_prompt_tokens = 0 + additional_completion_tokens = 0 + for event in data.get("events"): + additional_events += 1 + if event["event_type"] == "llms": + llm = await event_handlers.handle_llms(event, premium_status, session_id) + cost = llm.get("cost") + if cost is not None: + additional_cost += Decimal(cost) + additional_prompt_tokens += llm["prompt_tokens"] + additional_completion_tokens += llm["completion_tokens"] + llms.append(llm) + elif event["event_type"] == "tools": + tools.append(await event_handlers.handle_tools(event, session_id)) + elif event["event_type"] == "errors": + errors.append(await event_handlers.handle_errors(event, session_id)) + else: + actions.append(await event_handlers.handle_actions(supabase, event, session_id)) + + if additional_cost == Decimal(0): + additional_cost = None + + inserts = [] + if len(actions) != 0: + inserts.append(supabase.table("actions").insert(actions).execute()) + for action in actions: + await export.create_action_event(action) + if len(llms) != 0: + inserts.append(supabase.table("llms").insert(llms).execute()) + for llm in llms: + await export.create_llm_event(llm) + if len(tools) != 0: + inserts.append(supabase.table("tools").insert(tools).execute()) + for tool in tools: + await export.create_tool_event(tool) + if len(errors) != 0: + inserts.append(supabase.table("errors").insert(errors).execute()) + for error in errors: + await export.create_error_event(error) + + inserts.append( + update_stats( + supabase=supabase, + session_id=session_id, + cost=additional_cost, + events=additional_events, + prompt_tokens=additional_prompt_tokens, + completion_tokens=additional_completion_tokens, + errors=len(errors), + ) + ) + + if inserts: + results = await asyncio.gather(*inserts, return_exceptions=True) + runtime_errors = [result for result in results if isinstance(result, Exception)] + if len(runtime_errors) > 0: + raise RuntimeError(runtime_errors[0]) + + logger.info(colored(f"Completed request request for Session: {session_id}", "yellow")) + return JSONResponse("Success") + except ExpiredJWTError: + logger.warning("Expired JWT") + return JSONResponse({"path": request.url.path, "message": "Expired Token"}, status_code=401) + except InvalidModelError as e: + message = { + "path": request.url.path, + "message": f"Invalid model while posting event: {e}", + } + return JSONResponse(message, status_code=401) + except RuntimeError as e: + try: + data = await request.json() + logger.error(f"{request.url.path}: Error posting event: {e} Data received: {data}") + except Exception as log_error: + logger.error(f"{request.url.path}: Error posting event: {e} Could not read data: {log_error}") + + return JSONResponse( + {"path": request.url.path, "message": f"Error posting event: {e}"}, + status_code=400, + ) + + +@router.post("/update_events") +async def v2_update_events(request: Request, supabase: AsyncSupabaseClient): + try: + authorization_header = request.headers.get("Authorization") + if authorization_header is None: + raise RuntimeError("Bearer Token is Missing") + + token = authorization_header.split(" ")[1] + session_id = verify_jwt(token, jwt_secret) + data = await request.json() + + # premium_status = await get_premium_status(supabase, sessions['id']) + premium_status = False + + actions = [] + llms = [] + tools = [] + errors = [] + for event in data.get("events"): + if event["event_type"] == "llms": + llm = await event_handlers.handle_llms(event, premium_status, session_id) + llms.append(llm) + elif event["event_type"] == "tools": + tools.append(await event_handlers.handle_tools(event, session_id)) + elif event["event_type"] == "errors": + errors.append(await event_handlers.handle_errors(event, session_id)) + else: + actions.append(await event_handlers.handle_actions(supabase, event, session_id)) + + inserts = [] + for action in actions: + inserts.append(supabase.table("actions").update(action).eq("id", action.get("id")).execute()) + await export.update_action_event(action) + for llm in llms: + inserts.append(supabase.table("llms").update(llm).eq("id", llm.get("id")).execute()) + await export.update_llm_event(llm) + for tool in tools: + inserts.append(supabase.table("tools").update(tool).eq("id", tool.get("id")).execute()) + await export.update_tool_event(tool) + for error in errors: + inserts.append(supabase.table("errors").update(error).eq("id", error.get("id")).execute()) + await export.update_error_event(error) + + if inserts: + results = await asyncio.gather(*inserts, return_exceptions=True) + runtime_errors = [result for result in results if isinstance(result, RuntimeError)] + if len(runtime_errors) > 0: + raise RuntimeError(runtime_errors) + + logger.info(colored(f"Completed request request for Session: {session_id}", "yellow")) + return JSONResponse("Success") + except ExpiredJWTError: + logger.warning("Expired JWT") + return JSONResponse({"path": request.url.path, "message": "Expired Token"}, status_code=401) + except InvalidModelError as e: + message = { + "path": request.url.path, + "message": f"Invalid model while posting event: {e}", + } + return JSONResponse(message, status_code=401) + except RuntimeError as e: + try: + data = await request.json() + logger.error(f"{request.url.path}: Error posting event: {e} Data received: {data}") + except Exception as log_error: + logger.error(f"{request.url.path}: Error posting event: {e} Could not read data: {log_error}") + + return JSONResponse( + {"path": request.url.path, "message": f"Error posting event: {e}"}, + status_code=400, + ) + + +@router.put("/update_logs") +async def v2_update_logs(request: Request, supabase: AsyncSupabaseClient): + try: + authorization_header = request.headers.get("Authorization") + if authorization_header is None: + raise RuntimeError("Bearer Token is Missing") + + token = authorization_header.split(" ")[1] + session_id = verify_jwt(token, jwt_secret) + data = await request.json() + + if "logs" not in data: + raise RuntimeError("Logs data is missing") + + # Store logs in Supabase Storage + bucket_name = "session-logs" + file_path = f"{session_id}.txt" + + # Get the project_id + session_response = ( + await supabase.table("sessions").select("project_id").eq("id", session_id).execute() + ) + session = session_response.data[0] if session_response.data else None + + if not session: + raise RuntimeError("Session not found") + + project_id = session["project_id"] + + # Create the logs content + logs_content = data["logs"] + + # Append to existing logs in Supabase Storage + storage_client = supabase.storage.from_(bucket_name) + + # Check if file exists + try: + existing_file = await storage_client.download(f"{project_id}/{file_path}") + existing_content = existing_file.decode("utf-8") + new_content = existing_content + logs_content + except: + # File doesn't exist yet + new_content = logs_content + + # Upload the file + await storage_client.upload(f"{project_id}/{file_path}", new_content.encode("utf-8")) + + # Get the public URL + public_url = storage_client.get_public_url(f"{project_id}/{file_path}") + + # Update the session with the logs URL + await supabase.table("sessions").update({"logs_url": public_url}).eq("id", session_id).execute() + + logger.info(colored(f"Completed logs update for session: {session_id}", "yellow")) + return JSONResponse({"status": "success", "logs_url": public_url}) + + except ExpiredJWTError: + logger.warning("Expired JWT") + return JSONResponse({"path": request.url.path, "message": "Expired Token"}, status_code=401) + except RuntimeError as e: + try: + data = await request.json() + logger.error(f"{request.url.path}: Error updating logs: {e} Data received: {data}") + except Exception as log_error: + logger.error(f"{request.url.path}: Error updating logs: {e} Could not read data: {log_error}") + + return JSONResponse( + { + "path": request.url.path, + "message": f"Error updating logs: {e}", + }, + status_code=400, + ) + + +@router.get("/ttd/{ttd_id}") +async def v2_get_ttd(ttd_id: str, request: Request, supabase: AsyncSupabaseClient): + try: + ttds_response = await supabase.table("ttd").select("*").eq("ttd_id", ttd_id).execute() + return JSONResponse(ttds_response.data) + except RuntimeError as e: + logger.error(f"Error getting ttd: {e}") + return JSONResponse( + {"path": request.url.path, "message": f"Error getting ttd: {e}"}, + status_code=400, + ) + + +@router.post("/developer_errors") +async def v2_developer_errors(request: Request, supabase: AsyncSupabaseClient): + try: + data = await request.json() + logger.debug(data) + + developer_error = { + "api_key": request.headers.get("X-Agentops-Api-Key"), + "sdk_version": data.get("sdk_version", None), + "type": data.get("type", None), + "message": data.get("message", None), + "stack_trace": data.get("stack_trace", None), + "host_env": data.get("host_env", None), + } + + await supabase.table("developer_errors").insert(developer_error).execute() + logger.info( + colored( + f"Completed request request for API Key: {request.headers.get('X-Agentops-Api-Key')}", + "yellow", + ) + ) + return JSONResponse("", status_code=204) + except RuntimeError as e: + try: + data = await request.json() + logger.error(f"{request.url.path}: Error posting developer_error: {e} Data received: {data}") + except Exception as log_error: + logger.error( + f"{request.url.path}: Error posting developer_error: {e} Could not read data: {log_error}" + ) + + return JSONResponse( + { + "path": request.url.path, + "message": f"Error posting developer_error: {e}", + }, + status_code=400, + ) + + +@router.get("/sessions/{session_id}/stats") +async def v2_get_session_stats(session_id: str, request: Request, supabase: AsyncSupabaseClient): + try: + api_key = request.headers.get("X-Agentops-Api-Key") + if api_key is None: + raise RuntimeError("API Key is Missing") + + validate_uuid(api_key) + + # Get project ID from API key + project_response = await supabase.table("projects").select("id").eq("api_key", api_key).execute() + project = project_response.data[0] if project_response.data else None + + if not project: + raise RuntimeError("Invalid API Key") + + # Check if session belongs to this project + session_response = ( + await supabase.table("sessions") + .select("id") + .eq("id", session_id) + .eq("project_id", project["id"]) + .execute() + ) + if not session_response.data: + raise RuntimeError("Session does not belong to this project") + + stats_response = await supabase.table("stats").select("*").eq("session_id", session_id).execute() + stats = ( + stats_response.data[0] + if stats_response.data + else { + "events": 0, + "cost": "0.00", + "prompt_tokens": 0, + "completion_tokens": 0, + "errors": 0, + } + ) + + return JSONResponse(stats) + + except RuntimeError as e: + logger.error(f"Error getting session stats: {e}") + return JSONResponse({"path": request.url.path, "message": str(e)}, status_code=400) + + +@router.get("/sessions/{session_id}/export") +async def v2_export_session(session_id: str, request: Request, supabase: AsyncSupabaseClient): + try: + api_key = request.headers.get("X-Agentops-Api-Key") + if api_key is None: + raise RuntimeError("API Key is Missing") + + validate_uuid(api_key) + + # Get project ID from API key + project_response = await supabase.table("projects").select("id").eq("api_key", api_key).execute() + project = project_response.data[0] if project_response.data else None + + if not project: + raise RuntimeError("Invalid API Key") + + # Check if session belongs to this project + session_response = ( + await supabase.table("sessions") + .select("id") + .eq("id", session_id) + .eq("project_id", project["id"]) + .execute() + ) + if not session_response.data: + raise RuntimeError("Session does not belong to this project") + + session_response = await supabase.table("sessions").select("*").eq("id", session_id).execute() + actions_response = await supabase.table("actions").select("*").eq("session_id", session_id).execute() + llms_response = await supabase.table("llms").select("*").eq("session_id", session_id).execute() + tools_response = await supabase.table("tools").select("*").eq("session_id", session_id).execute() + errors_response = await supabase.table("errors").select("*").eq("session_id", session_id).execute() + + export_data = { + "session": session_response.data[0] if session_response.data else None, + "actions": actions_response.data, + "llms": llms_response.data, + "tools": tools_response.data, + "errors": errors_response.data, + } + + return JSONResponse(export_data) + + except RuntimeError as e: + logger.error(f"Error exporting session data: {e}") + return JSONResponse({"path": request.url.path, "message": str(e)}, status_code=400) + + +@router.get("/openapi.yaml") +async def v2_openapi_yaml(request: Request): + return JSONResponse(await request.send_file("openapi-spec-v2.yaml")) diff --git a/app/api/agentops/api/routes/v3.py b/app/api/agentops/api/routes/v3.py new file mode 100644 index 000000000..f515f8c7e --- /dev/null +++ b/app/api/agentops/api/routes/v3.py @@ -0,0 +1,123 @@ +from datetime import datetime +from uuid import UUID +import pydantic + +from fastapi import APIRouter, Depends, Request, HTTPException +from fastapi.responses import JSONResponse + +from agentops.common.orm import get_orm_session, Session +from agentops.opsboard.models import ProjectModel +from agentops.api.auth import JWTPayload, generate_jwt, get_jwt_token +from agentops.api.exceptions import InvalidAPIKeyError +from agentops.api.log_config import logger + +""" +Provides authentication functionality for obtaining JWT tokens. + +This is used by the SDK to transform an API key into a JWT token so that it can +rite data to the correct project. + +Routes: +- POST /v3/auth/token - Authenticate and issue JWT token +- GET /v3/auth/token - Verify and return JWT token information +""" + + +router = APIRouter(prefix="/v3") + + +class TokenSchema(pydantic.BaseModel): + api_key: str + + +class TokenResponse(pydantic.BaseModel): + token: str + project_id: str + project_prem_status: str + + @pydantic.field_validator("project_id", "token", mode="before") + @classmethod + def format_uuid(cls, v): + """Convert UUID to string format.""" + if isinstance(v, str): + return v + return str(v) + + +class VerifyTokenResponse(pydantic.BaseModel): + message: str + payload: dict + expires_at: str + + @pydantic.field_validator("expires_at", mode="before") + @classmethod + def format_datetime(cls, v): + """Convert a timestamp to ISO str format.""" + return datetime.fromtimestamp(v).isoformat() + + @pydantic.field_validator("payload", mode="before") + @classmethod + def format_payload(cls, v): + """Convert the payload to a dictionary format.""" + assert isinstance(v, JWTPayload) + return v.asdict() + + +@router.post("/auth/token") +async def get_token( + request: Request, + body: TokenSchema, + orm: Session = Depends(get_orm_session), +) -> TokenResponse: + """Authenticate and issue JWT token""" + try: + api_key = UUID(body.api_key) # raises ValueError + project = ProjectModel.get_by_api_key(orm, api_key) + + if not project: + raise InvalidAPIKeyError(403, "Invalid API key") + + return TokenResponse( + token=generate_jwt(project), + project_id=project.id, + project_prem_status=project.org.prem_status.value, + ) + + except ValueError as e: + # api_key is not a valid UUID + logger.warning(f"Invalid API key format: {str(e)}") + return JSONResponse({"error": "Invalid API key format"}, status_code=400) + except InvalidAPIKeyError as e: + # project not found for the given api_key + logger.warning(f"Invalid API key: {str(e)}") + return JSONResponse({"error": str(e)}, status_code=e.code) + except Exception as e: + logger.error(f"Error authenticating: {str(e)}") + return JSONResponse({"error": "Authentication failed"}, status_code=500) + + +@router.get("/auth/token") +async def verify_token( + request: Request, + orm: Session = Depends(get_orm_session), + jwt_payload: JWTPayload = Depends(get_jwt_token), +) -> VerifyTokenResponse: + """ + Verify and return JWT token information + + This endpoint verifies the JWT token in the Authorization header + and returns the token payload if valid. + """ + project: ProjectModel = ProjectModel.get_by_id(orm, jwt_payload.project_id) + + # if a user has upgraded or downgraded their plan, we need to reauthorize + # the token to use the new plan. the SDK will call acquire a new auth token + # when it sees a 401 response code. + if project.org.prem_status.value != jwt_payload.project_prem_status: + raise HTTPException(status_code=401, detail="Reauthorized to use new plan") + + return VerifyTokenResponse( + message="JWT token is valid", + payload=jwt_payload, + expires_at=jwt_payload.exp, + ) diff --git a/app/api/agentops/api/routes/v4/__init__.py b/app/api/agentops/api/routes/v4/__init__.py new file mode 100644 index 000000000..d23440e96 --- /dev/null +++ b/app/api/agentops/api/routes/v4/__init__.py @@ -0,0 +1,66 @@ +from fastapi import APIRouter + +from agentops.common.route_config import RouteConfig, register_routes +from agentops.auth.middleware import AuthenticatedRoute + +from .metrics.views import ProjectMetricsView +from .traces.views import TraceListView, TraceDetailView +from .logs import LogsUploadView, get_trace_logs +from .objects import ObjectUploadView + +from agentops.api.routes.v4.stripe_webhooks import router as stripe_webhooks_router + +__all__ = ["router"] + + +router = APIRouter(prefix="/v4") + + +route_config: list[RouteConfig] = [ + # Metrics + RouteConfig( + name='get_project_metrics', + path="/meterics/project/{project_id}", + endpoint=ProjectMetricsView, + methods=["GET"], + ), + # Traces + RouteConfig( + name='get_project_traces', + path="/traces/list/{project_id}", + endpoint=TraceListView, + methods=["GET"], + ), + RouteConfig( + name='get_trace', + path="/traces/detail/{trace_id}", + endpoint=TraceDetailView, + methods=["GET"], + ), + # Objects + RouteConfig( + name='upload_object', + path="/objects/upload/", + endpoint=ObjectUploadView, + methods=["POST"], + ), + # Logs + RouteConfig( + name='upload_logs', + path="/logs/upload/", + endpoint=LogsUploadView, + methods=["POST"], + ), + RouteConfig( + name='get_trace_logs', + path="/logs/{trace_id}", + endpoint=get_trace_logs, + methods=["GET"], + ), +] + +api_router = APIRouter(route_class=AuthenticatedRoute) +register_routes(api_router, route_config, prefix="/v4") +router.include_router(api_router) + +router.include_router(stripe_webhooks_router) diff --git a/app/api/agentops/api/routes/v4/exceptions.py b/app/api/agentops/api/routes/v4/exceptions.py new file mode 100644 index 000000000..975542910 --- /dev/null +++ b/app/api/agentops/api/routes/v4/exceptions.py @@ -0,0 +1,21 @@ +"""Custom Exceptions for the v4 endpoints""" + +from typing import Optional + + +class InvalidParameterError(Exception): + """Exception raised for invalid parameter values.""" + + def __init__(self, param_name: str, message: str): + self.param_name = param_name + self.message = message + super().__init__(f"Invalid parameter '{param_name}': {message}") + + +class DatabaseError(Exception): + """Exception raised for database-related errors.""" + + def __init__(self, message: str, query: Optional[str] = None): + self.message = message + self.query = query + super().__init__(f"Database error: {message}") diff --git a/app/api/agentops/api/routes/v4/logs.py b/app/api/agentops/api/routes/v4/logs.py new file mode 100644 index 000000000..42b0c5ed4 --- /dev/null +++ b/app/api/agentops/api/routes/v4/logs.py @@ -0,0 +1,125 @@ +""" +API for receiving log files from the AgentOps SDK. + +Authorized by JWT. +Accept a body of content to store. +Returns the public URL where the data can be accessed. + +Uses Supabase Bucket storage (via the AWS S3 interface). +""" + +import re +from fastapi import Depends, HTTPException, Request, status + +from agentops.common.environment import APP_URL, FREEPLAN_LOGS_LINE_LIMIT +from agentops.common.views import add_cors_headers +from agentops.common.orm import Session, get_orm_session +from agentops.common.freeplan import FreePlanFilteredResponse +from agentops.auth.views import public_route +from agentops.opsboard.models import ProjectModel +from agentops.api.environment import SUPABASE_S3_LOGS_BUCKET +from agentops.api.storage import get_s3_client +from agentops.api.storage import BaseObjectUploadView +from agentops.api.models.traces import TraceModel + + +@public_route +class LogsUploadView(BaseObjectUploadView): + bucket_name: str = SUPABASE_S3_LOGS_BUCKET + + @property + def filename(self) -> str: + """Generate a unique filename for the object""" + trace_id = self.request.headers.get("Trace-Id") + + if not trace_id: + raise HTTPException( + status_code=status.HTTP_400_BAD_REQUEST, + detail="No trace ID provided", + ) + + # only allow alphanumeric characters, underscores, dashes, and dots + if re.search(r"[^a-zA-Z0-9_.-]", trace_id): + raise HTTPException( + status_code=status.HTTP_400_BAD_REQUEST, + detail="Trace ID contains invalid characters", + ) + + return f'{trace_id}.log' + + +class LogContentResponse(FreePlanFilteredResponse): + _freeplan_maxlines = { + "content": FREEPLAN_LOGS_LINE_LIMIT, + } + + content: str + trace_id: str + + +def convert_trace_id(trace_id: str) -> str: + """Convert hex trace_id to int if in hex format (contains at least one letter a-f).""" + try: + # Only convert if string contains hex letters and is valid hex + if any(c in 'abcdefABCDEF' for c in trace_id) and all( + c in '0123456789abcdefABCDEF' for c in trace_id + ): + return str(int(trace_id, 16)) + return trace_id + except ValueError: + return trace_id + + +@add_cors_headers( + origins=[APP_URL], + methods=["GET", "OPTIONS"], +) +async def get_trace_logs( + *, + request: Request, + orm: Session = Depends(get_orm_session), + trace_id: str, +) -> LogContentResponse: + """ + Retrieve logs for a specific trace ID. + Verifies that the user has access to the trace before returning the logs. + """ + trace_id_int = convert_trace_id(trace_id) + + trace = await TraceModel.select( + filters={ + "trace_id": trace_id, + } + ) + if not trace.spans: # trace does not exist + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="You do not have access to this trace", + ) + + project = ProjectModel.get_by_id(orm, trace.project_id) + if not project or not project.org.is_user_member(request.state.session.user_id): + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="You do not have access to this trace", + ) + + try: + s3_client = get_s3_client() + response = s3_client.get_object( + Bucket=SUPABASE_S3_LOGS_BUCKET, + Key=f"{trace_id_int}.log", + ) + content = response['Body'].read().decode('utf-8') + + return LogContentResponse( + content=content, + trace_id=trace_id, + freeplan_truncated=project.is_freeplan, + ) + + except s3_client.exceptions.NoSuchKey: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail=f"No logs found for trace ID: {trace_id}", + ) diff --git a/app/api/agentops/api/routes/v4/metrics/__init__.py b/app/api/agentops/api/routes/v4/metrics/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/api/agentops/api/routes/v4/metrics/responses.py b/app/api/agentops/api/routes/v4/metrics/responses.py new file mode 100644 index 000000000..21ca11002 --- /dev/null +++ b/app/api/agentops/api/routes/v4/metrics/responses.py @@ -0,0 +1,95 @@ +from typing import Optional, Any +from decimal import Decimal +from datetime import datetime, date +from uuid import UUID +import pydantic + + +class SpanCount(pydantic.BaseModel): + total: int + success: int + fail: int + unknown: int + indeterminate: int + + +class TotalTokens(pydantic.BaseModel): + all: int + success: int + fail: int + + +class AverageTokens(pydantic.BaseModel): + all: float + success: float + fail: float + + @pydantic.field_validator('all', 'success', 'fail', mode='before') + @classmethod + def round_float(cls, v: float) -> float: + """Round all values to 2 decimal places.""" + return round(v, 2) + + +class TokenMetrics(pydantic.BaseModel): + total_cost: str + average_cost_per_session: str + prompt_tokens: int + completion_tokens: int + total_tokens: TotalTokens + avg_tokens: AverageTokens + + @pydantic.field_validator('total_cost', 'average_cost_per_session', mode='before') + @classmethod + def format_cost(cls, v: Decimal) -> str: + """Ensure the cost is formatted as a string with 5 decimal places.""" + return f"{float(v):.5f}" + + +class DurationMetrics(pydantic.BaseModel): + min_duration_ns: Optional[int] = None + max_duration_ns: Optional[int] = None + avg_duration_ns: int + total_duration_ns: Optional[int] = None + trace_durations: list[Any] + + +class ProjectMetricsResponse(pydantic.BaseModel): + project_id: str + trace_count: int + span_count: SpanCount + token_metrics: TokenMetrics + duration_metrics: DurationMetrics + success_datetime: list[str] + fail_datetime: list[str] + indeterminate_datetime: list[str] + spans_per_trace: dict[int, int] + trace_durations: list[int] + trace_cost_dates: dict[str, float] + start_time: str + end_time: str + freeplan_truncated: bool = False + + @pydantic.field_validator('project_id', mode='before') + @classmethod + def format_uuid(cls, v: UUID) -> str: + """Ensure the project_id is formatted as a string.""" + return str(v) + + @pydantic.field_validator('trace_cost_dates', mode='before') + @classmethod + def format_date_keys_float_values(cls, v: dict[date, Decimal]) -> dict[str, float]: + """Ensure the trace_cost_dates are able to be serialized properly.""" + return {date.isoformat(): float(cost) for date, cost in v.items()} + + @pydantic.field_validator('success_datetime', 'fail_datetime', 'indeterminate_datetime', mode='before') + @classmethod + def format_datetime_list(cls, v: list[datetime]) -> list[str]: + """Ensure the datetime lists are formatted as ISO strings.""" + return [d.isoformat() for d in v] + + @pydantic.field_validator('start_time', 'end_time', mode='before') + @classmethod + def format_datetime(cls, v: datetime) -> str: + """Ensure the start_time and end_time are formatted as ISO strings.""" + return v.isoformat() diff --git a/app/api/agentops/api/routes/v4/metrics/views.py b/app/api/agentops/api/routes/v4/metrics/views.py new file mode 100644 index 000000000..fd3875fcb --- /dev/null +++ b/app/api/agentops/api/routes/v4/metrics/views.py @@ -0,0 +1,217 @@ +from typing import Optional +from datetime import datetime +from uuid import UUID +from fastapi import Depends, Query, HTTPException +import hashlib + +from agentops.common.environment import APP_URL, FREEPLAN_METRICS_DAYS_CUTOFF +from agentops.common.route_config import BaseView +from agentops.common.views import add_cors_headers +from agentops.common.orm import get_orm_session, Session +from agentops.common.freeplan import freeplan_clamp_start_time, freeplan_clamp_end_time + +from agentops.opsboard.models import ProjectModel +from agentops.api.models.metrics import ProjectMetricsModel + +from .responses import ( + ProjectMetricsResponse, + SpanCount, + TotalTokens, + AverageTokens, + TokenMetrics, + DurationMetrics, +) + + +# Simple in-memory cache with TTL +from time import time + + +class MetricsCache: + def __init__(self, ttl_seconds: int = 300): # 5 minute default TTL + self._cache = {} + self._ttl = ttl_seconds + + def _make_key(self, project_id: str, start_time: Optional[datetime], end_time: Optional[datetime]) -> str: + """Create a cache key from parameters""" + key_parts = [ + project_id, + start_time.isoformat() if start_time else "none", + end_time.isoformat() if end_time else "none", + ] + key_str = "|".join(key_parts) + return hashlib.md5(key_str.encode()).hexdigest() + + def get(self, project_id: str, start_time: Optional[datetime], end_time: Optional[datetime]): + """Get cached value if not expired""" + key = self._make_key(project_id, start_time, end_time) + if key in self._cache: + cached_data, cached_time = self._cache[key] + if time() - cached_time < self._ttl: + return cached_data + else: + # Expired, remove from cache + del self._cache[key] + return None + + def set(self, project_id: str, start_time: Optional[datetime], end_time: Optional[datetime], data): + """Set cache value with current timestamp""" + key = self._make_key(project_id, start_time, end_time) + self._cache[key] = (data, time()) + + # Simple cleanup - remove old entries if cache gets too large + if len(self._cache) > 1000: + # Remove oldest 100 entries + sorted_items = sorted(self._cache.items(), key=lambda x: x[1][1]) + for key, _ in sorted_items[:100]: + del self._cache[key] + + +# Global cache instance +metrics_cache = MetricsCache(ttl_seconds=300) # 5 minute cache + + +class ProjectMetricsView(BaseView): + """ + View class for handling the project metrics endpoint. This class encapsulates + the logic for retrieving and formatting project metrics data. + """ + + orm: Session + project: ProjectModel + freeplan_truncated: bool = False + + @add_cors_headers( + origins=[APP_URL], + methods=["GET", "OPTIONS"], + ) + async def __call__( + self, + *, + orm: Session = Depends(get_orm_session), + project_id: str, + start_time: Optional[datetime] = Query( + None, + description="Filter by start time (ISO 8601 format, e.g., '2023-01-01T00:00:00Z')", + ), + end_time: Optional[datetime] = Query( + None, + description="Filter by end time (ISO 8601 format, e.g., '2023-01-01T00:00:00Z')", + ), + ) -> ProjectMetricsResponse: + """ + Callable method to handle the request and return a JSONResponse. This method + validates the input parameters, retrieves the metrics data, formats the + response and converts exceptions to responses. + """ + self.orm = orm + self.project = await self.get_project(project_id) + + # Normalize time parameters for caching + normalized_start = self.get_start_time(start_time) + normalized_end = self.get_end_time(end_time) + + # Check cache first + cached_response = metrics_cache.get(project_id, normalized_start, normalized_end) + if cached_response is not None: + # Return cached response with freeplan_truncated flag + cached_response.freeplan_truncated = self.freeplan_truncated + return cached_response + + metrics = await ProjectMetricsModel.select( + filters={ + 'project_id': self.project.id, + 'start_time': normalized_start, + 'end_time': normalized_end, + } + ) + + # TODO handle empty response + response = await self.get_response(metrics) + + # Cache the response + metrics_cache.set(project_id, normalized_start, normalized_end, response) + + return response + + def get_start_time(self, start_time: Optional[datetime]) -> Optional[datetime]: + """Validates and formats the start_time parameter with freeplan handling.""" + if self.project.is_freeplan: + start_time, modified = freeplan_clamp_start_time(start_time, FREEPLAN_METRICS_DAYS_CUTOFF) + self.freeplan_truncated |= modified + + return start_time + + def get_end_time(self, end_time: Optional[datetime]) -> Optional[datetime]: + """Validates and formats the end_time parameter with freeplan handling.""" + if self.project.is_freeplan: + end_time, modified = freeplan_clamp_end_time(end_time, FREEPLAN_METRICS_DAYS_CUTOFF) + self.freeplan_truncated |= modified + + return end_time + + async def get_project(self, project_id: str | UUID) -> ProjectModel: + project = ProjectModel.get_by_id(self.orm, project_id) + + if not project or not project.org.is_user_member(self.request.state.session.user_id): + raise HTTPException(status_code=404, detail="Project not found") + + return project + + async def get_response(self, metrics: ProjectMetricsModel) -> ProjectMetricsResponse: + """ + Loads an aggregated collection of trace metrics data for a given project. + + `ProjectMetricsModel` handles retrieving and aggregating the data from the + databases, as well as performing calculations and normalizing the data + (normalizing meaning it will always return the expected types). + + The response types format the data in a suitable format for the frontend + and handle all serialization. + """ + + return ProjectMetricsResponse( + project_id=self.project.id, + trace_count=metrics.duration.trace_count, + start_time=metrics.duration.start_time, + end_time=metrics.duration.end_time, + span_count=SpanCount( + total=metrics.span_count, + success=metrics.success_count, + fail=metrics.fail_count, + unknown=metrics.indeterminate_count, + indeterminate=metrics.indeterminate_count, + ), + token_metrics=TokenMetrics( + total_cost=metrics.total_cost, + average_cost_per_session=metrics.average_cost_per_trace, + prompt_tokens=metrics.prompt_tokens, + completion_tokens=metrics.completion_tokens, + cache_read_input_tokens=metrics.cache_read_input_tokens, + reasoning_tokens=metrics.reasoning_tokens, + total_tokens=TotalTokens( + all=metrics.total_tokens, + success=metrics.success_tokens, + fail=metrics.fail_tokens, + ), + avg_tokens=AverageTokens( + all=metrics.avg_tokens, + success=metrics.avg_success_tokens, + fail=metrics.avg_fail_tokens, + ), + ), + duration_metrics=DurationMetrics( + min_duration_ns=metrics.duration.min_duration, + max_duration_ns=metrics.duration.max_duration, + avg_duration_ns=metrics.duration.avg_duration, + total_duration_ns=metrics.duration.total_duration, + trace_durations=[td.trace_duration for td in metrics.trace_durations], + ), + success_datetime=metrics.success_dates, + fail_datetime=metrics.fail_dates, + indeterminate_datetime=metrics.indeterminate_dates, + trace_durations=[td.trace_duration for td in metrics.trace_durations], + spans_per_trace=metrics.spans_per_trace, + trace_cost_dates=metrics.trace_cost_dates, + freeplan_truncated=self.freeplan_truncated, + ) diff --git a/app/api/agentops/api/routes/v4/objects.py b/app/api/agentops/api/routes/v4/objects.py new file mode 100644 index 000000000..71e542a60 --- /dev/null +++ b/app/api/agentops/api/routes/v4/objects.py @@ -0,0 +1,27 @@ +""" +API for storing object data. + +Authorized by JWT. +Accept a body of content to store. +Returns the public URL where the data can be accessed. + +Uses Supabase Bucket storage (via the AWS S3 interface). +""" + +import uuid + +from agentops.api.environment import SUPABASE_S3_BUCKET +from agentops.api.storage import BaseObjectUploadView +from agentops.auth.views import public_route + + +@public_route +class ObjectUploadView(BaseObjectUploadView): + bucket_name: str = SUPABASE_S3_BUCKET + + @property + def filename(self) -> str: + """Generate a unique filename for the object""" + if not hasattr(self, '_filename'): + self._filename = f"{self.token['project_id']}/{uuid.uuid4().hex}" + return self._filename diff --git a/app/api/agentops/api/routes/v4/stripe_webhooks.py b/app/api/agentops/api/routes/v4/stripe_webhooks.py new file mode 100644 index 000000000..7865420af --- /dev/null +++ b/app/api/agentops/api/routes/v4/stripe_webhooks.py @@ -0,0 +1,1026 @@ +import stripe +from fastapi import APIRouter, Request, HTTPException, Depends, Header +from sqlalchemy.orm import Session +from sqlalchemy import case +from datetime import datetime, timedelta, timezone +import logging +from typing import Dict, Any + +from agentops.api.environment import STRIPE_WEBHOOK_SECRET, STRIPE_SUBSCRIPTION_PRICE_ID +from agentops.common.orm import get_orm_session +from agentops.opsboard.models import ( + OrgModel, + PremStatus, + UserOrgModel, + OrgRoles, + WebhookEvent, + BillingPeriod, + BillingAuditLog, +) +from agentops.opsboard.services.billing_service import billing_service + +router = APIRouter() +logger = logging.getLogger(__name__) + + +async def sync_org_licenses( + org: OrgModel, seat_quantity: int, orm: Session, event_id: str = None +) -> Dict[str, list]: + """ + Sync organization member licenses based on seat quantity. + Returns dict with 'newly_licensed' and 'newly_unlicensed' lists. + """ + # Get all org members ordered by role priority + members = ( + orm.query(UserOrgModel) + .filter(UserOrgModel.org_id == org.id) + .order_by( + # Order by role: owner=1, admin=2, developer=3 + case( + (UserOrgModel.role == OrgRoles.owner, 1), + (UserOrgModel.role == OrgRoles.admin, 2), + else_=3, + ), + UserOrgModel.user_id, # Secondary sort by user_id for consistency + ) + .all() + ) + + # Track changes for logging + newly_licensed = [] + newly_unlicensed = [] + + # Update license status based on seat quantity + for i, member in enumerate(members): + should_be_paid = i < seat_quantity + + if member.is_paid != should_be_paid: + if should_be_paid: + newly_licensed.append(member.user_email or str(member.user_id)) + else: + newly_unlicensed.append(member.user_email or str(member.user_id)) + + member.is_paid = should_be_paid + + # Add audit log for the sync action + if newly_licensed or newly_unlicensed: + # Find the org owner to use as the user_id for this system action + owner_membership = ( + orm.query(UserOrgModel) + .filter(UserOrgModel.org_id == org.id, UserOrgModel.role == OrgRoles.owner) + .first() + ) + system_user_id = owner_membership.user_id if owner_membership else None + + if system_user_id: + audit_log = BillingAuditLog( + org_id=org.id, + user_id=system_user_id, # Use org owner's ID for system actions + action='licenses_synced_by_webhook', + details={ + 'event_id': event_id, + 'seat_quantity': seat_quantity, + 'newly_licensed': newly_licensed, + 'newly_unlicensed': newly_unlicensed, + 'system_action': True, # Flag to indicate this was a system action + }, + ) + orm.add(audit_log) + + return { + 'newly_licensed': newly_licensed, + 'newly_unlicensed': newly_unlicensed, + 'total_members': len(members), + } + + +async def is_event_processed(event_id: str, orm: Session) -> bool: + """Check if we've already processed this webhook event.""" + return orm.query(WebhookEvent).filter(WebhookEvent.event_id == event_id).count() > 0 + + +async def mark_event_processed(event_id: str, orm: Session): + """Mark an event as processed.""" + webhook_event = WebhookEvent(event_id=event_id) + orm.add(webhook_event) + orm.commit() + + +def log_webhook_metric(event_type: str, status: str, metadata: Dict[str, Any] = None): + """Log structured metrics for webhook processing for anomaly detection""" + log_data = { + "metric_type": "WEBHOOK_METRIC", + "webhook_provider": "stripe", + "event_type": event_type, + "status": status, + "timestamp": datetime.utcnow().isoformat(), + **(metadata or {}), + } + logger.info(f"WEBHOOK_METRIC: {log_data}") + + +@router.post("/stripe-webhook", include_in_schema=False) +async def stripe_webhook( + request: Request, + stripe_signature: str = Header(None), + orm: Session = Depends(get_orm_session), +): + """ + Handle incoming Stripe webhooks. + Find our webhooks here: + https://dashboard.stripe.com/test/webhooks + https://dashboard.stripe.com/webhooks + """ + if not STRIPE_WEBHOOK_SECRET: + logger.error( + "āœ— CRITICAL: STRIPE_WEBHOOK_SECRET is not configured - Cannot verify webhook signatures!" + ) + logger.error("This means webhook events from Stripe cannot be validated and will be rejected.") + logger.error("Set the STRIPE_WEBHOOK_SECRET environment variable to fix this issue.") + log_webhook_metric("unknown", "config_error", {"error": "missing_webhook_secret"}) + raise HTTPException(status_code=500, detail="Webhook secret not configured") + + # Log webhook secret status (masked) for debugging + masked_secret = ( + f"{STRIPE_WEBHOOK_SECRET[:8]}..." if len(STRIPE_WEBHOOK_SECRET) > 8 else STRIPE_WEBHOOK_SECRET + ) + logger.debug(f"āœ“ Using webhook secret: {masked_secret}") + + # Also log if STRIPE_SUBSCRIPTION_PRICE_ID is missing (needed for subscription validation) + if not STRIPE_SUBSCRIPTION_PRICE_ID: + logger.warning("āœ— STRIPE_SUBSCRIPTION_PRICE_ID not configured - Subscription validation may fail") + + if not stripe_signature: + logger.error("Missing Stripe-Signature header.") + log_webhook_metric("unknown", "missing_signature") + raise HTTPException(status_code=400, detail="Missing Stripe-Signature header") + + try: + payload = await request.body() + event = stripe.Webhook.construct_event(payload, stripe_signature, STRIPE_WEBHOOK_SECRET) + except ValueError as e: # Invalid payload + logger.error(f"Invalid webhook payload: {e}") + log_webhook_metric("unknown", "invalid_payload", {"error": str(e)}) + raise HTTPException(status_code=400, detail=f"Invalid payload: {e}") + except stripe.error.SignatureVerificationError as e: + logger.error(f"Invalid webhook signature: {e}") + log_webhook_metric("unknown", "invalid_signature", {"error": str(e)}) + raise HTTPException(status_code=400, detail=f"Invalid signature: {e}") + except Exception as e: + logger.error(f"Could not construct webhook event: {e}") + log_webhook_metric("unknown", "construction_error", {"error": str(e), "error_type": type(e).__name__}) + raise HTTPException(status_code=500, detail=f"Could not construct event: {e}") + + log_webhook_metric(event.type, "received", {"event_id": event.id}) + + try: + if event.type == "checkout.session.completed": + await handle_checkout_completed(event, orm) + elif event.type == "customer.subscription.updated": + await handle_subscription_updated(event, orm) + elif event.type == "customer.subscription.deleted": + await handle_subscription_deleted(event, orm) + elif event.type == "invoice.payment_failed": + await handle_payment_failed(event, orm) + elif event.type == "charge.refunded": + await handle_charge_refunded(event, orm) + elif event.type == "invoice.created": + await handle_invoice_created(event, orm) + elif event.type == "invoice.payment_succeeded": + await handle_invoice_payment_succeeded(event, orm) + else: + logger.debug(f"Received unhandled event type: {event.type}") + log_webhook_metric(event.type, "unhandled") + + log_webhook_metric(event.type, "processed", {"event_id": event.id}) + + except Exception as e: + logger.error(f"Error processing webhook {event.type}: {e}") + log_webhook_metric( + event.type, + "processing_error", + {"error": str(e), "error_type": type(e).__name__, "event_id": event.id}, + ) + + return {"status": "success"} + + +async def handle_checkout_completed(event, orm: Session): + """Handle successful checkout completion.""" + if await is_event_processed(event.id, orm): + logger.info(f"Event {event.id} already processed, skipping") + return {"status": "already_processed"} + + checkout_session = event.data.object + subscription_id = checkout_session.get("subscription") + client_reference_id = checkout_session.get("client_reference_id") + session_id = checkout_session.get("id") + metadata = checkout_session.get("metadata", {}) + + # Try to get org_id from metadata as fallback + if not client_reference_id and metadata.get("org_id"): + client_reference_id = metadata.get("org_id") + logger.warning( + f"client_reference_id missing from checkout.session.completed event. " + f"Using org_id from metadata: {client_reference_id}. Session ID: {session_id}" + ) + + if not client_reference_id: + error_msg = f"checkout.session.completed event missing client_reference_id. Session ID: {session_id}" + logger.error(error_msg) + log_webhook_metric( + "checkout.session.completed", + "missing_reference_id", + {"session_id": session_id, "subscription_id": subscription_id}, + ) + return + + if not subscription_id: + error_msg = f"checkout.session.completed event missing subscription_id. Session ID: {session_id}" + logger.error(error_msg) + log_webhook_metric( + "checkout.session.completed", + "missing_subscription_id", + {"session_id": session_id, "client_reference_id": client_reference_id}, + ) + return + + try: + subscription = stripe.Subscription.retrieve(subscription_id, expand=['items']) + if not subscription or not subscription.get('items') or not subscription.get('items').get('data'): + logger.error(f"Subscription {subscription_id} has no items or items data.") + return + + items_data = subscription.get('items', {}).get('data', []) + if not items_data: + logger.error(f"Subscription {subscription_id} has no items data array or it is empty.") + return + + purchased_price_id = items_data[0].get('price', {}).get('id') + if not purchased_price_id: + logger.error(f"Could not extract price ID from subscription {subscription_id}") + return + + if purchased_price_id != STRIPE_SUBSCRIPTION_PRICE_ID: + logger.error( + f"Purchased price ID {purchased_price_id} does not match " + f"expected STRIPE_SUBSCRIPTION_PRICE_ID {STRIPE_SUBSCRIPTION_PRICE_ID} for org {client_reference_id}." + ) + log_webhook_metric( + "checkout.session.completed", + "price_mismatch", + { + "purchased_price_id": purchased_price_id, + "expected_price_id": STRIPE_SUBSCRIPTION_PRICE_ID, + "org_id": client_reference_id, + "subscription_id": subscription_id, + "session_id": session_id, + }, + ) + return + + subscription_status = subscription.get('status') + if subscription_status not in ['active', 'trialing', 'scheduled']: + logger.warning( + f"Subscription {subscription_id} has status '{subscription_status}', " + f"not 'active', 'trialing', or 'scheduled'" + ) + + except stripe.error.StripeError as e: + logger.error( + "BILLING_WEBHOOK_ERROR", + extra={ + "event_type": event.type, + "event_id": event.id, + "org_id": client_reference_id, + "subscription_id": subscription_id, + "error_type": type(e).__name__, + "error_message": str(e), + "requires_manual_intervention": True, + }, + ) + raise HTTPException(status_code=500, detail=f"Stripe API error: {e}") + + org: OrgModel = orm.query(OrgModel).filter(OrgModel.id == client_reference_id).with_for_update().first() + + if org: + if org.subscription_id == subscription_id: + logger.info(f"Subscription {subscription_id} already processed for org {org.id}") + log_webhook_metric( + "checkout.session.completed", + "duplicate_processing", + {"org_id": str(org.id), "subscription_id": subscription_id}, + ) + return + + old_status = org.prem_status + org.subscription_id = subscription_id + org.prem_status = PremStatus.pro + + owner_member = ( + orm.query(UserOrgModel) + .filter(UserOrgModel.org_id == org.id, UserOrgModel.role == OrgRoles.owner) + .first() + ) + + if owner_member: + owner_member.is_paid = True + logger.info(f"Marked owner as paid for org {org.id}") + # NOTE: We intentionally only license the owner at checkout + # The subscription.updated webhook will handle syncing all purchased seats + # This allows flexibility for manual license assignment in the future + else: + logger.warning(f"No owner found for org {org.id} - cannot mark as paid") + + try: + orm.commit() + await mark_event_processed(event.id, orm) + + # Log successful upgrade + log_webhook_metric( + "checkout.session.completed", + "org_upgraded", + { + "org_id": str(org.id), + "subscription_id": subscription_id, + "old_status": old_status.value if old_status else "none", + "new_status": "pro", + }, + ) + except Exception as e: + orm.rollback() + logger.error( + "BILLING_WEBHOOK_ERROR", + extra={ + "event_type": event.type, + "event_id": event.id, + "org_id": str(org.id) if org else client_reference_id, + "subscription_id": subscription_id, + "error_type": type(e).__name__, + "error_message": str(e), + "requires_manual_intervention": True, + }, + ) + log_webhook_metric( + "checkout.session.completed", + "database_error", + { + "org_id": str(org.id), + "subscription_id": subscription_id, + "error": str(e), + "error_type": type(e).__name__, + }, + ) + raise HTTPException(status_code=500, detail="Database update failed") + else: + logger.error(f"Org not found with client_reference_id: {client_reference_id}") + logger.error( + "BILLING_WEBHOOK_ERROR", + extra={ + "event_type": event.type, + "event_id": event.id, + "org_id": client_reference_id, + "subscription_id": subscription_id, + "error_type": "OrgNotFound", + "error_message": f"Organization with ID {client_reference_id} not found after checkout.", + "requires_manual_intervention": True, + }, + ) + log_webhook_metric( + "checkout.session.completed", + "org_not_found", + { + "client_reference_id": client_reference_id, + "subscription_id": subscription_id, + "session_id": session_id, + }, + ) + + +async def handle_subscription_updated(event, orm: Session): + """Handle subscription updates (status changes, plan changes, etc.).""" + if await is_event_processed(event.id, orm): + logger.info(f"Event {event.id} already processed, skipping") + return {"status": "already_processed"} + + subscription = event.data.object + subscription_id = subscription.get("id") + status = subscription.get("status") + current_period_end = subscription.get("current_period_end") + + org: OrgModel = ( + orm.query(OrgModel).filter(OrgModel.subscription_id == subscription_id).with_for_update().first() + ) + + if not org: + logger.warning(f"No org found with subscription_id: {subscription_id}") + return + + # Check if there was a recent manual license update to avoid race conditions + recent_cutoff = datetime.now(timezone.utc) - timedelta(seconds=5) + recent_manual_update = ( + orm.query(BillingAuditLog) + .filter( + BillingAuditLog.org_id == org.id, + BillingAuditLog.action.in_(['member_licensed', 'member_unlicensed']), + BillingAuditLog.created_at >= recent_cutoff, + ) + .first() + ) + + if recent_manual_update: + logger.info( + f"Skipping license sync for org {org.id} due to recent manual update " + f"(action: {recent_manual_update.action} at {recent_manual_update.created_at})" + ) + skip_license_sync = True + else: + skip_license_sync = False + + # Extract seat quantity from subscription items and detect legacy subscriptions + seat_quantity = 0 + is_legacy_subscription = True + legacy_price_id = None + items = subscription.get('items', {}).get('data', []) + + if items: + for item in items: + price = item.get('price', {}) + price_id = price.get('id') + + if price_id == STRIPE_SUBSCRIPTION_PRICE_ID: + is_legacy_subscription = False + seat_quantity = item.get('quantity', 0) + break + elif 'seat' in str(price.get('product', {}).get('name', '')).lower(): + legacy_price_id = price_id + seat_quantity = item.get('quantity', 0) + + logger.info( + f"Subscription updated for org {org.id}: status={status}, seat_quantity={seat_quantity}, is_legacy={is_legacy_subscription}" + ) + # Handle legacy subscriptions - set them to cancel at period end + # should be auto handled by the manual run of scripts/sunset_legacy_subscriptions.py + # TODO: Remove this entire legacy subscription handling block (31 days after migration) + if is_legacy_subscription and status == "active": + # Check if we need to set cancellation + if not subscription.get('cancel_at_period_end'): + try: + logger.info(f"Detected legacy subscription {subscription_id} for org {org.id}") + + # Log the action - use org owner's user_id since user_id cannot be NULL + from agentops.opsboard.models import UserOrgModel, OrgRoles + + owner_membership = ( + orm.query(UserOrgModel) + .filter(UserOrgModel.org_id == org.id, UserOrgModel.role == OrgRoles.owner) + .first() + ) + system_user_id = owner_membership.user_id if owner_membership else None + + if not system_user_id: + logger.warning(f"No owner found for org {org.id}, cannot create audit log") + else: + audit_log = BillingAuditLog( + org_id=org.id, + user_id=system_user_id, # Use org owner's ID for system actions + action='legacy_subscription_sunset', + details={ + 'subscription_id': subscription_id, + 'old_price_id': legacy_price_id or 'unknown', + 'cancel_at': current_period_end, + 'event_id': event.id, + 'system_action': True, # Flag to indicate this was a system action + }, + ) + orm.add(audit_log) + + # Send notification email + await send_legacy_billing_notification(org, subscription, orm) + + # Cancel at period end and mark email as sent in single call + stripe.Subscription.modify( + subscription_id, + cancel_at_period_end=True, + metadata={ + 'cancellation_reason': 'billing_model_change', + 'notification_email_sent': 'sent', + 'original_price_id': legacy_price_id or 'unknown', + }, + ) + + except stripe.error.StripeError as e: + logger.error(f"Failed to update legacy subscription: {e}") + + # Skip seat sync for legacy subscriptions + skip_license_sync = True + + # Check if this is a legacy subscription being notified + elif ( + subscription.get('cancel_at_period_end') + and subscription.get('metadata', {}).get('cancellation_reason') == 'billing_model_change' + and subscription.get('metadata', {}).get('notification_email_sent') == 'pending' + ): + # Send notification email if not already sent + await send_legacy_billing_notification(org, subscription, orm) + + # Update metadata to mark email as sent + try: + stripe.Subscription.modify( + subscription_id, + metadata={ + 'cancellation_reason': 'billing_model_change', + 'notification_email_sent': 'sent', + 'original_price_id': subscription.get('metadata', {}).get('original_price_id', 'unknown'), + }, + ) + except stripe.error.StripeError as e: + logger.error(f"Failed to update subscription metadata: {e}") + + # Update org status based on subscription status + if status == "active": + org.prem_status = PremStatus.pro + + # Sync member licenses based on seat quantity (unless we just did a manual update or it's legacy) + if seat_quantity > 0 and not skip_license_sync and not is_legacy_subscription: + # If we want granular control over who gets licensed, we can add a flag to the org model + # and only license the owner at checkout + # Some orgs may prefer manual control over who gets licensed + + # Sync licenses + sync_result = await sync_org_licenses(org, seat_quantity, orm, event.id) + + # Log the changes + if sync_result['newly_licensed']: + logger.info( + f"Licensed {len(sync_result['newly_licensed'])} members for org {org.id}: {sync_result['newly_licensed']}" + ) + if sync_result['newly_unlicensed']: + logger.info( + f"Unlicensed {len(sync_result['newly_unlicensed'])} members for org {org.id}: {sync_result['newly_unlicensed']}" + ) + + # Log metrics for monitoring + log_webhook_metric( + "subscription.updated", + "licenses_synced", + { + "org_id": str(org.id), + "seat_quantity": seat_quantity, + "total_members": sync_result['total_members'], + "newly_licensed": len(sync_result['newly_licensed']), + "newly_unlicensed": len(sync_result['newly_unlicensed']), + }, + ) + + elif status in ["past_due", "unpaid"]: + # Check if we're past the 3-day grace period + if current_period_end: + period_end_date = datetime.fromtimestamp(current_period_end) + grace_period_end = period_end_date + timedelta(days=3) + + if datetime.now() > grace_period_end: + logger.warning( + f"Org {org.id} subscription is {status} and past 3-day grace period. Demoting to free." + ) + org.prem_status = PremStatus.free + org.subscription_id = None + + # Remove all licenses when demoting to free + orm.query(UserOrgModel).filter(UserOrgModel.org_id == org.id).update( + {UserOrgModel.is_paid: False} + ) + + else: + days_remaining = (grace_period_end - datetime.now()).days + logger.warning( + f"Org {org.id} subscription is {status}. {days_remaining} days left in grace period." + ) + elif status in ["canceled", "incomplete_expired"]: + org.prem_status = PremStatus.free + org.subscription_id = None + + # Remove all licenses when subscription is canceled + orm.query(UserOrgModel).filter(UserOrgModel.org_id == org.id).update({UserOrgModel.is_paid: False}) + + logger.info(f"Removed all licenses for org {org.id} due to subscription cancellation") + + try: + orm.commit() + await mark_event_processed(event.id, orm) + except Exception as e: + orm.rollback() + logger.error( + "BILLING_WEBHOOK_ERROR", + extra={ + "event_type": event.type, + "event_id": event.id, + "org_id": str(org.id), + "subscription_id": subscription_id, + "error_type": type(e).__name__, + "error_message": str(e), + "requires_manual_intervention": True, + }, + ) + + +async def handle_subscription_deleted(event, orm: Session): + """Handle subscription cancellation/deletion.""" + subscription = event.data.object + subscription_id = subscription.get("id") + + org: OrgModel = ( + orm.query(OrgModel).filter(OrgModel.subscription_id == subscription_id).with_for_update().first() + ) + + if not org: + logger.warning(f"No org found with subscription_id: {subscription_id}") + return + + # Check if this was a legacy subscription being sunset + cancellation_reason = subscription.get('metadata', {}).get('cancellation_reason') + + if cancellation_reason == 'billing_model_change': + # Log the legacy subscription cancellation - use org owner's user_id since user_id cannot be NULL + from agentops.opsboard.models import UserOrgModel, OrgRoles + + owner_membership = ( + orm.query(UserOrgModel) + .filter(UserOrgModel.org_id == org.id, UserOrgModel.role == OrgRoles.owner) + .first() + ) + system_user_id = owner_membership.user_id if owner_membership else None + + if system_user_id: + audit_log = BillingAuditLog( + org_id=org.id, + user_id=system_user_id, # Use org owner's ID for system actions + action='legacy_subscription_cancelled', + details={ + 'subscription_id': subscription_id, + 'cancelled_at': datetime.now(timezone.utc).isoformat(), + 'original_price_id': subscription.get('metadata', {}).get('original_price_id', 'unknown'), + 'system_action': True, # Flag to indicate this was a system action + }, + ) + orm.add(audit_log) + + logger.info(f"Legacy subscription {subscription_id} cancelled for org {org.id}") + + org.prem_status = PremStatus.free + org.subscription_id = None + + # Remove all licenses when subscription is deleted + orm.query(UserOrgModel).filter(UserOrgModel.org_id == org.id).update({UserOrgModel.is_paid: False}) + logger.info(f"Removed all licenses for org {org.id} due to subscription deletion") + + try: + orm.commit() + except Exception as e: + orm.rollback() + logger.error( + "BILLING_WEBHOOK_ERROR", + extra={ + "event_type": event.type, + "event_id": event.id, + "org_id": str(org.id), + "subscription_id": subscription_id, + "error_type": type(e).__name__, + "error_message": str(e), + "requires_manual_intervention": True, + }, + ) + + +async def handle_payment_failed(event, orm: Session): + """Handle failed payment attempts.""" + invoice = event.data.object + subscription_id = invoice.get("subscription") + attempt_count = invoice.get("attempt_count", 0) + + org: OrgModel = orm.query(OrgModel).filter(OrgModel.subscription_id == subscription_id).first() + + if not org: + logger.warning(f"No org found with subscription_id: {subscription_id}") + log_webhook_metric( + "invoice.payment_failed", + "org_not_found", + {"subscription_id": subscription_id, "attempt_count": attempt_count}, + ) + return + + logger.warning(f"Org {org.id} has failed payment, attempt #{attempt_count}") + + log_webhook_metric( + "invoice.payment_failed", + "payment_failure", + {"org_id": str(org.id), "subscription_id": subscription_id, "attempt_count": attempt_count}, + ) + + if attempt_count >= 3: + logger.error(f"CRITICAL: Org {org.id} has {attempt_count} failed payment attempts") + # Critical: multiple payment failures + log_webhook_metric( + "invoice.payment_failed", + "critical_payment_failure", + { + "org_id": str(org.id), + "subscription_id": subscription_id, + "attempt_count": attempt_count, + "severity": "critical", + }, + ) + + +async def handle_charge_refunded(event, orm: Session): + """Handle refunded charges - immediately revoke access.""" + charge = event.data.object + refunded = charge.get("refunded") + amount_refunded = charge.get("amount_refunded", 0) + + if not refunded: + return + + # Get the invoice associated with this charge + invoice_id = charge.get("invoice") + if not invoice_id: + logger.warning(f"Refunded charge {charge.get('id')} has no associated invoice") + return + + try: + # Retrieve the invoice to get the subscription + invoice = stripe.Invoice.retrieve(invoice_id) + subscription_id = invoice.get("subscription") + + if not subscription_id: + logger.warning(f"Invoice {invoice_id} has no associated subscription") + return + + # Find the org with this subscription + # Use SELECT FOR UPDATE to lock the row and prevent race conditions + org: OrgModel = ( + orm.query(OrgModel).filter(OrgModel.subscription_id == subscription_id).with_for_update().first() + ) + + if not org: + logger.warning(f"No org found with subscription_id: {subscription_id}") + return + + # Check if it's a full refund + if amount_refunded >= charge.get("amount"): + logger.info(f"Full refund detected for org {org.id}. Revoking pro access.") + org.prem_status = PremStatus.free + org.subscription_id = None + + try: + orm.commit() + except Exception as e: + orm.rollback() + logger.error( + "BILLING_WEBHOOK_ERROR", + extra={ + "event_type": event.type, + "event_id": event.id, + "org_id": str(org.id), + "subscription_id": subscription_id, + "charge_id": charge.get('id'), + "amount_refunded": amount_refunded, + "error_type": type(e).__name__, + "error_message": str(e), + "requires_manual_intervention": True, + }, + ) + else: + logger.info(f"Partial refund of {amount_refunded} cents for org {org.id}. No action taken.") + + except stripe.error.StripeError as e: + logger.error(f"Stripe API error handling refund: {e}") + except Exception as e: + logger.error(f"Unexpected error handling refund: {e}") + + +async def handle_invoice_created(event, orm: Session): + """Handle invoice creation - add usage-based charges.""" + if await is_event_processed(event.id, orm): + logger.info(f"Event {event.id} already processed, skipping") + return {"status": "already_processed"} + + invoice = event.data.object + subscription_id = invoice.get("subscription") + customer_id = invoice.get("customer") + + if not subscription_id: + logger.debug(f"Invoice {invoice.get('id')} is not for a subscription, skipping usage charges") + return + + org: OrgModel = orm.query(OrgModel).filter(OrgModel.subscription_id == subscription_id).first() + + if not org: + logger.warning(f"No org found with subscription_id: {subscription_id}") + return + + # Check if this is a legacy subscription being sunset + # TODO: Remove after <31 days after migration was run goes here> + try: + subscription = stripe.Subscription.retrieve(subscription_id) + if ( + subscription.get('cancel_at_period_end') + and subscription.get('metadata', {}).get('cancellation_reason') == 'billing_model_change' + ): + logger.info(f"Skipping usage charges for sunset legacy subscription {subscription_id}") + await mark_event_processed(event.id, orm) + return + except stripe.error.StripeError as e: + logger.error(f"Error retrieving subscription {subscription_id}: {e}") + + period_start_timestamp = invoice.get("period_start") + period_end_timestamp = invoice.get("period_end") + + if not period_start_timestamp or not period_end_timestamp: + logger.error(f"Invoice {invoice.get('id')} missing period information") + return + + period_start = datetime.fromtimestamp(period_start_timestamp) + period_end = datetime.fromtimestamp(period_end_timestamp) + + # Skip creating billing periods for zero-duration periods (setup/proration invoices) + if period_start == period_end: + logger.info(f"Skipping billing period creation for zero-duration invoice {invoice.get('id')}") + await mark_event_processed(event.id, orm) + return + + try: + usage_quantities = await billing_service.get_usage_for_period( + orm, str(org.id), period_start, period_end + ) + + if not usage_quantities: + logger.info(f"No usage found for org {org.id} in period {period_start} to {period_end}") + await mark_event_processed(event.id, orm) + return + + usage_costs = await billing_service.calculate_usage_costs(usage_quantities) + + for usage_type, cost_cents in usage_costs.items(): + if cost_cents > 0: + quantity = usage_quantities.get(usage_type, 0) + if usage_type == 'tokens': + description = f"API Tokens: {quantity:,} tokens" + elif usage_type == 'spans': + description = f"Span Uploads: {quantity:,} spans" + else: + description = f"{usage_type.title()}: {quantity:,}" + + try: + stripe.InvoiceItem.create( + customer=customer_id, + invoice=invoice.get("id"), + amount=cost_cents, + currency='usd', + description=description, + ) + + logger.info( + f"Added {usage_type} charge of {cost_cents} cents to invoice {invoice.get('id')}" + ) + + except stripe.error.StripeError as e: + logger.error(f"Failed to add {usage_type} charge to invoice: {e}") + log_webhook_metric( + "invoice.created", + "add_item_error", + { + "org_id": str(org.id), + "invoice_id": invoice.get("id"), + "usage_type": usage_type, + "error": str(e), + }, + ) + + await billing_service.create_billing_period_snapshot(orm, org, period_start, period_end) + + await mark_event_processed(event.id, orm) + + log_webhook_metric( + "invoice.created", + "usage_charges_added", + { + "org_id": str(org.id), + "invoice_id": invoice.get("id"), + "usage_costs": usage_costs, + "usage_quantities": usage_quantities, + }, + ) + + except Exception as e: + logger.error(f"Error processing usage charges for invoice: {e}") + log_webhook_metric( + "invoice.created", + "processing_error", + { + "org_id": str(org.id), + "invoice_id": invoice.get("id"), + "error": str(e), + "error_type": type(e).__name__, + }, + ) + + +async def handle_invoice_payment_succeeded(event, orm: Session): + """Handle successful invoice payment - update billing period status.""" + if await is_event_processed(event.id, orm): + logger.info(f"Event {event.id} already processed, skipping") + return {"status": "already_processed"} + + invoice = event.data.object + invoice_id = invoice.get("id") + subscription_id = invoice.get("subscription") + + if not subscription_id: + return + + org: OrgModel = orm.query(OrgModel).filter(OrgModel.subscription_id == subscription_id).first() + + if not org: + logger.warning(f"No org found with subscription_id: {subscription_id}") + return + + period_start_timestamp = invoice.get("period_start") + if period_start_timestamp: + period_start = datetime.fromtimestamp(period_start_timestamp) + + billing_period = ( + orm.query(BillingPeriod) + .filter(BillingPeriod.org_id == org.id, BillingPeriod.period_start == period_start) + .first() + ) + + if billing_period: + billing_period.status = 'paid' + billing_period.stripe_invoice_id = invoice_id + billing_period.invoiced_at = datetime.now(timezone.utc) + orm.commit() + + logger.info(f"Marked billing period as paid for org {org.id}, invoice {invoice_id}") + else: + logger.warning(f"No billing period found for org {org.id} with period_start {period_start}") + + await mark_event_processed(event.id, orm) + + log_webhook_metric( + "invoice.payment_succeeded", + "billing_period_paid", + {"org_id": str(org.id), "invoice_id": invoice_id, "subscription_id": subscription_id}, + ) + + +async def send_legacy_billing_notification(org: OrgModel, subscription: dict, orm: Session): + """Send email notification about legacy billing sunset""" + try: + owner_member = ( + orm.query(UserOrgModel) + .filter(UserOrgModel.org_id == org.id, UserOrgModel.role == OrgRoles.owner) + .first() + ) + + if not owner_member or not owner_member.user_id: + logger.warning(f"No owner found for org {org.id} - cannot send legacy billing notification") + return + + from agentops.opsboard.models import UserModel + + owner = orm.query(UserModel).filter(UserModel.id == owner_member.user_id).first() + + if not owner or not owner.billing_email: + logger.warning(f"No billing email found for owner of org {org.id}") + return + + period_end = None + if subscription.get('current_period_end'): + period_end = datetime.fromtimestamp(subscription['current_period_end'], tz=timezone.utc) + + # TODO: Integrate with your email service + # For now, just log that we would send an email + # audit_log = BillingAuditLog( + # org_id=org.id, + # user_id=owner.id, + # action='legacy_billing_notification_sent', + # details={ + # 'email': owner.billing_email, + # 'subscription_id': subscription.get('id'), + # 'cancel_at_period_end': subscription.get('current_period_end'), + # 'notification_type': 'billing_model_change', + # }, + # ) + # orm.add(audit_log) + logger.info( + f"LEGACY_BILLING_NOTIFICATION: Would send email to {owner.billing_email} " + f"for org {org.name} (ID: {org.id}) " + f"with cancellation date: {period_end.strftime('%B %d, %Y') if period_end else 'Unknown'}" + ) + + # Don't commit here - let the calling function handle the commit + # to ensure all operations are atomic + + except Exception as e: + logger.error(f"Failed to send legacy billing notification for org {org.id}: {e}") diff --git a/app/api/agentops/api/routes/v4/traces/__init__.py b/app/api/agentops/api/routes/v4/traces/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/api/agentops/api/routes/v4/traces/responses.py b/app/api/agentops/api/routes/v4/traces/responses.py new file mode 100644 index 000000000..6ab168d84 --- /dev/null +++ b/app/api/agentops/api/routes/v4/traces/responses.py @@ -0,0 +1,140 @@ +from typing import Optional, Any +from datetime import datetime +import pydantic + +from agentops.common.otel import otel_attributes_to_nested +from agentops.common.freeplan import FreePlanFilteredResponse +from agentops.api.models.span_metrics import ( + SpanMetricsResponse, + TraceMetricsResponse, +) + + +class TraceListItem(pydantic.BaseModel): + freeplan_truncated: bool = False + trace_id: str + root_service_name: str + root_span_name: str + start_time: str + end_time: str + duration: int + span_count: int + error_count: int + tags: Optional[list[str]] = None + total_cost: Optional[float] = None + + @pydantic.field_validator('start_time', 'end_time', mode='before') + def format_datetime(cls, v: datetime) -> str: + """Ensure the start_time and end_time are formatted as ISO strings.""" + return v.isoformat() + + +class TraceListResponse(pydantic.BaseModel): + traces: list[TraceListItem] + metrics: TraceMetricsResponse + total: int + limit: int + offset: int + freeplan_truncated: bool = False + + +class SpanItem(FreePlanFilteredResponse): + _freeplan_exclude = ( + 'attributes', + 'resource_attributes', + 'span_attributes', + 'event_timestamps', + 'event_names', + 'event_attributes', + 'link_trace_ids', + 'link_span_ids', + 'link_trace_states', + 'link_attributes', + # 'metrics', + ) + + span_id: str + parent_span_id: Optional[str] = None + + span_name: str + span_kind: str + span_type: Optional[str] = None # populated post-init + service_name: str + + start_time: str + end_time: str + duration: int + status_code: str + status_message: Optional[str] = None + + attributes: dict[str, Any] = pydantic.Field(default_factory=dict) + resource_attributes: dict[str, Any] = pydantic.Field(default_factory=dict) + span_attributes: dict[str, Any] = pydantic.Field(default_factory=dict) + + event_timestamps: list[str] = pydantic.Field(default_factory=list) + event_names: list[str] = pydantic.Field(default_factory=list) + event_attributes: list[Any] = pydantic.Field(default_factory=list) + + link_trace_ids: list[str] = pydantic.Field(default_factory=list) + link_span_ids: list[str] = pydantic.Field(default_factory=list) + link_trace_states: list[str] = pydantic.Field(default_factory=list) + link_attributes: list[Any] = pydantic.Field(default_factory=list) + + metrics: Optional[SpanMetricsResponse] = None + + @pydantic.field_validator('start_time', 'end_time', mode='before') + def format_datetime(cls, v: datetime) -> str: + """Ensure the start_time and end_time are formatted as ISO strings.""" + return v.isoformat() + + @pydantic.field_validator('event_timestamps', mode='before') + def format_event_timestamps(cls, v: list[datetime]) -> list[str]: + """Ensure event timestamps are formatted as ISO strings.""" + return [dt.isoformat() for dt in v] + + @pydantic.model_validator(mode='after') + def set_span_type(self): + if self.span_attributes: + self.span_type = self.format_span_type(self.span_attributes) + + return self + + def format_span_type(self, data: Any, current_path: str = "") -> str: + """Determine the span type from the span attributes dictionary.""" + # TODO this is LLM slop migrated from the v4 release and needs to be refactored + SPAN_TYPE_MAP = { + "gen_ai": "request", + "agent": "agent", + "tool": "tool", + } + if isinstance(data, dict): + # Check if current path/key is in SPAN_TYPE_MAP + for key in data.keys(): + full_path = f"{current_path}.{key}" if current_path else key + if key in SPAN_TYPE_MAP: + return SPAN_TYPE_MAP[key] + + # Recursively check nested dictionaries + result = self.format_span_type(data[key], full_path) + if result != "other": + return result + elif isinstance(data, list): + # Check each item in the list + for item in data: + result = self.format_span_type(item, current_path) + if result != "other": + return result + + return "other" + + @pydantic.field_validator('attributes', 'resource_attributes', 'span_attributes', mode='before') + def format_attributes(cls, v: dict[str, str]) -> dict[str, Any]: + return otel_attributes_to_nested(v) + + +class TraceDetailResponse(FreePlanFilteredResponse): + project_id: str + trace_id: str + tags: Optional[list[str]] = pydantic.Field(default_factory=list) + metrics: TraceMetricsResponse + spans: list[SpanItem] diff --git a/app/api/agentops/api/routes/v4/traces/views.py b/app/api/agentops/api/routes/v4/traces/views.py new file mode 100644 index 000000000..09125e95a --- /dev/null +++ b/app/api/agentops/api/routes/v4/traces/views.py @@ -0,0 +1,397 @@ +from typing import Optional +from datetime import datetime +from fastapi import Depends, Query, HTTPException, status +import hashlib +from time import time + +from agentops.common.environment import ( + APP_URL, + FREEPLAN_TRACE_MIN_NUM, + FREEPLAN_TRACE_DAYS_CUTOFF, + FREEPLAN_SPANS_LIST_LIMIT, +) +from agentops.common.route_config import BaseView +from agentops.common.views import add_cors_headers +from agentops.common.orm import get_orm_session, Session +from agentops.common.freeplan import freeplan_clamp_datetime + +from agentops.opsboard.models import ProjectModel +from agentops.api.models.traces import TraceModel, TraceSummaryModel, TraceListModel +from agentops.api.models.span_metrics import SpanMetricsResponse, TraceMetricsResponse + +from .responses import ( + TraceListResponse, + TraceListItem, + TraceDetailResponse, + SpanItem, +) + + +def has_llm_attributes(span_attributes: dict) -> bool: + """ + Check if a span has LLM-related attributes that indicate it should have metrics. + Based on the OpenTelemetry semantic conventions for AI and LLM spans. + """ + # Check for Gen AI attributes + gen_ai_attrs = [ + 'gen_ai.completion', + 'gen_ai.prompt', + 'gen_ai.usage', + 'gen_ai.usage.prompt_tokens', + 'gen_ai.usage.completion_tokens', + 'gen_ai.usage.total_tokens', + 'gen_ai.usage.prompt_cost', + 'gen_ai.usage.completion_cost', + 'gen_ai.usage.total_cost', + 'gen_ai.usage.cache_read_input_tokens', + 'gen_ai.usage.reasoning_tokens', + ] + + # Check for legacy LLM attributes + legacy_attrs = [ + 'ai.system', + 'ai.llm', + 'llm.request.model', + 'llm.response.model', + 'llm.system', + ] + + # Check if any of these attributes exist in the span + for attr in gen_ai_attrs + legacy_attrs: + if attr in span_attributes: + return True + + return False + + +# Simple in-memory cache for trace lists +class TraceListCache: + def __init__(self, ttl_seconds: int = 300): # 5 minute default TTL + self._cache = {} + self._ttl = ttl_seconds + + def _make_key( + self, + project_id: str, + start_time: Optional[datetime], + end_time: Optional[datetime], + query: Optional[str], + limit: int, + offset: int, + order_by: str, + sort_order: str, + ) -> str: + """Create a cache key from parameters""" + key_parts = [ + project_id, + start_time.isoformat() if start_time else "none", + end_time.isoformat() if end_time else "none", + query or "none", + str(limit), + str(offset), + order_by, + sort_order, + ] + key_str = "|".join(key_parts) + return hashlib.md5(key_str.encode()).hexdigest() + + def get(self, **kwargs): + """Get cached value if not expired""" + key = self._make_key(**kwargs) + if key in self._cache: + cached_data, cached_time = self._cache[key] + if time() - cached_time < self._ttl: + return cached_data + else: + del self._cache[key] + return None + + def set(self, data, **kwargs): + """Set cache value with current timestamp""" + key = self._make_key(**kwargs) + self._cache[key] = (data, time()) + + # Simple cleanup + if len(self._cache) > 500: + sorted_items = sorted(self._cache.items(), key=lambda x: x[1][1]) + for key, _ in sorted_items[:50]: + del self._cache[key] + + +# Global cache instance +# Reduce cache TTL to 30 seconds to ensure newly ingested traces appear promptly +trace_list_cache = TraceListCache(ttl_seconds=30) # 30-second cache for trace lists + + +class BaseTraceView(BaseView): + """ + Common base class for trace views. + """ + + orm: Session + project: ProjectModel + freeplan_truncated: bool = False + + async def get_project(self, project_id: str) -> ProjectModel: + """ + Retrieves the project by ID and checks if the user has access to it. + Raises HTTPException if the project is not found or access is denied. + """ + project = ProjectModel.get_by_id(self.orm, project_id) + + if not project or not project.org.is_user_member(self.request.state.session.user_id): + raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Project not found") + + return project + + async def get_trace_ids(self, limit: int, offset: int = 0) -> set[str]: + """ + Retrieves the trace IDs for the project, limited by the specified number and offset. + """ + traces = await TraceSummaryModel.select( + # fields=["trace_id"], + filters={"project_id": self.project.id}, + order_by="start_time DESC", + limit=limit, + offset=offset, + ) + return {trace.trace_id for trace in traces} + + async def trace_is_freeplan_truncated(self, trace: TraceModel) -> bool: + """ + Determines if a trace is truncated for free plan users. + """ + if not self.project.is_freeplan: + return False # not a freeplan, always allow + + if not hasattr(self, '_freeplan_trace_ids'): # cache the minimum visible trace IDs + self._freeplan_trace_ids = await self.get_trace_ids(FREEPLAN_TRACE_MIN_NUM) + + if trace.trace_id in self._freeplan_trace_ids: # trace is in the minimum visible traces, allow + return False + + return freeplan_clamp_datetime(trace.end_time, FREEPLAN_TRACE_DAYS_CUTOFF) > trace.end_time + + +class TraceListView(BaseTraceView): + """ + TraceListView handles the logic for retrieving a list of traces based on the provided filters. + It uses the TraceListModel to query the database and formats the response using the + TraceListResponse model. + """ + + limit: int + offset: int + + @add_cors_headers( + origins=[APP_URL], + methods=["GET", "OPTIONS"], + ) + async def __call__( + self, + *, + orm: Session = Depends(get_orm_session), + project_id: str, + start_time: Optional[datetime] = Query( + None, description="Filter by timestamp start (ISO 8601 format, e.g., '2023-01-01T00:00:00Z')" + ), + end_time: Optional[datetime] = Query( + None, description="Filter by timestamp end (ISO 8601 format, e.g., '2023-01-01T00:00:00Z')" + ), + query: Optional[str] = Query( + None, description="Search by span name, trace_id, or tags (case insensitive)" + ), + limit: int = Query( + 20, ge=1, le=100, description="Maximum number of traces to return (default: 20, max: 100)" + ), + offset: int = Query(0, ge=0, description="Offset for pagination (default: 0)"), + order_by: str = Query("start_time", description="Field to sort by (default: 'timestamp')."), + sort_order: str = Query( + # TODO restrict this to an Enum + "DESC", + description="Sort order for timestamp (ASC or DESC)", + ), + ) -> TraceListResponse: + """ + Callable method to handle the request and return a JSONResponse. This method + validates the input parameters, retrieves the trace data, formats the + response and converts exceptions to responses. + """ + self.orm = orm + self.limit = limit + self.offset = offset + self.project = await self.get_project(project_id) + + # Check cache first + # Only use the cache if we're not requesting the very first page (offset == 0) OR + # if specific filters are provided. The first page is the one that is most sensitive + # to freshness because it shows the most recent traces. By fetching it live we ensure + # the newest traces are always visible immediately after page refresh. + should_use_cache = offset != 0 or query is not None or start_time is not None or end_time is not None + + cache_params = { + 'project_id': project_id, + 'start_time': start_time, + 'end_time': end_time, + 'query': query, + 'limit': limit, + 'offset': offset, + 'order_by': order_by, + 'sort_order': sort_order, + } + + cached_response = None + if should_use_cache: + cached_response = trace_list_cache.get(**cache_params) + + if cached_response is not None: + # Update freeplan_truncated flag based on current project status + if self.project.is_freeplan and cached_response.total > FREEPLAN_TRACE_MIN_NUM: + return TraceListResponse( + traces=cached_response.traces, + metrics=cached_response.metrics, + total=cached_response.total, + limit=cached_response.limit, + offset=cached_response.offset, + freeplan_truncated=True, + ) + return cached_response + + trace_list = await TraceListModel.select( + filters={ + "project_id": self.project.id, + "start_time": start_time, + "end_time": end_time, + }, + search=query, + order_by=f"{order_by} {sort_order}", + limit=self.limit, + offset=self.offset, + ) + + if self.project.is_freeplan and trace_list.trace_count > FREEPLAN_TRACE_MIN_NUM: + # if we're showing more than the minimum number of traces we are truncating + self.freeplan_truncated = True + + response = await self.get_response(trace_list) + + # Cache the response only if we used cache for this request + if should_use_cache: + trace_list_cache.set(response, **cache_params) + + return response + + async def get_response(self, trace_list: TraceListModel) -> TraceListResponse: + """ + Formats the trace list response from the TraceListModel instance. + """ + + return TraceListResponse( + traces=[ + TraceListItem( + trace_id=trace.trace_id, + root_service_name=trace.service_name, + root_span_name=trace.span_name, + start_time=trace.start_time, + end_time=trace.end_time, + duration=trace.duration, + span_count=trace.span_count, + error_count=trace.error_count, + tags=trace.tags, + total_cost=trace.total_cost, + freeplan_truncated=await self.trace_is_freeplan_truncated(trace), + ) + for trace in trace_list.traces + ], + metrics=TraceMetricsResponse.from_trace_with_metrics(trace_list), + total=trace_list.trace_count, + limit=self.limit, + offset=self.offset, + freeplan_truncated=self.freeplan_truncated, + ) + + +class TraceDetailView(BaseTraceView): + """ + TraceDetailView handles the logic for retrieving the details of a specific + trace based on the trace_id. It uses the TraceModel to query the database and + formats the response using the TraceDetailResponse model. + """ + + @add_cors_headers( + origins=[APP_URL], + methods=["GET", "OPTIONS"], + ) + async def __call__( + self, + *, + orm: Session = Depends(get_orm_session), + trace_id: str, + ) -> TraceDetailResponse: + """ + Callable method to handle the request and return a JSONResponse. This method + validates the input parameters, retrieves the trace data, formats the + response and converts exceptions to responses. + """ + self.orm = orm + + trace = await TraceModel.select( + filters={ + "trace_id": trace_id, + } + ) + + if not trace.spans: + raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Trace not found.") + + self.project = await self.get_project(trace.project_id) + self.freeplan_truncated = await self.trace_is_freeplan_truncated(trace) + + return await self.get_response(trace) + + async def get_response(self, trace: TraceModel) -> TraceDetailResponse: + """ + Formats the trace detail response from the TraceModel instance. + """ + + return TraceDetailResponse( + project_id=trace.project_id, + trace_id=trace.trace_id, + tags=trace.tags, + metrics=TraceMetricsResponse.from_trace_with_metrics(trace), + spans=[ + SpanItem( + span_id=span.span_id, + parent_span_id=span.parent_span_id, + span_name=span.span_name, + span_kind=span.span_kind, + # span_type is inferred from span_attributes after init + service_name=span.service_name, + start_time=span.start_time, + end_time=span.end_time, + duration=span.duration, + status_code=span.status_code, + status_message=span.status_message, + attributes={}, # TODO remove this + span_attributes=span.span_attributes, + resource_attributes=span.resource_attributes, + event_timestamps=span.event_timestamps, + event_names=span.event_names, + event_attributes=span.event_attributes, + link_trace_ids=span.link_trace_ids, + link_span_ids=span.link_span_ids, + link_trace_states=span.link_trace_states, + link_attributes=span.link_attributes, + metrics=SpanMetricsResponse.from_span_with_metrics(span) + if has_llm_attributes(span.span_attributes) + else None, + freeplan_truncated=( + # the trace has been identified as truncated and the span is beyond the limit + self.freeplan_truncated + or (self.freeplan_truncated and trace.spans.index(span) > FREEPLAN_SPANS_LIST_LIMIT) + ), + ) + for span in trace.spans + ], + freeplan_truncated=self.freeplan_truncated, + ) diff --git a/app/api/agentops/api/routes/v4/utils.py b/app/api/agentops/api/routes/v4/utils.py new file mode 100644 index 000000000..fe7c2af17 --- /dev/null +++ b/app/api/agentops/api/routes/v4/utils.py @@ -0,0 +1,53 @@ +from typing import Optional, TypeVar, ParamSpec +from collections import OrderedDict + +from fastapi.responses import JSONResponse + +from agentops.api.routes.v4.exceptions import InvalidParameterError + +P = ParamSpec("P") +R = TypeVar("R") + + +def create_error_response(error_type: str, status_code: int, message: str, **extra_fields) -> JSONResponse: + """ + Create a standardized error response. + + Args: + error_type: Type of the error (e.g., "Invalid parameter", "Database error") + status_code: HTTP status code + message: Error message + **extra_fields: Additional fields to include in the response + + Returns: + JSONResponse with standardized format + """ + # Use OrderedDict to ensure field order matches test expectations + content = OrderedDict() + content["error"] = error_type + + # For InvalidParameterError, order should be error, param, message + if "param" in extra_fields: + content["param"] = extra_fields.pop("param") + + content["message"] = message + + # Add any remaining extra fields + for key, value in extra_fields.items(): + content[key] = value + + return JSONResponse(status_code=status_code, content=content) + + +def validate_status_code(status_code: Optional[str]) -> Optional[str]: + """Validate status code parameter.""" + if not status_code: + return None + + valid_status_codes = ["OK", "ERROR", "UNSET"] + if status_code not in valid_status_codes: + raise InvalidParameterError( + "status_code", f"Invalid status code. Expected one of: {', '.join(valid_status_codes)}." + ) + + return status_code diff --git a/app/api/agentops/api/storage.py b/app/api/agentops/api/storage.py new file mode 100644 index 000000000..4604375b3 --- /dev/null +++ b/app/api/agentops/api/storage.py @@ -0,0 +1,121 @@ +from typing import Optional +from abc import ABC +from io import BytesIO +from pydantic import BaseModel +from fastapi import HTTPException, Depends, status +import boto3 +from botocore.client import Config + +from agentops.api.log_config import logger +from agentops.api.environment import ( + SUPABASE_URL, + SUPABASE_S3_ACCESS_KEY_ID, + SUPABASE_S3_SECRET_ACCESS_KEY, +) +from agentops.api.auth import get_jwt_token, JWTPayload +from agentops.common.route_config import BaseView + + +_s3_client_instance: Optional[boto3.client] = None + + +def get_s3_client() -> boto3.client: + """Maintain a single global instance of the S3 client""" + global _s3_client_instance + + if _s3_client_instance is None: + _s3_client_instance = boto3.client( + 's3', + endpoint_url=f"{SUPABASE_URL}/storage/v1/s3", + aws_access_key_id=SUPABASE_S3_ACCESS_KEY_ID, + aws_secret_access_key=SUPABASE_S3_SECRET_ACCESS_KEY, + config=Config(signature_version='s3v4'), + region_name='us-west-1', + ) + return _s3_client_instance + + +class ObjectUploadResponse(BaseModel): + url: str + size: int + + +class BaseObjectUploadView(BaseView, ABC): + """ + Abstract base class for handling object uploads to S3-compatible storage. + This class provides a framework for uploading objects to a storage bucket + and generating public URLs for the uploaded objects. Subclasses must + implement or override the `filename` property to define a unique naming + convention for the uploaded files. + + Attributes: + bucket_name (str): The name of the S3 bucket where the object will be uploaded. + max_size (int): The maximum allowed size for the uploaded object in bytes. + Defaults to 10 MB (10 * 1024 * 1024). + token (dict): A dictionary containing authentication or metadata + information, such as project-specific identifiers. + client (boto3.client): An S3 client instance for interacting with the + storage service. + + Methods: + __call__() -> ObjectUploadResponse: + Handles the upload process by reading the request body, uploading + the object, and returning a response with the public URL and size + of the uploaded object. + upload_body(body: BytesIO) -> None: + Uploads the object to the storage bucket using the provided body. + filename() -> str: + Generates or retrieves a unique filename for the object. This + property must be implemented or overridden in subclasses. + public_url() -> str: + Generates a public URL for accessing the uploaded object. + """ + + bucket_name: str + max_size: int = 25 * 1024 * 1024 # 25 MB + + token: dict + client: boto3.client + + async def __call__(self, token: JWTPayload = Depends(get_jwt_token)) -> ObjectUploadResponse: + assert self.bucket_name is not None, "`bucket_name` must be provided" + + self.token = token + self.client = get_s3_client() + + body = BytesIO() + total_size = 0 + + # read the body in chunks so we don't ever load an entire oversized file into memory + async for chunk in self.request.stream(): + total_size += len(chunk) + + if total_size > self.max_size: + logger.error("Uploaded file exceeds maximum size limit") + raise HTTPException( + status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE, + detail=f"File size exceeds the maximum limit of {self.max_size} bytes", + ) + + body.write(chunk) + + body.seek(0) + await self.upload_body(body) + return ObjectUploadResponse( + url=self.public_url, + size=total_size, + ) + + async def upload_body(self, body: BytesIO) -> None: + """Upload the object to S3.""" + self.client.upload_fileobj(body, self.bucket_name, self.filename) + + @property + def filename(self) -> str: + """Generate a unique filename for the object""" + ... + + @property + def public_url(self) -> str: + """Generate a public URL for the object""" + return f"{SUPABASE_URL}/storage/v1/object/public/{self.bucket_name}/{self.filename}" diff --git a/app/api/agentops/api/utils.py b/app/api/agentops/api/utils.py new file mode 100644 index 000000000..394dc78c8 --- /dev/null +++ b/app/api/agentops/api/utils.py @@ -0,0 +1,136 @@ +import datetime +import uuid +from decimal import Decimal + +import jwt +from tokencost import TOKEN_COSTS, count_message_tokens, count_string_tokens +from typing_extensions import deprecated + +from agentops.api.db.supabase_client import AsyncSupabaseClient, get_async_supabase +from agentops.api.environment import JWT_SECRET_KEY +from agentops.api.exceptions import ExpiredJWTError, InvalidAPIKeyError +from agentops.api.log_config import logger + + +@deprecated("use agentops.api.auth.generate_jwt") +def generate_jwt(session_id, jwt_secret): + payload = { + "session_id": session_id, + "exp": ( + datetime.datetime.now() + datetime.timedelta(hours=24) # Token expires in 24 hour + ).timestamp(), + } + token = jwt.encode(payload, jwt_secret or JWT_SECRET_KEY, algorithm="HS256") + return token + + +@deprecated("use agentops.api.auth.generate_jwt") +def verify_jwt(token, secret_key): + try: + payload = jwt.decode(token, secret_key, algorithms=["HS256"]) + return payload["session_id"] + except jwt.ExpiredSignatureError: + raise ExpiredJWTError(401, "Expired Token") + except jwt.DecodeError: + RuntimeError("Invalid token") + + +def validate_uuid(uuid_string) -> uuid.UUID: + try: + return uuid.UUID(uuid_string, version=4) + except ValueError: + raise InvalidAPIKeyError(401, "Invalid API KEY format") + except TypeError: + raise InvalidAPIKeyError(401, "Invalid API KEY format") + except Exception as e: + raise RuntimeError(f"Error validating UUID: {e}") + + +async def get_premium_status(supabase: AsyncSupabaseClient = None, user_id: str = None) -> bool: + if supabase is None and user_id is not None: + supabase = await get_async_supabase() + + try: + # return await supabase.get("users", "premium", "id", user_id) + # TODO: when we refactor premium management, add logic here + return False + except Exception as e: + logger.warning(f"Could not fetch premium status: {e}") + return False + + +async def update_stats( + supabase: AsyncSupabaseClient, + session_id, + cost: Decimal | None, + events, + prompt_tokens, + completion_tokens, + errors, +): + _current_stats = ( + await supabase.table("stats").select("*").eq("session_id", session_id).limit(1).single().execute() + ) + if _current_stats.data: + current_stats = _current_stats.data + else: + logger.error(f"Could not find stats for session {session_id}") + return + + current_cost = ( + Decimal(str(current_stats["cost"])) if current_stats and current_stats["cost"] else Decimal(0) + ) + updated_cost = current_cost + (cost if cost else Decimal(0)) + updated_cost = str(updated_cost) if updated_cost != Decimal(0) else None + + stats = { + "session_id": session_id, + "cost": updated_cost, + "events": events + (current_stats["events"] if current_stats else 0), + "prompt_tokens": prompt_tokens + (current_stats["prompt_tokens"] if current_stats else 0), + "completion_tokens": completion_tokens + (current_stats["completion_tokens"] if current_stats else 0), + "errors": errors + (current_stats["errors"] if current_stats else 0), + } + + await supabase.table("stats").upsert(stats, on_conflict="session_id").execute() + + +def calculate_costs(model, prompt, completion): + try: + if model not in TOKEN_COSTS: + raise RuntimeError(f"Model {model} not in TOKEN_COSTS") + + # Prompt cost + if type(prompt) == str: + prompt_tokens = count_string_tokens(prompt, model) + else: + prompt_tokens = count_message_tokens(prompt, model) + + # Completion cost + completion_tokens = count_string_tokens(completion, model) + + # Calculate cost + return str( + prompt_tokens * Decimal(str(TOKEN_COSTS[model]["input_cost_per_token"])) + + completion_tokens * Decimal(str(TOKEN_COSTS[model]["output_cost_per_token"])) + ) + + except RuntimeError as e: + logger.error(f"An error occurred while calculating cost: {e}. ") + return 0 + + +def strip_host_env(d: dict): + if d is None: + return None + + if isinstance(d, dict): + for k in list(d.keys()): # convert dict_keys into list for in-place deletion + if k == "host_env": + del d[k] + elif isinstance(d[k], dict): + strip_host_env(d[k]) + elif isinstance(d[k], list): + for i in d[k]: + strip_host_env(i) + return d diff --git a/app/api/agentops/app.py b/app/api/agentops/app.py new file mode 100644 index 000000000..5ff4a9317 --- /dev/null +++ b/app/api/agentops/app.py @@ -0,0 +1,76 @@ +""" +AgentOps Backend parent app + +Collect app instances from all sub-apps and mount them here. + +This allows for a single entry point for the backend, and for us to have +domain-specific middleware for each sub-app. + +""" + +from fastapi import FastAPI +import sentry_sdk + +from agentops.api.log_config import logger +from .common.sentry import sanitize_event +from .common.environment import API_DOMAIN +from .common.openapi import create_combined_openapi_fn +from .common.lifespan import lifespan +from .auth.app import app as auth_app +from .api.app import app as api_app +from .opsboard.app import app as opsboard_app +from .public.app import app as public_app +from .deploy.app import app as deploy_app + +__all__ = ['app'] + +sentry_sdk.init( + traces_sample_rate=1.0, + profiles_sample_rate=1.0, + before_send=sanitize_event, +) + +# Create the main app with docs enabled in dev only +app = FastAPI( + title="AgentOps Backend", + description="AgentOps Backend Services", + docs_url="/docs" if ("localhost" in API_DOMAIN) else None, + openapi_url="/openapi.json" if ("localhost" in API_DOMAIN) else None, + lifespan=lifespan, +) +logger.info("āš”ļøFastAPI app initialized") +logger.info(f"Docs available at: {app.docs_url}" if app.docs_url else "Docs disabled") + +# Configure the mounted apps +# TODO this is redundant, but it's just for docs +mounted_apps = { + "/": api_app, + # Add other mounted apps when they are enabled + "/auth": auth_app, + "/opsboard": opsboard_app, + "/public": public_app, + "/deploy": deploy_app, +} + +# Set the custom OpenAPI schema generator that combines all APIs +app.openapi = create_combined_openapi_fn( + main_app=app, + mounted_apps=mounted_apps, + title="AgentOps Combined API", + version="1.0.0", + description="Combined API for all AgentOps services", +) + +app.mount("/auth", auth_app) +app.mount("/opsboard", opsboard_app) +app.mount("/public", public_app) +app.mount("/deploy", deploy_app) +app.mount("/", api_app) + + +if "localhost" not in API_DOMAIN: + # only run Sentry in prod since it breaks the docs routes. + from sentry_sdk.integrations.asgi import SentryAsgiMiddleware + + logger.info("Sentry middleware enabled") + app = SentryAsgiMiddleware(app) diff --git a/app/api/agentops/auth/README.md b/app/api/agentops/auth/README.md new file mode 100644 index 000000000..63e7a4387 --- /dev/null +++ b/app/api/agentops/auth/README.md @@ -0,0 +1,123 @@ +# AgentOps Authentication System + +## Architecture Overview + +The AgentOps authentication system combines Supabase for identity management with a Redis-backed session store. Authentication flows begin when users authenticate through Supabase, which returns JWT tokens containing user information. Our system then creates its own session, stores the mapping in Redis, and issues an HTTP-only cookie containing a signed session identifier. This approach provides the security benefits of server-side sessions while leveraging Supabase's robust identity platform. + +## Session Management + +The `Session` class provides a clean interface to the Redis backend. Each session is identified by a UUID and contains a reference to the authenticated user. The interface is deliberately minimal: + +Server-side session storage was chosen over client-side JWT tokens because it allows for immediate session invalidation and extension, neither of which is possible with self-contained JWTs. The Redis backend provides fast access with automatic TTL management. + +## Authentication Flow + +The authentication flow consists of two distinct steps, designed to securely handle Supabase tokens: + +1. The `auth_callback` view receives the hash fragment from Supabase (containing access and refresh tokens) and renders a page with strict Content-Security-Policy that extracts these tokens. + +2. The client-side JavaScript forwards these tokens to `auth_session`, which validates the Supabase JWT, creates a new session, and sets a secure HTTP-only cookie containing our signed session ID. + +This approach prevents tokens from appearing in server logs or browser history, reducing the risk of token leakage. + +## Request Authentication + +All API endpoints require authentication by default through the `AuthenticatedRoute` class. Only routes explicitly marked with the `@public_route` decorator are accessible without authentication. This "secure by default" pattern prevents accidentally exposing sensitive endpoints. + +The middleware extracts the session cookie, validates it, retrieves the session from Redis, and provides it to the route handler via `request.state.session`. When enabled, session expiration is automatically extended on each authenticated request. + +## Security Considerations + +The security model specifically avoids client-side JWTs because they cannot be invalidated, their expiration cannot be extended, and they present risks if stored in localStorage. Instead, HTTP-only cookies with the Secure and SameSite=strict flags prevent JavaScript access and CSRF attacks. + +Content Security Policy with nonces is implemented on authentication pages to prevent XSS attacks, and all cookies are scoped to specific domains to limit exposure. The session store architecture allows for immediate invalidation of all sessions if needed. + +## Cookie Management + +The authentication system uses a minimalist cookie approach to maintain user sessions securely. Understanding how these cookies work is important for developers integrating with the AgentOps API. + +### How Session Cookies Work + +When a user authenticates: + +1. A server-side session is created and stored in Redis +2. A session identifier (UUID) is generated +3. This identifier is JWT-encoded with our internal secret +4. The encoded token is stored in an HTTP-only cookie + +For subsequent requests: + +1. The cookie is automatically sent with each request to the API +2. The middleware extracts and validates the cookie +3. The session ID is decoded and used to retrieve the full session from Redis +4. If authentication is successful, the session object is made available to the endpoint handler + +### Cookie Properties + +Our session cookies are configured with several important security properties: + +- **HTTP-only**: Cannot be accessed by JavaScript, protecting against XSS attacks +- **Secure**: Only sent over HTTPS in production environments +- **SameSite=strict**: Only sent for same-site requests, preventing CSRF attacks +- **Domain-scoped**: Limited to the API domain +- **Expiration**: Automatically expires after the configured session lifetime + +### Client Integration Considerations + +When developing a client application that interacts with AgentOps: + +- There's no need to manually extract or send tokens - browsers handle cookies automatically +- Authentication state persists across page reloads as long as the session is valid +- Logging out requires an explicit call to the logout endpoint, which clears the cookie +- Cross-domain requests require credentials: `credentials: 'include'` (fetch) or `withCredentials: true` (axios) +- Mobile apps and non-browser clients need to handle cookies appropriately for their platform + +### Cross-Origin and SameSite Cookies + +The API server includes CORS configuration that allows requests from the main application domain (`APP_DOMAIN`). This works with SameSite=strict cookies through the following mechanism: + +- The CORS `allow_origins` list includes the main application URL (`APP_URL`) +- The `allow_credentials` flag is set to `True`, permitting cookies to be included in cross-origin requests +- Clients must explicitly include credentials in their requests +- The browser will then include cookies with cross-origin requests to trusted domains + +## Implementing Authentication in an Application + +The `AuthenticatedRoute` class enforces authentication for all endpoints by default, while the `@public_route` decorator allows specific endpoints to be accessible without authentication. + +```python +from fastapi import FastAPI, APIRouter, Request +from uuid import UUID +from agentops.auth.middleware import AuthenticatedRoute +from agentops.auth.views import public_route +from agentops.auth.session import Session + +app = FastAPI() + +# Create a router with the AuthenticatedRoute class +router = APIRouter(route_class=AuthenticatedRoute) + +# Protected endpoint (requires authentication) +@router.get("/protected-endpoint") +async def protected_endpoint(request: Request): + session: Session = request.state.session + user_id: UUID = session.user_id + return {"message": f"Hello, user {str(user_id)}!"} + +# Public endpoint (no authentication required) +@router.get("/public-endpoint") +@public_route +async def public_endpoint(): + return {"message": "This endpoint is accessible without authentication"} + +# Include the router in your application +app.include_router(router) +``` + +With this implementation: + +1. All routes on the router require authentication by default +2. The middleware extracts and validates the session cookie from requests +3. For authenticated endpoints, `request.state.session` is populated with the user's session +4. Session expiration is automatically extended when enabled +5. Routes with the `@public_route` decorator are accessible without authentication diff --git a/app/api/agentops/auth/__init__.py b/app/api/agentops/auth/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/api/agentops/auth/app.py b/app/api/agentops/auth/app.py new file mode 100644 index 000000000..2d881e162 --- /dev/null +++ b/app/api/agentops/auth/app.py @@ -0,0 +1,94 @@ +from fastapi import FastAPI, APIRouter +from fastapi.middleware.cors import CORSMiddleware + +from agentops.common.route_config import RouteConfig, register_routes +from agentops.common.middleware import CacheControlMiddleware, ExceptionMiddleware +from agentops.common.environment import ALLOWED_ORIGINS + +from .middleware import AuthenticatedRoute +from .views import ( + auth_callback, + auth_code, + auth_session, + auth_login, + auth_otp, + auth_oauth, + auth_signup, + auth_password_reset, + auth_logout, +) + +__all__ = ['app'] + +route_config: list[RouteConfig] = [ + RouteConfig( + name='auth_callback', + path="/callback", + endpoint=auth_callback, + methods=["GET"], + ), + RouteConfig( + name='auth_code', + path="/code", + endpoint=auth_code, + methods=["GET"], + ), + RouteConfig( + name='auth_session', + path="/session", + endpoint=auth_session, + methods=["POST"], + ), + RouteConfig( + name='auth_login', + path="/login", + endpoint=auth_login, + methods=["POST"], + ), + RouteConfig( + name='auth_otp', + path="/otp", + endpoint=auth_otp, + methods=["POST"], + ), + RouteConfig( + name='auth_oauth', + path="/oauth", + endpoint=auth_oauth, + methods=["POST"], + ), + RouteConfig( + name='auth_signup', + path="/signup", + endpoint=auth_signup, + methods=["POST"], + ), + RouteConfig( + name='auth_password_reset', + path="/password_reset", + endpoint=auth_password_reset, + methods=["POST"], + ), + RouteConfig( + name='auth_logout', + path="/logout", + endpoint=auth_logout, + methods=["POST"], + ), +] + +app = FastAPI(title="AgentOps Auth") + +app.add_middleware( + CORSMiddleware, + allow_origins=ALLOWED_ORIGINS, + allow_credentials=True, + allow_methods=['GET', 'POST', 'OPTIONS'], + allow_headers=["*"], +) +app.add_middleware(CacheControlMiddleware) +app.add_middleware(ExceptionMiddleware) + +router = APIRouter(route_class=AuthenticatedRoute) +register_routes(router, route_config, prefix="/auth") +app.include_router(router) diff --git a/app/api/agentops/auth/environment.py b/app/api/agentops/auth/environment.py new file mode 100644 index 000000000..b7b2fd604 --- /dev/null +++ b/app/api/agentops/auth/environment.py @@ -0,0 +1,38 @@ +import os +from agentops.api.log_config import logger + +# generate an AUTH_COOKIE_SECRET with: +# import secrets; print(secrets.token_hex(32)) +_DEV_AUTH_COOKIE_SECRET = "your_cookie_signing_secret" +AUTH_COOKIE_SECRET = os.getenv("AUTH_COOKIE_SECRET", _DEV_AUTH_COOKIE_SECRET) + +AUTH_COOKIE_NAME = os.getenv("AUTH_COOKIE_NAME", "session_id") +AUTH_JWT_ALGO = "HS256" # this is for our internal JWT on the session cookie + + +# Sessions are extended on every interaction with the API. This means a user +# won't need to log in again as long as they interact with the API at least once +# every 7 days, for up to 30 days while the cookie remains valid. + +# extend sessions on every interaction +AUTH_EXTEND_SESSIONS: bool = True +# session expiry relates to the record stored in the cache backend +AUTH_SESSION_EXPIRY = 60 * 60 * 24 * 7 # 7 days in seconds +# cookie expiry relates to the cookie stored in the browser +AUTH_COOKIE_EXPIRY = 60 * 60 * 24 * 30 # 30 days in seconds + +SUPABASE_JWT_SECRET: str = os.getenv("JWT_SECRET_KEY") + + +if AUTH_COOKIE_SECRET == _DEV_AUTH_COOKIE_SECRET: + logger.warning("[agentops.auth.environment] Using an unsafe AUTH_COOKIE_SECRET") + +if not SUPABASE_JWT_SECRET: + logger.warning("[agentops.auth.environment] No JWT_SECRET_KEY set") + + +AUTH_ADDITIONAL_REFERERS = [ + # Add any additional referers that should be allowed to access the auth app + "https://accounts.google.com/", + "https://github.com/", +] diff --git a/app/api/agentops/auth/exceptions.py b/app/api/agentops/auth/exceptions.py new file mode 100644 index 000000000..24a21c1b5 --- /dev/null +++ b/app/api/agentops/auth/exceptions.py @@ -0,0 +1,35 @@ +from fastapi import HTTPException +import gotrue + + +class AuthException(HTTPException): + """Shared status_code for all auth exceptions""" + + # TODO don't return detailed messages to the client in production + def __init__(self, detail: str = "Failed to authenticate user."): + super().__init__(status_code=401, detail=detail) + + @classmethod + def from_gotrue_autherror(cls, exc: gotrue.errors.AuthApiError): + """ + Create an AuthException from a GoTrue exception. + + This let's us handle explicit messaging to the user and prevents printing + all exception messages to the user. + """ + if exc.message == "Email not confirmed": + return AuthUnconfirmedEmailException() + return cls() # don't bubble messages we don't explicitly approve + + +class AuthUnconfirmedEmailException(AuthException): + """Raised when the user has not confirmed their email address""" + + def __init__(self): + super().__init__( + detail=( + "Your email address has not been confirmed. " + "Check your inbox for a confirmation email and click the link " + "before signing in for the first time." + ) + ) diff --git a/app/api/agentops/auth/middleware.py b/app/api/agentops/auth/middleware.py new file mode 100644 index 000000000..7f54b346c --- /dev/null +++ b/app/api/agentops/auth/middleware.py @@ -0,0 +1,73 @@ +from collections.abc import Callable +from fastapi import Request, Response +from fastapi.routing import APIRoute + +from .environment import ( + AUTH_EXTEND_SESSIONS, + AUTH_COOKIE_NAME, +) +from .exceptions import AuthException +from .session import Session +from .views import _decode_session_cookie + + +class AuthenticatedRoute(APIRoute): + """ + Route class that enforces authentication for endpoints. + + Protects all endpoints except those explicitly marked as public. + + Populates request.state.session with the user's Session object. + + Usage: + from fastapi import FastAPI, APIRouter + from api.agentops.auth.middleware import AuthenticatedRoute + + app = FastAPI() + router = APIRouter(route_class=AuthenticatedRoute) + app.include_router(router) + ... + """ + + def _get_session(self, request: Request) -> Session: + """ + Get the user's session from the request. + + Raises AuthException if the user is not authenticated or if the session has expired. + + If AUTH_EXTEND_SESSIONS is enabled, the session expiry is extended. + """ + if not (cookie := request.cookies.get(AUTH_COOKIE_NAME)): + raise AuthException("User is not authenticated.") + + if not (session := _decode_session_cookie(cookie)): + raise AuthException("User's session has expired.") + + if AUTH_EXTEND_SESSIONS: + session.extend() + + return session + + def get_route_handler(self) -> Callable: + """ + Override the default route handler to inject authentication logic. + + This method wraps the original route handler to ensure that the session + is populated in request.state.session before calling the handler. + + If the endpoint is marked as public, it will not raise an AuthException + when the session is not found or invalid. + """ + original_route_handler = super().get_route_handler() + + async def custom_route_handler(request: Request) -> Response: + try: + request.state.session = self._get_session(request) + except AuthException as e: + if not getattr(self.endpoint, 'is_public', False): + raise e + + response = await original_route_handler(request) + return response + + return custom_route_handler diff --git a/app/api/agentops/auth/schemas.py b/app/api/agentops/auth/schemas.py new file mode 100644 index 000000000..b6d8fd399 --- /dev/null +++ b/app/api/agentops/auth/schemas.py @@ -0,0 +1,84 @@ +from typing import Literal +import pydantic + + +class BaseSchema(pydantic.BaseModel): + """ + Base schema type intended to be used for creating input schemas. + """ + + pass + + +class BaseResponse(BaseSchema): + """ + Base response type intended to be directly populated by a sqlalchemy model. + """ + + model_config = pydantic.ConfigDict( + from_attributes=True, + ) + + +class StatusResponse(BaseResponse): + """ + Status response type intended to be used for simple success/failure responses. + """ + + success: bool = True + message: str | None = None + + +class RedirectMessageResponse(StatusResponse): + """ + Response type for redirecting to a specific URL. + """ + + url: str + + +class LoginSchema(BaseSchema): + """ + Schema for login data. + """ + + email: str + password: str + + +class OTPSchema(BaseSchema): + """ + Schema for the request to send a one-time password (OTP) to the user's email. + """ + + email: str + + +OAuthProvider = Literal["google", "github"] + + +class OAuthSchema(BaseSchema): + """ + Schema for the request to initiate OAuth login. + """ + + provider: OAuthProvider + redirect_to: str | None = None + + +class SignupSchema(BaseSchema): + """ + Schema for user signup data. + """ + + email: str + password: str + full_name: str + + +class PasswordResetSchema(BaseSchema): + """ + Schema for the request to reset a user's password. + """ + + email: str diff --git a/app/api/agentops/auth/session.py b/app/api/agentops/auth/session.py new file mode 100644 index 000000000..a6e1049d0 --- /dev/null +++ b/app/api/agentops/auth/session.py @@ -0,0 +1,93 @@ +from typing import Optional +from dataclasses import dataclass +from uuid import uuid4, UUID + +from agentops.common import cache +from .environment import AUTH_SESSION_EXPIRY + + +def _make_key(session_id: str | UUID) -> str: + """Generate a cache key for a session ID.""" + return f"agentops.session:{session_id}" + + +@dataclass +class Session: + """ + User session management using a cache backend. + + This class provides methods for creating, retrieving, extending, and expiring + user sessions, with each session associating a unique session ID with a user ID. + Sessions are stored in the cache with a configurable expiry time (AUTH_SESSION_EXPIRY). + + Usage: + ```python + # Create a new session + session = Session.create(user_id=user.id) + + # Get an existing session + if session := Session.get(session_id): + # Session is valid, user is authenticated + user_id = session.user_id + + # Extend session expiry + session.extend() + + # Log out by expiring the session + session.expire() + ``` + """ + + session_id: UUID + user_id: UUID + + @classmethod + def get(cls, session_id: str | UUID) -> Optional['Session']: + """ + Retrieve a session by its ID. + + Args: + session_id (str | UUID): The session ID to look up + + Returns: + Optional[Session]: Session object if found, None otherwise + """ + session_id = str(session_id) + if user_id := cache.get(_make_key(session_id)): + return cls( + session_id=UUID(session_id), + user_id=UUID(user_id), + ) + + return None + + @classmethod + def create(cls, user_id: UUID) -> 'Session': + """ + Create a new session for a user. + + Args: + user_id (UUID): The user ID to associate with the session + + Returns: + Session: The newly created session + """ + session = cls(uuid4(), user_id) + cache.setex(_make_key(session.session_id), AUTH_SESSION_EXPIRY, str(session.user_id)) + return session + + def extend(self) -> None: + """ + Extend the session's expiry time. + + Resets the expiry time to AUTH_SESSION_EXPIRY seconds from now. + """ + return cache.expire(_make_key(self.session_id), AUTH_SESSION_EXPIRY) + + def expire(self) -> None: + """ + Delete the session from the cache. + + Used for logout operations or to invalidate a session. + """ + return cache.delete(_make_key(self.session_id)) diff --git a/app/api/agentops/auth/templates/auth_callback.html b/app/api/agentops/auth/templates/auth_callback.html new file mode 100644 index 000000000..16ef90430 --- /dev/null +++ b/app/api/agentops/auth/templates/auth_callback.html @@ -0,0 +1,66 @@ +{# +Auth Callback Handler + +Supabase redirects to this page after authentication. + +We process the parameters in JavaScript because they are only present on the URL +hash, which prevents it from ever being leaked in logs and to proxies, but means +that it is not accessible by the server. + +CSP is enforced as strictly as possible by passing a random nonce to the body and +via the `Content-Security-Policy` header that only allows the script inside this +template, as marked by the nonce, to run. No external scripts are allowed. +(Note that if there is ever a need to load external content into this page, the CSP +policies we have in place will need to be re-evaluated.) + +`window.location.hash` must *always* be called when this page is loaded to prevent +sensitive data in the URL from being stored in the browser history. + +We also set the `Referrer-Policy` header to `no-referrer` to prevent the +browser from sending the URL of this page to the next page, just in case. + +Given these constraints, the only way to leak sensitive data is if the user +has a malicious browser extension that reads the URL and sends it to an attacker, +or if the user manually copies and pastes the URL. + +#} + + + + + + + Logging in... + + + + + + + + \ No newline at end of file diff --git a/app/api/agentops/auth/views.py b/app/api/agentops/auth/views.py new file mode 100644 index 000000000..09e3e40bb --- /dev/null +++ b/app/api/agentops/auth/views.py @@ -0,0 +1,554 @@ +# HTTP only cookie- allowed to be accessed during requests only; not accessible to javascript +# set to agentops.ai domain to share across subdomains +# store session ID in cookie, reference central session store (redis?) +# extend session expiration +30 mins when it is used to extend login +# require MFA when editing sensitive information + +# supabase returns the tokens as part of the URL hash, which makes them harder to leak; +# they won't show up in logs/proxies/etc but we must call window.location.replace to +# remove them from the browser history + +# we use the returned hash params to query the supabase backed which returns a +# Supabase JWT, containing the user_id, among other fields. +# after validating that JWT, we create our own session ID, store it in the session +# store backend, and then JWT-encode the session_id before storing it as an +# HTTP-only cookie + +# since we host the auth callback on the api subdomain it doesn't need to live +# across domains + +## Reasons for not using client-side JWTs +# JWT stores session state client-side, so avoids central session store +# can be accessed from javascript if stored in local storage +# JWTs can be signed to prevent tampering, but not encrypted +# JWTs can be set to expire after a certain amount of time, but not extendable, +# not invalidatable from a central location +# can be used across domains, which is useful but also XSS risk +from typing import Union, Callable +import os +from functools import wraps +import inspect +import base64 +import uuid +import jwt +from pathlib import Path +import urllib.parse + +import pydantic +from fastapi import Request, Response +from fastapi.exceptions import HTTPException +from fastapi.responses import JSONResponse, HTMLResponse, RedirectResponse +from jinja2 import Environment, FileSystemLoader +import gotrue + +from agentops.api.log_config import logger +from agentops.common.route_config import reverse_path, BaseView +from agentops.common.environment import DASHBOARD_URL, API_DOMAIN, API_URL, APP_URL +from agentops.common import rate_limit +from agentops.api.db.supabase_client import get_supabase # TODO move this + +from .environment import ( + SUPABASE_JWT_SECRET, + AUTH_COOKIE_SECRET, + AUTH_COOKIE_NAME, + AUTH_COOKIE_EXPIRY, + AUTH_JWT_ALGO, + AUTH_ADDITIONAL_REFERERS, +) +from .schemas import ( + StatusResponse, + RedirectMessageResponse, + LoginSchema, + OTPSchema, + OAuthProvider, + OAuthSchema, + SignupSchema, + PasswordResetSchema, +) +from .exceptions import AuthException +from .session import Session + +TEMPLATE_DIR = Path(__file__).parent / "templates" +templates = Environment(loader=FileSystemLoader(TEMPLATE_DIR)) + + +_all__ = [ + 'public_route', + 'auth_callback', + 'auth_code', + 'auth_session', + 'auth_login', + 'auth_otp', + 'auth_oauth', + 'auth_signup', + 'auth_password_reset', + 'auth_logout', +] + + +OAUTH_SCOPES: dict[OAuthProvider, str] = { + 'github': "read:user user:email", + 'google': "https://www.googleapis.com/auth/userinfo.email https://www.googleapis.com/auth/userinfo.profile", +} +# don't redirect to these pages after login/signup; this prevents from returning users +# to the signin page if that's where they started +REDIRECT_OVERRIDES = ( + "/signin", + "/signup", +) + + +def _get_api_domain() -> str: + """ + Removes the port from the development domain. + """ + return API_DOMAIN.split(':')[0] + + +class SupabaseUserData(pydantic.BaseModel): + """ + Dataclass for data extracted from a Supabase JWT. + """ + + model_config = {'extra': 'ignore'} + + iss: str # Issuer: The URL of your Supabase project + sub: str # Subject: The user's UUID + iat: int # Issued At: When the token was created + exp: int # Expiration Time: When the token expires + aud: str # Audience: Usually "authenticated" + + email: str # The user's email address + role: str # The user's role (typically "authenticated") + app_metadata: dict # Contains information like the provider used for authentication + user_metadata: dict # Custom data associated with the user, such as their name + session_id: str # A unique identifier for the current session + + +def _decode_supabase_jwt(token: str) -> SupabaseUserData: + """ + Decode the Supabase JWT to get the available data about the authenticated user. + """ + # Add leeway to account for clock skew between Supabase and our server + user_info = jwt.decode( + token, SUPABASE_JWT_SECRET, algorithms=['HS256'], audience="authenticated", leeway=10 + ) + return SupabaseUserData(**user_info) + + +def _encode_session_cookie(session: Session) -> str: + """ + Encode the session as a JWT for use in setting our own session cookie. + + Currently this just includes the session_id in order to avoid storing any + sensitive information in the cookie. + """ + session_id = str(session.session_id) + return jwt.encode({"session_id": session_id}, AUTH_COOKIE_SECRET, algorithm=AUTH_JWT_ALGO) + + +def _decode_session_cookie(cookie: str) -> Session | None: + """ + Decode the session cookie to get the Session object. + Raises AuthException if the cookie is invalid or expired. + Returns None if the session is not found. + """ + try: + data = jwt.decode(cookie, AUTH_COOKIE_SECRET, algorithms=[AUTH_JWT_ALGO]) + return Session.get(data['session_id']) + except (KeyError, jwt.InvalidTokenError): + raise AuthException("Could not decode internal session JWT.") + + +def _validate_request(request: Request) -> None: + """ + Validate the request to lock down public roues; 100% security through + obscurity, but better than nothing. + """ + + if 'localhost' in API_URL: + # Bypass all checks in local development + return + + # Railway always sets the x-forwarded-for header, so we can use that to get the + # original IP address of the request. This should never be empty, but maybe our + # IP address gets exposed and someone makes a direct request to the API? + forwarded_for = request.headers.get("x-forwarded-for") + if not forwarded_for: + logger.error("Request was made to a public route without a forwarded IP address.") + raise HTTPException(500) + + # Rate limit the request based on the forwarded IP address + rate_limit.record_interaction(forwarded_for) + if rate_limit.is_blocked(forwarded_for): + logger.warning(f"Rate limit exceeded for IP: {forwarded_for}") + raise HTTPException(429) + + # Check if the request was made to the correct host. This is also set by + # Railway, but we should check it anyway. + forwarded_host = request.headers.get("x-forwarded-host") + if forwarded_host != API_DOMAIN: + logger.error(f"Request was made to a public route from an unexpected host: {forwarded_host}") + raise HTTPException(500) + + # Check if the Origin header is present + # If this is missing this is a strong indicator we are being accessed outside a browser + origin = request.headers.get("origin") + if origin and not origin.startswith(APP_URL): + logger.warning(f"Request was made to a public route from an unexpected origin: {origin}") + raise HTTPException(500) + + # Check if the referrer header is present + # If this is missing this is a strong indicator we are being accessed outside a browser + referrer = request.headers.get("referer") + if referrer and not any(referrer.startswith(u) for u in (APP_URL, *AUTH_ADDITIONAL_REFERERS)): + logger.warning(f"Request was made to a public route from an unexpected referrer: {referrer}") + raise HTTPException(500) + + # Check for a user agent header. + # If this is missing this is a strong indicator we are being accessed outside a browser + user_agent = request.headers.get("user-agent") + if not user_agent: + logger.warning(f"Request was made to a public route from an unexpected user agent: {user_agent}") + raise HTTPException(500) + + +def public_route(decorated: Union[Callable, type[BaseView]]) -> Union[Callable, type[BaseView]]: + """ + Mark a route as public. + + We default to requiring authentication on all routes unless they are + explicitly marked as public. This is enforced by the middleware. + + Can be applied to functions or BaseView classes. + """ + + if inspect.isclass(decorated): + # class based views + if not issubclass(decorated, BaseView): + raise TypeError(f"Class {decorated.__name__} must inherit from BaseView to use @public_route") + + view_func = decorated.__call__ + + @wraps(view_func) + async def wrapper(self, *args, **kwargs): + # for BaseView, request is available as self.request + _validate_request(self.request) + return await view_func(self, *args, **kwargs) + + wrapper.is_public = True + decorated.__call__ = wrapper + return decorated + else: + # function-based views + @wraps(decorated) + async def wrapper(*args, **kwargs): + # for functions, request comes from kwargs + request = kwargs.get('request') + assert request is not None, "`Request` must be available to views decorated with `@public_route`" + _validate_request(request) + return await decorated(*args, **kwargs) + + wrapper.is_public = True + return wrapper + + +@public_route +async def auth_callback(request: Request) -> HTMLResponse: + """ + Serves the authentication callback page, which captures the tokens from the URL hash + and forwards them to our auth_session endpoint. + + This view just serves the HTML page, which is a simple JavaScript app that + captures the tokens from the URL hash and forwards them to our auth_session endpoint. + """ + # Content Security Policy headers prevent any scripts from running on the page, + # except those with the correct nonce + nonce = base64.b64encode(os.urandom(32)).decode('utf-8') + headers = { + 'Content-Security-Policy': f"script-src 'nonce-{nonce}'", + 'Referrer-Policy': 'no-referrer', + } + + # Check if there's a redirect_to parameter in the query string + redirect_to = request.query_params.get('redirect_to') + + # If no explicit redirect_to, check for invite parameter to construct the redirect + if not redirect_to: + invite_org_id = request.query_params.get('invite') + if invite_org_id: + redirect_to = f"{APP_URL}/settings/organization?invite={invite_org_id}" + else: + redirect_to = DASHBOARD_URL + + # Ensure the redirect URL is to our app domain for security + if not redirect_to.startswith(APP_URL): + redirect_to = DASHBOARD_URL + + template = templates.get_template('auth_callback.html') + content = template.render( + nonce=nonce, auth_session_url=reverse_path('auth_session'), dashboard_url=redirect_to + ) + + return HTMLResponse(content=content, headers=headers) + + +def _create_session_for_response(response: Response, access_token: str) -> Response: + """ + Create a session for the user based on the access token and set the session cookie in the response. + """ + user_data: SupabaseUserData = _decode_supabase_jwt(access_token) + user_id = uuid.UUID(user_data.sub) + + session = Session.create(user_id) + + cookie_value = _encode_session_cookie(session) + + cookie_domain = _get_api_domain() + cookie_secure = 'https' in API_URL + + response.set_cookie( + key=AUTH_COOKIE_NAME, + value=cookie_value, + httponly=True, # not accessible to JavaScript + secure=cookie_secure, # only send over https in production + domain=cookie_domain, # set cookie for the api domain + max_age=AUTH_COOKIE_EXPIRY, + samesite="strict", + path="/", # valid across all paths + ) + + return response + + +@public_route +async def auth_code(request: Request, code: str) -> RedirectResponse: + """ + Handles the OAuth callback by exchanging the authorization code for a session. + This is the endpoint that the OAuth provider redirects to after the user has authenticated. + It expects a 'code' parameter in the query string, which is the authorization code + received from the OAuth provider. + """ + supabase_client = get_supabase() + + try: + auth_response = supabase_client.auth.exchange_code_for_session({'auth_code': code}) + except gotrue.errors.AuthApiError as e: + raise AuthException.from_gotrue_autherror(e) + + if hasattr(auth_response, 'error'): + raise AuthException("Failed to exchange code for session.") + + access_token = auth_response.session.access_token + + # TODO this often redirects back to the signin page, just send all users to the dashboard + # redirect_to = request.query_params.get('redirect_to') + # if redirect_to and redirect_to.startswith('/'): + # response = RedirectResponse(url=f"{APP_URL}{redirect_to}") + # else: + # response = RedirectResponse(url=DASHBOARD_URL) + + response = RedirectResponse(url=DASHBOARD_URL) + return _create_session_for_response(response, access_token) + + +# TODO annotate response type +@public_route +async def auth_session(request: Request) -> JSONResponse: + """ + Receives the auth payload from the callback, validates it, creates a session, + and returns a response with a cookie referencing the session. + """ + print("auth_session: Processing request") + + # we just pass the hash params directly into the body of the request + # so these are URL-encoded + body = await request.body() + print(f"auth_session: Raw body length: {len(body)}") + + params = urllib.parse.parse_qs(body.decode('utf-8')) + print(f"auth_session: Parsed params keys: {list(params.keys())}") + + access_token = params.get('access_token', [None])[0] + + if not access_token: + print("auth_session: ERROR - No access_token in request body") + raise AuthException("Invalid parameters passed to callback URL.") + + print("auth_session: Found access_token, attempting to decode JWT") + + try: + # Decode the JWT to see what user info we have + user_data = _decode_supabase_jwt(access_token) + print(f"auth_session: Decoded JWT for user {user_data.sub} with email {user_data.email}") + + # Check if this is an invite acceptance (look for invited_to_org in metadata) + invited_to_org = None + if user_data.user_metadata and 'invited_to_org' in user_data.user_metadata: + invited_to_org = user_data.user_metadata.get('invited_to_org') + print(f"auth_session: User is accepting invite to org {invited_to_org}") + except Exception as e: + print(f"auth_session: ERROR - Failed to decode JWT: {str(e)}") + raise AuthException("Failed to decode access token") + + content = StatusResponse(message="User authenticated successfully.") + response = JSONResponse(content=content.model_dump()) + + print("auth_session: Creating session and setting cookie") + result = _create_session_for_response(response, access_token) + print("auth_session: Session created successfully, returning response") + + return result + + +# TODO annotate response type +@public_route +async def auth_login(request: Request, body: LoginSchema) -> JSONResponse: + """ + Handle username/password logins. + """ + supabase = get_supabase() + # returns `AuthResponse` (.venv/lib/python3.12/site-packages/gotrue/types.py:95) + try: + auth_response = supabase.auth.sign_in_with_password( + { + 'email': body.email, + 'password': body.password, + } + ) + except gotrue.errors.AuthApiError as e: + raise AuthException.from_gotrue_autherror(e) + + if hasattr(auth_response, 'error'): + raise AuthException() + + access_token = auth_response.session.access_token + content = StatusResponse(message="User authenticated successfully.") + response = JSONResponse(content=content.model_dump()) + return _create_session_for_response(response, access_token) + + +@public_route +async def auth_otp(request: Request, body: OTPSchema) -> StatusResponse: + """ + Initiates the login flow by sending a one-time password (OTP) to the user's email. + """ + supabase = get_supabase() + try: + auth_response = supabase.auth.sign_in_with_otp( + { + 'email': body.email, + 'options': { + # set this to false if you do not want the user to be automatically signed up + 'should_create_user': False, + 'email_redirect_to': f"{API_URL}{reverse_path('auth_callback')}", + }, + } + ) + except gotrue.errors.AuthApiError as e: + raise AuthException.from_gotrue_autherror(e) + + if hasattr(auth_response, 'error'): + raise AuthException("Failed to send OTP.") + + return StatusResponse(message="Please check your email.") + + +@public_route +async def auth_oauth(request: Request, body: OAuthSchema) -> RedirectMessageResponse: + """ + Redirects the user to the OAuth provider for authentication. + """ + supabase = get_supabase() + provider = body.provider + redirect_url = f"{API_URL}{reverse_path('auth_code')}" + + if provider not in OAUTH_SCOPES: + raise AuthException(f"Unsupported OAuth provider: {provider}") + + # TODO re-enable this once invalid redirect destinations have been fixed in `auth_code` + # if body.redirect_to: + # params = urllib.parse.urlencode({"redirect_to": body.redirect_to}) + # redirect_url += f"?redirect_to={params}" + + try: + auth_response = supabase.auth.sign_in_with_oauth( + { + 'provider': provider, + 'options': { + 'redirect_to': redirect_url, + 'scopes': OAUTH_SCOPES[provider], + }, + } + ) + except gotrue.errors.AuthApiError as e: + raise AuthException.from_gotrue_autherror(e) + + if hasattr(auth_response, 'error'): + raise AuthException("Failed to initiate OAuth flow.") + + return RedirectMessageResponse( + message="Redirecting to OAuth provider...", + url=auth_response.url, + ) + + +@public_route +async def auth_signup(request: Request, body: SignupSchema) -> StatusResponse: + """ + Handles user signup by creating a new user with the provided email and password. + """ + supabase = get_supabase() + + try: + auth_response = supabase.auth.sign_up( + { + 'email': body.email, + 'password': body.password, + 'options': { + 'data': { + 'full_name': body.full_name, + } + }, + } + ) + except gotrue.errors.AuthApiError as e: + raise AuthException.from_gotrue_autherror(e) + + if hasattr(auth_response, 'error'): + raise AuthException("Failed to sign up user.") + + return StatusResponse(message="User signed up successfully.") + + +@public_route +async def auth_password_reset(request: Request, body: PasswordResetSchema) -> StatusResponse: + """ + Initiates a password reset flow by sending a reset email to the user. + """ + supabase = get_supabase() + + try: + # Use the frontend callback URL, same as the invite flow + redirect_url = f"{APP_URL}/auth/callback" + auth_response = supabase.auth.reset_password_for_email(body.email, {"redirect_to": redirect_url}) + except gotrue.errors.AuthApiError as e: + raise AuthException.from_gotrue_autherror(e) + + if hasattr(auth_response, 'error'): + raise AuthException("Failed to send password reset email.") + + return StatusResponse(message="Password reset email sent successfully.") + + +async def auth_logout(request: Request) -> StatusResponse: + """ + Signs the user out by clearing the session cookie and expiring the session. + """ + content = StatusResponse(message="User logged out successfully.") + response = JSONResponse(content=content.model_dump()) + + response.delete_cookie(key=AUTH_COOKIE_NAME, domain=_get_api_domain(), path="/") + request.state.session.expire() + + return response diff --git a/app/api/agentops/common/__init__.py b/app/api/agentops/common/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/api/agentops/common/cache.py b/app/api/agentops/common/cache.py new file mode 100644 index 000000000..d5470efcc --- /dev/null +++ b/app/api/agentops/common/cache.py @@ -0,0 +1,171 @@ +from agentops.api.log_config import logger +from .environment import ( + REDIS_HOST, + REDIS_PORT, + REDIS_USER, + REDIS_PASSWORD, +) + + +if REDIS_HOST and REDIS_PORT: + from redis import Redis + + logger.info("Using Redis cache for production.") + + _redis_creds = { + 'host': REDIS_HOST, + 'port': REDIS_PORT, + 'decode_responses': True, + } + if REDIS_USER and REDIS_PASSWORD: + _redis_creds['username'] = REDIS_USER + _redis_creds['password'] = REDIS_PASSWORD + + _backend = Redis(**_redis_creds) + +else: + import os + import sqlite3 + from collections import defaultdict + import time + + class BaseDevCache: + """ + Base class for local development cache. + + Includes noops for methods we don't need in local development. + """ + + def zadd(self, key: str, mapping: dict) -> None: + logger.warning("[agentops.common.cache] zadd() is not implemented in development") + + def zremrangebyscore(self, key: str, min: int, max: int) -> None: + logger.warning("[agentops.common.cache] zremrangebyscore() is not implemented in development") + + def zcount(self, key: str, min: int, max: int) -> int: + logger.warning("[agentops.common.cache] zcount() is not implemented in development") + return 0 + + class SimpleCache(BaseDevCache): + """In-memory cache for local development.""" + + def __init__(self): + self.store = defaultdict(lambda: None) + self.expiry = {} + + def get(self, key: str) -> str | None: + if key in self.expiry and time.time() > self.expiry[key]: + del self.store[key] + del self.expiry[key] + return None + return self.store[key] + + def setex(self, key: str, expiry: int, value: str) -> None: + self.store[key] = value + self.expiry[key] = time.time() + expiry + + def expire(self, key: str, expiry: int) -> None: + if key in self.store: + self.expiry[key] = time.time() + expiry + + def delete(self, key: str) -> None: + if key in self.store: + del self.store[key] + if key in self.expiry: + del self.expiry[key] + + class SQLiteCache(BaseDevCache): + """SQLite-backed cache for local development.""" + + def __init__(self): + self.db_path = os.path.join(os.getcwd(), "cache.db") + self.conn = sqlite3.connect(self.db_path) + self.conn.execute(""" + CREATE TABLE IF NOT EXISTS cache ( + key TEXT PRIMARY KEY, + value TEXT, + expiry INTEGER + ) + """) + self.conn.commit() + + def get(self, key: str) -> str | None: + cursor = self.conn.execute("SELECT value, expiry FROM cache WHERE key = ?", (key,)) + row = cursor.fetchone() + if row: + value, expiry = row + if expiry is not None and time.time() > expiry: + self.delete(key) + return None + return value + return None + + def setex(self, key: str, expiry: int, value: str) -> None: + expiry_time = int(time.time() + expiry) + self.conn.execute( + """ + INSERT OR REPLACE INTO cache (key, value, expiry) + VALUES (?, ?, ?) + """, + (key, value, expiry_time), + ) + self.conn.commit() + + def expire(self, key: str, expiry: int) -> None: + expiry_time = int(time.time() + expiry) + self.conn.execute( + """ + UPDATE cache SET expiry = ? WHERE key = ? + """, + (expiry_time, key), + ) + self.conn.commit() + + def delete(self, key: str) -> None: + self.conn.execute("DELETE FROM cache WHERE key = ?", (key,)) + self.conn.commit() + + if os.path.exists("/.dockerenv"): + logger.info("Using in-memory cache for local development.") + _backend = SimpleCache() + elif os.environ.get('GITHUB_ACTIONS') == 'true': + logger.info("Using in-memory cache for GitHub Actions.") + _backend = SimpleCache() + else: + logger.info("Using SQLite cache for local development.") + _backend = SQLiteCache() + + +def get(key: str) -> str | None: + """Get a value from the cache by key.""" + return _backend.get(key) + + +def setex(key: str, expiry: int, value: str) -> None: + """Set a value in the cache with an expiry time.""" + _backend.setex(key, expiry, value) + + +def expire(key: str, expiry: int) -> None: + """Set the expiry time for a key in the cache.""" + _backend.expire(key, expiry) + + +def delete(key: str) -> None: + """Delete a key from the cache.""" + _backend.delete(key) + + +def zadd(key: str, mapping: dict) -> None: + """Add elements to a sorted set.""" + _backend.zadd(key, mapping) + + +def zremrangebyscore(key: str, min: int, max: int) -> None: + """Remove elements from a sorted set by score.""" + _backend.zremrangebyscore(key, min, max) + + +def zcount(key: str, min: int, max: int) -> int: + """Count elements in a sorted set by score.""" + return _backend.zcount(key, min, max) diff --git a/app/api/agentops/common/environment.py b/app/api/agentops/common/environment.py new file mode 100644 index 000000000..ff073216f --- /dev/null +++ b/app/api/agentops/common/environment.py @@ -0,0 +1,97 @@ +import os + +# Base URLs and domains +APP_DOMAIN = os.getenv("APP_DOMAIN", "app.agentops.ai") +API_DOMAIN = os.getenv("API_DOMAIN", "api.agentops.ai") + +# Protocol - defaults to https but can be overridden for local development +PROTOCOL = os.getenv("PROTOCOL", "https") + +# Full base URLs +APP_URL = f"{PROTOCOL}://{APP_DOMAIN}" +API_URL = f"{PROTOCOL}://{API_DOMAIN}" + +# Common application URLs +DASHBOARD_URL = f"{APP_URL}/projects" +LOGIN_URL = f"{APP_URL}/login" + +# CORS Configuration +ALLOWED_ORIGINS = [ + APP_URL, +] + + +SQLALCHEMY_LOG_LEVEL = os.environ.get("SQLALCHEMY_LOG_LEVEL") + + +SUPABASE_URL = os.getenv("SUPABASE_URL") +SUPABASE_KEY = os.getenv("SUPABASE_KEY") + +# Supabase Postgres connection details +SUPABASE_HOST = os.getenv('SUPABASE_HOST') +SUPABASE_PORT = os.getenv('SUPABASE_PORT') +SUPABASE_DATABASE = os.getenv('SUPABASE_DATABASE') +SUPABASE_USER = os.getenv('SUPABASE_USER') +SUPABASE_PASSWORD = os.getenv('SUPABASE_PASSWORD') + +# Supabase allows up to 20 pool connections and 1000 max connections. +# Since we share connections with other instances (dev, staging) these defaults +# are kept low and are expected to be overridden in production. +# pool sizes are referenced *both* for the direct psycopg connection pool and +# the SQLAlchemy connection pool (so in practice they are doubled) +SUPABASE_MIN_POOL_SIZE: int = int(os.getenv('SUPABASE_MIN_POOL_SIZE', 1)) +SUPABASE_MAX_POOL_SIZE: int = int(os.getenv('SUPABASE_MAX_POOL_SIZE', 10)) + +# you can see the max pool size with (observed to be 240): +# SELECT name, setting +# FROM pg_settings +# WHERE name IN ('max_connections', 'superuser_reserved_connections'); + +# you can see active connections with: +# SELECT count(*) AS total, state, usename, backend_type +# FROM pg_stat_activity +# GROUP BY state, usename, backend_type; + + +REDIS_HOST = os.getenv('REDIS_HOST') +REDIS_PORT = os.getenv('REDIS_PORT') +REDIS_USER = os.getenv('REDIS_USER') +REDIS_PASSWORD = os.getenv('REDIS_PASSWORD') + + +# enable rate limiting on public endpoints (default: false) +RATE_LIMIT_ENABLE: bool = os.getenv("RATE_LIMIT_ENABLE", "false").lower() == "true" +# Window time for counting rate limited requests +RATE_LIMIT_WINDOW: int = int(os.getenv("RATE_LIMIT_WINDOW", 60)) # 60 seconds (1 minute) +# Maximum allowed requests within the window +RATE_LIMIT_COUNT: int = int(os.getenv("RATE_LIMIT_COUNT", 6)) # 6 requests per minute +# How long to keep the rate limit key in cache after exceeding limits +RATE_LIMIT_EXPIRY: int = int(os.getenv("RATE_LIMIT_EXPIRY", 60 * 60)) # 1 hour + + +# number of users to allow for free users +FREEPLAN_MAX_USERS: int = int(os.getenv('FREEPLAN_MAX_USERS', 1)) +# # number or orgs to allow for free users +# TODO since freeplan is at the org level do we only allow a user to belong to one org? +# FREEPLAN_MAX_ORGS = int(os.getenv('FREEPLAN_MAX_ORGS', 1)) +# number of projects to allow for free users +FREEPLAN_MAX_PROJECTS: int = int(os.getenv('FREEPLAN_MAX_PROJECTS', 1)) + +# number of days we allow access to metrics data for free users +FREEPLAN_METRICS_DAYS_CUTOFF: int = int(os.getenv('FREEPLAN_METRICS_DAYS_CUTOFF', 30)) + +# number of days to allow access to traces for free users +FREEPLAN_TRACE_DAYS_CUTOFF: int = int(os.getenv('FREEPLAN_TRACE_DAYS_CUTOFF', 3)) +# minimum number of traces to include in a trace view +FREEPLAN_TRACE_MIN_NUM: int = int(os.getenv('FREEPLAN_TRACE_MIN_NUM', 3)) +# number of spans to include the full contents of in a trace detail view +FREEPLAN_SPANS_LIST_LIMIT: int = int(os.getenv('FREEPLAN_SPANS_LIST_LIMIT', 30)) + +# number of lines to show in the logs for free users +FREEPLAN_LOGS_LINE_LIMIT: int = int(os.getenv('FREEPLAN_LOGS_LINE_LIMIT', 100)) + +# TODO 10,000 spans per month is not enforced. + +# GitHub Oauth +GITHUB_CLIENT_ID = os.environ.get("GITHUB_OAUTH_CLIENT_ID") +GITHUB_CLIENT_SECRET = os.environ.get("GITHUB_OAUTH_CLIENT_SECRET") diff --git a/app/api/agentops/common/freeplan.py b/app/api/agentops/common/freeplan.py new file mode 100644 index 000000000..b8a894dce --- /dev/null +++ b/app/api/agentops/common/freeplan.py @@ -0,0 +1,202 @@ +from typing import Any +from datetime import datetime, timedelta, timezone +import pydantic + + +# Free: +# 30 spans in waterfall +# 100 lines of logs +# one project +# one seat +# one org +# metrics up to one month lookback +# 5,000 spans per month +# cant view traces older than 3 days other than last 3 traces regardless how old +# Pro: +# 100,000 spans per month included +# tool costs +# evals +# notifications +# exports +# custom attributes +# cost breakdowns by model +# enterprise: +# whateva you want babyy + + +def freeplan_clamp_datetime(dt: None | datetime, days: int) -> datetime: + """ + Clamp a datetime object to a maximum number of days in the past for free plan users. + + If the provided datetime is older than the cutoff date (further in the past), + returns the cutoff date. Otherwise, returns the original datetime. + """ + cutoff = datetime.now(timezone.utc) - timedelta(days=days) + return max(dt, cutoff) if dt else cutoff + + +def freeplan_clamp_start_time(start_time: None | datetime, days: int) -> tuple[datetime, bool]: + """ + Clamp a start_time datetime for freeplan users and return whether it was modified. + + Args: + start_time: The original start time (can be None) + days: Number of days to allow in the past + + Returns: + tuple[datetime, bool]: (clamped_datetime, was_modified) + - clamped_datetime: The final datetime to use + - was_modified: True if the original value was changed for freeplan limits + """ + clamped = freeplan_clamp_datetime(start_time, days) + return clamped, (start_time is None or clamped != start_time) + + +def freeplan_clamp_end_time(end_time: None | datetime, days: int) -> tuple[datetime, bool]: + """ + Clamp an end_time datetime for freeplan users and return whether it was modified. + + Args: + end_time: The original end time (can be None) + days: Number of days to allow in the past + + Returns: + tuple[datetime, bool]: (clamped_datetime, was_modified) + - clamped_datetime: The final datetime to use + - was_modified: True if the original value was changed for freeplan limits + """ + # If end_time is not provided, we start freeplan users at the current time + actual_end_time = end_time if end_time is not None else datetime.now(timezone.utc) + clamped = freeplan_clamp_datetime(actual_end_time, days) + return clamped, (end_time is None or clamped != actual_end_time) + + +class FreePlanFilteredResponse(pydantic.BaseModel): + """ + Base class for responses that need to be filtered for free plan users. + + This class provides three mechanisms to control the data returned to free plan users: + 1. Exclude certain fields from the response (replacing them with empty values) + 2. Truncate list fields to a maximum number of items + 3. Truncate string fields to a maximum number of lines + + When the `freeplan_truncated` flag is set to True, the `model_dump` method will apply + these restrictions to the response. + + Attributes: + _freeplan_exclude (tuple[str]): A tuple of field names to be excluded from the response. + _freeplan_maxitems (dict[str, int]): A dictionary mapping field names to the maximum + number of items allowed in that list field. + _freeplan_maxlines (dict[str, int]): A dictionary mapping field names to the maximum + number of lines allowed in that string field. + freeplan_truncated (bool): A flag to indicate whether the response should be restricted + for free plan users. + + Example for field exclusion: + + class MyResponse(FreePlanFilteredResponse): + _freeplan_exclude = ('field1', 'field2') + + field1: str + field2: str + field3: str + + response = MyResponse(field1='value1', field2='value2', field3='value3') + response.freeplan_truncated = True + + print(response.model_dump()) # {'field3': 'value3', 'field1': '', 'field2': ''} + + Example for item truncation: + class MyResponse(FreePlanFilteredResponse): + _freeplan_maxitems = {'list_field': 2} + + list_field: list[str] + + response = MyResponse(list_field=['item1', 'item2', 'item3', 'item4']) + response.freeplan_truncated = True + + print(response.model_dump()) # {'list_field': ['item1', 'item2']} + + Example for line truncation: + + class MyResponse(FreePlanFilteredResponse): + _freeplan_maxlines = {'multiline_field': 3} + + multiline_field: str + + response = MyResponse(multiline_field='line1\\nline2\\nline3\\nline4\\nline5') + response.freeplan_truncated = True + + print(response.model_dump()) # {'multiline_field': 'line1\\nline2\\nline3'} + """ + + # fields to return empty values for in freeplans + _freeplan_exclude: tuple[str] = () + # list fields to return truncated values for in freeplans (limit number of items) + _freeplan_maxitems: dict[str, int] = {} + # string fields to return truncated values for in freeplans (limit line length) + _freeplan_maxlines: dict[str, int] = {} + + freeplan_truncated: bool = False # flag to activate this filtering + + def _freeplan_get_empty_fields(self) -> dict[str, Any]: + """Get the fields we're filtering as empty values of the expected type.""" + # we want to always adhere to the schema in the returned data, so we instantiate + # the fields as empty values of the expected type + fields = {} + + for field in self._freeplan_exclude: + field_type = self.__annotations__.get(field) + fields[field] = field_type() if field_type else None + + return fields + + def model_dump(self, **kwargs): + """Override model_dump to exclude fields we don't allow with freeplan""" + if not self.freeplan_truncated: + # if the flag is not set, just call the default implementation + return super().model_dump(**kwargs) + + # by default pydantic doesn't call the model_dump method on nested models + # so we need to do that manually here + dump = {} + exclude = kwargs.get('exclude', []) + + def _is_model(obj: Any) -> bool: + return isinstance(obj, pydantic.BaseModel) + + def _dump_list(value: list) -> list: + return [item.model_dump(**kwargs) if _is_model(item) else item for item in value] + + def _apply_max_lines(value: str, max_lines: int) -> str: + """Apply max lines to a string value.""" + return "\n".join(value.splitlines()[:max_lines]) + + for field, value in self.__dict__.items(): + if field in exclude: + continue # support default behavior of `exclude` + + if field in self._freeplan_exclude: + continue # save resources by not serializing skipped fields + + if _is_model(value): + dump[field] = value.model_dump(**kwargs) + elif isinstance(value, list): + dump[field] = _dump_list(value) + else: + dump[field] = value + + if field in self._freeplan_maxitems: + # restrict the field to a maximum number of items + assert isinstance(dump[field], list), f"Field {field} must be a list to truncate item count" + max_items: int = self._freeplan_maxitems[field] + dump[field] = dump[field][:max_items] + + if field in self._freeplan_maxlines: + # restrict the field to a maximum number of lines + assert isinstance(dump[field], str), f"Field {field} must be a string to truncate line count" + max_lines: int = self._freeplan_maxlines[field] + dump[field] = _apply_max_lines(dump[field], max_lines) + + # overwrite the fields we don't allow with freeplan + return {**dump, **self._freeplan_get_empty_fields()} diff --git a/app/api/agentops/common/lifespan.py b/app/api/agentops/common/lifespan.py new file mode 100644 index 000000000..fa96ae519 --- /dev/null +++ b/app/api/agentops/common/lifespan.py @@ -0,0 +1,37 @@ +from contextlib import asynccontextmanager +from fastapi import FastAPI +import logging +from .postgres import close_connection as close_postgres +from ..api.db.clickhouse_client import close_clickhouse_clients +from ..api.db.supabase_client import close_supabase_clients + +logger = logging.getLogger(__name__) + + +@asynccontextmanager +async def lifespan(app: FastAPI): + """Manage application lifecycle.""" + # Startup + logger.info("Starting up AgentOps API...") + + yield + + logger.info("Shutting down AgentOps API...") + + try: + close_postgres() + logger.info("PostgreSQL connections closed") + except Exception as e: + logger.error(f"Error closing PostgreSQL: {e}") + + try: + await close_clickhouse_clients() + logger.info("ClickHouse connections closed") + except Exception as e: + logger.error(f"Error closing ClickHouse: {e}") + + try: + await close_supabase_clients() + logger.info("Supabase clients closed") + except Exception as e: + logger.error(f"Error closing Supabase: {e}") diff --git a/app/api/agentops/common/middleware.py b/app/api/agentops/common/middleware.py new file mode 100644 index 000000000..cf9f8259b --- /dev/null +++ b/app/api/agentops/common/middleware.py @@ -0,0 +1,58 @@ +from fastapi import Request, Response +from starlette.middleware.base import BaseHTTPMiddleware +from fastapi.responses import JSONResponse +from agentops.api.log_config import logger + + +DEFAULT_CONTENT_TYPE = "application/json" + + +class DefaultContentTypeMiddleware(BaseHTTPMiddleware): + """Middleware to set default Content-Type if not set by the view""" + + async def dispatch(self, request: Request, call_next) -> Response: + response = await call_next(request) + + if "content-type" not in response.headers: + response.headers["content-type"] = DEFAULT_CONTENT_TYPE + + return response + + +class CacheControlMiddleware(BaseHTTPMiddleware): + """Middleware to set cache control headers on responses""" + + async def dispatch(self, request: Request, call_next) -> Response: + response = await call_next(request) + + if "cache-control" not in response.headers: + response.headers["cache-control"] = "no-store, no-cache, must-revalidate, max-age=0" + if "pragma" not in response.headers: + response.headers["pragma"] = "no-cache" + if "expires" not in response.headers: + response.headers["expires"] = "0" + + return response + + +class ExceptionMiddleware(BaseHTTPMiddleware): + """Middleware to handle exceptions and return a JSON response""" + + async def dispatch(self, request: Request, call_next) -> Response: + """ + Return a JSON response with a 500 status code if an unhandled exception occurs. + + Intentionally exclude all information about the exception in the response. + + Note that `HTTPException`s are handled by FastAPI and will not reach this point. + """ + try: + response = await call_next(request) + return response + except Exception as e: + logger.error(f"Exception: {e}", exc_info=True) + + return JSONResponse( + status_code=500, + content={"error": "Internal Server Error"}, + ) diff --git a/app/api/agentops/common/openapi.py b/app/api/agentops/common/openapi.py new file mode 100644 index 000000000..a541bc948 --- /dev/null +++ b/app/api/agentops/common/openapi.py @@ -0,0 +1,95 @@ +""" +OpenAPI Schema Utilities + +Utilities for combining OpenAPI schemas from multiple FastAPI applications. +""" + +from fastapi import FastAPI +from fastapi.openapi.utils import get_openapi +from typing import Dict + + +def create_combined_openapi_fn( + main_app: FastAPI, + mounted_apps: Dict[str, FastAPI], + title: str = "Combined API", + version: str = "1.0.0", + description: str = "Combined API Schema", +): + """ + Create a function that combines OpenAPI schemas from multiple FastAPI apps. + + Args: + main_app: The main FastAPI application + mounted_apps: Dictionary of mounted apps with their mount paths as keys + title: Title for the combined OpenAPI schema + version: Version string for the combined schema + description: Description for the combined schema + + Returns: + A function that can be assigned to app.openapi + """ + + def custom_openapi(): + # Return cached schema if available + if main_app.openapi_schema: + return main_app.openapi_schema + + # Get the OpenAPI schema for the main app + openapi_schema = get_openapi( + title=title, + version=version, + description=description, + routes=main_app.routes, + ) + + # Add paths from mounted apps with proper prefixes + for mount_path, app in mounted_apps.items(): + # Skip apps mounted at root (these should be handled separately) + if mount_path == "/": + prefix = "" + else: + # Ensure mount_path starts with / and doesn't end with / + mount_path = "/" + mount_path.strip("/") + prefix = mount_path + + # Get schema for the mounted app + app_schema = get_openapi( + title=f"{app.title}" if hasattr(app, 'title') else "API", + version=version, + routes=app.routes, + ) + + # Add paths with appropriate prefix + for path, path_item in app_schema.get("paths", {}).items(): + # Handle root paths specially (e.g., "/" becomes "/api/") + if path == "/": + path = "" + # Add the path with the appropriate prefix + openapi_schema["paths"][f"{prefix}{path}"] = path_item + + # Merge components + if "components" in app_schema and "schemas" in app_schema["components"]: + if "components" not in openapi_schema: + openapi_schema["components"] = {} + if "schemas" not in openapi_schema["components"]: + openapi_schema["components"]["schemas"] = {} + + openapi_schema["components"]["schemas"].update(app_schema["components"]["schemas"]) + + # Merge security schemes if present + if "components" in app_schema and "securitySchemes" in app_schema["components"]: + if "components" not in openapi_schema: + openapi_schema["components"] = {} + if "securitySchemes" not in openapi_schema["components"]: + openapi_schema["components"]["securitySchemes"] = {} + + openapi_schema["components"]["securitySchemes"].update( + app_schema["components"]["securitySchemes"] + ) + + # Cache the schema + main_app.openapi_schema = openapi_schema + return main_app.openapi_schema + + return custom_openapi diff --git a/app/api/agentops/common/orm.py b/app/api/agentops/common/orm.py new file mode 100644 index 000000000..8a97af703 --- /dev/null +++ b/app/api/agentops/common/orm.py @@ -0,0 +1,176 @@ +from typing import Optional, Callable, Generator +import logging +from functools import wraps +from contextlib import contextmanager + +from sqlalchemy import create_engine, Engine +from sqlalchemy.orm import ( + sessionmaker, + selectinload, + joinedload, + Session, + DeclarativeBase, +) +from sqlalchemy.inspection import inspect +from sqlalchemy.orm.state import LoaderCallableStatus + +from agentops.common.environment import ( + API_DOMAIN, + SQLALCHEMY_LOG_LEVEL, + SUPABASE_MIN_POOL_SIZE, + SUPABASE_MAX_POOL_SIZE, +) + + +__all__ = [ + "require_loaded", + "get_orm_session", + "session_scope", + "selectinload", + "joinedload", + "Session", + "BaseModel", +] + + +logging.getLogger("sqlalchemy.engine").setLevel( + getattr( + logging, + str(SQLALCHEMY_LOG_LEVEL).upper(), + logging.ERROR, + ) +) + +_engine: Optional[Engine] = None + + +class BaseModel(DeclarativeBase): + pass + + +def patch_relationship() -> None: + """ + Patch the SQLAlchemy relationship function to raise an error if the relationship + is not loaded. This is useful for ensuring that relationships are always loaded + when accessed, preventing lazy loading in production code. + """ + import sqlalchemy.orm as orm + + _orig_relationship = orm.relationship + + def raise_lazy_relationships(*args, **kwargs): + """ + Override the default behavior of SQLAlchemy's relationship to raise an error + if the relationship is not loaded. This is useful for ensuring that + relationships are always loaded when accessed, preventing lazy loading + in production code. + """ + kwargs.setdefault("lazy", "raise") + return _orig_relationship(*args, **kwargs) + + orm.relationship = raise_lazy_relationships + + +if 'localhost' in API_DOMAIN: + # If running locally, patch `orm.relationship` to raise an error if not loaded. + patch_relationship() + + +def require_loaded(*fields) -> Callable: + """ + Decorator that requires that the specified fields are loaded before calling the + decorated function. + + This is useful for ensuring that relationships are loaded before accessing them, + since we can encounter false negatives/positives and do not ever want to run + lazy loading in production code. + + Usage: + + class MyModel(BaseModel): + related_field1 = relationship("RelatedModel1") + related_field2 = relationship("RelatedModel2") + + @require_loaded('related_field1', 'related_field2') + def my_method(self): + return self.related_field1, self.related_field2 + """ + + def decorator(fn): + @wraps(fn) + def wrapper(self, *args, **kwargs): + state = inspect(self) + for field in fields: + attr_state = state.attrs.get(field) + try: + assert attr_state is not None + assert hasattr(attr_state, 'loaded_value') + assert attr_state.loaded_value is not LoaderCallableStatus.NO_VALUE + except AssertionError: + raise RuntimeError(f"relationship '{field}' not loaded for {self.__class__.__name__}") + + return fn(self, *args, **kwargs) + + return wrapper + + return decorator + + +def get_engine() -> Engine: + """ + Get the SQLAlchemy engine for the application. + """ + # import the ConnectionConfig late so that we ensure it has the correct values + # in testing, for example, we patch this to update it with test values + from .postgres import ConnectionConfig + + global _engine + + if _engine is None: + # create an engine in parallel with the supabase postgres connection. + # originally, I tried to utilize the existing pool, but it ended up being + # very unreliable in longer running tasks. it's possible we can dig deeper + # into the internals of psycopg_pool to make it work, but for now, + # we create a new engine that uses the same connection string. + _engine = create_engine( + ConnectionConfig.to_connection_string(protocol="postgresql+psycopg"), + pool_size=SUPABASE_MIN_POOL_SIZE, + max_overflow=SUPABASE_MAX_POOL_SIZE - SUPABASE_MIN_POOL_SIZE, + pool_pre_ping=True, # Test connections before use + pool_recycle=3600, # Recycle idle connections after 1 hour + ) + + return _engine + + +def _create_session() -> Session: + """Internal function to create a new SQLAlchemy session.""" + return sessionmaker(bind=get_engine(), expire_on_commit=False)() + + +def get_orm_session() -> Generator[Session, None, None]: + """ + Create a new SQLAlchemy ORM session. + When used with FastAPI's Depends(), it will automatically close the session. + Example: `orm: Session = Depends(get_orm_session)` + """ + session = _create_session() + try: + yield session + finally: + session.close() + + +@contextmanager +def session_scope() -> Generator[Session, None, None]: + """Provide a transactional scope around a series of operations.""" + session = _create_session() + try: + session.begin() + yield session + session.commit() + except Exception: + session.rollback() + raise + finally: + session.close() diff --git a/app/api/agentops/common/otel.py b/app/api/agentops/common/otel.py new file mode 100644 index 000000000..d576fd3ef --- /dev/null +++ b/app/api/agentops/common/otel.py @@ -0,0 +1,105 @@ +from typing import Any + + +def _is_array_index(key: str) -> bool: + """Check if a key represents an array index.""" + return key.isdigit() + + +def _migrate_legacy_gen_ai_prompt(result: dict) -> None: + """Handle legacy OpenAI agents format migration in-place.""" + if 'gen_ai' in result and isinstance(result['gen_ai'], dict): + if 'prompt' in result['gen_ai'] and isinstance(result['gen_ai']['prompt'], str): + # Convert legacy format to indexed format + legacy_prompt = result['gen_ai']['prompt'] + result['gen_ai']['prompt'] = [ + { + 'content': legacy_prompt, + 'role': 'user', # Default role for legacy data + } + ] + + +def otel_attributes_to_nested(attributes: dict[str, str]) -> dict[str, Any]: + """ + Convert OTEL attributes from a flat dictionary to a nested dictionary suitable + for JSON serialization. + + 'foo.bar.0.baz': 'value' -> {'foo': {'bar': [{'baz': 'value'}]}} + """ + result = {} + + for path, value in attributes.items(): + keys = path.split('.') + current = result + + # Navigate to the correct position + for i, key in enumerate(keys[:-1]): # All keys except the last + next_key = keys[i + 1] + + # Skip if we hit a string value (can't traverse into it) + if isinstance(current, str): + break + + if isinstance(current, list): + # Current is a list, key must be numeric + if not _is_array_index(key): + break # Type mismatch: string key on list + + key_int = int(key) + # Extend list if needed + while len(current) <= key_int: + # Determine what to append based on next key + if _is_array_index(next_key): + current.append([]) + else: + current.append({}) + current = current[key_int] + + elif isinstance(current, dict): + # Skip small numeric keys (0-9) on dicts as they likely indicate array indices + if _is_array_index(key) and int(key) < 10: + break # Type mismatch: numeric index on dict + + if key not in current: + # Create new structure based on next key + if next_key == "0": # Specifically "0" suggests array start + current[key] = [] + else: + current[key] = {} + + # Skip if the existing value is a string + if isinstance(current[key], str): + break + + current = current[key] + else: + break # Unexpected type + + else: # No break occurred, we can set the final value + final_key = keys[-1] + + # Skip if current is a string + if isinstance(current, str): + continue + + if isinstance(current, list): + # Current is a list, final key must be numeric + if not _is_array_index(final_key): + continue # Type mismatch + + key_int = int(final_key) + while len(current) <= key_int: + current.append(None) + current[key_int] = value + + elif isinstance(current, dict): + # Skip small numeric keys on dicts + if _is_array_index(final_key) and int(final_key) < 10: + continue # Type mismatch + current[final_key] = value + + # Apply legacy format migrations + _migrate_legacy_gen_ai_prompt(result) + + return result diff --git a/app/api/agentops/common/postgres.py b/app/api/agentops/common/postgres.py new file mode 100644 index 000000000..815092be3 --- /dev/null +++ b/app/api/agentops/common/postgres.py @@ -0,0 +1,84 @@ +import atexit +import signal +import logging +from psycopg_pool import ConnectionPool +from .environment import ( + SUPABASE_HOST, + SUPABASE_PORT, + SUPABASE_DATABASE, + SUPABASE_USER, + SUPABASE_PASSWORD, + SUPABASE_MIN_POOL_SIZE, + SUPABASE_MAX_POOL_SIZE, +) + +logger = logging.getLogger(__name__) +_supabase_pool: ConnectionPool | None = None + + +class ConnectionConfig: + """ + Connection configuration for Supabase. + + This is an intermediary because it allows us to easily modify the vars in tests. + """ + + host: str = SUPABASE_HOST + port: str | int = SUPABASE_PORT + database: str = SUPABASE_DATABASE + user: str = SUPABASE_USER + password: str = SUPABASE_PASSWORD + + def __init__(self) -> None: + """Non-instantiable class has a lower chance of being printed.""" + raise NotImplementedError("Cannot instantiate ConnectionConfig.") + + @classmethod + def to_connection_string(cls, protocol: str = "postgresql") -> str: + """Format config as a URL connection string.""" + return f"{protocol}://{cls.user}:{cls.password}@{cls.host}:{cls.port}/{cls.database}" + + +def _cleanup_handler(signum=None, frame=None): + """Universal cleanup handler for both signals and atexit.""" + logger.info(f"Cleanup handler called (signal: {signum})") + close_connection() + + +def get_connection(config: type[ConnectionConfig] = ConnectionConfig) -> ConnectionPool: + """ + Get the global Supabase Postgres connection pool. + """ + global _supabase_pool + + if _supabase_pool is None: + _supabase_pool = ConnectionPool( + config.to_connection_string(), + min_size=SUPABASE_MIN_POOL_SIZE, + max_size=SUPABASE_MAX_POOL_SIZE, + ) + + # Register cleanup handlers + atexit.register(_cleanup_handler) + signal.signal(signal.SIGTERM, _cleanup_handler) + signal.signal(signal.SIGINT, _cleanup_handler) + + logger.info(f"PostgreSQL pool created: min={SUPABASE_MIN_POOL_SIZE}, max={SUPABASE_MAX_POOL_SIZE}") + + return _supabase_pool + + +def close_connection() -> None: + """ + Close the global Supabase Postgres connection pool. + """ + global _supabase_pool + + if _supabase_pool is not None: + try: + _supabase_pool.close() + logger.info("PostgreSQL connection pool closed successfully") + except Exception as e: + logger.error(f"Error closing PostgreSQL pool: {e}") + finally: + _supabase_pool = None diff --git a/app/api/agentops/common/rate_limit.py b/app/api/agentops/common/rate_limit.py new file mode 100644 index 000000000..57ed2072e --- /dev/null +++ b/app/api/agentops/common/rate_limit.py @@ -0,0 +1,66 @@ +import time + +from . import cache +from .environment import ( + RATE_LIMIT_ENABLE, + RATE_LIMIT_WINDOW, + RATE_LIMIT_COUNT, + RATE_LIMIT_EXPIRY, +) + +WINDOW_US = RATE_LIMIT_WINDOW * 1_000_000 # convert to microseconds + + +def _key(ip: str) -> str: + """Create a Redis key for the IP address.""" + return f"agentops.rate:{ip}" + + +def _now_us() -> int: + """Get the current time in microseconds.""" + return int(time.time() * 1_000_000) + + +def record_interaction(ip: str) -> None: + """ + Record an interaction from the given IP address. + Uses a sliding window approach with sorted sets in Redis. + """ + key, now = _key(ip), _now_us() + + cache.zremrangebyscore(key, 0, now - WINDOW_US) + cache.zadd(key, {str(now): now}) + cache.expire(key, RATE_LIMIT_EXPIRY) + + +def is_blocked(ip: str) -> bool: + """ + Check if the IP address is rate-limited. + Returns True if the number of recent requests exceeds RATE_LIMIT_COUNT. + Always returns False if RATE_LIMIT_ENABLE is False. + """ + if not RATE_LIMIT_ENABLE: + return False + + key, now = _key(ip), _now_us() + + count = cache.zcount(key, now - WINDOW_US, now) + return count > RATE_LIMIT_COUNT + + +def clear(ip: str) -> None: + """ + Clear rate limit records for the given IP. + This is primarily used for testing. + """ + key = _key(ip) + cache.delete(key) + + +def get_count(ip: str) -> int: + """ + Get the current count of requests for the given IP within the rate limit window. + This is primarily used for testing. + """ + key, now = _key(ip), _now_us() + return cache.zcount(key, now - WINDOW_US, now) diff --git a/app/api/agentops/common/route_config.py b/app/api/agentops/common/route_config.py new file mode 100644 index 000000000..b9216e4e8 --- /dev/null +++ b/app/api/agentops/common/route_config.py @@ -0,0 +1,210 @@ +from typing import Any, Callable, Optional, Union, TypeVar +from dataclasses import dataclass +from fastapi import APIRouter, Request +from abc import ABC, abstractmethod +import inspect + + +__all__ = ["RouteConfig", "BaseView", "register_routes", "reverse_path"] + +_path_registry: dict[str, str] = {} + + +class BaseView(ABC): + """ + Abstract base class for views in the route configuration. + This class must be extended to create specific views. + """ + + request: Request + + def __init__(self, request: Request): + self.request = request + + @classmethod + async def create(cls, **kwargs) -> 'BaseView': + """ + This method is called when the view is instantiated. + It can be overridden to perform any setup required for the view. + """ + return cls(**kwargs) + + @abstractmethod + async def __call__(self, *args, **kwargs): + """This method is called when the view is invoked.""" + ... + + +TBaseView = TypeVar('TBaseView', bound=BaseView) + + +def _apply_view_docs(wrapper: Callable, view_class: type[TBaseView]) -> None: + """Applies documentation-related attributes to the wrapper function from a class based view.""" + call_method = getattr(view_class, '__call__') + call_sig = inspect.signature(call_method) + + params = [] + has_request_param = any(name == 'request' for name in call_sig.parameters.keys()) + + for name, param in call_sig.parameters.items(): + if name == 'self': + # Only replace 'self' with 'request: Request' if there's no existing 'request' parameter + if not has_request_param: + param = inspect.Parameter( + 'request', + inspect.Parameter.POSITIONAL_OR_KEYWORD, + annotation=Request, + ) + else: + # Skip 'self' parameter if there's already a 'request' parameter + continue + params.append(param) + + wrapper.__doc__ = view_class.__doc__ # use the view class docstring + wrapper.__name__ = view_class.__dict__.get('__name__', view_class.__name__) + wrapper.__signature__ = inspect.Signature( + parameters=params, + return_annotation=call_sig.return_annotation, + ) + + +@dataclass +class RouteConfig: + """ + Route configuration for a FastAPI route. + + Usage with function endpoints: + ```python + from fastapi import APIRouter + from agentops.common.route_config import RouteConfig, register_routes + + route_config: list[RouteConfig] = [ + RouteConfig( + name="example_route", + path="/example", + endpoint=example_endpoint, + methods=["GET"], + ), + ] + router = APIRouter(prefix="/api") + register_routes(router, route_config) + + # use the router like you would normally + app.include_router(router) + + # this allows us to reverse paths by name + from agentops.common.route_config import reverse_path + path = reverse_path("example_route") + >> "/api/example" + ``` + + Usage with class-based views: + ```python + from agentops.common.route_config import BaseView, RouteConfig + + class ExampleView(BaseView): + __name__ = "Get Example Data" + + async def __call__(self, item_id: int) -> dict: + return {"id": item_id, "data": "example"} + + route_config: list[RouteConfig] = [ + RouteConfig( + name="example_view", + path="/example/{item_id}", + endpoint=ExampleView, + methods=["GET"], + ), + ] + ``` + """ + + name: str + path: str + endpoint: Union[Callable, type[TBaseView]] + methods: list[str] + summary: Optional[str] = None + description: Optional[str] = None + deprecated: Optional[bool] = None + + @property + def kwargs(self) -> dict[str, Any]: + return { + "summary": self.summary, + "description": self.description, + "deprecated": self.deprecated, + } + + def _create_class_view(self, view_class: type[TBaseView]) -> Callable: + async def wrapper(request: Request, **kwargs): + view_instance = await view_class.create(request=request) + + # filter kwargs to only include parameters that the __call__ method expects + call_method = getattr(view_instance, '__call__') + sig = inspect.signature(call_method) + filtered_kwargs = {} + for param_name, param in sig.parameters.items(): + if param_name in kwargs: + filtered_kwargs[param_name] = kwargs[param_name] + + return await view_instance(**filtered_kwargs) + + _apply_view_docs(wrapper, view_class) + + # copy is_public attribute from class __call__ method to wrapper for AuthenticatedRoute middleware + # TODO this is a bit too couple with agentops.auth for my taste, but we can fix that later. + if hasattr(view_class.__call__, 'is_public'): + wrapper.is_public = view_class.__call__.is_public + + return wrapper + + def as_view(self) -> Callable: + """ + Returns the appropriate callable for this route. + If endpoint is a class-based view, wraps it with request injection. + If endpoint is a function, returns it as-is. + """ + if not inspect.isclass(self.endpoint): + return self.endpoint + + if issubclass(self.endpoint, BaseView): + return self._create_class_view(self.endpoint) + + raise TypeError(f"`endpoint` {self.endpoint.__name__} must be a function or inherit from BaseView") + + +def reverse_path(route_name: str) -> Optional[str]: + """ + Reverse a path by name. + Args: + route_name (str): The name of the route to reverse (from `RouteConfig.name`) + """ + global _path_registry + + return _path_registry.get(route_name, None) + + +def register_routes(router: APIRouter, configs: list[RouteConfig], prefix: str = "") -> None: + """ + Registers a list of route configurations with a FastAPI router, applying an optional prefix. + + Args: + router (APIRouter): The FastAPI router to register the routes with. + configs (list[RouteConfig]): A list of RouteConfig objects defining the routes to register. + prefix (str): An optional prefix to prepend to the route paths. This is in addition to + any prefix already defined on the router itself and is used when adding an app + to a parent app with `app.mount()` (since we are not able to determine the prefix + of the parent app at runtime). + """ + global _path_registry + + for config in configs: + _path_registry[config.name] = f"{prefix}{router.prefix}{config.path}" + + for method in config.methods: + router.add_api_route( + path=config.path, + endpoint=config.as_view(), + methods=[method], + **config.kwargs, + ) diff --git a/app/api/agentops/common/sentry.py b/app/api/agentops/common/sentry.py new file mode 100644 index 000000000..9502a2905 --- /dev/null +++ b/app/api/agentops/common/sentry.py @@ -0,0 +1,56 @@ +""" +Callback handler for sanitizing Sentry events. + +This was created to address credential leaks from Supabase auth (gotrue) which +uses `TypedDict` for all internal data structures, which can be printed out +in variable extraction in Sentry events. + +A long-term solution would require patching the types in the `gotrue` library +to use a sanitizable type, but that is an extensive refactor. +""" + +from typing import Optional, Any + + +SENSITIVE_DATA_PLACEHOLDER = "[REDACTED]" + +# non-exhaustive list of vars to remove from Sentry events +REMOVE_VARS = { + "password", + "secret", + "token", + "api_key", +} + + +def _sanitize_dictionaries(vars: dict) -> dict: + """ + Recursively remove sensitive content from the given dictionary of variables. + """ + for key in list(vars): + if key.lower() in REMOVE_VARS: + vars[key] = SENSITIVE_DATA_PLACEHOLDER + elif isinstance(vars[key], dict): + vars[key] = _sanitize_dictionaries(vars[key]) + elif isinstance(vars[key], list): + # Create a new list to hold the sanitized items + sanitized_list = [] + for i, item in enumerate(vars[key]): + if isinstance(item, dict): + sanitized_list.append(_sanitize_dictionaries(item)) + else: + sanitized_list.append(item) + vars[key] = sanitized_list + return vars + + +def sanitize_event(event: dict[str, Any], hint: dict[str, Any]) -> Optional[dict[str, Any]]: + if 'exception' not in event: + return event + + for value in event["exception"].get("values", []): + frames = value.get("stacktrace", {}).get("frames", []) + for frame in frames: + if frame_vars := frame.get("vars"): + frame['vars'] = _sanitize_dictionaries(frame_vars) + return event diff --git a/app/api/agentops/common/usage_tracking.py b/app/api/agentops/common/usage_tracking.py new file mode 100644 index 000000000..bbbb36597 --- /dev/null +++ b/app/api/agentops/common/usage_tracking.py @@ -0,0 +1,9 @@ +from enum import Enum + + +class UsageType(str, Enum): + """Types of usage we track for billing""" + + TOKENS = "tokens" + SPANS = "spans" + # Future: STORAGE = "storage", COMPUTE = "compute", etc. diff --git a/app/api/agentops/common/views.py b/app/api/agentops/common/views.py new file mode 100644 index 000000000..c543d7bb2 --- /dev/null +++ b/app/api/agentops/common/views.py @@ -0,0 +1,47 @@ +import functools +from fastapi.responses import JSONResponse +from pydantic import BaseModel +from .environment import APP_URL + + +def add_cors_headers( + *, + origins: list[str] | None = None, + methods: list[str] | None = None, +): + """ + Render a Pydantic object response as a JSON response with CORS headers. + + Use this decorator when you need control over individual views that need to + have CORS headers added to the response. + + Arguments: + origins: List of allowed origins for CORS. Defaults to the APP_URL. + methods: List of allowed methods for CORS. Defaults to GET, OPTIONS. + """ + + if origins is None: + origins = [APP_URL] + + if methods is None: + methods = ["GET", "OPTIONS"] + + def decorator(func): + @functools.wraps(func) + async def wrapper(*args, **kwargs) -> JSONResponse: + response_object: BaseModel = await func(*args, **kwargs) + assert isinstance(response_object, BaseModel), "View must return a Pydantic model" + + return JSONResponse( + content=response_object.model_dump(), + headers={ + "Access-Control-Allow-Origin": ', '.join(origins), + "Access-Control-Allow-Credentials": "true", + "Access-Control-Allow-Methods": ', '.join(methods), + "Access-Control-Allow-Headers": "*", + }, + ) + + return wrapper + + return decorator diff --git a/app/api/agentops/deploy/__init__.py b/app/api/agentops/deploy/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/api/agentops/deploy/app.py b/app/api/agentops/deploy/app.py new file mode 100644 index 000000000..86962333b --- /dev/null +++ b/app/api/agentops/deploy/app.py @@ -0,0 +1,33 @@ +from fastapi import FastAPI, APIRouter +from fastapi.middleware.cors import CORSMiddleware + +from agentops.common.environment import ALLOWED_ORIGINS +from agentops.common.middleware import ( + CacheControlMiddleware, + DefaultContentTypeMiddleware, + ExceptionMiddleware, +) +from agentops.common.route_config import register_routes +from agentops.auth.middleware import AuthenticatedRoute + +from .routes import route_config + +__all__ = ["app"] + +app = FastAPI(title="Deploy") + +app.add_middleware( + CORSMiddleware, + allow_origins=ALLOWED_ORIGINS, + allow_credentials=True, + allow_methods=["GET", "POST", "DELETE", "OPTIONS"], + allow_headers=["*"], +) + +app.add_middleware(DefaultContentTypeMiddleware) +app.add_middleware(CacheControlMiddleware) +app.add_middleware(ExceptionMiddleware) + +router = APIRouter(route_class=AuthenticatedRoute) +register_routes(router, route_config, prefix="/deploy") +app.include_router(router) diff --git a/app/api/agentops/deploy/models.py b/app/api/agentops/deploy/models.py new file mode 100644 index 000000000..2d2be38e5 --- /dev/null +++ b/app/api/agentops/deploy/models.py @@ -0,0 +1,99 @@ +from __future__ import annotations +from typing import Optional +from uuid import UUID +import sqlalchemy.exc +from sqlalchemy import orm +from sqlalchemy.orm import joinedload, deferred +import sqlalchemy as model +from agentops.common.orm import BaseModel +import jockey + + +def normalize_uuid(id_: str | UUID) -> UUID: + """Normalize value to a UUID.""" + return UUID(id_) if isinstance(id_, str) else id_ + + +class HostingProjectModel(BaseModel): + """Model that maps to the deploy.projects table""" + + __tablename__ = "projects" + __table_args__ = {"schema": "deploy"} + + id = model.Column(model.UUID, model.ForeignKey("public.projects.id"), primary_key=True) + github_oath_access_token = model.Column(model.String, nullable=True) + user_callback_url = model.Column(model.String, nullable=True) + watch_path = model.Column(model.String, nullable=True) + entrypoint = model.Column(model.String, nullable=True) + git_branch = model.Column(model.String, nullable=True) # which branch to deploy (could be tag or hash) + git_url = model.Column(model.String, nullable=True) # repo url + # TODO remove `deferred` once migration has been applied. + pack_name = deferred(model.Column(model.String, nullable=True, default=None)) + + project = orm.relationship("agentops.opsboard.models.ProjectModel") + + @property + def namespace(self) -> str: + """ + Get the Kubernetes namespace for this deployment. + + Used to ensure isolation of resources between users. + """ + # Use project_id as namespace + return str(self.id) + + @property + def app_name(self) -> str: + """ + Get the application name for this deployment. + + Used to identify resources related to this deployment. + TODO update the app_labels upstream to make this more explicit. + """ + return str(self.id) + + @property + def deployment_config(self) -> jockey.DeploymentConfig: + """Get the deployment configuration for this project.""" + # TODO we can simplify this after the migration runs + try: + pack_name = self.pack_name + except sqlalchemy.exc.ProgrammingError: + pack_name = None + + return jockey.DeploymentConfig.from_pack( + pack_name, + namespace=self.namespace, + project_id=self.id, + github_access_token=self.github_oath_access_token, + repository_url=self.git_url, + branch=self.git_branch, + entrypoint=self.entrypoint, + watch_path=self.watch_path, + agentops_api_key=str(self.project.api_key), + callback_url=self.user_callback_url, + secret_names=jockey.list_secrets(self.namespace, self.id), + ) + + @classmethod + def get_by_id(cls, session: orm.Session, project_id: str | UUID) -> Optional[HostingProjectModel]: + """Get a hosting project by ID with project and org relationships preloaded.""" + from agentops.opsboard.models import ProjectModel + + return ( + session.query(cls) + .filter(cls.id == normalize_uuid(project_id)) + .options(joinedload(cls.project).joinedload(ProjectModel.org)) + .first() + ) + + @classmethod + def get_or_create_by_id(cls, session: orm.Session, project_id: str | UUID) -> HostingProjectModel: + """Get or create a hosting project by ID.""" + + if not (instance := cls.get_by_id(session, project_id)): + instance = cls(id=normalize_uuid(project_id)) + session.add(instance) + session.commit() + session.refresh(instance) + return instance diff --git a/app/api/agentops/deploy/routes.py b/app/api/agentops/deploy/routes.py new file mode 100644 index 000000000..6ec4bdef6 --- /dev/null +++ b/app/api/agentops/deploy/routes.py @@ -0,0 +1,135 @@ +from agentops.common.route_config import RouteConfig +from agentops.deploy.views.setup import ( + GithubListReposView, + GithubOAuthCallbackView, +) +from agentops.deploy.views.deploy import ( + CreateUpdateSecretView, + ListSecretsView, + DeleteSecretView, + UpdateDeploymentView, + InitiateBuildView, + InitiateDeploymentView, + InitiateRunView, + DeploymentStatusView, + DeploymentBuildLogView, + DeploymentHistoryView, + ListUserDeploymentsView, + DeleteDeploymentView, +) + + +route_config: list[RouteConfig] = [ + RouteConfig( + name='github_auth', + path="/github/auth", + endpoint=GithubOAuthCallbackView, + methods=["GET"], + summary="Github authorization callback", + description="Exchange github auth code for access_token and store in new or updated deploy project", + ), + RouteConfig( + name='fetch_user_repos', + path="/github/repos", + endpoint=GithubListReposView, + methods=["GET"], + summary="List repositories user has access to", + description="List the repositories the user has allowed the integration to have access to", + ), + RouteConfig( + name='create_update_secret', + path="/deployments/{project_id}/secrets", + endpoint=CreateUpdateSecretView, + methods=["POST"], + summary="Create or update a secret for a project", + description="Create or update a secret key-value pair for a specific project deployment", + ), + RouteConfig( + name='list_secrets', + path="/deployments/{project_id}/secrets", + endpoint=ListSecretsView, + methods=["GET"], + summary="List secrets for a project", + description="Get all secret names for a specific project deployment (values are not returned for security)", + ), + RouteConfig( + name='delete_secret', + path="/deployments/{project_id}/secrets/{secret_name}", + endpoint=DeleteSecretView, + methods=["DELETE"], + summary="Delete a secret for a project", + description="Delete a specific secret key-value pair for a project deployment", + ), + RouteConfig( + name='initiate_build', + path="/deployments/{project_id}/build", + endpoint=InitiateBuildView, + methods=["POST"], + summary="Build image only", + description="Build and push Docker image without creating deployment resources", + ), + RouteConfig( + name='initiate_deployment', + path="/deployments/{project_id}/launch", + endpoint=InitiateDeploymentView, + methods=["POST"], + summary="Initiate a project deployment", + description="Start the deployment process for a specific project", + ), + RouteConfig( + name='initiate_run', + path="/deployments/{project_id}/run", + endpoint=InitiateRunView, + methods=["POST"], + summary="Run agent job", + description="Build image and run as one-time job with input data", + ), + RouteConfig( + name='deployment_status', + path="/deployments/{project_id}/jobs/{job_id}/status", + endpoint=DeploymentStatusView, + methods=["GET"], + summary="Get deployment job status and events", + description="Get the current status and event history for a specific deployment job", + ), + RouteConfig( + name='deployment_build_logs', + path="/deployments/{project_id}/jobs/{job_id}/logs", + endpoint=DeploymentBuildLogView, + methods=["GET"], + summary="Stream build logs from builder pod", + description="Stream real-time build logs from the builder pod for a specific deployment job", + ), + RouteConfig( + name='deployment_history', + path="/deployments/{project_id}/history", + endpoint=DeploymentHistoryView, + methods=["GET"], + summary="Get project deployment history", + description="Get all deployment jobs and their status for a project", + ), + RouteConfig( + name='update_deployment', + path="/deployments/{project_id}", + endpoint=UpdateDeploymentView, + methods=["POST"], + summary="Update deployment configuration", + description="Update the deployment configuration for a specific project", + ), + RouteConfig( + name='update_deployment', + path="/deployments", + endpoint=ListUserDeploymentsView, + methods=["GET"], + summary="Get a list of all deployments (projects)", + description="Get a list of all the projects a user has access ", + ), + RouteConfig( + name='delete_deployment', + path="/deployments/{project_id}", + endpoint=DeleteDeploymentView, + methods=["DELETE"], + summary="Delete a deployment", + description="Delete a deployment and clean up associated resources for a specific project", + ), +] diff --git a/app/api/agentops/deploy/schemas.py b/app/api/agentops/deploy/schemas.py new file mode 100644 index 000000000..769390104 --- /dev/null +++ b/app/api/agentops/deploy/schemas.py @@ -0,0 +1,122 @@ +from typing import Optional, Any +from enum import Enum +from datetime import datetime +import pydantic +from agentops.opsboard.schemas import OrgSummaryResponse + + +class StatusResponse(pydantic.BaseModel): + success: bool + message: str + + +class DeploymentStatusResponse(StatusResponse): + job_id: str + + +class DeploymentEventSchema(pydantic.BaseModel): + type: str + status: str + message: str + timestamp: datetime + + @pydantic.field_validator('timestamp', mode='before') + def validate_timestamp(cls, value: datetime) -> str: + if not isinstance(value, datetime): + raise ValueError(f"`timestamp` must be a datetime, got {type(value)}") + return value.isoformat() + + @pydantic.field_validator('status', mode='before') + def validate_status(cls, value: Enum) -> str: + if not isinstance(value, Enum): + raise ValueError(f"`status` must be an Enum, got {type(value)}") + return value.value + + +class DeploymentEventResponse(pydantic.BaseModel): + events: list[DeploymentEventSchema] = pydantic.Field(default_factory=list) + + +class DeploymentJobSchema(pydantic.BaseModel): + id: str + queued_at: str + status: str + message: str + + +class DeploymentHistoryResponse(pydantic.BaseModel): + jobs: list[DeploymentJobSchema] = pydantic.Field(default_factory=list) + + +class SecretSchema(pydantic.BaseModel): + name: str + value: Optional[str] = None + + +class CreateSecretRequest(pydantic.BaseModel): + name: str + value: str + + +class UpdateDeploymentRequest(pydantic.BaseModel): + github_oath_access_token: Optional[str] = None + user_callback_url: Optional[str] = None + watch_path: Optional[str] = None + entrypoint: Optional[str] = None + git_branch: Optional[str] = None + git_url: Optional[str] = None + + +class ListSecretsResponse(pydantic.BaseModel): + secrets: list[SecretSchema] = pydantic.Field(default_factory=list) + + +class RunJobRequest(pydantic.BaseModel): + """Request schema for running a job with input data.""" + + inputs: dict[str, Any] = pydantic.Field( + description="Input data to pass to the agent", + examples=[{"topic": "AI trends", "format": "summary"}], + ) + callback_url: Optional[str] = pydantic.Field( + description="Callback URL to receive run results. No callback URL will use the project default", + examples=["https://your-callback-url.com"], + default=None, + ) + + +class HostingProjectResponse(pydantic.BaseModel): + """ + Combined response that includes both project and hosting project data. + This matches the frontend IHostingProject interface. + """ + + # Project fields + id: str + name: str + api_key: str + org_id: str + environment: str + org: OrgSummaryResponse + trace_count: int = 0 + + # Hosting project fields + git_url: Optional[str] = None + git_branch: Optional[str] = None + entrypoint: Optional[str] = None + watch_path: Optional[str] = None + user_callback_url: Optional[str] = None + github_oath_access_token: Optional[str] = None + + @pydantic.field_validator("id", "api_key", "org_id", mode="before") + @classmethod + def validate_uuid(cls, v): + from agentops.opsboard.schemas import uuid_to_str + + return uuid_to_str(v) + + @pydantic.field_validator("environment", mode="before") + @classmethod + def validate_environment_enum(cls, v): + """Convert the environment Enum to a string.""" + return v.value if isinstance(v, Enum) else v diff --git a/app/api/agentops/deploy/views/__init__.py b/app/api/agentops/deploy/views/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/api/agentops/deploy/views/deploy.py b/app/api/agentops/deploy/views/deploy.py new file mode 100644 index 000000000..f91f75b3b --- /dev/null +++ b/app/api/agentops/deploy/views/deploy.py @@ -0,0 +1,433 @@ +from datetime import datetime +import logging + +from fastapi import Depends, HTTPException +from fastapi.responses import StreamingResponse +from sqlalchemy.orm import Session, joinedload + +from jockey import ( + TaskType, + BaseEvent, + queue_task, + get_task_status, + get_task_events, + get_tasks, + create_secret, + delete_secret, + list_secrets, + delete_deployment_resources, +) +from jockey.backend.models.image import Image + +from agentops.common.orm import get_orm_session +from agentops.common.route_config import BaseView +from agentops.opsboard.models import ProjectModel +from agentops.deploy.models import HostingProjectModel +from agentops.deploy.schemas import ( + StatusResponse, + HostingProjectResponse, + UpdateDeploymentRequest, + DeploymentJobSchema, + RunJobRequest, + DeploymentStatusResponse, + DeploymentEventSchema, + DeploymentEventResponse, + DeploymentHistoryResponse, + SecretSchema, + CreateSecretRequest, + ListSecretsResponse, +) + +logger = logging.getLogger(__name__) + +# project_id is the internal project ID that the deployment belongs to +# it is the same on both the `ProjectModel` and `HostingProjectModel` +# job_id is the ID generated by the deploy backend for the iteration of the deployment + + +class BaseDeploymentView(BaseView): + async def get_hosting_project(self, orm: Session, project_id: str) -> HostingProjectModel: + # load project in a separate query because ProjectModel.get_by_id loads a + # bunch of stuff we need for the auth check + if not (project := ProjectModel.get_by_id(orm, project_id)): + raise HTTPException(status_code=404, detail="Project not found") + + if not project.org.is_user_member(self.request.state.session.user_id): + raise HTTPException(status_code=404, detail="Project not found") + + return HostingProjectModel.get_or_create_by_id(orm, project_id) + + +class CreateUpdateSecretView(BaseDeploymentView): + async def __call__( + self, + project_id: str, + body: CreateSecretRequest, + orm: Session = Depends(get_orm_session), + ) -> StatusResponse: + """ + Create or update a secret for a deployment. + + This will be stored directly on the k8s cluster. + """ + project: HostingProjectModel = await self.get_hosting_project(orm, project_id) + delete_secret(project.namespace, project.id, body.name) + create_secret(project.namespace, project.id, body.name, body.value) + + return StatusResponse(success=True, message="Successfully created secret") + + +class ListSecretsView(BaseDeploymentView): + async def __call__( + self, + project_id: str, + orm: Session = Depends(get_orm_session), + ) -> ListSecretsResponse: + """ + List all secrets for a deployment + + Currently, we just list the names of the keys and doesn't allow retrieval of values for security. + """ + project: HostingProjectModel = await self.get_hosting_project(orm, project_id) + secret_names: list[str] = list_secrets(project.namespace, project.id) + + return ListSecretsResponse( + secrets=[SecretSchema(name=name) for name in secret_names], + ) + + +class DeleteSecretView(BaseDeploymentView): + async def __call__( + self, + project_id: str, + secret_name: str, + orm: Session = Depends(get_orm_session), + ) -> StatusResponse: + """ + Delete a secret for a deployment. + + This will remove the secret from the k8s cluster. + """ + project: HostingProjectModel = await self.get_hosting_project(orm, project_id) + delete_secret(project.namespace, project.id, secret_name) + + return StatusResponse(success=True, message="Successfully deleted secret") + + +class UpdateDeploymentView(BaseDeploymentView): + async def __call__( + self, + project_id: str, + body: UpdateDeploymentRequest, + orm: Session = Depends(get_orm_session), + ) -> StatusResponse: + """ + Update deployment configuration for a project. + + Updates the HostingProjectModel with the provided values. + Only non-None values in the request will be updated. + """ + project: HostingProjectModel = await self.get_hosting_project(orm, project_id) + + for field_name, field_value in body.model_dump(exclude_none=True).items(): + if hasattr(project, field_name): + setattr(project, field_name, field_value) + + orm.commit() + + return StatusResponse( + success=True, + message="Deployment configuration updated successfully", + ) + + +class InitiateBuildView(BaseDeploymentView): + async def __call__( + self, + project_id: str, + orm: Session = Depends(get_orm_session), + ) -> DeploymentStatusResponse: + """ + Build image only without deploying. + + This endpoint builds the Docker image and pushes it to the registry + but does not create any Kubernetes deployment resources. + """ + project: HostingProjectModel = await self.get_hosting_project(orm, project_id) + + # Queue the build job for background processing + job_id = queue_task( + TaskType.BUILD, + config=project.deployment_config, + project_id=project.id, + ) + + return DeploymentStatusResponse( + success=True, + message="Image build queued successfully", + job_id=job_id, + ) + + +class InitiateDeploymentView(BaseDeploymentView): + async def __call__( + self, + project_id: str, + orm: Session = Depends(get_orm_session), + ) -> DeploymentStatusResponse: + """ + Initiate a deployment for a project. + + Takes config from the `HostingProjectModel` and queues a deployment job. + """ + project: HostingProjectModel = await self.get_hosting_project(orm, project_id) + + job_id = queue_task( + TaskType.SERVE, + config=project.deployment_config, + project_id=project.id, + ) + + return DeploymentStatusResponse( + success=True, + message="Deployment initiated successfully", + job_id=job_id, + ) + + +class InitiateRunView(BaseDeploymentView): + async def __call__( + self, + project_id: str, + body: RunJobRequest, + orm: Session = Depends(get_orm_session), + ) -> DeploymentStatusResponse: + """ + Build image and run as a one-time job with input data. + + This endpoint builds the image (if needed) and then runs it as a + Kubernetes Job that executes once with the provided input data + and returns the result. + """ + project: HostingProjectModel = await self.get_hosting_project(orm, project_id) + + # Queue the job run for background processing + job_id = queue_task( + TaskType.RUN, + config=project.deployment_config, + project_id=project.id, + inputs=body.inputs, + callback_url=body.callback_url, + ) + + return DeploymentStatusResponse( + success=True, + job_id=job_id, + message="Job execution queued successfully", + ) + + +class DeploymentStatusView(BaseDeploymentView): + async def __call__( + self, + project_id: str, + job_id: str, + start_date: datetime | None = None, + orm: Session = Depends(get_orm_session), + ) -> DeploymentEventResponse: + """ + Get a list of events from a specific deployment job. + + If `start_date` is provided, only events after that date will be returned. + This is useful for polling new events since the last check. + If no `start_date` is provided, all events will be returned. + """ + project: HostingProjectModel = await self.get_hosting_project(orm, project_id) + events: list[BaseEvent] = get_task_events( + job_id=job_id, + start_time=start_date, + ) + + return DeploymentEventResponse( + events=[ + DeploymentEventSchema( + type=event.event_type, + status=event.status, + message=event.message, + timestamp=event.timestamp, + ) + for event in events + ], + ) + + +class DeploymentBuildLogView(BaseDeploymentView): + async def __call__( + self, + project_id: str, + job_id: str, + orm: Session = Depends(get_orm_session), + ) -> StreamingResponse: + """ + Stream build logs from the builder pod for a specific deployment job. + + Args: + project_id: The project ID + job_id: The deployment job ID + orm: Database session + + Returns: + StreamingResponse with plain text logs + """ + project: HostingProjectModel = await self.get_hosting_project(orm, project_id) + + # Use job_id to find the builder pod (builder pods are now named with job_id) + if not (pod := Image.get_builder_pod(project.namespace, job_id)): + raise HTTPException(status_code=404, detail=f"Builder pod not found for job {job_id}") + + # TODO this is not flushing mid-stream for some reason. + return StreamingResponse( + pod.stream_logs(project.namespace), + media_type="text/event-stream", + headers={ + "Cache-Control": "no-cache, no-store, must-revalidate", + "Pragma": "no-cache", + "Expires": "0", + "Connection": "keep-alive", + # "X-Accel-Buffering": "no", + # "X-Content-Type-Options": "nosniff", + }, + ) + + +class DeploymentHistoryView(BaseDeploymentView): + async def __call__( + self, + project_id: str, + orm: Session = Depends(get_orm_session), + ) -> DeploymentHistoryResponse: + """ + Get a list of deployments and their last status event for a specific project. + """ + project: HostingProjectModel = await self.get_hosting_project(orm, project_id) + + jobs = [] + for job in get_tasks(project.namespace, project.id): + status_event: BaseEvent = get_task_status(job["job_id"]) + + try: + status = status_event.status.value + message = status_event.message + except (IndexError, AttributeError): + status = "unknown" + message = "" + + jobs.append( + DeploymentJobSchema( + id=job["job_id"], + queued_at=job["queued_at"], + status=status, + message=message, + ) + ) + + return DeploymentHistoryResponse(jobs=jobs) + + +class ListUserDeploymentsView(BaseDeploymentView): + async def __call__( + self, + orm: Session = Depends(get_orm_session), + ) -> list[HostingProjectResponse]: + """ + Get all projects for the current user that have a deployment (HostingProjectModel). + Returns combined data from both ProjectModel and HostingProjectModel. + """ + user_id = self.request.state.session.user_id + + # Get all projects the user has access to + projects = ProjectModel.get_all_for_user(orm, user_id) + project_ids = [p.id for p in projects] + + if not project_ids: + return [] + + # Query HostingProjectModel for all records with a matching project id + hosting_projects = ( + orm.query(HostingProjectModel) + .filter(HostingProjectModel.id.in_(project_ids)) + .options(joinedload(HostingProjectModel.project).joinedload(ProjectModel.org)) + .all() + ) + + # Create a mapping of project_id to hosting_project for easy lookup + hosting_project_map = {hp.id: hp for hp in hosting_projects} + + # Combine data from both models + combined_projects = [] + for project in projects: + if project.id in hosting_project_map: + hosting_project = hosting_project_map[project.id] + + # Create combined response + combined_project = HostingProjectResponse( + # Project fields + id=project.id, + name=project.name, + api_key=project.api_key, + org_id=project.org_id, + environment=project.environment, + org=project.org, + trace_count=0, # TODO: Add actual trace count if needed + # Hosting project fields + git_url=hosting_project.git_url, + git_branch=hosting_project.git_branch, + entrypoint=hosting_project.entrypoint, + watch_path=hosting_project.watch_path, + user_callback_url=hosting_project.user_callback_url, + github_oath_access_token=hosting_project.github_oath_access_token, + ) + + combined_projects.append(combined_project) + + return combined_projects + + +class DeleteDeploymentView(BaseDeploymentView): + async def __call__( + self, + project_id: str, + orm: Session = Depends(get_orm_session), + ) -> StatusResponse: + """ + Delete a deployment for a project. + + This will remove the HostingProjectModel record and clean up any associated resources. + """ + project: HostingProjectModel = await self.get_hosting_project(orm, project_id) + + # Delete all Kubernetes resources associated with the deployment + # This includes deployments, services, ingress, and secrets + deployment_name = project_id # Use project_id as deployment name + namespace = project.namespace + + try: + success = delete_deployment_resources( + namespace=namespace, deployment_name=deployment_name, deployment_id=project_id + ) + + if not success: + logger.warning(f"Some Kubernetes resources failed to delete for project {project_id}") + # Continue with database deletion even if k8s cleanup had issues + except Exception as e: + logger.error(f"Error during Kubernetes cleanup for project {project_id}: {e}") + # Continue with database deletion even if k8s cleanup failed + + # Delete the HostingProjectModel record + orm.delete(project) + orm.commit() + + return StatusResponse( + success=True, + message="Deployment deleted successfully", + ) diff --git a/app/api/agentops/deploy/views/setup.py b/app/api/agentops/deploy/views/setup.py new file mode 100644 index 000000000..4498492ba --- /dev/null +++ b/app/api/agentops/deploy/views/setup.py @@ -0,0 +1,127 @@ +import requests +from fastapi import Depends, HTTPException +from agentops.common.orm import get_orm_session, Session +from ...opsboard.models import ProjectModel +from ...opsboard.schemas import StatusResponse +from ..models import HostingProjectModel +from agentops.common.route_config import BaseView +from agentops.common.environment import GITHUB_CLIENT_ID, GITHUB_CLIENT_SECRET + + +class GithubOAuthCallbackView(BaseView): + """ + Exchange GitHub OAuth code for access token and store it in the deploy.projects table. + """ + + async def __call__( + self, + project_id: str, + code: str, + orm: Session = Depends(get_orm_session), + ) -> StatusResponse: + project = ProjectModel.get_by_id(orm, project_id) + if not project: + raise HTTPException(status_code=404, detail="Project not found") + + if not GITHUB_CLIENT_ID or not GITHUB_CLIENT_SECRET: + raise HTTPException(status_code=500, detail="GitHub OAuth not configured in the API") + + # Exchange code for access token + token_url = "https://github.com/login/oauth/access_token" + headers = {"Accept": "application/json"} + data = { + "client_id": GITHUB_CLIENT_ID, + "client_secret": GITHUB_CLIENT_SECRET, + "code": code, + } + try: + resp = requests.post(token_url, headers=headers, data=data) + resp.raise_for_status() + token_data = resp.json() + access_token = token_data.get("access_token") + if not access_token: + error = token_data.get("error") + raise HTTPException(status_code=400, detail="Failed to retrieve access token from GitHub. Error: " + error) + + # Create or update deploy.projects row + deploy_project = orm.query(HostingProjectModel).filter_by(id=project.id).first() + if not deploy_project: + deploy_project = HostingProjectModel( + id=project.id, + github_oath_access_token=access_token, + ) + orm.add(deploy_project) + else: + deploy_project.github_oath_access_token = access_token + orm.commit() + return StatusResponse(message="GitHub access token stored successfully in deploy.projects") + except Exception as e: + raise HTTPException(status_code=500, detail=f"GitHub OAuth failed: {str(e)}") + + +class GithubListReposView(BaseView): + """ + Use the project's stored GitHub access token to list repos the user has access to. + Handles pagination to fetch all repositories. + """ + + async def __call__( + self, + project_id: str, + orm: Session = Depends(get_orm_session), + ) -> list[dict]: + project = HostingProjectModel.get_by_id(orm, project_id) + if not project: + raise HTTPException(status_code=404, detail="Project not found") + if not project.github_oath_access_token: + raise HTTPException(status_code=400, detail="No GitHub access token stored for this project") + + headers = { + "Authorization": f"Bearer {project.github_oath_access_token}", + "Accept": "application/vnd.github+json", + } + + all_repos = [] + page = 1 + per_page = 100 # Maximum allowed by GitHub API + + try: + while True: + params = { + "page": page, + "per_page": per_page, + "sort": "created", # Sort by creation date + "direction": "desc" # Most recent first + } + + resp = requests.get("https://api.github.com/user/repos", headers=headers, params=params) + resp.raise_for_status() + repos = resp.json() + + # If no repos returned, we've reached the end + if not repos: + break + + # Add repos from this page + all_repos.extend([ + { + "id": repo["id"], + "name": repo["name"], + "full_name": repo["full_name"], + "private": repo["private"], + "html_url": repo["html_url"], + "description": repo.get("description"), + } + for repo in repos + ]) + + # If we got fewer repos than per_page, we've reached the end + if len(repos) < per_page: + break + + page += 1 + + return all_repos + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Failed to fetch repos from GitHub: {str(e)}") \ No newline at end of file diff --git a/app/api/agentops/exporter/README.md b/app/api/agentops/exporter/README.md new file mode 100644 index 000000000..2e15ddb10 --- /dev/null +++ b/app/api/agentops/exporter/README.md @@ -0,0 +1,49 @@ +## Exporter + +Exporter takes data from the existing schema in SupaBase (postgres) and reformats +it into an OTEL format for writing to the ClickHouse backend. + +This service is used both for a one-time migration of all data we have accumulated +in postgres, as well as a parallel processor for all data that is still coming into +the legacy API endpoint. + +### Legacy API Endpoint + +Data will still be written to the existing server in the existing schema, but at the +same time a parallel stream will write otel-formatted data to the ClickHouse backend. + +### One-Time Migration + +A script that can be executed on demand to migrate all data from the existing postgres +schema and populate the ClickHouse backend. + +## Next Steps + +- Select a portion of the data from the production database to process. + - Spin up dev Supabase postgres instance. + - Spin up exporter processing instance. + - SELECT ... LIMIT 0, 10000; + - Write data into a throwaway ClickHouse instance. + - Profit??? + +## Noise + +v3 API (v2 in repo) + +/create_session +/update_session + + abandon the word session + session -> trace + +/create_events +/update_events +events -> span + +/create_agent +agent -> span (that holds other spans) +"every event belongs to an agent" + +/sessions/{session_id}/stats # should be superceeded by braelyn API + +92.5 GB of data diff --git a/app/api/agentops/exporter/__init__.py b/app/api/agentops/exporter/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/api/agentops/exporter/export.py b/app/api/agentops/exporter/export.py new file mode 100644 index 000000000..17f851f0e --- /dev/null +++ b/app/api/agentops/exporter/export.py @@ -0,0 +1,163 @@ +""" +Export data to ClickHouse. + +Takes data from the existing v2.py endpoints and formats it as Spans and Traces. + +Traces and their root spans share the same ID which comes from the Session ID. + +`exporter` is a terrible name, but here we are. +""" + +from agentops.api.log_config import logger +from agentops.api.db.supabase_client import get_async_supabase +from .models import Session, Agent, LLMEvent, ActionEvent, ToolEvent, ErrorEvent +from .models import Trace, Span +from .processor import ( + clickhouse_create_trace, + clickhouse_create_span, + clickhouse_update_span, +) + + +def _filter_for_updated_data(keys: list, data: dict) -> dict: + """Return just the selected fields from the data.""" + return {k: v for k, v in data.items() if k in keys} + + +async def _get_project_id(session_id: str) -> str: + """Get the project ID from the session ID.""" + supabase = await get_async_supabase() + session = await supabase.table('sessions').select('project_id').eq('id', session_id).single().execute() + return session.data['project_id'] + + +async def create_session(data: dict) -> None: + """Save session data to ClickHouse.""" + logger.info("Started creating ClickHouse session") + session = Session(**data) + trace: Trace = await session.to_trace() + await clickhouse_create_trace(trace) + logger.info(f"Created ClickHouse session as trace {trace}") + + +async def update_session(data: dict) -> None: + """Update session data for an existing record in ClickHouse.""" + assert 'id' in data, 'session_id must be provided to update session data.' + + session = Session(**data) + trace: Trace = await session.to_trace() + span: Span = trace.spans[0] + await clickhouse_update_span(span.span_id, span.to_clickhouse_dict()) + + +async def create_agent(data: dict) -> None: + """Save agent data to ClickHouse.""" + assert 'session_id' in data, 'session_id must be provided to create agent data.' + project_id = await _get_project_id(data['session_id']) + + agent = Agent(**data) + span = await agent.to_span( + trace_id=str(data['session_id']), parent_span_id=str(data['session_id']), project_id=str(project_id) + ) + await clickhouse_create_span(span) + logger.info(f"Created ClickHouse agent as span {span}") + + +async def update_agent(data: dict) -> None: + raise NotImplementedError('Pretty sure we never update agent data.') + + +async def create_llm_event(data: dict) -> None: + """Save LLM event data to ClickHouse.""" + assert 'session_id' in data, 'session_id must be provided to create LLM event data.' + assert 'agent_id' in data, 'agent_id must be provided to create LLM event data.' + project_id = await _get_project_id(data['session_id']) + + llm_event = LLMEvent(**data) + span: Span = await llm_event.to_span( + trace_id=str(data['session_id']), parent_span_id=str(data['agent_id']), project_id=str(project_id) + ) + await clickhouse_create_span(span) + logger.info(f"Created ClickHouse LLM event as span {span}") + + +async def update_llm_event(data: dict) -> None: + """Update LLM event data for an existing record in ClickHouse.""" + assert 'id' in data, 'id must be provided to update LLM event data.' + + llm_event = LLMEvent(**data) + span: Span = await llm_event.to_span() + await clickhouse_update_span(span.span_id, span.to_clickhouse_dict()) + logger.info(f"Updated ClickHouse LLM event as span {span}") + + +# data['session_id'] = '06246901-8691-4ae3-848e-69aec2d0722b' +async def create_action_event(data: dict) -> None: + """Save action event data to ClickHouse.""" + assert 'session_id' in data, 'session_id must be provided to create action event data.' + assert 'agent_id' in data, 'agent_id must be provided to create action event data.' + project_id = await _get_project_id(data['session_id']) + + action_event = ActionEvent(**data) + span: Span = await action_event.to_span( + trace_id=str(data['session_id']), parent_span_id=str(data['agent_id']), project_id=str(project_id) + ) + await clickhouse_create_span(span) + logger.info(f"Created ClickHouse action event as span {span}") + + +async def update_action_event(data: dict) -> None: + """Update action event data for an existing record in ClickHouse.""" + assert 'id' in data, 'Action Event ID must be provided to update action event data.' + + action_event = ActionEvent(**data) + span: Span = await action_event.to_span() + await clickhouse_update_span(span.span_id, span.to_clickhouse_dict()) + logger.info(f"Updated ClickHouse action event as span {span}") + + +async def create_tool_event(data: dict) -> None: + """Save tool event data to ClickHouse.""" + assert 'session_id' in data, 'session_id must be provided to create tool event data.' + assert 'agent_id' in data, 'agent_id must be provided to create tool event data.' + project_id = await _get_project_id(data['session_id']) + + tool_event = ToolEvent(**data) + span: Span = await tool_event.to_span( + trace_id=str(data['session_id']), parent_span_id=str(data['agent_id']), project_id=str(project_id) + ) + await clickhouse_create_span(span) + logger.info(f"Created ClickHouse tool event as span {span}") + + +async def update_tool_event(data: dict) -> None: + """Update tool event data for an existing record in ClickHouse.""" + assert 'id' in data, 'id must be provided to update tool event data.' + + tool_event = ToolEvent(**data) + span: Span = await tool_event.to_span() + await clickhouse_update_span(span.span_id, span.to_clickhouse_dict()) + logger.info(f"Updated ClickHouse tool event as span {span}") + + +async def create_error_event(data: dict) -> None: + """Save error event data to ClickHouse.""" + assert 'session_id' in data, 'session_id must be provided to create error event data.' + project_id = await _get_project_id(data['session_id']) + + error_event = ErrorEvent(**data) + span: Span = await error_event.to_span( + trace_id=str(data['session_id']), parent_span_id=str(data['session_id']), project_id=str(project_id) + ) + await clickhouse_create_span(span) + logger.info(f"Created ClickHouse error event as span {span}") + + +async def update_error_event(data: dict) -> None: + """Update error event data for an existing record in ClickHouse.""" + assert 'id' in data, 'id must be provided to update error event data.' + + error_event = ErrorEvent(**data) + span: Span = await error_event.to_span() + await clickhouse_update_span(span.span_id, span.to_clickhouse_dict()) + logger.info(f"Updated ClickHouse error event as span {span}") diff --git a/app/api/agentops/exporter/models.py b/app/api/agentops/exporter/models.py new file mode 100644 index 000000000..6c5e89ead --- /dev/null +++ b/app/api/agentops/exporter/models.py @@ -0,0 +1,636 @@ +from typing import Any +import json +from uuid import UUID, uuid4 +from typing import Optional, Union +import pydantic +from datetime import datetime, timezone +from opentelemetry.trace import SpanKind + + +DEFAULT_SERVICE_NAME = "agentops" +DEFAULT_SCOPE_NAME = DEFAULT_SERVICE_NAME +DEFAULT_VERSION = "0.3.x" + + +def datetime_to_ns(dt: Optional[Union[datetime, int, float]]) -> Optional[int]: + """Convert datetime or timestamp to nanoseconds""" + if dt is None: + return None + + if isinstance(dt, datetime): + return int(dt.timestamp() * 1_000_000_000) + + # `int` is probably a millisecond timestamp + return int(dt) * 1_000_000 + + +def ns_to_datetime(ns: Optional[int]) -> Optional[datetime]: + """Convert nanoseconds to `datetime`""" + if not ns: + return None + return datetime.fromtimestamp(ns / 1_000_000_000, timezone.utc) + + +class Trace(pydantic.BaseModel): + id: UUID + spans: list["Span"] = pydantic.Field(default_factory=list) + + def __repr__(self) -> str: + return f"Trace(id={self.id})" + + +class Span(pydantic.BaseModel): + """ + Span is a representation of a single operation within a trace. + It can be a root span or a child span. + """ + + name: Optional[str] = None + trace_id: Optional[str] = None + span_id: str + parent_span_id: Optional[str] = None + kind: Union[SpanKind, str] = SpanKind.INTERNAL + start_time: int = 0 + end_time: Optional[int] = None + project_id: Optional[str] = None + service_name: str = DEFAULT_SERVICE_NAME + scope_name: str = DEFAULT_SCOPE_NAME + scope_version: str = DEFAULT_VERSION + resource_attributes: dict[str, str] = pydantic.Field(default_factory=dict) + span_attributes: dict[str, str] = pydantic.Field(default_factory=dict) + status_code: str = "OK" + status_message: str = "" + events: list[dict[str, Any]] = pydantic.Field(default_factory=list) + links: list[dict[str, Any]] = pydantic.Field(default_factory=list) + + model_config = { + 'arbitrary_types_allowed': True, + } + + def __repr__(self) -> str: + return f"Span(span_id={self.span_id}, parent_span_id={self.parent_span_id})" + + def model_post_init(self, __context) -> None: + if self.end_time is None: + self.end_time = self.start_time + + @property + def duration(self) -> int: + """Calculate duration in nanoseconds""" + if self.end_time and self.start_time: + return self.end_time - self.start_time + return 0 + + def to_clickhouse_dict(self) -> dict[str, Any]: + """Convert to a dictionary ready for ClickHouse insertion""" + + if self.start_time: + timestamp = ns_to_datetime(self.start_time) + else: + timestamp = datetime.now(timezone.utc) + + # otel_context = SpanContext( + # trace_id=trace_id, + # span_id=span_id, + # is_remote=False, + # trace_flags=TraceFlags(0x1), # SAMPLED + # trace_state=TraceState() + # ) + + events_timestamps = [] + events_names = [] + events_attributes = [] + + for event in self.events: + try: + event_timestamp = event.get('timestamp', 0) + events_timestamps.append( + datetime.fromtimestamp(event_timestamp / 1_000_000_000, timezone.utc) + ) + except (TypeError, ValueError, OverflowError): + # Fallback if timestamp is invalid + events_timestamps.append(timestamp) + + events_names.append(event.get('name', '')) + events_attributes.append(event.get('attributes', {})) + + links_trace_ids = [] + links_span_ids = [] + links_trace_states = [] + links_attributes = [] + + for link in self.links: + links_trace_ids.append(link.get('trace_id', '')) + links_span_ids.append(link.get('span_id', '')) + links_trace_states.append(link.get('trace_state', '')) + links_attributes.append(link.get('attributes', {})) + + if not isinstance(self.resource_attributes, dict): + self.resource_attributes = {} + self.resource_attributes["agentops.project.id"] = self.project_id + + # Schema from ClickHouse via `DESCRIBE` otel_traces; + # Timestamp DateTime64(9) + # TraceId String + # SpanId String + # ParentSpanId String + # TraceState String + # SpanName LowCardinality(String) + # SpanKind LowCardinality(String) + # ServiceName LowCardinality(String) + # ResourceAttributes Map(LowCardinality(String), String) + # ScopeName String + # ScopeVersion String + # SpanAttributes Map(LowCardinality(String), String) + # Duration Int64 + # StatusCode LowCardinality(String) + # StatusMessage String + # Events.Timestamp Array(DateTime64(9)) + # Events.Name Array(LowCardinality(String)) + # Events.Attributes Array(Map(LowCardinality(String), String)) + # Links.TraceId Array(String) + # Links.SpanId Array(String) + # Links.TraceState Array(String) + # Links.Attributes Array(Map(LowCardinality(String), String)) + # ProjectId String + return { + "Timestamp": timestamp, + "TraceId": self.trace_id, + "SpanId": self.span_id, + "ParentSpanId": self.parent_span_id, + "TraceState": "", + "SpanName": self.name, + "SpanKind": self.kind.name if isinstance(self.kind, SpanKind) else self.kind, + "ServiceName": self.service_name, + "ResourceAttributes": self.resource_attributes, + "ScopeName": self.scope_name, + "ScopeVersion": self.scope_version, + "SpanAttributes": self.span_attributes, + "Duration": self.duration, + "StatusCode": self.status_code, + "StatusMessage": self.status_message, + "Events.Timestamp": events_timestamps, + "Events.Name": events_names, + "Events.Attributes": events_attributes, + "Links.TraceId": links_trace_ids, + "Links.SpanId": links_span_ids, + "Links.TraceState": links_trace_states, + "Links.Attributes": links_attributes, + } + + +class BaseModel(pydantic.BaseModel): + model_config = { + 'arbitrary_types_allowed': True, + } + + +class Session(BaseModel): + """ + Session renamed to Trace + """ + + id: UUID + project_id: Optional[UUID] = None + init_timestamp: Optional[datetime] = None + end_timestamp: Optional[datetime] = None + tags: Optional[Union[str, list]] = None + end_state: Optional[str] = None + end_state_reason: Optional[str] = None + video: Optional[str] = None + host_env: Optional[dict] = None + project_id_secondary: Optional[dict] = None + + async def to_trace(self) -> Trace: + """Convert a Session to a Trace with spans""" + span = Span( + name="session", + trace_id=str(self.id), + span_id=str(self.id), # TODO this is the same as trace_id + parent_span_id=None, # parent span has no parent + kind=SpanKind.SERVER, + start_time=datetime_to_ns(self.init_timestamp), + end_time=datetime_to_ns(self.end_timestamp), + project_id=str(self.project_id), + service_name=DEFAULT_SERVICE_NAME, + scope_name=f"{DEFAULT_SCOPE_NAME}.session", + scope_version=DEFAULT_VERSION, + resource_attributes={ + "host.name": str(self.host_env) if self.host_env else "unknown", + "service.name": DEFAULT_SERVICE_NAME, + }, + span_attributes={ + "session.id": str(self.id), + "session.end_state": self.end_state or "", + "session.end_state_reason": self.end_state_reason or "", + }, + ) + + try: + if self.tags: + if not isinstance(self.tags, list): + self.tags = [self.tags] + for i, value in enumerate(self.tags): + span.span_attributes[f"session.tag.{i}"] = str(value) + except Exception: + pass + + trace = Trace(id=self.id) + trace.spans.append(span) + return trace + + +class Agent(BaseModel): + """ + Agent becomes a (parent) Span + """ + + id: UUID + session_id: Optional[UUID] = None + name: Optional[str] = None + logs: Optional[str] = None + + async def to_span( + self, + trace_id: Optional[str] = None, + parent_span_id: Optional[str] = None, + project_id: Optional[str] = None, + ) -> Span: + """Convert an Agent to a Span""" + span_attributes = { + "agent.id": str(self.id), + "agent.name": self.name or "", + "session.id": str(self.session_id), + } + + events = [] + if self.logs: + events.append( + { + "timestamp": 0, # we don't have a timestamp + "name": "logs", + "attributes": {"log.message": self.logs}, + } + ) + + return Span( + name=f"agent:{self.name}" if self.name else f"agent:{self.id}", + trace_id=trace_id, + span_id=str(self.id), + parent_span_id=parent_span_id, + kind=SpanKind.INTERNAL, + project_id=project_id, + service_name=DEFAULT_SERVICE_NAME, + scope_name=f"{DEFAULT_SCOPE_NAME}.agent", + scope_version=DEFAULT_VERSION, + resource_attributes={}, + span_attributes=span_attributes, + events=events, + ) + + +class ActionEvent(BaseModel): + """ + Action becomes a (child) Span + """ + + id: UUID + session_id: Optional[UUID] = None + agent_id: Optional[UUID] = None + action_type: Optional[str] = None + logs: Optional[str] = None + screenshot: Optional[str] = None + params: Optional[str] = None + returns: Optional[str] = None + init_timestamp: Optional[datetime] = None + end_timestamp: Optional[datetime] = None + + async def to_span( + self, + trace_id: Optional[str] = None, + parent_span_id: Optional[str] = None, + project_id: Optional[str] = None, + ) -> Span: + """Convert an ActionEvent to a Span""" + span_attributes = { + "action.id": str(self.id), + "action.type": self.action_type or "", + "session.id": str(self.session_id), + "agent.id": str(self.agent_id), + } + + if self.params: + if isinstance(self.params, dict): + span_attributes["action.params"] = json.dumps(self.params) + else: + span_attributes["action.params"] = str(self.params) + + if self.returns: + if isinstance(self.returns, dict): + span_attributes["action.returns"] = json.dumps(self.returns) + else: + span_attributes["action.returns"] = str(self.returns) + + if self.screenshot: + span_attributes["action.screenshot"] = self.screenshot + + init_timestamp_ns = datetime_to_ns(self.init_timestamp) + events = [] + if self.logs: + events.append( + {"timestamp": init_timestamp_ns, "name": "logs", "attributes": {"log.message": self.logs}} + ) + + return Span( + name=f"action:{self.action_type or 'unknown'}", + trace_id=trace_id, + span_id=str(self.id), + parent_span_id=parent_span_id, + kind=SpanKind.INTERNAL, + start_time=init_timestamp_ns, + end_time=datetime_to_ns(self.end_timestamp), + project_id=project_id, + service_name=DEFAULT_SERVICE_NAME, + scope_name=f"{DEFAULT_SCOPE_NAME}.action", + scope_version=DEFAULT_VERSION, + resource_attributes={}, + span_attributes=span_attributes, + events=events, + ) + + +class LLMEvent(BaseModel): + """ + LLMEvent becomes a (child) Span + """ + + id: UUID + session_id: Optional[UUID] = None + agent_id: Optional[UUID] = None + thread_id: Optional[UUID] = None + prompt: Optional[dict] = None + completion: Optional[dict] = None + model: Optional[str] = None + prompt_tokens: Optional[int] = None + completion_tokens: Optional[int] = None + cost: Optional[float] = None + promptarmor_flag: Optional[bool] = None + params: Optional[Union[str, dict]] = None + returns: Optional[Union[str, dict]] = None + init_timestamp: Optional[datetime] = None + end_timestamp: Optional[datetime] = None + + async def to_span( + self, + trace_id: Optional[str] = None, + parent_span_id: Optional[str] = None, + project_id: Optional[str] = None, + ) -> Span: + """Convert an LLMEvent to a Span with GenAI semantic conventions""" + + # Use GenAI semantic conventions for span attributes + # See: https://github.com/open-telemetry/semantic-conventions/blob/main/docs/gen-ai/gen-ai.md + + # { + # "gen_ai.completion.0.content": "Why couldn't the bicycle stand up by itself? It was two tired.", + # "gen_ai.completion.0.finish_reason": "stop", + # "gen_ai.completion.0.role": "assistant", + # "gen_ai.openai.api_base": "https://api.openai.com/v1/", + # "gen_ai.prompt.0.content": "Write a one-line joke", + # "gen_ai.prompt.0.role": "user", + # "gen_ai.request.model": "gpt-3.5-turbo", + # "gen_ai.response.id": "chatcmpl-B9ekm6iX1GDInqhtj5XlmIqFHamFf", + # "gen_ai.response.model": "gpt-3.5-turbo-0125", + # "gen_ai.system": "OpenAI", + # "gen_ai.usage.completion_tokens": "16", + # "gen_ai.usage.prompt_tokens": "12", + # "llm.headers": "None", + # "llm.is_streaming": "false", + # "llm.request.type": "chat", + # "llm.usage.total_tokens": "28" + # } + + span_attributes = { + "llm.id": str(self.id), + "llm.model": self.model if self.model else "", + "llm.prompt_tokens": str(self.prompt_tokens), + "llm.completion_tokens": str(self.completion_tokens), + "llm.total_tokens": str(self.prompt_tokens + self.completion_tokens), + "llm.cost": str(self.cost) if self.cost is not None else "0.0", + "session.id": str(self.session_id), + "agent.id": str(self.agent_id), + "thread.id": str(self.thread_id) if self.thread_id else "", + "llm.is_streaming": "false", + "llm.request.type": "chat", + "gen_ai.openai.api_base": "https://api.openai.com/v1/", + "gen_ai.usage.prompt_tokens": str(self.prompt_tokens), + "gen_ai.usage.completion_tokens": str(self.completion_tokens), + } + + try: + prompts = self.prompt.get('messages', self.prompt) + if not isinstance(prompts, list): + prompts = [prompts] + for i, prompt in enumerate(prompts): + if not isinstance(prompt, dict): + continue + if 'content' in prompt: + content = prompt['content'] + elif 'string' in prompt: + content = prompt['string'] + elif 'message' in prompt: + content = prompt['message'] + else: + content = prompt + span_attributes[f"gen_ai.prompt.{i}.content"] = str(content) + span_attributes[f"gen_ai.prompt.{i}.role"] = str(prompt.get('role', "")) + except (KeyError, TypeError): + span_attributes["gen_ai.prompt"] = self.prompt + + try: + completions = self.completion.get('messages', self.completion) + if not isinstance(completions, list): + completions = [completions] + for i, completion in enumerate(completions): + if not isinstance(completion, dict): + continue + span_attributes[f"gen_ai.completion.{i}.content"] = str(completion.get('content', "")) + span_attributes[f"gen_ai.completion.{i}.finish_reason"] = "stop" + span_attributes[f"gen_ai.completion.{i}.role"] = str(completion.get('role', "")) + # span_attributes[f"gen_ai.completion.{i}.tool_calls"] = json.dumps(completion.get('role', [])) + except (KeyError, TypeError): + span_attributes["gen_ai.completion"] = self.completion + + if self.promptarmor_flag is not None: + span_attributes["llm.promptarmor_flag"] = str(self.promptarmor_flag).lower() + + span_attributes["gen_ai.system"] = "llm" + span_attributes["gen_ai.operation.name"] = "chat" + span_attributes["gen_ai.request.model"] = self.model if self.model else "" + span_attributes["gen_ai.response.model"] = self.model if self.model else "" + + if self.params: + if isinstance(self.params, dict): + span_attributes["gen_ai.request.parameters"] = json.dumps(self.params) + else: + span_attributes["gen_ai.request.parameters"] = str(self.params) + + if self.returns: + if isinstance(self.returns, dict): + span_attributes["gen_ai.response.metadata"] = json.dumps(self.returns) + else: + span_attributes["gen_ai.response.metadata"] = str(self.returns) + + init_timestamp_ns = datetime_to_ns(self.init_timestamp) + end_timestamp_ns = datetime_to_ns(self.end_timestamp) or init_timestamp_ns + + return Span( + name=f"llm:{self.model}", + trace_id=trace_id, + span_id=str(self.id), + parent_span_id=parent_span_id, + kind=SpanKind.CLIENT, + start_time=init_timestamp_ns, + end_time=end_timestamp_ns, + project_id=project_id, + service_name=DEFAULT_SERVICE_NAME, + scope_name=f"{DEFAULT_SCOPE_NAME}.llm", + scope_version=DEFAULT_VERSION, + resource_attributes={}, + span_attributes=span_attributes, + events=[], + ) + + +class ToolEvent(BaseModel): + """ + ToolEvent becomes a (child) Span + """ + + id: UUID + session_id: Optional[UUID] = None + agent_id: Optional[UUID] = None + name: Optional[str] = None + logs: Optional[str] = None + params: Optional[Union[str, dict]] = None + returns: Optional[Union[dict, str]] = None + init_timestamp: Optional[datetime] = None + end_timestamp: Optional[datetime] = None + + async def to_span( + self, + trace_id: Optional[str] = None, + parent_span_id: Optional[str] = None, + project_id: Optional[str] = None, + ) -> Span: + """Convert a ToolEvent to a Span""" + span_attributes = { + "tool.id": str(self.id), + "tool.name": self.name, + "session.id": str(self.session_id), + "agent.id": str(self.agent_id), + "gen_ai.tool.name": self.name, + } + + if self.params: + if isinstance(self.params, dict): + span_attributes["tool.params"] = json.dumps(self.params) + else: + span_attributes["tool.params"] = str(self.params) + + if self.returns: + if isinstance(self.returns, dict): + span_attributes["tool.returns"] = json.dumps(self.returns) + else: + span_attributes["tool.returns"] = str(self.returns) + + init_timestamp_ns = datetime_to_ns(self.init_timestamp) + events = [] + if self.logs: + events.append( + {"timestamp": init_timestamp_ns, "name": "logs", "attributes": {"log.message": self.logs}} + ) + + return Span( + name=f"tool:{self.name}", + trace_id=trace_id, + span_id=str(self.id), + parent_span_id=parent_span_id, + kind=SpanKind.INTERNAL, + start_time=init_timestamp_ns, + end_time=datetime_to_ns(self.end_timestamp), + project_id=project_id, + service_name=DEFAULT_SERVICE_NAME, + scope_name=f"{DEFAULT_SCOPE_NAME}.tool", + scope_version=DEFAULT_VERSION, + resource_attributes={}, + span_attributes=span_attributes, + events=events, + ) + + +class ErrorEvent(BaseModel): + """ + ErrorEvent becomes a (child) Span + """ + + id: Optional[int] = pydantic.Field(default=uuid4()) + session_id: Optional[UUID] = None + trigger_event_id: Optional[UUID] = None + trigger_event_type: Optional[str] = None + error_type: Optional[str] = None + code: Optional[str] = None + details: Optional[str] = None + logs: Optional[str] = None + timestamp: Optional[datetime] = None + + async def to_span( + self, + trace_id: Optional[str] = None, + parent_span_id: Optional[str] = None, + project_id: Optional[str] = None, + ) -> Span: + """Convert an ErrorEvent to a Span""" + span_attributes = { + "error.type": self.error_type or "unknown_error", + "error.code": self.code if self.code else "", + "session.id": str(self.session_id), + "trigger_event.id": str(self.trigger_event_id) if self.trigger_event_id else "", + "trigger_event.type": str(self.trigger_event_type) if self.trigger_event_type else "", + } + + timestamp_ns = datetime_to_ns(self.timestamp) + events = [] + if self.details: + events.append( + { + "timestamp": timestamp_ns, + "name": "error.details", + "attributes": {"error.details": self.details}, + } + ) + if self.logs: + events.append( + {"timestamp": timestamp_ns, "name": "logs", "attributes": {"log.message": self.logs}} + ) + + return Span( + name=f"error:{self.error_type or 'unknown'}", + trace_id=trace_id, + span_id=str(self.id), + parent_span_id=parent_span_id, + kind=SpanKind.INTERNAL, + start_time=timestamp_ns, + end_time=timestamp_ns, # same as start for point-in-time event + project_id=project_id, + service_name=DEFAULT_SERVICE_NAME, + scope_name=f"{DEFAULT_SCOPE_NAME}.error", + scope_version=DEFAULT_VERSION, + resource_attributes={}, + span_attributes=span_attributes, + status_code="ERROR", + status_message=self.details + if self.details and len(self.details) < 100 + else (self.error_type or "unknown_error"), + events=events, + ) diff --git a/app/api/agentops/exporter/processor.py b/app/api/agentops/exporter/processor.py new file mode 100644 index 000000000..bccc4e496 --- /dev/null +++ b/app/api/agentops/exporter/processor.py @@ -0,0 +1,577 @@ +""" +Processor +--------- +The processor handles acquiring a connection to each endpoint and marshalling the data +between each. + +This module serves as both an internal API for working with the interchange of data between +the Supabase and ClickHouse databases, as well as a CLI tool for exporting data from Supabase +to ClickHouse as a batch operation. +""" + +from typing import Any, Optional, AsyncGenerator +import warnings +import asyncio +import os +import psycopg +import psycopg_pool +from clickhouse_driver.util.escape import escape_param as _clickhouse_escape_param + +from agentops.api.db.clickhouse_client import get_async_clickhouse +from .models import BaseModel, Session, Agent, ActionEvent, LLMEvent, ToolEvent, ErrorEvent +from .models import Trace, Span + + +EXPORT_TABLES_MODELS: dict[str, BaseModel] = { + 'sessions': Session, + 'agents': Agent, + 'actions': ActionEvent, + 'llms': LLMEvent, + 'tools': ToolEvent, + 'errors': ErrorEvent, +} +EXPORT_AS_SPANS = ( + 'agents', + 'actions', + 'llms', + 'tools', + 'errors', +) +IMPORT_TABLE_NAME = 'otel_traces' + +# Supabase connection pooling for export +SUPABASE_MIN_POOL_SIZE = 12 +SUPABASE_MAX_POOL_SIZE = 24 + +# DRY_RUN does not write data to ClickHouse +DRY_RUN = False + +# Pagination for exporting data from Supabase +PAGE_NUMBER = 0 +# Cutoff after a certain number of pages +MAX_PAGES = None + +# Timeout for writing a trace to ClickHouse +TIMEOUT = 240 +# Number of rows to fetch from Supabase per page for export +BATCH_ROW_COUNT = 1000 + +# Maximum number of concurrent workers +MAX_CONCURRENT = 42 +PARALLEL_READS = 21 + +# Filenames for persistent state +DROPPED_RECORDS_FILENAME = 'dropped_records.csv' +LAST_SESSION_ID_FILENAME = 'last_session_id.txt' + +# Global variables that will be initialized in main() or init functions +_last_session_file = None +LAST_SESSION_ID = None + + +def write_dropped_record(table: str, id: Any, exception: Exception) -> None: + """Make a note of a record that was dropped during processing.""" + with open(DROPPED_RECORDS_FILENAME, 'a') as f: + msg = str(exception).replace('"', "'").replace("\n", " ~ ") + f.write(f"{table},{str(id)},\"{msg}\"\n") + + +def write_last_session_id(session_id: Any) -> None: + """Write the last session_id by truncating and writing to the already open file.""" + print(session_id) + if _last_session_file: + _last_session_file.seek(0) + _last_session_file.truncate() + _last_session_file.write(str(session_id)) + _last_session_file.flush() + + +# Supabase connection pool instance +_supabase_pool: Optional[Any] = None + + +def get_supabase_pool() -> Any: + """Get a read-only connection pool to Supabase.""" + global _supabase_pool + + host = os.getenv('SUPABASE_HOST') + port = os.getenv('SUPABASE_PORT') + database = os.getenv('SUPABASE_DATABASE') + user = os.getenv('SUPABASE_USER') + password = os.getenv('SUPABASE_PASSWORD') + + if _supabase_pool is None: + _supabase_pool = psycopg_pool.AsyncConnectionPool( + f"postgresql://{user}:{password}@{host}:{port}/{database}", + min_size=SUPABASE_MIN_POOL_SIZE, + max_size=SUPABASE_MAX_POOL_SIZE, + # configure=lambda c: c.execute("SET default_transaction_read_only = on") + ) + return _supabase_pool + + +async def close_supabase_pool() -> None: + """Close the connection pool to Supabase.""" + global _supabase_pool + if _supabase_pool is not None: + await _supabase_pool.close() + _supabase_pool = None + + +class SupabaseExporterMeta(type): + def __class_getitem__(cls, model_class: BaseModel) -> 'SupabaseExporter': + if model_class not in EXPORT_TABLES_MODELS.values(): + raise ValueError(model_class.__name__) + + table_name = [k for k, v in EXPORT_TABLES_MODELS.items() if v == model_class][0] + return SupabaseExporter(table_name, model_class) + + +class SupabaseExporter(metaclass=SupabaseExporterMeta): + """ + Exporter that connects to a Supabase table and fetches records as model instances. + + Usage: + ``` + sessions = SupabaseExporter['sessions'] + async for session in sessions.fetchall("SELECT * FROM {table_name}"): + print(session) + ``` + `table_name` is always populated with the table name of the model class. + + Extra parameters can be passed to the fetchall method as keyword arguments. + ``` + async for session in sessions.fetchall("SELECT * FROM {table_name} WHERE id = '{id}'", id='123'): + print(session) + ``` + """ + + table_name: str + model_class: BaseModel + + def __init__(self, table_name: str, model_class: BaseModel) -> None: + self.table_name = table_name + self.model_class = model_class + + def get_model_instance(self, **kwargs) -> BaseModel: + try: + return self.model_class(**kwargs) + except Exception as e: + write_dropped_record(self.table_name, kwargs.get('id', 'unknown'), e) + + async def fetchall(self, query: str, **kwargs) -> AsyncGenerator[BaseModel, None]: + query = query.format(table_name=self.table_name, **kwargs) + async with get_supabase_pool().connection() as conn: + # Use a dictionary row factory to get rows as dictionaries + async with conn.cursor(row_factory=psycopg.rows.dict_row) as cur: + await cur.execute(query) + for row in await cur.fetchall(): + yield self.get_model_instance(**row) + + async def fetchone(self, query: str, **kwargs) -> BaseModel: + query = query.format(table_name=self.table_name, **kwargs) + async with get_supabase_pool().connection() as conn: + async with conn.cursor(row_factory=psycopg.rows.dict_row) as cur: + await cur.execute(query) + return self.get_model_instance(**await cur.fetchone()) + + +supabase = SupabaseExporter + + +async def fetch_all_for_session(model_class: BaseModel, session_id) -> AsyncGenerator[BaseModel, None]: + """Fetch all records for a session from a given table""" + query = """ + SELECT * FROM {table_name} + WHERE session_id = '{session_id}' + """ + exporter = supabase[model_class] + async for result in exporter.fetchall(query, session_id=session_id): + yield result + + +async def get_session_as_trace(session: Session) -> Trace: + """Convert a session to a trace with all related spans""" + write_last_session_id(session.id) + try: + trace: Trace = await session.to_trace() + parent_span_id = trace.spans[0].span_id + except Exception as e: + if not session: + write_dropped_record('session', 'unknown', e) + return + write_dropped_record('session', session.id, e) + return + + for table_name in EXPORT_AS_SPANS: + model_class = EXPORT_TABLES_MODELS[table_name] + async for record in fetch_all_for_session(model_class, session.id): + try: + if isinstance(record, (Agent, ErrorEvent)): + # agent and error belong to parent span + span = await record.to_span( + trace_id=trace.id, parent_span_id=parent_span_id, project_id=str(session.project_id) + ) + elif isinstance(record, (ActionEvent, LLMEvent, ToolEvent)): + # actions, llms, and tools belong to an agent + span = await record.to_span( + trace_id=trace.id, + parent_span_id=str(record.agent_id), + project_id=str(session.project_id), + ) + else: + warnings.warn(f"Unknown record type: {type(record)}") + continue + except Exception as e: + table_name = [k for k, v in EXPORT_TABLES_MODELS.items() if v == model_class][0] + write_dropped_record(table_name, record.id, e) + continue + trace.spans.append(span) + return trace + + +async def get_sessions(offset: int, limit: int) -> list[Session]: + """Get raw session records without processing them as traces yet""" + query = """ + SELECT * FROM {table_name} + WHERE id > '{last_session_id}' + ORDER BY id ASC + LIMIT {limit} + OFFSET {offset} + """ + sessions = [] + lsid = LAST_SESSION_ID if LAST_SESSION_ID else '00000000-0000-0000-0000-000000000000' + async for session in supabase[Session].fetchall(query, offset=offset, limit=limit, last_session_id=lsid): + sessions.append(session) + return sessions + + +async def get_sessions_as_traces(offset: int, limit: int) -> AsyncGenerator[Trace, None]: + """Get sessions and convert them to traces with parallel processing""" + sessions = await get_sessions(offset, limit) + for i in range(0, len(sessions), PARALLEL_READS): + batch = sessions[i : i + PARALLEL_READS] + tasks = [asyncio.create_task(get_session_as_trace(session)) for session in batch] + for task in asyncio.as_completed(tasks): + trace = await task + print(trace.id) + yield trace + + +# Cache for session_id to project_id mapping +_SESSION_PROJECT_CACHE = {} +_SESSION_PROJECT_CACHE_ORDER = [] +_SESSION_PROJECT_CACHE_MAX_SIZE = 10000 + + +async def get_project_id_for_session_id(session_id: str) -> str: + """ + Get the project id for a given session id + Caches the result for 10,000 sessions + """ + if not session_id: + print("Warning: Received empty session_id") + return None + + # Check cache first + if session_id in _SESSION_PROJECT_CACHE: + # Move to the end of the order list to mark as recently used + # Only try to remove if the session_id is actually in the order list + if session_id in _SESSION_PROJECT_CACHE_ORDER: + _SESSION_PROJECT_CACHE_ORDER.remove(session_id) + _SESSION_PROJECT_CACHE_ORDER.append(session_id) + else: + # Fix inconsistency by adding to order list if missing + _SESSION_PROJECT_CACHE_ORDER.append(session_id) + return _SESSION_PROJECT_CACHE[session_id] + + query = """ + SELECT * FROM sessions + WHERE id = '{session_id}' + LIMIT 1 + """ + result = await supabase[Session].fetchone(query, session_id=session_id) + if result: + project_id = result.project_id + # Add to cache + if len(_SESSION_PROJECT_CACHE_ORDER) >= _SESSION_PROJECT_CACHE_MAX_SIZE: + # Remove oldest entry + oldest_session_id = _SESSION_PROJECT_CACHE_ORDER.pop(0) + del _SESSION_PROJECT_CACHE[oldest_session_id] + _SESSION_PROJECT_CACHE[session_id] = project_id + _SESSION_PROJECT_CACHE_ORDER.append(session_id) + return project_id + raise Exception(f"Warning: No project_id found for session_id: {session_id}") + + +async def get_v2_sourced_rows(limit: int, offset: int) -> list: + """Get span from ClickHouse that were supplied by v2 exporter""" + client = await get_async_clickhouse() + query = """ + SELECT * FROM otel_2.otel_traces + WHERE mapContains(SpanAttributes, 'session.id') + LIMIT {limit} + OFFSET {offset} + """ + try: + query = query.format(table_name=IMPORT_TABLE_NAME, limit=limit, offset=offset) + result = await client.query(query) + if result and hasattr(result, 'result_rows') and len(result.result_rows) > 0: + rows = [] + for row in result.result_rows: + row_dict = dict(zip(result.column_names, row)) + rows.append(row_dict) + return rows + return [] + except Exception as e: + print(f"Error fetching rows: {e}") + return [] + + +async def assign_correct_project_id(span_id: str, project_id: str) -> bool: + """Assign the correct project id to each row""" + clickhouse_client = await get_async_clickhouse() + query = """ + ALTER TABLE otel_2.{table_name} + UPDATE ResourceAttributes = mapUpdate(ResourceAttributes, map('agentops.project.id', "{project_id}")) + WHERE SpanId = {span_id}; + """ + if project_id is None: + raise Exception(f"Project id is None for span_id: {span_id}") + + query = query.format(table_name=IMPORT_TABLE_NAME, project_id=project_id, span_id=span_id) + result = await clickhouse_client.query(query) + if result.rows_affected > 0: + return True + return False + + +async def count_v2_sourced_rows() -> int: + """Count the number of rows in the v2 sourced table""" + clickhouse_client = await get_async_clickhouse() + query = """ + SELECT COUNT(1) FROM otel_2.otel_traces + WHERE mapContains(SpanAttributes, 'session.id') + """ + result = await clickhouse_client.query(query) + return result.result_rows[0][0] + + +class _ClickhouseDriverContextShim: + # i just need context.server_info.get_timezone() + class ServerInfo: + def get_timezone(self): + return 'UTC' # TODO this is prob not correct + + server_info = ServerInfo() + + +def clickhouse_escape_param(value: Any) -> str: + """Escape a parameter for use in a ClickHouse query""" + # not robust enough to pass a full span for insertion or update :/ + context = _ClickhouseDriverContextShim() + return _clickhouse_escape_param(value, context) + + +def clickhouse_escape_value(value: str) -> Any: + """Escape a value for use in a ClickHouse query""" + # we don't pass the query to the full escape because it seems like `insert` + # handles most of it. + if value is None: + return 'NULL' + if isinstance(value, list): + return [clickhouse_escape_value(v) for v in value] + if isinstance(value, dict): + return {k: clickhouse_escape_value(v) for k, v in value.items()} + if isinstance(value, int): + return str(value) + return value + + +async def clickhouse_create(data: list[dict]) -> None: + """Create a record in ClickHouse""" + client = await get_async_clickhouse() + + for i, row in enumerate(data): + for key, value in row.items(): + data[i][key] = clickhouse_escape_value(value) + + if not DRY_RUN: + await client.insert( + table=IMPORT_TABLE_NAME, + data=[list(row.values()) for row in data], + column_names=list(data[0].keys()), + ) + else: + print(data) + + +async def clickhouse_create_trace(trace: Trace) -> None: + """Create a trace in ClickHouse""" + data = [span.to_clickhouse_dict() for span in trace.spans] + await clickhouse_create(data) + + +async def clickhouse_get_span_raw(span_id: str) -> dict: + """Get raw span data from ClickHouse""" + client = await get_async_clickhouse() + query = """ + SELECT * FROM {table_name} + WHERE SpanId = '{span_id}' + """ + query = query.format(table_name=IMPORT_TABLE_NAME, span_id=span_id) + result = await client.query(query) + if result and hasattr(result, 'result_rows') and len(result.result_rows) > 0: + row_dict = dict(zip(result.column_names, result.result_rows[0])) + return row_dict + + return None + + +async def clickhouse_create_span(span: Span) -> None: + """Create a single span in ClickHouse""" + data = [span.to_clickhouse_dict()] + await clickhouse_create(data) + + +async def clickhouse_delete_span(span_id: Any) -> None: + """Delete a span from ClickHouse by SpanId""" + client = await get_async_clickhouse() + query = """ + ALTER TABLE {table_name} + DELETE WHERE SpanId = '{span_id}' + """ + query = query.format(table_name=IMPORT_TABLE_NAME, span_id=str(span_id)) + if not DRY_RUN: + await client.query(query) + else: + print(query) + + +async def clickhouse_update_span(span_id: str, update_data: dict) -> None: + """Update a record in ClickHouse by deleting and re-inserting it.""" + # reasons for going this route at the moment: + # - serialization is a bitch and there is no tooling readily available to help with it + # - latency for propagation of updates is apparently comparable to deletion + + def merge_dicts_recursive(old, new): + result = old.copy() + for key, value in new.items(): + if key in result and isinstance(result[key], dict) and isinstance(value, dict): + result[key] = merge_dicts_recursive(result[key], value) + else: + result[key] = value + return result + + existing_span: dict = await clickhouse_get_span_raw(span_id) + if existing_span: + await clickhouse_delete_span(span_id) # yolo + else: + existing_span = {} + + merged_data = merge_dicts_recursive(existing_span, update_data) + await clickhouse_create( + [ + merged_data, + ] + ) + + +async def write_trace_with_timeout(trace: Trace) -> None: + """Write a trace to ClickHouse with a timeout""" + try: + write_task = asyncio.create_task(clickhouse_create_trace(trace)) + await asyncio.wait_for(write_task, timeout=TIMEOUT) + return True + except asyncio.TimeoutError: + write_dropped_record('trace', trace.id, "Timeout") + return False + except Exception as e: + write_dropped_record('trace', trace.id, str(e)) + return False + + +async def process_page(offset: int, limit: int) -> None: + """Process a page of sessions and write them to ClickHouse""" + pending_tasks = set() + async for trace in get_sessions_as_traces(offset=offset, limit=limit): + if len(pending_tasks) >= MAX_CONCURRENT: + done, pending_tasks = await asyncio.wait(pending_tasks, return_when=asyncio.FIRST_COMPLETED) + + for task in done: + await task + + task = asyncio.create_task(write_trace_with_timeout(trace)) + pending_tasks.add(task) + + if pending_tasks: # let the pool drain + done, pending = await asyncio.wait(pending_tasks) + for task in done: + await task + await close_supabase_pool() + + +async def count_session_rows() -> int: + """Count the number of rows in the sessions table""" + query = """ + SELECT COUNT(*) FROM sessions + WHERE id > '{last_session_id}' + """ + query = query.format( + last_session_id=LAST_SESSION_ID if LAST_SESSION_ID else '00000000-0000-0000-0000-000000000000' + ) + async with get_supabase_pool().connection() as conn: + async with conn.cursor() as cur: + await cur.execute(query) + rows = await cur.fetchone() + return rows[0] + + +def init_files(): + """Initialize files needed for the exporter.""" + global _last_session_file, LAST_SESSION_ID + + # Initialize dropped records file + if not os.path.exists(DROPPED_RECORDS_FILENAME): + with open(DROPPED_RECORDS_FILENAME, 'w') as f: + f.write("table,id,exception\n") + + # Initialize last session ID file + if not os.path.exists(LAST_SESSION_ID_FILENAME): + from pathlib import Path + + Path(LAST_SESSION_ID_FILENAME).touch() + + # Open the last session ID file + _last_session_file = open(LAST_SESSION_ID_FILENAME, 'r+') + LAST_SESSION_ID = _last_session_file.read().strip() + + +async def main() -> None: + """Main entry point for the exporter""" + # Initialize files + init_files() + + try: + row_count = await count_session_rows() + total_pages = row_count // BATCH_ROW_COUNT + print(f"Total pages: {total_pages}".center(80, "=")) + + for page_number in range(0, total_pages): + offset, limit = page_number * BATCH_ROW_COUNT, BATCH_ROW_COUNT + await process_page(offset, limit) + print(f"Processed page {page_number}".center(80, "=")) + if MAX_PAGES is not None and MAX_PAGES >= page_number: + break + finally: + if _last_session_file: + _last_session_file.close() + await close_supabase_pool() + + +if __name__ == "__main__": + from dotenv import load_dotenv + + load_dotenv('.env', override=True) + + asyncio.run(main()) diff --git a/app/api/agentops/exporter/project_id_adjustment_checkpoint.json b/app/api/agentops/exporter/project_id_adjustment_checkpoint.json new file mode 100644 index 000000000..cfe938d12 --- /dev/null +++ b/app/api/agentops/exporter/project_id_adjustment_checkpoint.json @@ -0,0 +1 @@ +{"offset": 0, "total_processed": 0, "timestamp": "2025-04-02T18:32:28.613188"} \ No newline at end of file diff --git a/app/api/agentops/opsboard/README.md b/app/api/agentops/opsboard/README.md new file mode 100644 index 000000000..e80641631 --- /dev/null +++ b/app/api/agentops/opsboard/README.md @@ -0,0 +1,102 @@ +# Opsboard + +The Opsboard module provides the backend API for user, organization, and project management in AgentOps. This module allows users to create and manage organizations, projects, and team members with role-based access controls. + +## Architecture + +Opsboard is a FastAPI application that serves REST API endpoints for the AgentOps dashboard. It uses: + +- **FastAPI**: Web framework with automatic OpenAPI documentation +- **SQLAlchemy ORM**: Database access and object-relational mapping +- **Pydantic**: Data validation and serialization +- **Authentication**: Uses the AgentOps auth module for secure user authentication + +The module is structured to provide a clean separation of concerns: + +``` +/opsboard +ā”œā”€ā”€ app.py # FastAPI application setup and middleware +ā”œā”€ā”€ environment.py # Environment-specific configuration +ā”œā”€ā”€ models.py # SQLAlchemy ORM models +ā”œā”€ā”€ routes.py # Route configuration and endpoint definitions +ā”œā”€ā”€ schemas.py # Pydantic models for request/response validation +ā””ā”€ā”€ views/ # Business logic and handlers + ā”œā”€ā”€ users.py # User management endpoints + ā”œā”€ā”€ orgs.py # Organization management endpoints + ā””ā”€ā”€ projects.py # Project management endpoints +``` + +## Features + +### User Management +- User profile management +- User preferences and settings +- Survey completion tracking + +### Organization Management +- Create and manage organizations +- Invite users to organizations +- Role-based access control (owner, admin, developer, business_user) +- Organization membership management + +### Project Management +- Create and manage projects within organizations +- Project environment configuration (production, staging, development, community) +- API key management for project access + +## Models + +The module uses the following primary data models: + +- **UserModel**: User profile information +- **OrgModel**: Organization details +- **UserOrgModel**: User-organization relationships with roles +- **OrgInviteModel**: Pending invitations to organizations +- **ProjectModel**: Project configuration and API keys + +## Authentication and Authorization + +Opsboard uses the AgentOps auth module for authentication. All routes require authentication via the `AuthenticatedRoute` middleware. Authorization is managed through role-based permissions within the organization context. + +## Endpoints + +### User Endpoints +- `GET /opsboard/users/me`: Get authenticated user profile +- `POST /opsboard/users/update`: Update user profile +- `POST /opsboard/users/complete_survey`: Mark user survey as complete + +### Organization Endpoints +- `GET /opsboard/orgs`: List organizations for the authenticated user +- `GET /opsboard/orgs/{org_id}`: Get organization details +- `POST /opsboard/orgs/create`: Create a new organization +- `POST /opsboard/orgs/{org_id}/update`: Update organization details +- `POST /opsboard/orgs/{org_id}/invite`: Invite a user to an organization +- `GET /opsboard/orgs/invites`: List pending organization invites +- `POST /opsboard/orgs/{org_id}/accept`: Accept an organization invitation +- `POST /opsboard/orgs/{org_id}/members/remove`: Remove a user from an organization +- `POST /opsboard/orgs/{org_id}/members/update`: Update a user's role in an organization +- `DELETE /opsboard/orgs/{org_id}`: Delete an organization + +### Project Endpoints +- `GET /opsboard/projects`: List projects for the authenticated user +- `GET /opsboard/projects/{project_id}`: Get project details +- `POST /opsboard/projects`: Create a new project +- `POST /opsboard/projects/{project_id}/update`: Update project details +- `POST /opsboard/projects/{project_id}/delete`: Delete a project +- `POST /opsboard/projects/{project_id}/regenerate-key`: Regenerate project API key + +## Premium Status + +Organizations can have different premium statuses that affect available features: +- `free`: Basic features +- `pro`: Advanced features +- `enterprise`: Enterprise-level features and support + +## Development + +To run tests for the Opsboard module, use the project's test runner with the opsboard-specific tests: + +```bash +# From the root of the project +pytest tests/opsboard/ +``` diff --git a/app/api/agentops/opsboard/__init__.py b/app/api/agentops/opsboard/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/api/agentops/opsboard/app.py b/app/api/agentops/opsboard/app.py new file mode 100644 index 000000000..344b692c5 --- /dev/null +++ b/app/api/agentops/opsboard/app.py @@ -0,0 +1,33 @@ +from fastapi import FastAPI, APIRouter +from fastapi.middleware.cors import CORSMiddleware + +from agentops.common.environment import ALLOWED_ORIGINS +from agentops.common.middleware import ( + CacheControlMiddleware, + DefaultContentTypeMiddleware, + ExceptionMiddleware, +) +from agentops.common.route_config import register_routes +from agentops.auth.middleware import AuthenticatedRoute + +from .routes import route_config + +__all__ = ["app"] + +app = FastAPI(title="Opsboard API") + +app.add_middleware( + CORSMiddleware, + allow_origins=ALLOWED_ORIGINS, + allow_credentials=True, + allow_methods=["GET", "POST", "DELETE", "OPTIONS", "PUT"], + allow_headers=["*"], +) + +app.add_middleware(DefaultContentTypeMiddleware) +app.add_middleware(CacheControlMiddleware) +app.add_middleware(ExceptionMiddleware) + +router = APIRouter(route_class=AuthenticatedRoute) +register_routes(router, route_config, prefix="/opsboard") +app.include_router(router) diff --git a/app/api/agentops/opsboard/billing_constants.py b/app/api/agentops/opsboard/billing_constants.py new file mode 100644 index 000000000..4734c5881 --- /dev/null +++ b/app/api/agentops/opsboard/billing_constants.py @@ -0,0 +1,15 @@ +from enum import Enum + + +class BillingConstants: + GRACE_PERIOD_DAYS = 3 + RACE_CONDITION_WINDOW_SECONDS = 5 + DEFAULT_SEAT_PRICE_CENTS = 4000 + + +class BillingAuditAction(str, Enum): + MEMBER_LICENSED = "member_licensed" + MEMBER_UNLICENSED = "member_unlicensed" + LICENSES_SYNCED_BY_WEBHOOK = "licenses_synced_by_webhook" + SUBSCRIPTION_CREATED = "subscription_created" + SUBSCRIPTION_CANCELLED = "subscription_cancelled" diff --git a/app/api/agentops/opsboard/environment.py b/app/api/agentops/opsboard/environment.py new file mode 100644 index 000000000..b847f99cb --- /dev/null +++ b/app/api/agentops/opsboard/environment.py @@ -0,0 +1 @@ +DEMO_ORG_ID = "c0000000-0000-0000-0000-000000000000" diff --git a/app/api/agentops/opsboard/models.py b/app/api/agentops/opsboard/models.py new file mode 100644 index 000000000..20c75e3a2 --- /dev/null +++ b/app/api/agentops/opsboard/models.py @@ -0,0 +1,819 @@ +""" +SQLAlchemy models for the opsboard application. + +NOTE: This is a subset of models migrated from the Supabase implementation. +We're only implementing the core user and organization management features initially. +""" + +from typing import Optional, TYPE_CHECKING +import enum +from dataclasses import dataclass +import uuid +from uuid import UUID +import sqlalchemy as model +from sqlalchemy import orm +from sqlalchemy.orm import joinedload, lazyload +from sqlalchemy.dialects.postgresql import JSONB +from agentops.common.environment import ( + FREEPLAN_MAX_USERS, + FREEPLAN_MAX_PROJECTS, +) +from agentops.common.orm import BaseModel, require_loaded +from .environment import DEMO_ORG_ID +from sqlalchemy import func + +if TYPE_CHECKING: + from agentops.api.auth import JWTPayload + + +def normalize_uuid(id_: str | UUID) -> UUID: + """Normalize value to a UUID.""" + return uuid.UUID(id_) if isinstance(id_, str) else id_ + + +class OrgRoles(enum.Enum): + """Role types for organization members""" + + # must match the database org_roles enum type (which is lowercase) + owner = "owner" + admin = "admin" + developer = "developer" + business_user = "business_user" + + +class PremStatus(enum.Enum): + """Premium status types for organizations""" + + # must match the database org_roles enum type (which is lowercase) + free = "free" + pro = "pro" + enterprise = "enterprise" + + +@dataclass +class PremStatusAttributes: + """Attributes for each premium status""" + + # `None` indicates there is no limit + + max_users: int | None + max_projects: int | None + + +class Environment(enum.Enum): + """Environment types for projects""" + + # must match the database org_roles enum type (which is lowercase) + production = "production" + staging = "staging" + development = "development" + community = "community" + + +class AuthUserModel(BaseModel): + """ + Model representing Supabase's built-in auth.users table. + + This model is provided for cases where auth.users access is absolutely necessary, + as Supabase does not recommend we access it directly. + + This model is read-only to prevent modification. + """ + + __tablename__ = "users" + __table_args__ = {"schema": "auth"} + __mapper_args__ = {"confirm_deleted_rows": False} # Make this model read-only + + def __setattr__(self, name, value): + """Prevent modifications to auth.users table.""" + if hasattr(self, '_sa_instance_state') and self._sa_instance_state.persistent: + raise RuntimeError("AuthUserModel is read-only. Do not modify auth.users table directly.") + super().__setattr__(name, value) + + id = model.Column(model.UUID, primary_key=True) + email = model.Column(model.String, nullable=True) + created_at = model.Column(model.DateTime(timezone=True), nullable=True) + # there are additional columns in auth.users that we don't reference here + + +class UserModel(BaseModel): + """User model that maps to the users table""" + + __tablename__ = "users" + __table_args__ = {"schema": "public"} + + # For SQLAlchemy ORM, just use UUID primary key without trying to validate the foreign key + # The actual foreign key constraint exists in the database already + id = model.Column(model.UUID, primary_key=True) + full_name = model.Column(model.String, nullable=True) + avatar_url = model.Column(model.String, nullable=True) + billing_address = model.Column(JSONB, nullable=True) + payment_method = model.Column(JSONB, nullable=True) + email = model.Column(model.String, default="", nullable=False) + survey_is_complete = model.Column(model.Boolean, default=False, nullable=False) + + orgs = orm.relationship("UserOrgModel", back_populates="user") + invites = orm.relationship( + "OrgInviteModel", foreign_keys="[OrgInviteModel.inviter_id]", back_populates="inviter_user" + ) + auth_user = orm.relationship( + "AuthUserModel", + foreign_keys=[id], + primaryjoin="UserModel.id == AuthUserModel.id", + uselist=False, + lazy="select", # Allow lazy loading for billing_email property + ) + + def mark_survey_complete(self): + self.survey_is_complete = True + + @property + def billing_email(self) -> str | None: + """Get the user's email from Supabase `auth.users` to ensure we use the canonical email.""" + # this performs a lazy load, but it's used infrequently so that's fine + return self.auth_user.email if self.auth_user else None + + @classmethod + def get_by_id(cls, orm: orm.Session, user_id: str | UUID) -> Optional['UserModel']: + """Get a user by ID with relationships preloaded.""" + return ( + orm.query(cls) + .options( + joinedload(cls.orgs), + joinedload(cls.invites), + ) + .filter(cls.id == normalize_uuid(user_id)) + .first() + ) + + +class OrgModel(BaseModel): + """Organization model that maps to the orgs table""" + + __tablename__ = "orgs" + __table_args__ = {"schema": "public"} + + id = model.Column(model.UUID, primary_key=True, default=uuid.uuid4) + name = model.Column(model.String, nullable=False) + prem_status = model.Column(model.Enum(PremStatus), default=PremStatus.free, nullable=False) + subscription_id = model.Column(model.String, nullable=True) + + users = orm.relationship("UserOrgModel", back_populates="org", cascade="all, delete-orphan") + projects = orm.relationship("ProjectModel", back_populates="org") + invites = orm.relationship("OrgInviteModel", back_populates="org", cascade="all, delete-orphan") + + def set_current_user(self, user_id: str | UUID) -> None: + """ + Set the current user for this organization. THis is the user performing + the request. + + This allows us to access `current_user_role` as a property later. + """ + user_org = self.get_user_membership(user_id) + self._current_user_role = user_org.role + + @property + def current_user_role(self) -> OrgRoles: + """Get the current user's role in this organization.""" + # this property helps us render this field in the response schema + if not hasattr(self, "_current_user_role"): + raise AttributeError("Current user role is not set. Call set_current_user() first.") + + return self._current_user_role + + @property + def is_freeplan(self) -> bool: + """Check if the organization is on a free plan.""" + return self.prem_status == PremStatus.free + + @property + def current_member_count(self) -> int: + """The number of users that are a member of this organization.""" + # Use optimized count if available + if hasattr(self, '_member_count'): + return self._member_count + # this includes the count of invites, too, so we can prevent the admin + # from over-inviting users + if not hasattr(self, 'users') or not hasattr(self, 'invites'): + raise AttributeError( + "Member count not available. Use get_by_id or get_all_for_user to load relationships." + ) + return len(self.users) + len(self.invites) + + @property + def max_member_count(self) -> int | None: + """The maximum number of users that can be a member of this organization.""" + return FREEPLAN_MAX_USERS if self.is_freeplan else None + + @property + def current_project_count(self) -> int: + """The number of projects that are a member of this organization.""" + # Use optimized count if available + if hasattr(self, '_project_count'): + return self._project_count + if not hasattr(self, 'projects'): + raise AttributeError( + "Project count not available. Use get_by_id or get_all_for_user to load relationships." + ) + return len(self.projects) + + @property + def max_project_count(self) -> int | None: + """The maximum number of projects that can be a member of this organization.""" + return FREEPLAN_MAX_PROJECTS if self.is_freeplan else None + + @property + def paid_member_count(self) -> int: + """Get count of members marked as paid.""" + # Use cached value if available (set by get_by_id_summary) + if hasattr(self, '_paid_member_count'): + return self._paid_member_count + + # If relationships are loaded, count only paid users + if hasattr(self, 'users') and isinstance(self.users, list): + return sum(1 for user_org in self.users if user_org.is_paid) + + # Fallback to database query for paid users only + from sqlalchemy.orm import Session + + if self.id and hasattr(self, '_sa_instance_state'): + orm = Session.object_session(self) + if orm: + return ( + orm.query(UserOrgModel) + .filter(UserOrgModel.org_id == self.id, UserOrgModel.is_paid) + .count() + ) + + # Default fallback - at least the owner should be paid + return 1 + + @property + def unpaid_member_count(self) -> int: + """ + Get count of members not included in paid seats. + This can be used in the future if we add granular control over who gets licensed + """ + if hasattr(self, 'users') and isinstance(self.users, list): + return sum(1 for user_org in self.users if not user_org.is_paid) + + from sqlalchemy.orm import Session + + if self.id and hasattr(self, '_sa_instance_state'): + orm = Session.object_session(self) + if orm: + return ( + orm.query(UserOrgModel) + .filter(UserOrgModel.org_id == self.id, ~UserOrgModel.is_paid) + .count() + ) + return 0 + + def create_user_membership(self, user_id: str | UUID, role: OrgRoles) -> 'UserOrgModel': + """Add a user to this organization with the given role.""" + + user_id = normalize_uuid(user_id) + user_org = UserOrgModel(user_id=user_id, org_id=self.id, role=role) + self.users.append(user_org) + return user_org + + @require_loaded('users') + def get_user_membership(self, user_id: str | UUID) -> Optional['UserOrgModel']: + """Get a user's membership in this organization.""" + user_id = normalize_uuid(user_id) + return next((user_org for user_org in self.users if user_org.user_id == user_id), None) + + def is_user_member(self, user_id: str | UUID) -> bool: + """Check if a user is a member of this organization.""" + # If we have the current user role set from summary queries, use that + if hasattr(self, '_current_user_role') and normalize_uuid(user_id) == normalize_uuid( + getattr(self, '_current_user_id', user_id) + ): + return True + return self.get_user_membership(user_id) is not None + + def is_user_admin_or_owner(self, user_id: str | UUID) -> bool: + """Check if a user is an admin or owner of this organization.""" + # If we have the current user role set from summary queries, use that + if hasattr(self, '_current_user_role') and normalize_uuid(user_id) == normalize_uuid( + getattr(self, '_current_user_id', user_id) + ): + return self._current_user_role in [OrgRoles.owner, OrgRoles.admin] + + if membership := self.get_user_membership(user_id): + return membership.role in [OrgRoles.owner, OrgRoles.admin] + + return False + + def is_user_owner(self, user_id: str | UUID) -> bool: + """Check if a user is the owner of this organization.""" + # If we have the current user role set from summary queries, use that + if hasattr(self, '_current_user_role') and normalize_uuid(user_id) == normalize_uuid( + getattr(self, '_current_user_id', user_id) + ): + return self._current_user_role == OrgRoles.owner + + if membership := self.get_user_membership(user_id): + return membership.role == OrgRoles.owner + + return False + + @classmethod + def get_by_id(cls, orm: orm.Session, org_id: str | UUID) -> Optional['OrgModel']: + """Get an organization by ID with relationships preloaded.""" + return ( + orm.query(cls) + .options( + joinedload(cls.users), + joinedload(cls.invites), + joinedload(cls.projects), + ) + .filter(cls.id == normalize_uuid(org_id)) + .first() + ) + + @classmethod + def get_all_for_user(cls, orm: orm.Session, user_id: str | UUID) -> Optional[list['OrgModel']]: + """Get all organizations for a user with relationships preloaded.""" + orgs = ( + orm.query(cls) + .options( + joinedload(cls.users), + joinedload(cls.invites), + joinedload(cls.projects), + ) + .join(UserOrgModel, UserOrgModel.org_id == cls.id) + .filter(UserOrgModel.user_id == normalize_uuid(user_id)) + .filter(cls.id != DEMO_ORG_ID) # TODO hard-code demo org and delete these rows + .all() + ) + for org in orgs: + # populate current user so `org.current_user_role` is available + org.set_current_user(user_id) + return orgs + + @classmethod + def get_all_for_user_summary(cls, orm: orm.Session, user_id: str | UUID) -> list['OrgModel']: + """ + Get all organizations for a user with only summary data. + + This method returns orgs with counts pre-calculated, avoiding the need + to load all related records. + """ + from sqlalchemy import func + + user_id = normalize_uuid(user_id) + + # First, get all orgs for the user with their role + orgs_with_roles = ( + orm.query(cls, UserOrgModel.role) + .join(UserOrgModel, UserOrgModel.org_id == cls.id) + .filter(UserOrgModel.user_id == user_id) + .filter(cls.id != DEMO_ORG_ID) + .all() + ) + + if not orgs_with_roles: + return [] + + # Extract org IDs for batch queries + org_ids = [org.id for org, _ in orgs_with_roles] + + # Batch query for user counts + user_counts = dict( + orm.query(UserOrgModel.org_id, func.count(UserOrgModel.user_id)) + .filter(UserOrgModel.org_id.in_(org_ids)) + .group_by(UserOrgModel.org_id) + .all() + ) + + # Batch query for invite counts + invite_counts = dict( + orm.query(OrgInviteModel.org_id, func.count(OrgInviteModel.invitee_email)) + .filter(OrgInviteModel.org_id.in_(org_ids)) + .group_by(OrgInviteModel.org_id) + .all() + ) + + # Batch query for project counts + project_counts = dict( + orm.query(ProjectModel.org_id, func.count(ProjectModel.id)) + .filter(ProjectModel.org_id.in_(org_ids)) + .group_by(ProjectModel.org_id) + .all() + ) + + # Assemble the results + orgs = [] + for org, role in orgs_with_roles: + # Set the current user role + org._current_user_role = role + org._current_user_id = user_id + + # Get counts from batch results + user_count = user_counts.get(org.id, 0) + invite_count = invite_counts.get(org.id, 0) + project_count = project_counts.get(org.id, 0) + + # Store counts as private attributes + org._member_count = user_count + invite_count + org._user_count = user_count # Store user count separately for billing + org._invite_count = invite_count # Store invite count separately + org._project_count = project_count + + orgs.append(org) + + return orgs + + @classmethod + def get_by_id_summary( + cls, orm: orm.Session, org_id: str | UUID, user_id: str | UUID + ) -> Optional['OrgModel']: + """ + Get an organization by ID with summary data only. + Returns org with current user role but without loading all relationships. + """ + from sqlalchemy import func + + org_id = normalize_uuid(org_id) + user_id = normalize_uuid(user_id) + + # Get org with user role + result = ( + orm.query(cls, UserOrgModel.role) + .join(UserOrgModel, (UserOrgModel.org_id == cls.id) & (UserOrgModel.user_id == user_id)) + .filter(cls.id == org_id) + .first() + ) + + if result: + org, role = result + org._current_user_role = role + org._current_user_id = user_id + + # Calculate counts separately + user_count = ( + orm.query(func.count(UserOrgModel.user_id)).filter(UserOrgModel.org_id == org.id).scalar() + or 0 + ) + invite_count = ( + orm.query(func.count(OrgInviteModel.invitee_email)) + .filter(OrgInviteModel.org_id == org.id) + .scalar() + or 0 + ) + project_count = ( + orm.query(func.count(ProjectModel.id)).filter(ProjectModel.org_id == org.id).scalar() or 0 + ) + + # Calculate paid member count separately + paid_user_count = ( + orm.query(func.count(UserOrgModel.user_id)) + .filter(UserOrgModel.org_id == org.id, UserOrgModel.is_paid) + .scalar() + or 0 + ) + + org._member_count = user_count + invite_count + org._user_count = user_count # Store user count separately for billing + org._invite_count = invite_count # Store invite count separately + org._project_count = project_count + org._paid_member_count = paid_user_count # Store paid member count + return org + + return None + + @classmethod + def get_all_for_user_optimized(cls, orm: orm.Session, user_id: str | UUID) -> list['OrgModel']: + """Deprecated: Use get_all_for_user_summary instead.""" + return cls.get_all_for_user_summary(orm, user_id) + + @classmethod + def get_by_id_for_detail(cls, orm: orm.Session, org_id: str | UUID) -> Optional['OrgModel']: + """ + Get an organization by ID optimized for detail view. + Only loads users (needed for detail view), not projects or invites. + """ + + org = ( + orm.query(cls) + .options( + joinedload(cls.users), + # Use lazyload to prevent automatic loading but avoid errors + lazyload(cls.projects), + lazyload(cls.invites), + ) + .filter(cls.id == normalize_uuid(org_id)) + .first() + ) + + if org: + # Calculate counts without loading all data + from sqlalchemy import func + + invite_count = ( + orm.query(func.count(OrgInviteModel.invitee_email)) + .filter(OrgInviteModel.org_id == org.id) + .scalar() + ) + project_count = ( + orm.query(func.count(ProjectModel.id)).filter(ProjectModel.org_id == org.id).scalar() + ) + + org._member_count = len(org.users) + invite_count + org._user_count = len(org.users) # Store user count separately for billing + org._invite_count = invite_count # Store invite count separately + org._project_count = project_count + + return org + + @classmethod + def get_by_id_for_permission_check( + cls, orm: orm.Session, org_id: str | UUID, user_id: str | UUID + ) -> Optional['OrgModel']: + """ + Get an organization by ID with only the current user's membership loaded. + Optimized for permission checks - doesn't load all users/invites/projects. + """ + # Use the summary method which already handles this efficiently + return cls.get_by_id_summary(orm, org_id, user_id) + + +class UserOrgModel(BaseModel): + """Model that maps to the user_orgs table (many-to-many)""" + + __tablename__ = "user_orgs" + __table_args__ = {"schema": "public"} + + user_id = model.Column(model.UUID, model.ForeignKey("public.users.id"), primary_key=True) + org_id = model.Column(model.UUID, model.ForeignKey("public.orgs.id"), primary_key=True) + role = model.Column( + model.Enum(OrgRoles, name="org_roles", create_constraint=False, native_enum=True), + default=OrgRoles.owner, + ) + user_email = model.Column(model.String) + is_paid = model.Column(model.Boolean, default=False) + + user = orm.relationship("UserModel", back_populates="orgs") + org = orm.relationship("OrgModel", back_populates="users") + + +class OrgInviteModel(BaseModel): + """Model that maps to the org_invites table.""" + + __tablename__ = "org_invites" + __table_args__ = {"schema": "public"} + + inviter_id = model.Column(model.UUID, model.ForeignKey("public.users.id"), nullable=False) + invitee_email = model.Column(model.String, primary_key=True) + org_id = model.Column(model.UUID, model.ForeignKey("public.orgs.id"), primary_key=True) + role = model.Column( + model.Enum(OrgRoles, name="org_roles", create_constraint=False, native_enum=True), + nullable=False, + ) + org_name = model.Column(model.String, nullable=False) + created_at = model.Column(model.DateTime(timezone=True), default=model.func.now()) + + inviter_user = orm.relationship("UserModel", foreign_keys=[inviter_id], back_populates="invites") + org = orm.relationship("OrgModel", back_populates="invites") + + +class SparseFieldException(ValueError): + """Exception raised when trying to access a field that is not available in the sparse model.""" + + def __init__(self, field_name: str): + super().__init__( + f"`{field_name}` is not available in sparse model. Call `get_project()` to load the full model." + ) + + @classmethod + def raise_for_field(cls, field_name: str): + raise cls(field_name) + + +class BaseProjectModel: + """Base model for projects that defines common attributes and interface.""" + + is_sparse: bool + id: UUID + api_key: UUID + + @property + def is_freeplan(self) -> bool: + """Check if the project is on a free plan.""" + raise NotImplementedError("Subclasses must implement is_freeplan") + + def get_project(self, orm: "orm.Session") -> Optional["ProjectModel"]: + """Get the full project model from the database.""" + raise NotImplementedError("Subclasses must implement get_project") + + +class ProjectModel(BaseProjectModel, BaseModel): + """Model that maps to the projects table""" + + __tablename__ = "projects" + __table_args__ = {"schema": "public"} + + is_sparse = False + id = model.Column(model.UUID, primary_key=True, default=uuid.uuid4) + org_id = model.Column(model.UUID, model.ForeignKey("public.orgs.id"), nullable=False) + api_key = model.Column(model.UUID, unique=True, default=uuid.uuid4) + name = model.Column(model.String, nullable=False) + environment = model.Column(model.Enum(Environment), default=Environment.development, nullable=False) + + org = orm.relationship("OrgModel", back_populates="projects") + + @property + @require_loaded('org') + def is_freeplan(self) -> bool: + """Check if the organization is on a pro plan.""" + return self.org.is_freeplan + + def get_project(self, orm: orm.Session) -> Optional["ProjectModel"]: + """For ProjectModel, return self since it's already the full model.""" + return self + + @classmethod + def get_by_id(cls, orm: orm.Session, project_id: str | UUID) -> Optional['ProjectModel']: + """Get a project by ID with org and necessary relationships preloaded.""" + # This loads org.users, org.invites, and org.projects relationships which are + # needed when returning a `ProjectResponse` in these view functions: + # - get_project + # - create_project + # - update_project + # - regenerate_api_key + # TODO: Consider optimizing with count queries instead of loading full relationships + # when we only need counts for org.current_member_count and org.current_project_count. + return ( + orm.query(cls) + .filter(cls.id == normalize_uuid(project_id)) + .options( + joinedload(cls.org).joinedload(OrgModel.users), + joinedload(cls.org).joinedload(OrgModel.invites), + joinedload(cls.org).joinedload(OrgModel.projects), + ) + .first() + ) + + @classmethod + def get_by_api_key(cls, orm: orm.Session, api_key: str | UUID) -> Optional['ProjectModel']: + """Get a project by API key with org and necessary relationships preloaded.""" + return ( + orm.query(cls) + .filter(cls.api_key == normalize_uuid(api_key)) + .options( + joinedload(cls.org).joinedload(OrgModel.users), + joinedload(cls.org).joinedload(OrgModel.invites), + joinedload(cls.org).joinedload(OrgModel.projects), + ) + .first() + ) + + @classmethod + def get_all_for_user(cls, orm: orm.Session, user_id: str | UUID) -> list['ProjectModel']: + """Get all projects the user has access to across all organizations they belong to.""" + projects = ( + orm.query(cls) + .join(OrgModel, cls.org_id == OrgModel.id) + .join( + UserOrgModel, + UserOrgModel.org_id == OrgModel.id, + ) + .filter(UserOrgModel.user_id == normalize_uuid(user_id)) + .filter(OrgModel.id != DEMO_ORG_ID) # TODO hard-code demo org and delete these rows + .options( + joinedload(cls.org).joinedload(OrgModel.users), + joinedload(cls.org).joinedload(OrgModel.invites), + joinedload(cls.org).joinedload(OrgModel.projects), + ) + .all() + ) + + # Set the current user for each project's org + for project in projects: + project.org.set_current_user(user_id) + + return projects + + @classmethod + def get_all_for_user_optimized(cls, orm: orm.Session, user_id: str | UUID) -> list['ProjectModel']: + """ + Get all projects the user has access to across all organizations they belong to. + + Optimized version that only loads minimal data needed for project summaries. + This avoids loading all users, invites, and projects for each organization. + """ + # Use a single query with minimal joins + projects = ( + orm.query(cls) + .join(OrgModel, cls.org_id == OrgModel.id) + .join(UserOrgModel, UserOrgModel.org_id == OrgModel.id) + .filter(UserOrgModel.user_id == normalize_uuid(user_id)) + .filter(OrgModel.id != DEMO_ORG_ID) + .options( + # Only load the org relationship itself, not all its relationships + joinedload(cls.org), + # Only load the specific user's membership for current_user_role + joinedload(cls.org).joinedload(OrgModel.users).load_only(UserOrgModel.role), + ) + .all() + ) + + # Set the current user for each project's org with minimal overhead + for project in projects: + # Manually set the user's role without loading all org members + user_org = next((uo for uo in project.org.users if uo.user_id == normalize_uuid(user_id)), None) + if user_org: + project.org._current_user_role = user_org.role + + return projects + + +class SparseProjectModel(BaseProjectModel): + """ + Sparse model for projects that is typically populated by a JWT token. + + In contexts where we only need the cache fields available inside the JWT, this + let's us save some db overhead and still reference a typed project object. + """ + + is_sparse = True + org_id = property(lambda self: SparseFieldException.raise_for_field("org_id")) + name = property(lambda self: SparseFieldException.raise_for_field("name")) + environment = property(lambda self: SparseFieldException.raise_for_field("environment")) + org = property(lambda self: SparseFieldException.raise_for_field("org")) + _prem_status: PremStatus + + def __init__(self, id: str | UUID, api_key: str | UUID, prem_status: str | PremStatus): + self.id = normalize_uuid(id) + self.api_key = normalize_uuid(api_key) + self._prem_status = PremStatus(prem_status) if isinstance(prem_status, str) else prem_status + + @property + def is_freeplan(self) -> bool: + """Check if the project is on a free plan.""" + return self._prem_status == PremStatus.free + + def get_project(self, orm: orm.Session) -> Optional[ProjectModel]: + """Get the full project model from the database.""" + return ProjectModel.get_by_id(orm, self.id) + + @classmethod + def from_auth_payload(cls, token: "JWTPayload") -> "SparseProjectModel": + """ + Create a SparseProjectModel from a JWT token. + """ + return cls( + id=token.project_id, + api_key=token.api_key, + prem_status=token.project_prem_status, + ) + + +class BillingAuditLog(BaseModel): + __tablename__ = "billing_audit_logs" + + id = model.Column(model.UUID, primary_key=True, default=uuid.uuid4) + org_id = model.Column(model.UUID, model.ForeignKey("public.orgs.id"), nullable=False) + user_id = model.Column(model.UUID, model.ForeignKey("public.users.id"), nullable=True) + action = model.Column( + model.String, nullable=False + ) # 'seats_updated', 'member_licensed', 'member_unlicensed' + details = model.Column(model.JSON, nullable=False) # JSON with before/after values + created_at = model.Column(model.DateTime, default=func.now()) + + +class WebhookEvent(BaseModel): + """Model for tracking processed webhook events to ensure idempotency""" + + __tablename__ = "webhook_events" + + event_id = model.Column(model.String, primary_key=True) + processed_at = model.Column(model.DateTime, default=func.now()) + + +class BillingPeriod(BaseModel): + """Model for billing period snapshots used in dashboard""" + + __tablename__ = "billing_periods" + + id = model.Column(model.UUID, primary_key=True, default=uuid.uuid4) + org_id = model.Column(model.UUID, model.ForeignKey("public.orgs.id"), nullable=False) + period_start = model.Column(model.DateTime, nullable=False) + period_end = model.Column(model.DateTime, nullable=False) + stripe_invoice_id = model.Column(model.String(255), nullable=True) + + # Costs breakdown (stored as cents) + seat_cost = model.Column(model.Integer, nullable=False, default=0) + seat_count = model.Column(model.Integer, nullable=False, default=0) + + # Usage costs (JSON for extensibility) + usage_costs = model.Column(JSONB, nullable=False, default={}) # {"tokens": 1500, "spans": 2000} + usage_quantities = model.Column(JSONB, nullable=False, default={}) # {"tokens": 5000000, "spans": 125000} + + total_cost = model.Column(model.Integer, nullable=False, default=0) + status = model.Column(model.String(20), default='pending') # 'pending', 'invoiced', 'paid' + invoiced_at = model.Column(model.DateTime, nullable=True) + created_at = model.Column(model.DateTime, default=func.now()) + + __table_args__ = (model.UniqueConstraint('org_id', 'period_start', name='_org_period_uc'),) diff --git a/app/api/agentops/opsboard/routes.py b/app/api/agentops/opsboard/routes.py new file mode 100644 index 000000000..66aca0207 --- /dev/null +++ b/app/api/agentops/opsboard/routes.py @@ -0,0 +1,249 @@ +from agentops.common.route_config import RouteConfig + +from .views.users import ( + get_user, + update_user, + update_user_survey_complete, +) + +from .views.orgs import ( + get_user_orgs, + get_org, + create_org, + update_org, + invite_to_org, + get_org_invites, + get_org_invites_for_org, + accept_org_invite, + remove_from_org, + change_member_role, + delete_org, + revoke_org_invite, + create_checkout_session, + create_free_subscription, + validate_discount_code, + cancel_subscription, + reactivate_subscription, + update_subscription, + create_customer_portal_session, + update_member_licenses, + get_stripe_pricing, + get_subscription_detail, + preview_member_add_cost, +) + +from .views.projects import ( + get_projects, + get_project, + create_project, + update_project, + delete_project, + regenerate_api_key, +) + +from .views.billing import BillingDashboardView + +route_config: list[RouteConfig] = [ + # User routes + RouteConfig( + name='get_user', + path="/users/me", + endpoint=get_user, + methods=["GET"], + ), + RouteConfig( + name='update_user', + path="/users/update", + endpoint=update_user, + methods=["POST"], + ), + RouteConfig( + name='update_user_survey_complete', + path="/users/complete_survey", + endpoint=update_user_survey_complete, + methods=["POST"], + ), + # Organization routes + RouteConfig( + name='get_user_orgs', + path="/orgs", + endpoint=get_user_orgs, + methods=["GET"], + ), + RouteConfig( + name='get_org_invites', + path="/orgs/invites", + endpoint=get_org_invites, + methods=["GET"], + ), + RouteConfig( + name='get_org_invites_for_org', + path="/orgs/{org_id}/invites", + endpoint=get_org_invites_for_org, + methods=["GET"], + ), + RouteConfig( + name='get_org', + path="/orgs/{org_id}", + endpoint=get_org, + methods=["GET"], + ), + RouteConfig( + name='create_org', + path="/orgs/create", + endpoint=create_org, + methods=["POST"], + ), + RouteConfig( + name='update_org', + path="/orgs/{org_id}/update", + endpoint=update_org, + methods=["POST"], + ), + RouteConfig( + name='invite_to_org', + path="/orgs/{org_id}/invite", + endpoint=invite_to_org, + methods=["POST"], + ), + RouteConfig( + name='accept_org_invite', + path="/orgs/{org_id}/accept", + endpoint=accept_org_invite, + methods=["POST"], + ), + RouteConfig( + name='remove_from_org', + path="/orgs/{org_id}/members/remove", + endpoint=remove_from_org, + methods=["POST"], + ), + RouteConfig( + name='change_member_role', + path="/orgs/{org_id}/members/update", + endpoint=change_member_role, + methods=["POST"], + ), + RouteConfig( + name='update_member_licenses', + path="/orgs/{org_id}/members/licenses", + endpoint=update_member_licenses, + methods=["PUT"], + ), + RouteConfig( + name='delete_org', + path="/orgs/{org_id}", + endpoint=delete_org, + methods=["DELETE"], + ), + RouteConfig( + name='create_checkout_session', + path="/orgs/{org_id}/create-checkout-session", + endpoint=create_checkout_session, + methods=["POST"], + ), + RouteConfig( + name='create_free_subscription', + path="/orgs/{org_id}/create-free-subscription", + endpoint=create_free_subscription, + methods=["POST"], + ), + RouteConfig( + name='validate_discount_code', + path="/orgs/{org_id}/validate-discount-code", + endpoint=validate_discount_code, + methods=["POST"], + ), + RouteConfig( + name='cancel_subscription', + path="/orgs/{org_id}/cancel-subscription", + endpoint=cancel_subscription, + methods=["POST"], + ), + RouteConfig( + name='reactivate_subscription', + path="/orgs/{org_id}/reactivate-subscription", + endpoint=reactivate_subscription, + methods=["POST"], + ), + RouteConfig( + name='get_subscription_detail', + path="/orgs/{org_id}/subscription-detail", + endpoint=get_subscription_detail, + methods=["GET"], + ), + RouteConfig( + name='update_subscription', + path="/orgs/{org_id}/update-subscription", + endpoint=update_subscription, + methods=["POST"], + ), + RouteConfig( + name='create_customer_portal_session', + path="/orgs/{org_id}/customer-portal", + endpoint=create_customer_portal_session, + methods=["POST"], + ), + RouteConfig( + name='get_stripe_pricing', + path="/orgs/{org_id}/stripe-pricing", + endpoint=get_stripe_pricing, + methods=["GET"], + ), + RouteConfig( + name='preview_member_add_cost', + path="/orgs/{org_id}/preview-member-cost", + endpoint=preview_member_add_cost, + methods=["GET"], + ), + RouteConfig( + name='revoke_org_invite', + path="/orgs/{org_id}/invites/{email}", + endpoint=revoke_org_invite, + methods=["DELETE"], + ), + # Project routes + RouteConfig( + name='get_projects', + path="/projects", + endpoint=get_projects, + methods=["GET"], + ), + RouteConfig( + name='get_project', + path="/projects/{project_id}", + endpoint=get_project, + methods=["GET"], + ), + RouteConfig( + name='create_project', + path="/projects", + endpoint=create_project, + methods=["POST"], + ), + RouteConfig( + name='update_project', + path="/projects/{project_id}/update", + endpoint=update_project, + methods=["POST"], + ), + RouteConfig( + name='delete_project', + path="/projects/{project_id}/delete", + endpoint=delete_project, + methods=["POST"], + ), + RouteConfig( + name='regenerate_api_key', + path="/projects/{project_id}/regenerate-key", + endpoint=regenerate_api_key, + methods=["POST"], + ), + # Billing routes + RouteConfig( + name='get_billing_dashboard', + path="/orgs/{org_id}/billing/dashboard", + endpoint=BillingDashboardView, + methods=["GET"], + ), +] diff --git a/app/api/agentops/opsboard/schemas.py b/app/api/agentops/opsboard/schemas.py new file mode 100644 index 000000000..e95a31595 --- /dev/null +++ b/app/api/agentops/opsboard/schemas.py @@ -0,0 +1,354 @@ +import pydantic +from enum import Enum +from uuid import UUID +from typing import Optional + + +def uuid_to_str(v) -> str: + """Convert UUID to string for Pydantic models.""" + if isinstance(v, UUID): + return str(v) + return v + + +class BaseSchema(pydantic.BaseModel): + """ + Base schema type intended to be used for creating input schemas. + """ + + pass + + +class BaseResponse(BaseSchema): + """ + Base response type intended to be directly populated by a sqlalchemy model. + """ + + model_config = pydantic.ConfigDict( + from_attributes=True, + ) + + +class StatusResponse(BaseResponse): + """ + Status response type intended to be used for simple success/failure responses. + """ + + success: bool = True + message: str | None = None + + +class UserResponse(BaseResponse): + """ + User response model. + """ + + id: str + full_name: str | None + avatar_url: str | None + billing_address: dict | None + payment_method: dict | None + email: str | None + survey_is_complete: bool | None + + @pydantic.field_validator("id", mode="before") + @classmethod + def validate_uuid(cls, v): + return uuid_to_str(v) + + +class UserUpdateSchema(BaseSchema): + """ + User update schema. + """ + + full_name: str | None = None + avatar_url: str | None = None + billing_address: dict | None = None + payment_method: dict | None = None + email: str | None = None + survey_is_complete: bool | None = None + + +class UserOrgResponse(BaseResponse): + """ + User-organization relationship information including role. + """ + + user_id: str + org_id: str + role: str + user_email: str | None + is_paid: bool = False # Whether this member counts against paid seats + + @pydantic.field_validator("user_id", "org_id", mode="before") + @classmethod + def validate_uuid(cls, v): + return uuid_to_str(v) + + +class OrgResponse(BaseResponse): + """ + Organization response model. + This contains fields which live directly on the OrgModel. + """ + + id: str + name: str + prem_status: str + subscription_id: str | None = None + subscription_end_date: int | None = None + subscription_start_date: int | None = None + subscription_cancel_at_period_end: bool | None = None + current_user_role: str | None = None + current_member_count: int | None = None + max_member_count: int | None = None + current_project_count: int | None = None + max_project_count: int | None = None + paid_member_count: Optional[int] = None + + @pydantic.field_validator("id", mode="before") + @classmethod + def validate_uuid(cls, v): + return uuid_to_str(v) + + @pydantic.field_validator("current_user_role", mode="before") + @classmethod + def validate_current_user_role_enum(cls, v): + """Convert the role Enum to a string.""" + return v.value if isinstance(v, Enum) else v + + @pydantic.field_validator("prem_status", mode="before") + @classmethod + def validate_prem_status_enum(cls, v): + """Convert the prem_status Enum to a string.""" + return v.value if isinstance(v, Enum) else v + + +class OrgDetailResponse(OrgResponse): + """ + Detailed organization response that includes user information. + Used for single organization view. + """ + + users: list[UserOrgResponse] + + @pydantic.field_validator("users", mode="before") + @classmethod + def validate_users(cls, v): + if not v: + return [] + return v + + +class OrgCreateSchema(BaseSchema): + """ + Schema for creating an organization. + """ + + name: str + + +class OrgUpdateSchema(BaseSchema): + """ + Schema for updating an organization. + """ + + name: str + + +class OrgInviteSchema(BaseSchema): + """ + Schema for inviting a user to an organization. + Email is used to identify the user, and role specifies their permissions level. + """ + + email: str + role: str + + +class OrgInviteResponse(BaseResponse): + """ + Organization invite response model. + """ + + inviter_id: str + invitee_email: str + org_id: str + role: str + org_name: str + created_at: str | None = None + + @pydantic.field_validator("inviter_id", "org_id", mode="before") + @classmethod + def validate_uuid(cls, v): + return uuid_to_str(v) + + @pydantic.field_validator("created_at", mode="before") + @classmethod + def validate_created_at(cls, v): + """Convert datetime to string.""" + if v is None: + return None + return v.isoformat() if hasattr(v, 'isoformat') else str(v) + + +class OrgInviteDetailResponse(BaseResponse): + """ + Detailed organization invite response model for organization admin view. + Includes additional information like inviter email and user existence status. + """ + + invitee_email: str + inviter_email: str + role: str + org_id: str + org_name: str + created_at: str | None = None + user_exists: bool + + @pydantic.field_validator("org_id", mode="before") + @classmethod + def validate_uuid(cls, v): + return uuid_to_str(v) + + @pydantic.field_validator("created_at", mode="before") + @classmethod + def validate_created_at(cls, v): + """Convert datetime to string.""" + if v is None: + return None + return v.isoformat() if hasattr(v, 'isoformat') else str(v) + + +class OrgMemberRemoveSchema(BaseSchema): + """ + Schema for removing a user from an organization. + """ + + user_id: str + + +class OrgMemberRoleSchema(BaseSchema): + """ + Schema for changing a user's role in an organization. + """ + + user_id: str + role: str + + +class ValidateDiscountCodeBody(BaseSchema): + """ + Schema for validating a discount code (promotion code or coupon ID). + """ + + discount_code: str + + +class ValidateDiscountCodeResponse(BaseResponse): + """ + Response schema for discount code validation. + """ + + valid: bool + discount_type: str | None = None # 'percent_off' or 'amount_off' + discount_value: float | None = None # percentage or amount in cents + discount_description: str | None = None + currency: str | None = None # only for amount_off + is_100_percent_off: bool = False # Explicit flag for 100% off discounts + + +class CreateFreeSubscriptionResponse(BaseResponse): + """ + Response schema for free subscription creation. + """ + + message: str + subscription_id: str + org_id: str + + +class OrgSummaryResponse(BaseResponse): + """ + Organization summary information for inclusion in other responses. + """ + + id: str + name: str + prem_status: str + current_user_role: str + + @pydantic.field_validator("id", mode="before") + @classmethod + def validate_uuid(cls, v): + return uuid_to_str(v) + + @pydantic.field_validator("prem_status", mode="before") + @classmethod + def validate_prem_status_enum(cls, v): + """Convert the prem_status Enum to a string.""" + return v.value if isinstance(v, Enum) else v + + @pydantic.field_validator("current_user_role", mode="before") + @classmethod + def validate_current_user_role_enum(cls, v): + """Convert the role Enum to a string.""" + return v.value if isinstance(v, Enum) else v + + +class ProjectSummaryResponse(BaseResponse): + """ + Project response model for listing projects. + """ + + id: str + name: str + api_key: str + org: OrgSummaryResponse + span_count: int = 0 + trace_count: int = 0 + + @pydantic.field_validator("id", "api_key", mode="before") + @classmethod + def validate_uuid(cls, v): + return uuid_to_str(v) + + +class ProjectResponse(BaseResponse): + """ + Project response model. + Basic project information including organization details. + """ + + id: str + org_id: str + name: str + environment: str + api_key: str + org: OrgResponse + + @pydantic.field_validator("id", "org_id", "api_key", mode="before") + @classmethod + def validate_uuid(cls, v): + return uuid_to_str(v) + + +class ProjectCreateSchema(BaseSchema): + """ + Schema for creating a project. + """ + + name: str + org_id: str + environment: str | None = None + + +class ProjectUpdateSchema(BaseSchema): + """ + Schema for updating a project. + Only name and environment can be updated. + """ + + name: str | None = None + environment: str | None = None diff --git a/app/api/agentops/opsboard/services/billing_service.py b/app/api/agentops/opsboard/services/billing_service.py new file mode 100644 index 000000000..499eb5fa4 --- /dev/null +++ b/app/api/agentops/opsboard/services/billing_service.py @@ -0,0 +1,709 @@ +import os +import stripe +import logging +from decimal import Decimal, InvalidOperation +from datetime import datetime, timezone +from typing import Dict, Optional +from sqlalchemy.orm import Session + +from ...common.usage_tracking import UsageType +from ..models import OrgModel, BillingPeriod +from ...api.db.clickhouse_client import get_clickhouse +from ...api.environment import ( + STRIPE_SECRET_KEY, + STRIPE_SUBSCRIPTION_PRICE_ID, + STRIPE_TOKEN_PRICE_ID, + STRIPE_SPAN_PRICE_ID, +) + +logger = logging.getLogger(__name__) + + +class BillingService: + def __init__(self): + # Validate and set Stripe configuration with detailed logging + self._validate_stripe_config() + stripe.api_key = STRIPE_SECRET_KEY + self._pricing_cache: Optional[Dict] = None + self._cache_timestamp: Optional[datetime] = None + self._cache_duration = 3600 # Cache for 1 hour + + self._usage_cache: Dict[str, tuple[Dict[str, int], datetime]] = {} + self._usage_cache_ttl = 300 # 5 minutes for usage data + + def _validate_stripe_config(self): + """Validate Stripe configuration and log detailed status""" + logger.info("=== BillingService Stripe Validation ===") + + # Check all required Stripe variables + required_vars = { + "STRIPE_SECRET_KEY": STRIPE_SECRET_KEY, + "STRIPE_SUBSCRIPTION_PRICE_ID": STRIPE_SUBSCRIPTION_PRICE_ID, + "STRIPE_TOKEN_PRICE_ID": STRIPE_TOKEN_PRICE_ID, + "STRIPE_SPAN_PRICE_ID": STRIPE_SPAN_PRICE_ID, + } + + all_present = True + for var_name, var_value in required_vars.items(): + if var_value: + masked_value = f"{var_value[:8]}..." if len(var_value) > 8 else var_value + logger.info(f"āœ“ {var_name}: {masked_value}") + else: + logger.error(f"āœ— {var_name}: NOT FOUND - This will cause billing failures!") + all_present = False + + if all_present: + logger.info("āœ“ All required Stripe variables present, attempting Stripe API test...") + try: + # Test Stripe API connectivity with a simple call + if STRIPE_SECRET_KEY: + stripe.api_key = STRIPE_SECRET_KEY + # This is a lightweight test call + stripe.Account.retrieve() + logger.info("āœ“ Stripe API connection successful") + else: + logger.error("āœ— Cannot test Stripe API - STRIPE_SECRET_KEY missing") + except stripe.error.AuthenticationError as e: + logger.error(f"āœ— Stripe API authentication failed: {e}") + except stripe.error.StripeError as e: + logger.error(f"āœ— Stripe API error: {e}") + except Exception as e: + logger.error(f"āœ— Unexpected error testing Stripe API: {e}") + else: + logger.error("āœ— Missing required Stripe variables - billing service will not work properly") + + logger.info("=========================================") + + def _should_refresh_cache(self) -> bool: + if not self._pricing_cache or not self._cache_timestamp: + return True + return (datetime.now() - self._cache_timestamp).total_seconds() > self._cache_duration + + def _extract_price_amount(self, price_object, price_id: str) -> Optional[float]: + """ + Extract price amount from Stripe price object handling all pricing models. + Returns price in cents (float for micro-pricing) or None if no valid pricing found. + + For micro-pricing (like $0.0001), Stripe uses unit_amount_decimal field. + This method converts all pricing to cents for consistent handling. + """ + logger.info( + f"Extracting price from {price_id}: " + f"billing_scheme={getattr(price_object, 'billing_scheme', 'missing')}, " + f"type={getattr(price_object, 'type', 'missing')}, " + f"active={getattr(price_object, 'active', 'missing')}" + ) + + # Log all available price-related attributes for debugging + unit_amount = getattr(price_object, 'unit_amount', None) + unit_amount_decimal = getattr(price_object, 'unit_amount_decimal', None) + custom_unit_amount = getattr(price_object, 'custom_unit_amount', None) + tiers = getattr(price_object, 'tiers', None) + currency_options = getattr(price_object, 'currency_options', None) + + logger.info( + f"Price object attributes for {price_id}: " + f"unit_amount={unit_amount}, " + f"unit_amount_decimal={unit_amount_decimal}, " + f"custom_unit_amount={custom_unit_amount is not None}, " + f"tiers_count={len(tiers) if tiers else 0}, " + f"currency_options={list(currency_options.keys()) if currency_options else []}" + ) + + # 1. Check unit_amount_decimal FIRST for micro-pricing (like $0.0001, $0.0002) + if unit_amount_decimal is not None: + try: + # Parse as string to avoid float precision issues + decimal_str = str(unit_amount_decimal).strip() + logger.info(f"Processing unit_amount_decimal: '{decimal_str}'") + + # Convert to Decimal for precise calculations + decimal_value = Decimal(decimal_str) + + # For micro-pricing, unit_amount_decimal appears to already be in the correct scale + # Dashboard shows $0.0002, API returns 0.02 -> this IS 0.02 cents + # Dashboard shows $0.0001, API returns 0.01 -> this IS 0.01 cents + # Dashboard shows $40.00, API returns 4000 -> this IS 4000 cents + price_amount = float(decimal_value) + + logger.info(f"Using unit_amount_decimal directly: {decimal_str} -> {price_amount} cents") + return price_amount + + except (ValueError, TypeError, InvalidOperation) as e: + logger.warning(f"Failed to parse unit_amount_decimal '{unit_amount_decimal}': {e}") + + # 2. Standard case: unit_amount (for regular pricing in cents) + if unit_amount is not None and unit_amount > 0: + logger.info(f"Using unit_amount: {unit_amount} cents") + return float(unit_amount) + + # 3. Check custom_unit_amount for variable pricing + if custom_unit_amount is not None: + if hasattr(custom_unit_amount, 'minimum') and custom_unit_amount.minimum is not None: + logger.info(f"Using custom_unit_amount.minimum: {custom_unit_amount.minimum}") + return float(custom_unit_amount.minimum) + elif hasattr(custom_unit_amount, 'maximum') and custom_unit_amount.maximum is not None: + logger.info(f"Using custom_unit_amount.maximum: {custom_unit_amount.maximum}") + return float(custom_unit_amount.maximum) + + # 4. Check tiered pricing + if tiers and len(tiers) > 0: + first_tier = tiers[0] + logger.info( + f"Checking first tier: {vars(first_tier) if hasattr(first_tier, '__dict__') else first_tier}" + ) + + # Check first tier for unit_amount + if hasattr(first_tier, 'unit_amount') and first_tier.unit_amount is not None: + logger.info(f"Using first tier unit_amount: {first_tier.unit_amount}") + return float(first_tier.unit_amount) + # Check first tier for unit_amount_decimal + elif hasattr(first_tier, 'unit_amount_decimal') and first_tier.unit_amount_decimal is not None: + try: + decimal_value = Decimal(str(first_tier.unit_amount_decimal)) + price_amount = float(decimal_value * 100) + logger.info( + f"Using first tier unit_amount_decimal: {first_tier.unit_amount_decimal} -> {price_amount} cents" + ) + return price_amount + except (ValueError, TypeError, InvalidOperation) as e: + logger.warning(f"Failed to parse tier unit_amount_decimal: {e}") + # Check first tier for flat_amount + elif hasattr(first_tier, 'flat_amount') and first_tier.flat_amount is not None: + logger.info(f"Using first tier flat_amount: {first_tier.flat_amount}") + return float(first_tier.flat_amount) + + # 5. Check currency_options for multi-currency prices + if currency_options: + # Try USD first, then any available currency + currencies_to_try = ['usd'] + [c for c in currency_options.keys() if c != 'usd'] + for currency in currencies_to_try: + if currency in currency_options: + options = currency_options[currency] + logger.info( + f"Checking currency_options[{currency}]: {vars(options) if hasattr(options, '__dict__') else options}" + ) + + # Check unit_amount_decimal first + if hasattr(options, 'unit_amount_decimal') and options.unit_amount_decimal is not None: + try: + decimal_value = Decimal(str(options.unit_amount_decimal)) + price_amount = float(decimal_value * 100) + logger.info( + f"Using currency_options[{currency}].unit_amount_decimal: {options.unit_amount_decimal} -> {price_amount} cents" + ) + return price_amount + except (ValueError, TypeError, InvalidOperation) as e: + logger.warning(f"Failed to parse currency option unit_amount_decimal: {e}") + + # Check unit_amount + if hasattr(options, 'unit_amount') and options.unit_amount is not None: + logger.info(f"Using currency_options[{currency}].unit_amount: {options.unit_amount}") + return float(options.unit_amount) + + logger.warning( + f"No valid pricing amount found for {price_id}. " + f"unit_amount={unit_amount}, " + f"unit_amount_decimal={unit_amount_decimal}, " + f"custom_unit_amount={custom_unit_amount}, " + f"tiers={len(tiers) if tiers else 0}, " + f"currency_options={list(currency_options.keys()) if currency_options else []}" + ) + return None + + def get_usage_pricing(self) -> Dict[UsageType, Dict]: + """Fetch usage pricing from Stripe or return cached values""" + if not self._should_refresh_cache(): + return self._pricing_cache + + try: + token_price_id = STRIPE_TOKEN_PRICE_ID + span_price_id = STRIPE_SPAN_PRICE_ID + + pricing = {} + + if token_price_id: + try: + token_price = stripe.Price.retrieve(token_price_id, expand=['currency_options', 'tiers']) + + # Add detailed logging for debugging price configuration + logger.info( + f"Retrieved token price {token_price_id}: type={getattr(token_price, 'type', 'unknown')}, " + f"unit_amount={getattr(token_price, 'unit_amount', 'missing')}, " + f"billing_scheme={getattr(token_price, 'billing_scheme', 'missing')}, " + f"active={getattr(token_price, 'active', 'missing')}" + ) + + price_amount = self._extract_price_amount(token_price, token_price_id) + + if price_amount is not None: + pricing[UsageType.TOKENS] = { + 'price_per_unit': Decimal(str(price_amount)) / 100, + 'unit_size': getattr(token_price.transform_quantity, 'divide_by', 1000) + if hasattr(token_price, 'transform_quantity') and token_price.transform_quantity + else 1000, + 'display_unit': 'thousand tokens', + 'stripe_price_id': token_price_id, + } + logger.info( + f"Token pricing configured: ${price_amount / 100:.4f} per {pricing[UsageType.TOKENS]['unit_size']} tokens" + ) + else: + logger.error(f"Token price {token_price_id} has no valid pricing amount") + raise ValueError("Token price has no valid pricing amount") + + except (stripe.error.StripeError, ValueError, TypeError, AttributeError) as e: + logger.warning(f"Failed to retrieve token price {token_price_id}: {e}, using default") + pricing[UsageType.TOKENS] = { + 'price_per_unit': Decimal("0.0002"), # $0.0002 per 1000 tokens + 'unit_size': 1000, + 'display_unit': 'thousand tokens', + } + else: + logger.info("No STRIPE_TOKEN_PRICE_ID configured, using default token pricing") + pricing[UsageType.TOKENS] = { + 'price_per_unit': Decimal("0.0002"), # $0.0002 per 1000 tokens + 'unit_size': 1000, + 'display_unit': 'thousand tokens', + } + + if span_price_id: + try: + span_price = stripe.Price.retrieve(span_price_id, expand=['currency_options', 'tiers']) + + # Add detailed logging for debugging price configuration + logger.info( + f"Retrieved span price {span_price_id}: type={getattr(span_price, 'type', 'unknown')}, " + f"unit_amount={getattr(span_price, 'unit_amount', 'missing')}, " + f"billing_scheme={getattr(span_price, 'billing_scheme', 'missing')}, " + f"active={getattr(span_price, 'active', 'missing')}" + ) + + price_amount = self._extract_price_amount(span_price, span_price_id) + + if price_amount is not None: + pricing[UsageType.SPANS] = { + 'price_per_unit': Decimal(str(price_amount)) / 100, + 'unit_size': getattr(span_price.transform_quantity, 'divide_by', 1000) + if hasattr(span_price, 'transform_quantity') and span_price.transform_quantity + else 1000, + 'display_unit': 'thousand spans', + 'stripe_price_id': span_price_id, + } + logger.info( + f"Span pricing configured: ${price_amount / 100:.4f} per {pricing[UsageType.SPANS]['unit_size']} spans" + ) + else: + logger.error(f"Span price {span_price_id} has no valid pricing amount") + raise ValueError("Span price has no valid pricing amount") + + except (stripe.error.StripeError, ValueError, TypeError, AttributeError) as e: + logger.warning(f"Failed to retrieve span price {span_price_id}: {e}, using default") + pricing[UsageType.SPANS] = { + 'price_per_unit': Decimal("0.0001"), # $0.0001 per 1000 spans + 'unit_size': 1000, + 'display_unit': 'thousand spans', + } + else: + logger.info("No STRIPE_SPAN_PRICE_ID configured, using default span pricing") + pricing[UsageType.SPANS] = { + 'price_per_unit': Decimal("0.0001"), # $0.0001 per 1000 spans + 'unit_size': 1000, + 'display_unit': 'thousand spans', + } + + self._pricing_cache = pricing + self._cache_timestamp = datetime.now() + + except stripe.error.StripeError as e: + logger.error(f"Failed to fetch pricing from Stripe: {e}") + return { + UsageType.TOKENS: { + 'price_per_unit': Decimal("0.0002"), # $0.0002 per 1000 tokens + 'unit_size': 1000, + 'display_unit': 'thousand tokens', + }, + UsageType.SPANS: { + 'price_per_unit': Decimal("0.0001"), # $0.0001 per 1000 spans + 'unit_size': 1000, + 'display_unit': 'thousand spans', + }, + } + except Exception as e: + logger.error(f"Unexpected error in get_usage_pricing: {e}") + return { + UsageType.TOKENS: { + 'price_per_unit': Decimal("0.0002"), # $0.0002 per 1000 tokens + 'unit_size': 1000, + 'display_unit': 'thousand tokens', + }, + UsageType.SPANS: { + 'price_per_unit': Decimal("0.0001"), # $0.0001 per 1000 spans + 'unit_size': 1000, + 'display_unit': 'thousand spans', + }, + } + + return self._pricing_cache + + def get_seat_price(self) -> int: + """Get per-seat price in cents from Stripe or environment""" + try: + main_price_id = STRIPE_SUBSCRIPTION_PRICE_ID + if main_price_id: + price = stripe.Price.retrieve(main_price_id, expand=['currency_options', 'tiers']) + if price.recurring and price.recurring.usage_type == 'licensed': + price_amount = self._extract_price_amount(price, main_price_id) + if price_amount is not None: + # Convert float to int for seat pricing (seats should be whole cents) + return int(round(price_amount)) + else: + logger.warning( + f"Seat price {main_price_id} has no valid pricing amount, falling back to default" + ) + else: + logger.warning(f"Seat price {main_price_id} is not configured for licensed usage") + except stripe.error.StripeError as e: + logger.error(f"Failed to fetch seat price from Stripe: {e}") + except Exception as e: + logger.error(f"Unexpected error fetching seat price: {e}") + + return int(os.getenv("STRIPE_SEAT_PRICE_CENTS", "4000")) + + async def get_usage_for_period( + self, + orm: Session, + org_id: str, + period_start: datetime, + period_end: datetime, + project_id: Optional[str] = None, + ) -> Dict[str, int]: + """Get usage quantities for a billing period by querying ClickHouse directly""" + from ..models import ProjectModel + + # Ensure we have timezone-aware datetimes + if period_start.tzinfo is None: + period_start = period_start.replace(tzinfo=timezone.utc) + if period_end.tzinfo is None: + period_end = period_end.replace(tzinfo=timezone.utc) + + # Convert to UTC for consistent ClickHouse querying + period_start_utc = period_start.astimezone(timezone.utc) + period_end_utc = period_end.astimezone(timezone.utc) + + # Validate that the period is reasonable (not more than 32 days for billing overview) + period_duration = period_end_utc - period_start_utc + if period_duration.days > 32: + logger.warning( + f"Billing period duration is {period_duration.days} days for org {org_id}, this may indicate a date scoping issue" + ) + + cache_key = ( + f"{org_id}:{period_start_utc.isoformat()}:{period_end_utc.isoformat()}:{project_id or 'all'}" + ) + if cache_key in self._usage_cache: + cached_data, cached_time = self._usage_cache[cache_key] + if (datetime.now() - cached_time).total_seconds() < self._usage_cache_ttl: + logger.debug(f"Returning cached usage data for org {org_id}") + return cached_data + + # If project_id is specified, only query for that project + if project_id: + # Verify the project belongs to the org + project = ( + orm.query(ProjectModel.id) + .filter(ProjectModel.org_id == org_id, ProjectModel.id == project_id) + .first() + ) + if not project: + empty_result = {} + self._usage_cache[cache_key] = (empty_result, datetime.now()) + return empty_result + project_ids = [project_id] + else: + projects = orm.query(ProjectModel.id).filter(ProjectModel.org_id == org_id).all() + project_ids = [str(p.id) for p in projects] + + if not project_ids: + empty_result = {} + self._usage_cache[cache_key] = (empty_result, datetime.now()) + return empty_result + + clickhouse_client = get_clickhouse() + + try: + usage_query = """ + SELECT + COUNT(*) as span_count, + SUM( + COALESCE( + toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.total_tokens'], '0')), + toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.prompt_tokens'], '0')) + + toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.completion_tokens'], '0')) + + toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.cache_read_input_tokens'], '0')) + + toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.reasoning_tokens'], '0')) + ) + ) as total_tokens + FROM otel_2.otel_traces + WHERE project_id IN %(project_ids)s + AND Timestamp >= %(period_start)s + AND Timestamp <= %(period_end)s + """ + + # Use timezone-aware formatting for ClickHouse (ClickHouse expects UTC) + formatted_start = period_start_utc.strftime('%Y-%m-%d %H:%M:%S') + formatted_end = period_end_utc.strftime('%Y-%m-%d %H:%M:%S') + + logger.info( + f"Querying usage for org {org_id} from {formatted_start} to {formatted_end} (project_ids: {project_ids})" + ) + + result = clickhouse_client.query( + usage_query, + { + 'project_ids': project_ids, + 'period_start': formatted_start, + 'period_end': formatted_end, + }, + ) + + if result.result_rows: + span_count, total_tokens = result.result_rows[0] + + logger.info(f"Usage data for org {org_id}: {total_tokens} total tokens, {span_count} spans") + else: + span_count, total_tokens = 0, 0 + logger.info( + f"No usage data found for org {org_id} in period {formatted_start} to {formatted_end}" + ) + + usage_data = { + 'tokens': int(total_tokens) if total_tokens else 0, + 'spans': int(span_count) if span_count else 0, + } + + logger.info( + f"Final usage data for org {org_id}: {usage_data['tokens']} tokens and {usage_data['spans']} spans" + ) + + self._usage_cache[cache_key] = (usage_data, datetime.now()) + + if len(self._usage_cache) > 100: + current_time = datetime.now() + expired_keys = [ + k + for k, (_, cached_time) in self._usage_cache.items() + if (current_time - cached_time).total_seconds() > self._usage_cache_ttl + ] + for key in expired_keys: + del self._usage_cache[key] + + return usage_data + + except Exception as e: + logger.error(f"Error querying usage data for org {org_id}: {e}") + return {} + + async def get_usage_by_project_for_period( + self, orm: Session, org_id: str, period_start: datetime, period_end: datetime + ) -> Dict[str, Dict[str, int]]: + """Get usage quantities for a billing period broken down by project""" + from ..models import ProjectModel + + # Ensure we have timezone-aware datetimes + if period_start.tzinfo is None: + period_start = period_start.replace(tzinfo=timezone.utc) + if period_end.tzinfo is None: + period_end = period_end.replace(tzinfo=timezone.utc) + + # Convert to UTC for consistent ClickHouse querying + period_start_utc = period_start.astimezone(timezone.utc) + period_end_utc = period_end.astimezone(timezone.utc) + + projects = orm.query(ProjectModel.id, ProjectModel.name).filter(ProjectModel.org_id == org_id).all() + project_ids = [str(p.id) for p in projects] + project_names = {str(p.id): p.name for p in projects} + + if not project_ids: + return {} + + clickhouse_client = get_clickhouse() + + try: + # Same query as get_usage_for_period but grouped by project_id + usage_query = """ + SELECT + project_id, + COUNT(*) as span_count, + SUM( + COALESCE( + toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.total_tokens'], '0')), + toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.prompt_tokens'], '0')) + + toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.completion_tokens'], '0')) + + toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.cache_read_input_tokens'], '0')) + + toUInt64OrZero(ifNull(SpanAttributes['gen_ai.usage.reasoning_tokens'], '0')) + ) + ) as total_tokens + FROM otel_2.otel_traces + WHERE project_id IN %(project_ids)s + AND Timestamp >= %(period_start)s + AND Timestamp <= %(period_end)s + GROUP BY project_id + """ + + formatted_start = period_start_utc.strftime('%Y-%m-%d %H:%M:%S') + formatted_end = period_end_utc.strftime('%Y-%m-%d %H:%M:%S') + + logger.info( + f"Querying per-project usage for org {org_id} from {formatted_start} to {formatted_end}" + ) + + result = clickhouse_client.query( + usage_query, + { + 'project_ids': project_ids, + 'period_start': formatted_start, + 'period_end': formatted_end, + }, + ) + + project_usage = {} + + for row in result.result_rows: + project_id, span_count, total_tokens = row + + project_usage[str(project_id)] = { + 'tokens': int(total_tokens) if total_tokens else 0, + 'spans': int(span_count) if span_count else 0, + 'project_name': project_names.get(str(project_id), 'Unknown Project'), + } + + # Include projects with zero usage + for project_id, project_name in project_names.items(): + if project_id not in project_usage: + project_usage[project_id] = { + 'tokens': 0, + 'spans': 0, + 'project_name': project_name, + } + + logger.info(f"Found usage data for {len(project_usage)} projects in org {org_id}") + return project_usage + + except Exception as e: + logger.error(f"Error querying per-project usage data for org {org_id}: {e}") + return {} + + async def calculate_usage_costs(self, usage_quantities: Dict[str, int]) -> Dict[str, int]: + """Calculate costs from usage quantities + + For micro-pricing (like $0.0001, $0.0002), we enforce a minimum charge threshold + to avoid charging customers $0.00. Costs are only included if they round to at least 1 cent. + """ + costs = {} + pricing = self.get_usage_pricing() + + for usage_type_str, quantity in usage_quantities.items(): + try: + usage_type = UsageType(usage_type_str) + if usage_type in pricing: + price_config = pricing[usage_type] + + units = Decimal(str(quantity)) / Decimal(str(price_config['unit_size'])) + cost_dollars = units * price_config['price_per_unit'] + cost_cents = cost_dollars * 100 + final_cost_cents = int(cost_cents.quantize(Decimal('1'), rounding='ROUND_HALF_UP')) + + # Only include costs that are at least 1 cent to avoid $0.00 charges + if final_cost_cents >= 1: + costs[usage_type_str] = final_cost_cents + logger.info( + f"Usage cost for {usage_type_str}: {quantity} units -> {final_cost_cents} cents " + f"(${cost_dollars:.6f})" + ) + else: + logger.info( + f"Usage cost for {usage_type_str}: {quantity} units -> {cost_cents:.6f} cents " + f"(below 1 cent threshold, not charged)" + ) + except (ValueError, TypeError, InvalidOperation) as e: + logger.warning( + f"Error calculating cost for usage type {usage_type_str} with quantity {quantity}: {e}" + ) + continue + except Exception as e: + logger.error(f"Unexpected error calculating cost for usage type {usage_type_str}: {e}") + continue + + return costs + + async def create_billing_period_snapshot( + self, orm: Session, org: OrgModel, period_start: datetime, period_end: datetime + ) -> BillingPeriod: + """Create a billing snapshot for the period""" + + seat_count = org.paid_member_count or 1 + seat_cost = seat_count * self.get_seat_price() + + usage_quantities = await self.get_usage_for_period(orm, str(org.id), period_start, period_end) + + usage_costs = await self.calculate_usage_costs(usage_quantities) + + total_cost = seat_cost + sum(usage_costs.values()) + + billing_period = BillingPeriod( + org_id=org.id, + period_start=period_start, + period_end=period_end, + seat_cost=seat_cost, + seat_count=seat_count, + usage_costs=usage_costs, + usage_quantities=usage_quantities, + total_cost=total_cost, + status='pending', + ) + + orm.add(billing_period) + orm.commit() + + return billing_period + + +billing_service = BillingService() + + +# Log final validation summary when module is imported +def _log_billing_service_ready(): + """Log final status of billing service configuration""" + logger.info("=== Billing Service Configuration Summary ===") + + # Check if all required variables are present + required_vars = [ + STRIPE_SECRET_KEY, + STRIPE_SUBSCRIPTION_PRICE_ID, + STRIPE_TOKEN_PRICE_ID, + STRIPE_SPAN_PRICE_ID, + ] + all_present = all(var for var in required_vars) + + if all_present: + logger.info("āœ“ All Stripe variables configured - Billing service ready for production") + else: + missing = [ + name + for name, var in [ + ("STRIPE_SECRET_KEY", STRIPE_SECRET_KEY), + ("STRIPE_SUBSCRIPTION_PRICE_ID", STRIPE_SUBSCRIPTION_PRICE_ID), + ("STRIPE_TOKEN_PRICE_ID", STRIPE_TOKEN_PRICE_ID), + ("STRIPE_SPAN_PRICE_ID", STRIPE_SPAN_PRICE_ID), + ] + if not var + ] + logger.error(f"āœ— Billing service NOT ready - missing: {', '.join(missing)}") + logger.error("This will cause billing operations to fail or use fallback values") + + logger.info("============================================") + + +# Call validation when module is imported +_log_billing_service_ready() diff --git a/app/api/agentops/opsboard/views/__init__.py b/app/api/agentops/opsboard/views/__init__.py new file mode 100644 index 000000000..a873517e9 --- /dev/null +++ b/app/api/agentops/opsboard/views/__init__.py @@ -0,0 +1,46 @@ +from .users import get_user, update_user, update_user_survey_complete +from .orgs import ( + get_user_orgs, + get_org, + create_org, + update_org, + invite_to_org, + get_org_invites, + accept_org_invite, + remove_from_org, + change_member_role, + preview_member_add_cost, +) +from .projects import ( + get_projects, + get_project, + create_project, + update_project, + delete_project, + regenerate_api_key, +) + +__all__ = [ + # User views + 'get_user', + 'update_user', + 'update_user_survey_complete', + # Organization views + 'get_user_orgs', + 'get_org', + 'create_org', + 'update_org', + 'invite_to_org', + 'get_org_invites', + 'accept_org_invite', + 'remove_from_org', + 'change_member_role', + 'preview_member_add_cost', + # Project views + 'get_projects', + 'get_project', + 'create_project', + 'update_project', + 'delete_project', + 'regenerate_api_key', +] diff --git a/app/api/agentops/opsboard/views/billing.py b/app/api/agentops/opsboard/views/billing.py new file mode 100644 index 000000000..43c607644 --- /dev/null +++ b/app/api/agentops/opsboard/views/billing.py @@ -0,0 +1,430 @@ +from typing import List, Optional, Dict +from datetime import datetime, timezone, timedelta +from pydantic import BaseModel, field_validator +from fastapi import Depends, HTTPException, Query +from sqlalchemy.orm import Session +import stripe +import logging + +from agentops.common.orm import get_orm_session +from agentops.common.route_config import BaseView +from agentops.common.views import add_cors_headers +from agentops.common.environment import APP_URL +from agentops.api.environment import STRIPE_SECRET_KEY, STRIPE_SUBSCRIPTION_PRICE_ID +from ..models import OrgModel, BillingPeriod +from ..services.billing_service import billing_service + +logger = logging.getLogger(__name__) + + +class UsageCostBreakdown(BaseModel): + usage_type: str + quantity: int + cost_cents: int + + +class BillingPeriodResponse(BaseModel): + id: str + period_start: str + period_end: str + seat_cost: int + seat_count: int + usage_costs: Dict[str, int] + usage_quantities: Dict[str, int] + usage_breakdown: List[UsageCostBreakdown] + total_cost: int + status: str + + @field_validator('period_start', 'period_end', mode='before') + def format_datetime(cls, v) -> str: + """Ensure datetime fields are formatted as ISO strings.""" + if isinstance(v, datetime): + return v.isoformat() + return v + + +# costs are in cents +class ProjectUsageBreakdown(BaseModel): + project_id: str + project_name: str + tokens: int + spans: int + token_cost: int + span_cost: int + total_cost: int + + +class BillingDashboardResponse(BaseModel): + current_period: Optional[BillingPeriodResponse] + past_periods: List[BillingPeriodResponse] + total_spent_all_time: int + is_legacy_billing: bool = False + legacy_cancellation_date: Optional[str] = None + project_breakdown: Optional[List[ProjectUsageBreakdown]] = None + + @field_validator('legacy_cancellation_date', mode='before') + def format_legacy_date(cls, v) -> Optional[str]: + """Format datetime as ISO string if present.""" + if isinstance(v, datetime): + return v.isoformat() + return v + + +class BillingDashboardView(BaseView): + """Get billing dashboard data with cost breakdown""" + + @add_cors_headers( + origins=[APP_URL], + methods=["GET", "OPTIONS"], + ) + async def __call__( + self, + org_id: str, + start_date: Optional[str] = Query(None, alias="start_date"), + end_date: Optional[str] = Query(None, alias="end_date"), + project_id: Optional[str] = Query(None, alias="project_id"), + period: Optional[str] = Query(None, alias="period"), # For backward compatibility + orm: Session = Depends(get_orm_session), + ) -> BillingDashboardResponse: + """Get billing dashboard data with cost breakdown""" + + # Handle FastAPI Query objects when called directly in tests + + # Check for various FastAPI Query object types + if hasattr(start_date, 'default') or str(type(start_date)).find('Query') != -1: + logger.debug(f"Converting start_date Query object to None: {type(start_date)}") + start_date = None + if hasattr(end_date, 'default') or str(type(end_date)).find('Query') != -1: + logger.debug(f"Converting end_date Query object to None: {type(end_date)}") + end_date = None + if hasattr(project_id, 'default') or str(type(project_id)).find('Query') != -1: + logger.debug(f"Converting project_id Query object to None: {type(project_id)}") + project_id = None + if hasattr(period, 'default') or str(type(period)).find('Query') != -1: + logger.debug(f"Converting period Query object to None: {type(period)}") + period = None + + logger.debug( + f"Final parameter values: period={period}, start_date={start_date}, end_date={end_date}, project_id={project_id}" + ) + + org = OrgModel.get_by_id_summary(orm, org_id, self.request.state.session.user_id) + if not org or not org.is_user_member(self.request.state.session.user_id): + raise HTTPException(status_code=403, detail="Access denied") + + now = datetime.now(timezone.utc) + + # Handle specific billing period if provided (backward compatibility) + if period: + try: + billing_period = ( + orm.query(BillingPeriod) + .filter(BillingPeriod.id == period, BillingPeriod.org_id == org_id) + .first() + ) + + if not billing_period: + raise HTTPException(status_code=404, detail="Billing period not found") + + # Convert stored billing period to response format + usage_breakdown = [] + for usage_type, quantity in billing_period.usage_quantities.items(): + cost = billing_period.usage_costs.get(usage_type, 0) + usage_breakdown.append( + UsageCostBreakdown( + usage_type=usage_type, + quantity=quantity, + cost_cents=cost, + ) + ) + + stored_period = BillingPeriodResponse( + id=str(billing_period.id), + period_start=billing_period.period_start, + period_end=billing_period.period_end, + seat_cost=billing_period.seat_cost, + seat_count=billing_period.seat_count, + usage_costs=billing_period.usage_costs, + usage_quantities=billing_period.usage_quantities, + usage_breakdown=usage_breakdown, + total_cost=billing_period.total_cost, + status=billing_period.status, + ) + + return BillingDashboardResponse( + current_period=stored_period, + past_periods=[], + total_spent_all_time=stored_period.total_cost, + project_breakdown=[], # Not supported for stored periods + ) + + except ValueError: + raise HTTPException(status_code=400, detail="Invalid period ID format") + + # Handle custom date range if provided + if start_date and end_date and isinstance(start_date, str) and isinstance(end_date, str): + try: + s_date = datetime.fromisoformat(start_date.replace('Z', '+00:00')) + e_date = datetime.fromisoformat(end_date.replace('Z', '+00:00')) + if e_date.hour == 0 and e_date.minute == 0 and e_date.second == 0: + e_date = e_date.replace(hour=23, minute=59, second=59, microsecond=999999) + except ValueError: + raise HTTPException(status_code=400, detail="Invalid date format. Use ISO 8601 format.") + + manual_usage = await billing_service.get_usage_for_period(orm, org_id, s_date, e_date, project_id) + manual_usage_costs = await billing_service.calculate_usage_costs(manual_usage) + project_usage = await billing_service.get_usage_by_project_for_period(orm, org_id, s_date, e_date) + + usage_breakdown = [] + for usage_type, quantity in manual_usage.items(): + cost = manual_usage_costs.get(usage_type, 0) + usage_breakdown.append( + UsageCostBreakdown( + usage_type=usage_type, + quantity=quantity, + cost_cents=cost, + ) + ) + + seat_price = billing_service.get_seat_price() + manual_period = BillingPeriodResponse( + id="custom", + period_start=s_date.isoformat(), + period_end=e_date.isoformat(), + seat_cost=org.paid_member_count * seat_price, + seat_count=org.paid_member_count, + usage_costs=manual_usage_costs, + usage_quantities=manual_usage, + usage_breakdown=usage_breakdown, + total_cost=(org.paid_member_count * seat_price) + sum(manual_usage_costs.values()), + status="custom", + ) + + project_breakdown = [] + if project_usage: + usage_costs_service = billing_service + for proj_id, usage_data in project_usage.items(): + # If project_id filter is specified, only include that project + if project_id and proj_id != project_id: + continue + project_usage_dict = {'tokens': usage_data['tokens'], 'spans': usage_data['spans']} + project_costs = await usage_costs_service.calculate_usage_costs(project_usage_dict) + + project_breakdown.append( + ProjectUsageBreakdown( + project_id=proj_id, + project_name=usage_data['project_name'], + tokens=usage_data['tokens'], + spans=usage_data['spans'], + token_cost=project_costs.get('tokens', 0), + span_cost=project_costs.get('spans', 0), + total_cost=project_costs.get('tokens', 0) + project_costs.get('spans', 0), + ) + ) + + return BillingDashboardResponse( + current_period=manual_period, + past_periods=[], + total_spent_all_time=manual_period.total_cost, + project_breakdown=project_breakdown, + ) + + # Use Stripe billing period by default, or custom date range if provided + + current_start = now.replace(day=1, hour=0, minute=0, second=0, microsecond=0) + current_end = now + + logger.info(f"Initial billing period for org {org_id}: {current_start} to {current_end}") + + if org.subscription_id and STRIPE_SECRET_KEY: + try: + stripe.api_key = STRIPE_SECRET_KEY + subscription = stripe.Subscription.retrieve(org.subscription_id) + + if subscription: + subscription_status = subscription.get('status', 'unknown') + + if subscription_status in ['trialing', 'active']: + from .orgs import extract_subscription_period_dates + + period_start, period_end = extract_subscription_period_dates(subscription) + + if period_start and period_end: + current_start = datetime.fromtimestamp(period_start, tz=timezone.utc) + current_end = datetime.fromtimestamp(period_end, tz=timezone.utc) + logger.info( + f"Using Stripe billing period for org {org_id}: " + f"{current_start} to {current_end}" + ) + else: + logger.warning( + f"Could not extract dates from Stripe subscription {org.subscription_id}" + ) + logger.warning(f"Falling back to monthly calendar period for org {org_id}") + else: + starts_at = subscription.get('start_date') or subscription.get('started_at') + if starts_at and subscription_status in ['scheduled', 'incomplete']: + scheduled_start = datetime.fromtimestamp(starts_at, tz=timezone.utc) + scheduled_end = scheduled_start + timedelta(days=30) + + current_start = scheduled_start + current_end = scheduled_end + + else: + logger.warning( + f"Subscription {org.subscription_id} has unsupported status " + f"'{subscription_status}' - falling back to monthly calendar period" + ) + + except Exception as e: + logger.error(f"Failed to retrieve Stripe subscription {org.subscription_id}: {e}") + logger.warning( + f"Falling back to monthly calendar period for org {org_id} due to Stripe error" + ) + + logger.info(f"Final billing period for org {org_id}: {current_start} to {current_end}") + current_usage = await billing_service.get_usage_for_period( + orm, org_id, current_start, current_end, project_id + ) + project_usage = await billing_service.get_usage_by_project_for_period( + orm, org_id, current_start, current_end + ) + + current_period = None + if current_usage or org.paid_member_count > 0: + usage_costs = await billing_service.calculate_usage_costs(current_usage) + + seat_price = billing_service.get_seat_price() + + usage_breakdown = [] + for usage_type, quantity in current_usage.items(): + cost = usage_costs.get(usage_type, 0) + usage_breakdown.append( + UsageCostBreakdown( + usage_type=usage_type, + quantity=quantity, + cost_cents=cost, + ) + ) + + current_period = BillingPeriodResponse( + id="current", + period_start=current_start, + period_end=current_end, + seat_cost=org.paid_member_count * seat_price, + seat_count=org.paid_member_count, + usage_costs=usage_costs, + usage_quantities=current_usage, + usage_breakdown=usage_breakdown, + total_cost=(org.paid_member_count * seat_price) + sum(usage_costs.values()), + status="current", + ) + + # For now, we're not showing historical periods since we're moving away from stored periods + # In the future, this could be calculated from Stripe's billing history if needed + past_period_responses = [] + total_spent = current_period.total_cost if current_period else 0 + + is_legacy = False + legacy_cancellation_date = None + + if org.subscription_id and STRIPE_SECRET_KEY: + try: + subscription = stripe.Subscription.retrieve(org.subscription_id) + has_current_pricing = False + subscription_items = subscription.get('items', {}).get('data', []) + logger.info(f"Subscription has {len(subscription_items)} items") + + for item in subscription_items: + price_id = item.get('price', {}).get('id') + logger.info( + f"Subscription item price ID: {price_id}, " + f"current price ID: {STRIPE_SUBSCRIPTION_PRICE_ID}" + ) + if price_id == STRIPE_SUBSCRIPTION_PRICE_ID: + has_current_pricing = True + break + + # Legacy if no current pricing found OR subscription is canceled/canceling + is_canceling = ( + subscription.get('cancel_at_period_end', False) + or subscription.get('canceled_at') is not None + or subscription.get('cancel_at') is not None + or subscription.get('status') in ['canceled', 'unpaid', 'incomplete_expired'] + ) + is_legacy = not has_current_pricing or is_canceling + logger.info( + f"Legacy determination: has_current_pricing={has_current_pricing}, " + f"is_canceling={is_canceling}, status={subscription.get('status')}, " + f"is_legacy={is_legacy}" + ) + + if is_legacy: + cancellation_timestamp = None + date_source = None + + if subscription.get('cancel_at'): + cancellation_timestamp = subscription['cancel_at'] + date_source = "cancel_at" + elif subscription.get('current_period_end'): + cancellation_timestamp = subscription['current_period_end'] + date_source = "current_period_end" + elif subscription.get('canceled_at'): + cancellation_timestamp = subscription['canceled_at'] + date_source = "canceled_at" + + if cancellation_timestamp: + legacy_cancellation_date = datetime.fromtimestamp( + cancellation_timestamp, tz=timezone.utc + ) + logger.info( + f"Set legacy cancellation date from Stripe {date_source}: " + f"{legacy_cancellation_date}" + ) + else: + logger.warning( + f"Legacy subscription {org.subscription_id} has no cancellation date fields" + ) + + except Exception as e: + logger.error(f"Failed to check legacy subscription status: {e}") + import traceback + + logger.error(traceback.format_exc()) + + if is_legacy and not legacy_cancellation_date and current_period: + legacy_cancellation_date = current_period.period_end + logger.info( + f"Using current period end as legacy cancellation date fallback: {legacy_cancellation_date}" + ) + + project_breakdown = [] + if project_usage: + usage_costs_service = billing_service + for proj_id, usage_data in project_usage.items(): + # If project_id filter is specified, only include that project + if project_id and proj_id != project_id: + continue + project_usage_dict = {'tokens': usage_data['tokens'], 'spans': usage_data['spans']} + project_costs = await usage_costs_service.calculate_usage_costs(project_usage_dict) + + project_breakdown.append( + ProjectUsageBreakdown( + project_id=proj_id, + project_name=usage_data['project_name'], + tokens=usage_data['tokens'], + spans=usage_data['spans'], + token_cost=project_costs.get('tokens', 0), + span_cost=project_costs.get('spans', 0), + total_cost=project_costs.get('tokens', 0) + project_costs.get('spans', 0), + ) + ) + + return BillingDashboardResponse( + current_period=current_period, + past_periods=past_period_responses, + total_spent_all_time=total_spent, + is_legacy_billing=is_legacy, + legacy_cancellation_date=legacy_cancellation_date, + project_breakdown=project_breakdown, + ) diff --git a/app/api/agentops/opsboard/views/orgs.py b/app/api/agentops/opsboard/views/orgs.py new file mode 100644 index 000000000..637dd70c5 --- /dev/null +++ b/app/api/agentops/opsboard/views/orgs.py @@ -0,0 +1,2222 @@ +from typing import Optional, Dict +from fastapi import Request, Depends, HTTPException +import stripe +import pydantic +import logging +import time +from sqlalchemy import func +from enum import Enum +from pydantic import Field +import os + +from agentops.common.orm import get_orm_session, Session +from agentops.api.environment import ( + STRIPE_SECRET_KEY, + STRIPE_SUBSCRIPTION_PRICE_ID, + STRIPE_TOKEN_PRICE_ID, + STRIPE_SPAN_PRICE_ID, +) +from agentops.common.environment import APP_URL +from agentops.api.db.supabase_client import get_supabase +from ..models import ( + OrgModel, + UserOrgModel, + OrgInviteModel, + OrgRoles, + UserModel, + PremStatus, + AuthUserModel, + BillingAuditLog, +) +from ..schemas import ( + OrgCreateSchema, + OrgDetailResponse, + OrgInviteDetailResponse, + OrgInviteResponse, + OrgInviteSchema, + OrgMemberRemoveSchema, + OrgMemberRoleSchema, + OrgResponse, + OrgUpdateSchema, + StatusResponse, + ValidateDiscountCodeBody, + ValidateDiscountCodeResponse, + CreateFreeSubscriptionResponse, +) + +logger = logging.getLogger(__name__) + + +def _validate_and_set_stripe_key(function_name: str = "") -> bool: + """Validate Stripe configuration and set API key with logging""" + context = f" in {function_name}" if function_name else "" + + if not STRIPE_SECRET_KEY: + logger.error(f"āœ— STRIPE_SECRET_KEY not found{context} - Cannot initialize Stripe API") + return False + + # Mask the key for logging + masked_key = f"{STRIPE_SECRET_KEY[:8]}..." if len(STRIPE_SECRET_KEY) > 8 else STRIPE_SECRET_KEY + logger.info(f"āœ“ Setting Stripe API key{context}: {masked_key}") + + try: + stripe.api_key = STRIPE_SECRET_KEY + return True + except Exception as e: + logger.error(f"āœ— Failed to set Stripe API key{context}: {e}") + return False + + +def _validate_stripe_price_ids(function_name: str = "") -> None: + """Log status of all Stripe price IDs for debugging""" + context = f" in {function_name}" if function_name else "" + + price_vars = { + "STRIPE_SUBSCRIPTION_PRICE_ID": STRIPE_SUBSCRIPTION_PRICE_ID, + "STRIPE_TOKEN_PRICE_ID": STRIPE_TOKEN_PRICE_ID, + "STRIPE_SPAN_PRICE_ID": STRIPE_SPAN_PRICE_ID, + } + + logger.info(f"=== Stripe Price ID Status{context} ===") + found_count = 0 + for var_name, var_value in price_vars.items(): + if var_value: + masked_value = f"{var_value[:12]}..." if len(var_value) > 12 else var_value + logger.info(f"āœ“ {var_name}: {masked_value}") + found_count += 1 + else: + logger.warning(f"āœ— {var_name}: NOT FOUND") + + logger.info(f"Price IDs configured: {found_count}/{len(price_vars)}") + logger.info("=======================================") + + +def extract_subscription_period_dates(subscription: Dict) -> tuple[Optional[int], Optional[int]]: + """ + Extract billing period dates from Stripe subscription object. + Handles both standard subscriptions and 100% discounted subscriptions. + + Returns: (period_start_timestamp, period_end_timestamp) + """ + # Try root level first + period_start = subscription.get('current_period_start') + period_end = subscription.get('current_period_end') + + # If not at root level, check subscription items (for 100% discount subscriptions) + if not period_start or not period_end: + items = subscription.get('items', {}) + if items and items.get('data') and len(items['data']) > 0: + first_item = items['data'][0] + period_start = first_item.get('current_period_start', period_start) + period_end = first_item.get('current_period_end', period_end) + + return period_start, period_end + + +def update_org_subscription( + orm: Session, org: OrgModel, subscription_id: str, mark_owner_paid: bool = True +) -> None: + """Update organization with new subscription and mark all members as paid.""" + org.subscription_id = subscription_id + org.prem_status = PremStatus.pro + + if mark_owner_paid: + # Mark ALL members as paid since we're billing for the full organization + updated_count = ( + orm.query(UserOrgModel) + .filter(UserOrgModel.org_id == org.id) + .update({UserOrgModel.is_paid: True}, synchronize_session=False) + ) + + logger.info(f"Marked {updated_count} members as paid for org {org.id} during subscription creation") + + +class BillingErrorCode(str, Enum): + STRIPE_API_ERROR = "stripe_api_error" + NO_SUBSCRIPTION = "no_subscription" + OWNER_REQUIRED = "owner_license_required" + PERMISSION_DENIED = "permission_denied" + SUBSCRIPTION_CANCELLED = "subscription_cancelled" + LEGACY_BILLING_PLAN = "legacy_billing_plan" + + +class CreateCheckoutSessionBody(pydantic.BaseModel): + price_id: str + discount_code: Optional[str] = None + quantity: int = Field(default=1, ge=1, le=100) # Add seat quantity with limits + + +class CreateCheckoutSessionResponse(pydantic.BaseModel): + clientSecret: str + + +class CancelSubscriptionBody(pydantic.BaseModel): + subscription_id: str + + +def get_user_orgs( + *, + request: Request, + orm: Session = Depends(get_orm_session), +) -> list[OrgResponse]: + """ + Get all organizations for the authenticated user. + Returns a list of organizations with basic information, without member details. + + Optimized to avoid N+1 queries by using count subqueries instead of loading all relationships. + """ + orgs: list[OrgModel] = OrgModel.get_all_for_user(orm, request.state.session.user_id) + + org_responses = [] + for org in orgs: + org_response = OrgResponse.model_validate(org) + + if org.subscription_id and org.prem_status != PremStatus.free: + try: + if not _validate_and_set_stripe_key("get_user_orgs"): + logger.warning( + f"Skipping subscription retrieval for org {org.id} - Stripe not configured" + ) + org_responses.append(org_response) + continue + + subscription = stripe.Subscription.retrieve(org.subscription_id) + + if subscription: + current_period_start, current_period_end = extract_subscription_period_dates(subscription) + cancel_at_period_end = subscription.get('cancel_at_period_end') + + if current_period_start: + org_response.subscription_start_date = current_period_start + if current_period_end: + org_response.subscription_end_date = current_period_end + if cancel_at_period_end is not None: + org_response.subscription_cancel_at_period_end = cancel_at_period_end + except Exception as e: + logger.warning( + f"Could not fetch subscription details for org {org.id}: {type(e).__name__}: {e}" + ) + + org_responses.append(org_response) + + return org_responses + + +def get_org( + *, + request: Request, + org_id: str, + orm: Session = Depends(get_orm_session), +) -> OrgDetailResponse: + """ + Get detailed information for a specific organization, including its members. + + Optimized to only load users (needed for response), not projects or invites. + """ + org: Optional[OrgModel] = OrgModel.get_by_id_for_detail(orm, org_id) + + if not org or not org.is_user_member(request.state.session.user_id): + raise HTTPException(status_code=404, detail="Organization not found") + + org.set_current_user(request.state.session.user_id) + + return OrgDetailResponse.model_validate(org) + + +def create_org( + *, + request: Request, + orm: Session = Depends(get_orm_session), + body: OrgCreateSchema, +) -> OrgResponse: + """ + Create a new organization and add the authenticated user as owner. + """ + if not (user := UserModel.get_by_id(orm, request.state.session.user_id)): + raise HTTPException(status_code=500, detail="User not found") + + org: OrgModel = OrgModel(name=body.name) + orm.add(org) + orm.flush() # generate the id + + # TODO user may not have an email address here + # this displays in the UI for the user in the list of org members + user_org: UserOrgModel = UserOrgModel( + user_id=user.id, + org_id=org.id, + role=OrgRoles.owner, + user_email=user.email, + is_paid=True, # Mark owner as paid from creation + ) + orm.add(user_org) + + orm.commit() + + # Reload with relationships to ensure we have users loaded + org = OrgModel.get_by_id(orm, org.id) + + org.set_current_user(request.state.session.user_id) + return OrgResponse.model_validate(org) + + +def update_org( + *, + request: Request, + org_id: str, + orm: Session = Depends(get_orm_session), + body: OrgUpdateSchema, +) -> OrgResponse: + """ + Update an organization's name. User must be an owner or admin. + Premium status and subscription management happens elsewhere. + """ + org: Optional[OrgModel] = OrgModel.get_by_id_summary(orm, org_id, request.state.session.user_id) + + if not org or not org.is_user_admin_or_owner(request.state.session.user_id): + raise HTTPException(status_code=404, detail="Organization not found") + + org.name = body.name # this is the only field that can be updated + + orm.commit() + + # Return the updated org with summary data + org = OrgModel.get_by_id_summary(orm, org_id, request.state.session.user_id) + + if not org: + raise HTTPException(status_code=404, detail="Organization not found after update") + + return OrgResponse.model_validate(org) + + +def invite_to_org( + *, + request: Request, + org_id: str, + orm: Session = Depends(get_orm_session), + body: OrgInviteSchema, +) -> StatusResponse: + """Invite a user to an organization. User must be an owner or admin.""" + org: Optional[OrgModel] = OrgModel.get_by_id(orm, org_id) + + if not org or not org.is_user_admin_or_owner(request.state.session.user_id): + raise HTTPException(status_code=404, detail="Organization not found") + + # Normalize email to lowercase for case-insensitive comparison + normalized_email = body.email.lower() + + is_already_member = any( + user_org.user_email.lower() == normalized_email for user_org in org.users if user_org.user_email + ) + if is_already_member: + raise HTTPException(status_code=400, detail="User is already a member of this organization") + + # Check member limit + if org.max_member_count and not org.current_member_count < org.max_member_count: + raise HTTPException(status_code=400, detail="Organization has reached its member limit") + + # Get the inviter's email (current user) + inviter_user = UserModel.get_by_id(orm, request.state.session.user_id) + if not inviter_user or not inviter_user.billing_email: + raise HTTPException(status_code=500, detail="Unable to determine inviter email") + + existing_invite = ( + orm.query(OrgInviteModel) + .filter(func.lower(OrgInviteModel.invitee_email) == normalized_email, OrgInviteModel.org_id == org_id) + .first() + ) + if existing_invite: + raise HTTPException(status_code=400, detail="User already has a pending invitation") + + invite = OrgInviteModel( + inviter_id=request.state.session.user_id, + invitee_email=normalized_email, + org_id=org_id, + role=body.role, + org_name=org.name, + ) + orm.add(invite) + orm.commit() + + logger.debug("Created org_invites record for %s", body.email) + + # Send email notification (handles both existing and new users) + email_sent = False + email_error = None + try: + _send_invitation_email( + invitee_email=body.email, + inviter_email=inviter_user.billing_email, + org_name=org.name, + role=body.role, + org_id=org_id, + orm=orm, + ) + email_sent = True + except Exception as e: + # Don't fail the whole invitation if email fails, but log it + email_error = str(e) + logger.error("Failed to send invitation email to %s: %s", body.email, e) + + # Return appropriate message based on what happened + if email_sent: + return StatusResponse(message="Invitation sent successfully") + elif "already been registered" in str(email_error): + return StatusResponse( + message=( + "Invitation created. The user already has an account - " + "they can accept the invitation from their pending invites." + ) + ) + else: + return StatusResponse( + message=( + "Invitation created but email could not be sent. " + "The user can still accept from their pending invites." + ) + ) + + +def _send_invitation_email( + invitee_email: str, inviter_email: str, org_name: str, role: str, org_id: str, orm: Session +) -> None: + """Send invitation email using standard OTP flow.""" + try: + logger.debug("Sending invitation email to %s", invitee_email) + + supabase = get_supabase() + + # Use the dashboard URL for the redirect, not the API URL + # This ensures users land on the frontend auth callback page + # Note: Supabase strips query parameters from redirect URLs, so we rely on the 'data' field + redirect_url = f"{APP_URL}/auth/callback" + logger.debug("Magic link redirect URL: %s", redirect_url) + logger.debug("Invite data will be passed in JWT: org_id=%s", org_id) + + auth_response = supabase.auth.sign_in_with_otp( + { + 'email': invitee_email, + 'options': { + 'should_create_user': True, + 'email_redirect_to': redirect_url, + 'data': { + 'invited_to_org': org_id, + 'invited_by': inviter_email, + 'org_name': org_name, + 'role': role, + }, + }, + } + ) + + if hasattr(auth_response, 'error') or auth_response is None: + logger.error("Failed to send OTP: %s", getattr(auth_response, 'error', 'Unknown error')) + return + + logger.debug("Magic link sent successfully to %s", invitee_email) + + except Exception as e: + logger.error("Error sending invitation email: %s: %s", type(e).__name__, e) + + +def get_org_invites( + *, + request: Request, + orm: Session = Depends(get_orm_session), +) -> list[OrgInviteResponse]: + """Get all pending invitations for the authenticated user.""" + user = UserModel.get_by_id(orm, request.state.session.user_id) + if not user: + return [] + + invites = [] + + # Try both billing_email and regular email + for email_field in [user.billing_email, user.email]: + if email_field: + found_invites = ( + orm.query(OrgInviteModel) + .filter(func.lower(OrgInviteModel.invitee_email) == email_field.lower()) + .all() + ) + invites.extend(found_invites) + + # Remove duplicates (in case both emails found the same invite) + seen_invite_ids = set() + unique_invites = [] + for invite in invites: + invite_key = (invite.org_id, invite.invitee_email.lower()) + if invite_key not in seen_invite_ids: + seen_invite_ids.add(invite_key) + unique_invites.append(invite) + + return [OrgInviteResponse.model_validate(invite) for invite in unique_invites] + + +def accept_org_invite( + *, + request: Request, + org_id: str, + orm: Session = Depends(get_orm_session), +) -> StatusResponse: + """Accept an invitation to join an organization.""" + logger.info(f"accept_org_invite: Started for user_id={request.state.session.user_id}, org_id={org_id}") + + user = UserModel.get_by_id(orm, request.state.session.user_id) + + # For new users, the trigger might not have created the public.users record yet + # In this case, we need to get the email directly from auth.users + email_to_check = None + + if not user: + logger.warning( + f"accept_org_invite: User not found in public.users for ID: {request.state.session.user_id}" + ) + print(f"accept_org_invite: User not found in public.users for ID: {request.state.session.user_id}") + # Try to get email from auth.users directly + auth_user = orm.query(AuthUserModel).filter(AuthUserModel.id == request.state.session.user_id).first() + if auth_user and auth_user.email: + logger.info(f"accept_org_invite: Found user in auth.users with email: {auth_user.email}") + print(f"accept_org_invite: Found user in auth.users with email: {auth_user.email}") + email_to_check = auth_user.email + else: + logger.error( + f"accept_org_invite: User not found in auth.users either for ID: {request.state.session.user_id}" + ) + print( + f"accept_org_invite: ERROR - User not found in auth.users either for ID: {request.state.session.user_id}" + ) + raise HTTPException(status_code=404, detail="User not found") + else: + logger.info( + f"accept_org_invite: Found user {user.id} with email={user.email}, billing_email={user.billing_email}" + ) + print(f"accept_org_invite: Accepting invite for user {user.id}, org {org_id}") + print(f"accept_org_invite: User email: {user.email}, billing_email: {user.billing_email}") + + # Also check if auth_user is loaded + if user.auth_user: + logger.debug( + f"accept_org_invite: Auth user loaded, email from auth.users: {user.auth_user.email}" + ) + print(f"accept_org_invite: Auth user loaded, email from auth.users: {user.auth_user.email}") + else: + logger.warning("accept_org_invite: Auth user NOT loaded - this might be the issue!") + print("accept_org_invite: Auth user NOT loaded - this might be the issue!") + + # Log all invites for debugging + all_invites = orm.query(OrgInviteModel).filter(OrgInviteModel.org_id == org_id).all() + logger.debug(f"accept_org_invite: Found {len(all_invites)} invites for org {org_id}") + print( + f"accept_org_invite: All invites for org {org_id}: {[(inv.invitee_email, inv.inviter_id) for inv in all_invites]}" + ) + + invite = None + + # If we have a direct email from auth.users (new user case), use that + if email_to_check: + print(f"accept_org_invite: Looking for invite with email from auth.users: {email_to_check}") + invite = ( + orm.query(OrgInviteModel) + .filter( + func.lower(OrgInviteModel.invitee_email) == email_to_check.lower(), + OrgInviteModel.org_id == org_id, + ) + .first() + ) + if invite: + print(f"accept_org_invite: Found invite for email: {email_to_check}") + else: + # Normal case - user exists in public.users + # Try both billing_email and regular email + for email_field in [user.billing_email, user.email]: + if email_field: + print(f"accept_org_invite: Looking for invite with email: {email_field}") + invite = ( + orm.query(OrgInviteModel) + .filter( + func.lower(OrgInviteModel.invitee_email) == email_field.lower(), + OrgInviteModel.org_id == org_id, + ) + .first() + ) + if invite: + print(f"accept_org_invite: Found invite for email: {email_field}") + break + else: + print(f"accept_org_invite: No invite found with email: {email_field}") + + if not invite: + if user: + print(f"accept_org_invite: ERROR - No invitation found for user {user.id} in org {org_id}") + print( + f"accept_org_invite: ERROR - Checked emails: billing_email={user.billing_email}, email={user.email}" + ) + else: + print( + f"accept_org_invite: ERROR - No invitation found for auth email {email_to_check} in org {org_id}" + ) + raise HTTPException(status_code=404, detail="Invitation not found") + + # For new users, we need to wait for the trigger to create the user record + # before we can add them to the org + if not user: + # Wait a moment for the trigger to complete + import time + + max_retries = 5 + for i in range(max_retries): + time.sleep(0.5) # Wait 500ms + user = UserModel.get_by_id(orm, request.state.session.user_id) + if user: + print(f"accept_org_invite: User record found after {i + 1} retries") + break + + if not user: + print("accept_org_invite: ERROR - User record still not created after waiting") + raise HTTPException( + status_code=500, detail="User record not yet created. Please try again in a moment." + ) + + # Check if already a member (safety check) + existing_member = ( + orm.query(UserOrgModel).filter(UserOrgModel.user_id == user.id, UserOrgModel.org_id == org_id).first() + ) + + new_member_added = False + user_org = None + if not existing_member: + # Create user-org relationship + user_org = UserOrgModel( + user_id=user.id, + org_id=org_id, + role=invite.role, + user_email=user.billing_email or user.email or email_to_check, + is_paid=True, # Mark all new members as paid by default + ) + orm.add(user_org) + new_member_added = True + + # Always delete the invite + print( + f"accept_org_invite: Deleting invite record: inviter_id={invite.inviter_id}, invitee_email={invite.invitee_email}, org_id={invite.org_id}" + ) + orm.delete(invite) + + # If a new member was added and the org has a subscription, update the seat count + if new_member_added: + org = orm.query(OrgModel).filter(OrgModel.id == org_id).first() + if org and org.subscription_id and org.prem_status == PremStatus.pro: + try: + # Get the current user count (actual members, not invites) for billing + new_seat_count = orm.query(UserOrgModel).filter(UserOrgModel.org_id == org_id).count() + + # Update Stripe subscription + import stripe + from agentops.api.environment import STRIPE_SECRET_KEY + + stripe.api_key = STRIPE_SECRET_KEY + + subscription = stripe.Subscription.retrieve( + org.subscription_id, expand=["items.data.price.product"] + ) + + # Find the seat item + seat_item = None + for item in subscription.get('items', {}).get('data', []): + price = item.get('price', {}) + if price.get('id') == STRIPE_SUBSCRIPTION_PRICE_ID: + seat_item = item + break + + if seat_item and new_seat_count > 0: + stripe.Subscription.modify( + org.subscription_id, + items=[ + { + 'id': seat_item.get('id'), + 'quantity': new_seat_count, + } + ], + proration_behavior='create_prorations', + ) + print( + f"accept_org_invite: Updated subscription to {new_seat_count} seats for org {org_id}" + ) + + # Add audit log + from agentops.opsboard.models import BillingAuditLog + + audit_log = BillingAuditLog( + org_id=org_id, + user_id=user.id, + action='member_auto_licensed_on_invite_accept', + details={ + 'member_id': str(user.id), + 'member_email': user.billing_email or user.email or email_to_check, + 'new_seat_count': new_seat_count, + 'invite_role': invite.role.value, + }, + ) + orm.add(audit_log) + + except Exception as e: + print(f"accept_org_invite: Warning - failed to update subscription: {e}") + # Don't fail the invite acceptance if subscription update fails + logger.warning( + f"Failed to auto-update subscription for org {org_id} when user {user.id} joined: {e}" + ) + + orm.commit() + print("accept_org_invite: Invite deleted and committed") + + return StatusResponse(message="Organization invitation accepted") + + +def remove_from_org( + *, + request: Request, + org_id: str, + orm: Session = Depends(get_orm_session), + body: OrgMemberRemoveSchema, +) -> StatusResponse: + """ + Remove a user from an organization. User must be an owner or admin. + Automatically updates Stripe subscription if a paid member is removed. + """ + # admins can only remove non-owners + # owners can remove anyone except the last owner + org: Optional[OrgModel] = OrgModel.get_by_id(orm, org_id) + + if not org or not org.is_user_admin_or_owner(request.state.session.user_id): + raise HTTPException(status_code=404, detail="Organization not found") + + user_to_remove = ( + orm.query(UserOrgModel) + .filter( + UserOrgModel.user_id == body.user_id, + UserOrgModel.org_id == org_id, + UserOrgModel.role != OrgRoles.owner, + UserOrgModel.user_id != request.state.session.user_id, # can't remove yourself + ) + .first() + ) + + if not user_to_remove: + raise HTTPException(status_code=400, detail="User cannot be removed") + + # Remove the user from the organization + orm.delete(user_to_remove) + + # If the org has a subscription, update Stripe (since we bill for all members) + if org.subscription_id and org.prem_status == PremStatus.pro: + try: + # Get the new user count after removal (actual members, not invites) for billing + new_seat_count = orm.query(UserOrgModel).filter(UserOrgModel.org_id == org_id).count() + + # Update Stripe subscription + import stripe + from agentops.api.environment import STRIPE_SECRET_KEY + + stripe.api_key = STRIPE_SECRET_KEY + + subscription = stripe.Subscription.retrieve( + org.subscription_id, expand=["items.data.price.product"] + ) + + # Find the seat item + seat_item = None + for item in subscription.get('items', {}).get('data', []): + price = item.get('price', {}) + if price.get('id') == STRIPE_SUBSCRIPTION_PRICE_ID: + seat_item = item + break + + if seat_item: + stripe.Subscription.modify( + org.subscription_id, + items=[ + { + 'id': seat_item.get('id'), + 'quantity': max(1, new_seat_count), # Ensure at least 1 seat + } + ], + proration_behavior='create_prorations', + ) + logger.info( + f"remove_from_org: Updated subscription to {max(1, new_seat_count)} seats for org {org_id}" + ) + + # Add audit log + from agentops.opsboard.models import BillingAuditLog + + audit_log = BillingAuditLog( + org_id=org_id, + user_id=request.state.session.user_id, + action='member_unlicensed_on_removal', + details={ + 'removed_member_id': str(user_to_remove.user_id), + 'removed_member_email': user_to_remove.user_email or 'Unknown', + 'new_seat_count': max(1, new_seat_count), + 'removed_by': str(request.state.session.user_id), + }, + ) + orm.add(audit_log) + + except Exception as e: + logger.warning(f"remove_from_org: Failed to update subscription for org {org_id}: {e}") + # Don't fail the member removal if subscription update fails + + orm.commit() + + return StatusResponse(message="User removed from organization") + + +def change_member_role( + *, + request: Request, + org_id: str, + orm: Session = Depends(get_orm_session), + body: OrgMemberRoleSchema, +) -> StatusResponse: + """ + Change a user's role within an organization. Authenticate user must be an owner or admin. + """ + org: Optional[OrgModel] = OrgModel.get_by_id(orm, org_id) + + if not org or not org.is_user_admin_or_owner(request.state.session.user_id): + raise HTTPException(status_code=404, detail="Organization not found") + + # Get the role we're changing + update_record: Optional[UserOrgModel] = ( + orm.query(UserOrgModel) + .filter(UserOrgModel.user_id == body.user_id) + .filter(UserOrgModel.org_id == org_id) + .first() + ) + + if not update_record: + raise HTTPException(status_code=404, detail="User not found in organization") + + # if we're changing to owner, make sure we are an owner + if body.role == OrgRoles.owner.value and not org.is_user_owner(request.state.session.user_id): + raise HTTPException(status_code=400, detail="Only owners can assign the owner role") + + # If we're changing from owner to another role, check if it's the last owner + # TODO this can be simplified + if update_record.role == OrgRoles.owner and body.role != OrgRoles.owner.value: + owner_count = ( + orm.query(UserOrgModel) + .filter(UserOrgModel.org_id == org_id) + .filter(UserOrgModel.role == OrgRoles.owner) + .count() + ) + + if owner_count <= 1: + raise HTTPException(status_code=400, detail="Cannot remove the last owner") + + update_record.role = OrgRoles(body.role) + orm.commit() + + return StatusResponse(message="User role updated") + + +def delete_org( + *, + request: Request, + org_id: str, + orm: Session = Depends(get_orm_session), +) -> StatusResponse: + """ + Delete an organization. User must be the owner. + Organization cannot be deleted if it still contains projects. + """ + org: Optional[OrgModel] = OrgModel.get_by_id(orm, org_id) + + if not org or not org.is_user_owner(request.state.session.user_id): + raise HTTPException(status_code=403, detail="Organization cannot be deleted") + + if org.projects: + raise HTTPException( + status_code=400, + detail="Organization cannot be deleted while it still contains projects", + ) + + orm.delete(org) + orm.commit() + + return StatusResponse(message="Organization deleted") + + +class UpdateMemberLicensesBody(pydantic.BaseModel): + add: list[str] = Field(default_factory=list) + remove: list[str] = Field(default_factory=list) + + +class UpdateMemberLicensesResponse(pydantic.BaseModel): + message: str + paid_members_count: int + + +async def update_member_licenses( + *, + request: Request, + org_id: str, + body: UpdateMemberLicensesBody, + orm: Session = Depends(get_orm_session), +) -> UpdateMemberLicensesResponse: + """Update which members are included in paid seats. Automatically updates Stripe subscription.""" + stripe.api_key = STRIPE_SECRET_KEY + user: Optional[UserModel] = UserModel.get_by_id(orm, request.state.session.user_id) + if not user: + raise HTTPException( + status_code=401, + detail="User not authenticated.", + headers={"X-Error-Code": BillingErrorCode.PERMISSION_DENIED}, + ) + + org: Optional[OrgModel] = OrgModel.get_by_id(orm, org_id) + if not org or not org.is_user_admin_or_owner(request.state.session.user_id): + raise HTTPException( + status_code=403, + detail="Permission denied. Only owners and admins can manage licenses.", + headers={"X-Error-Code": BillingErrorCode.PERMISSION_DENIED}, + ) + + if not org.subscription_id: + raise HTTPException( + status_code=400, + detail="Organization does not have an active subscription.", + headers={"X-Error-Code": BillingErrorCode.NO_SUBSCRIPTION}, + ) + + # Check if this is a legacy subscription + try: + subscription = stripe.Subscription.retrieve(org.subscription_id) + + # Check if subscription is scheduled to cancel + if subscription.get('cancel_at_period_end'): + raise HTTPException( + status_code=400, + detail="Your subscription is scheduled to cancel. Seat management is not available for cancelled subscriptions.", + headers={"X-Error-Code": BillingErrorCode.SUBSCRIPTION_CANCELLED}, + ) + + # Check if using current price ID + is_current_pricing = False + for item in subscription.get('items', {}).get('data', []): + if item.get('price', {}).get('id') == STRIPE_SUBSCRIPTION_PRICE_ID: + is_current_pricing = True + break + + if not is_current_pricing: + raise HTTPException( + status_code=400, + detail="Your organization is on a legacy billing plan. Seat management is not available for legacy plans. Your subscription will automatically cancel at the end of the current billing period.", + headers={"X-Error-Code": BillingErrorCode.LEGACY_BILLING_PLAN}, + ) + except stripe.error.StripeError as e: + logger.error(f"Failed to retrieve subscription for legacy check: {e}") + # Continue anyway - don't block the operation if we can't check + + if body.remove: + owner_ids = ( + orm.query(UserOrgModel.user_id) + .filter( + UserOrgModel.user_id.in_(body.remove), + UserOrgModel.org_id == org_id, + UserOrgModel.role == OrgRoles.owner, + ) + .all() + ) + + if owner_ids: + raise HTTPException( + status_code=400, + detail="Cannot remove license from organization owner", + headers={"X-Error-Code": BillingErrorCode.OWNER_REQUIRED}, + ) + + # The main transaction is handled by the lifespan manager, so we don't need a nested transaction. + # We lock the organization row to prevent race conditions. + org = orm.query(OrgModel).filter(OrgModel.id == org_id).with_for_update().first() + + # Calculate final_paid based on the effective state after changes, BEFORE updating the db. + all_member_ids = { + str(uid) for (uid,) in orm.query(UserOrgModel.user_id).filter(UserOrgModel.org_id == org_id) + } + paid_member_ids = { + str(uid) + for (uid,) in orm.query(UserOrgModel.user_id).filter( + UserOrgModel.org_id == org_id, UserOrgModel.is_paid + ) + } + + # Apply changes to our in-memory set to calculate the final state + paid_member_ids.update(body.add) + paid_member_ids.difference_update(body.remove) + + # Ensure all licensed members are actual members of the org + final_paid_ids = paid_member_ids.intersection(all_member_ids) + final_paid = len(final_paid_ids) + + members_to_add = [] + members_to_remove = [] + + if body.add: + members_to_add = ( + orm.query(UserOrgModel) + .filter(UserOrgModel.user_id.in_(body.add), UserOrgModel.org_id == org_id) + .all() + ) + + orm.query(UserOrgModel).filter( + UserOrgModel.user_id.in_(body.add), UserOrgModel.org_id == org_id + ).update({UserOrgModel.is_paid: True}, synchronize_session=False) + + if body.remove: + members_to_remove = ( + orm.query(UserOrgModel) + .filter(UserOrgModel.user_id.in_(body.remove), UserOrgModel.org_id == org_id) + .all() + ) + + orm.query(UserOrgModel).filter( + UserOrgModel.user_id.in_(body.remove), UserOrgModel.org_id == org_id + ).update({UserOrgModel.is_paid: False}, synchronize_session=False) + + try: + subscription = stripe.Subscription.retrieve(org.subscription_id, expand=["items.data.price.product"]) + + # Find the specific subscription item for licensed seats + seat_item = None + for item in subscription.get('items', {}).get('data', []): + price = item.get('price', {}) + if price.get('id') == os.getenv("STRIPE_SUBSCRIPTION_PRICE_ID"): + seat_item = item + break + + if not seat_item: + raise HTTPException( + status_code=500, + detail="Could not find subscription item for seat pricing. Please contact support.", + headers={"X-Error-Code": BillingErrorCode.STRIPE_API_ERROR}, + ) + + stripe.Subscription.modify( + org.subscription_id, + items=[ + { + 'id': seat_item.get('id'), + 'quantity': final_paid, + } + ], + proration_behavior='create_prorations', + ) + + except stripe.error.StripeError as e: + # Since we are in a transaction, raising an exception will trigger a rollback. + logger.error(f"Stripe error updating subscription for org {org_id}: {e}") + raise HTTPException( + status_code=500, + detail="Failed to update subscription. Please try again.", + headers={"X-Error-Code": BillingErrorCode.STRIPE_API_ERROR}, + ) + + # Create audit logs + for member in members_to_add: + audit_log = BillingAuditLog( + org_id=org_id, + user_id=user.id, + action='member_licensed', + details={ + 'member_id': str(member.user_id), + 'member_email': member.user_email if member.user_email else 'Unknown', + 'updated_by': user.email, + }, + ) + orm.add(audit_log) + + for member in members_to_remove: + audit_log = BillingAuditLog( + org_id=org_id, + user_id=user.id, + action='member_unlicensed', + details={ + 'member_id': str(member.user_id), + 'member_email': member.user_email if member.user_email else 'Unknown', + 'updated_by': user.email, + }, + ) + orm.add(audit_log) + + orm.flush() # We can flush to ensure audit logs are written before the transaction commits. + orm.commit() # Commit the transaction to persist all changes + + logger.info( + f"Member licenses updated for org {org_id} by user {user.email}: " + f"added {len(members_to_add)}, removed {len(members_to_remove)}" + ) + + return UpdateMemberLicensesResponse( + message="Successfully updated member licenses", paid_members_count=final_paid + ) + + +async def _resolve_discount_code(discount_code: str) -> tuple[Optional[object], Optional[str]]: + """ + Helper function to resolve a discount code string to either a promotion code or coupon. + Returns (coupon, promotion_code_id) where one will be None. + """ + # Try as promotion code first (most common) + try: + promotion_codes = stripe.PromotionCode.list(code=discount_code, active=True, limit=1) + if promotion_codes.data: + promo_code = promotion_codes.data[0] + return promo_code.coupon, promo_code.id + except Exception: + pass + + # Try as coupon ID + try: + coupon = stripe.Coupon.retrieve(discount_code) + if coupon and coupon.valid: + return coupon, None + except Exception: + pass + + return None, None + + +async def validate_discount_code( + *, + request: Request, + org_id: str, + body: ValidateDiscountCodeBody, + orm: Session = Depends(get_orm_session), +) -> ValidateDiscountCodeResponse: + """ + Validate a discount code (promotion code or coupon ID) before checkout. + Returns discount details if valid. + """ + stripe.api_key = STRIPE_SECRET_KEY + + if not STRIPE_SECRET_KEY: + raise HTTPException(status_code=500, detail="Stripe secret key not configured.") + + # Verify user has permission + org: Optional[OrgModel] = OrgModel.get_by_id(orm, org_id) + if not org: + raise HTTPException(status_code=404, detail="Organization not found") + + if not org.is_user_admin_or_owner(request.state.session.user_id): + raise HTTPException( + status_code=403, detail="User does not have permission to manage this organization." + ) + + # Try as promotion code first (most common) + try: + promotion_codes = stripe.PromotionCode.list(code=body.discount_code, active=True, limit=1) + if promotion_codes.data: + promo_code = promotion_codes.data[0] + coupon = promo_code.coupon + + # Build discount description + if coupon.percent_off: + discount_description = f"{coupon.percent_off}% off" + discount_type = "percent_off" + discount_value = coupon.percent_off + currency = None + else: + # For amount_off, we need to handle currency + amount_in_dollars = coupon.amount_off / 100 # Convert cents to dollars + currency_symbol = "$" if coupon.currency.upper() == "USD" else coupon.currency.upper() + discount_description = f"{currency_symbol}{amount_in_dollars:.2f} off" + discount_type = "amount_off" + discount_value = coupon.amount_off + currency = coupon.currency.upper() + + # Add duration info to description + if coupon.duration == "once": + discount_description += " for the first month" + elif coupon.duration == "repeating": + discount_description += f" for {coupon.duration_in_months} months" + elif coupon.duration == "forever": + discount_description += " forever" + + return ValidateDiscountCodeResponse( + valid=True, + discount_type=discount_type, + discount_value=discount_value, + discount_description=discount_description, + currency=currency, + is_100_percent_off=(coupon.percent_off == 100), + ) + except Exception as e: + logger.debug(f"Not a valid promotion code: {str(e)}") + + # Try as coupon ID + try: + coupon = stripe.Coupon.retrieve(body.discount_code) + if coupon and coupon.valid: + # Build discount description + if coupon.percent_off: + discount_description = f"{coupon.percent_off}% off" + discount_type = "percent_off" + discount_value = coupon.percent_off + currency = None + else: + # For amount_off, we need to handle currency + amount_in_dollars = coupon.amount_off / 100 # Convert cents to dollars + currency_symbol = "$" if coupon.currency.upper() == "USD" else coupon.currency.upper() + discount_description = f"{currency_symbol}{amount_in_dollars:.2f} off" + discount_type = "amount_off" + discount_value = coupon.amount_off + currency = coupon.currency.upper() + + # Add duration info to description + if coupon.duration == "once": + discount_description += " for the first month" + elif coupon.duration == "repeating": + discount_description += f" for {coupon.duration_in_months} months" + elif coupon.duration == "forever": + discount_description += " forever" + + return ValidateDiscountCodeResponse( + valid=True, + discount_type=discount_type, + discount_value=discount_value, + discount_description=discount_description, + currency=currency, + is_100_percent_off=(coupon.percent_off == 100), + ) + except Exception as e: + logger.debug(f"Not a valid coupon ID: {str(e)}") + + # Neither worked, return invalid + return ValidateDiscountCodeResponse(valid=False) + + +async def create_checkout_session( + *, + request: Request, + org_id: str, + body: CreateCheckoutSessionBody, + orm: Session = Depends(get_orm_session), +) -> CreateCheckoutSessionResponse: + """ + Create a Stripe Checkout Session for an organization to upgrade their plan. + Optionally supports promotion codes or coupon IDs for discounts. + """ + stripe.api_key = STRIPE_SECRET_KEY + + if not STRIPE_SECRET_KEY: + raise HTTPException(status_code=500, detail="Stripe secret key not configured.") + + user: Optional[UserModel] = UserModel.get_by_id(orm, request.state.session.user_id) + if not user or not user.billing_email: + raise HTTPException(status_code=400, detail="User email is required to create a checkout session.") + + org: Optional[OrgModel] = OrgModel.get_by_id(orm, org_id) + + if not org: + raise HTTPException(status_code=404, detail="Organization not found") + + if not org.is_user_admin_or_owner(request.state.session.user_id): + raise HTTPException( + status_code=403, detail="User does not have permission to upgrade this organization." + ) + + # Validate org.id is not None or empty + if not org.id: + logger.error(f"Organization {org_id} has no id attribute") + raise HTTPException(status_code=500, detail="Organization data is invalid") + + legacy_subscription_end = None # Track when legacy subscription ends + + if org.subscription_id and org.prem_status != PremStatus.free: + try: + subscription = stripe.Subscription.retrieve(org.subscription_id) + if subscription.status in ['active', 'trialing']: + # Check if it's a legacy subscription scheduled to cancel + if subscription.get('cancel_at_period_end'): + # Check if it's a legacy subscription by price ID + is_legacy = True + for item in subscription.get('items', {}).get('data', []): + if item.get('price', {}).get('id') == STRIPE_SUBSCRIPTION_PRICE_ID: + is_legacy = False + break + + if not is_legacy: + # Non-legacy subscription cancelling - don't allow new subscription + raise HTTPException( + status_code=400, + detail="Your current subscription is scheduled to end. Please wait until it expires to resubscribe.", + ) + # For legacy subscriptions, we'll schedule the new one to start when old ends + legacy_subscription_end = subscription.get('current_period_end') + else: + # Active subscription not scheduled to cancel + raise HTTPException( + status_code=400, detail="Organization already has an active subscription" + ) + except stripe.error.StripeError: + # If we can't retrieve the subscription, continue with checkout + # This handles cases where the subscription_id is invalid/deleted + logger.warning(f"Could not retrieve subscription {org.subscription_id} for org {org.id}") + pass + + try: + price = stripe.Price.retrieve(body.price_id) + if ( + hasattr(price, 'recurring') + and hasattr(price.recurring, 'usage_type') + and price.recurring.usage_type != 'licensed' + ): + logger.error(f"Price {body.price_id} is not configured for licensed usage") + raise HTTPException(status_code=400, detail="Invalid price configuration") + except stripe.error.StripeError as e: + logger.error(f"Failed to retrieve price: {e}") + raise HTTPException(status_code=500, detail="Failed to validate pricing") + + try: + session_params = { + 'ui_mode': 'custom', + 'customer_email': user.billing_email, + 'payment_method_types': ['card'], + 'mode': 'subscription', + 'line_items': [ + { + 'price': body.price_id, + 'quantity': body.quantity, + } + ], + 'client_reference_id': str(org.id), + 'return_url': ( + f"{APP_URL}/settings/organization?org_id={org_id}&checkout_status={{CHECKOUT_SESSION_STATUS}}" + ), + 'metadata': {'initial_seats': str(body.quantity), 'org_id': str(org.id)}, + } + + if body.discount_code: + # First try as promotion code + try: + promotion_codes = stripe.PromotionCode.list(code=body.discount_code, active=True, limit=1) + if promotion_codes.data: + # It's a valid promotion code, use the ID + session_params['discounts'] = [{'promotion_code': promotion_codes.data[0].id}] + else: + # Not a promotion code, try as coupon ID + coupon = stripe.Coupon.retrieve(body.discount_code) + if coupon and coupon.valid: + session_params['discounts'] = [{'coupon': body.discount_code}] + else: + raise HTTPException(status_code=400, detail="Invalid discount code") + except stripe.error.StripeError: + # Not a promotion code, try as coupon ID + try: + coupon = stripe.Coupon.retrieve(body.discount_code) + if coupon and coupon.valid: + session_params['discounts'] = [{'coupon': body.discount_code}] + else: + raise HTTPException(status_code=400, detail="Invalid discount code") + except Exception: + raise HTTPException(status_code=400, detail="Invalid discount code") + + # If this is a legacy subscription transition, schedule the new subscription to start when old ends + if legacy_subscription_end: + session_params['subscription_data'] = { + 'starts_at': legacy_subscription_end, + 'description': 'Subscription scheduled to start after legacy plan ends', + } + + # Add idempotency key to prevent duplicate checkout sessions + # Include user_id and price_id to make it more deterministic for the same request + idempotency_key = ( + f"checkout_{org.id}_{user.id}_{body.price_id}_{body.quantity}_{int(time.time() // 10)}" + ) + + checkout_session = stripe.checkout.Session.create(**session_params, idempotency_key=idempotency_key) + + return CreateCheckoutSessionResponse(clientSecret=checkout_session.client_secret) + except HTTPException: + # Re-raise HTTPException without wrapping it + raise + except stripe.error.StripeError as e: + raise HTTPException(status_code=500, detail=f"Stripe error: {str(e)}") + except Exception as e: + raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}") + + +async def create_free_subscription( + *, + request: Request, + org_id: str, + body: CreateCheckoutSessionBody, + orm: Session = Depends(get_orm_session), +) -> CreateFreeSubscriptionResponse: + """ + Create a subscription directly for cases where a 100% off discount is applied. + This bypasses the checkout session since no payment is required. + """ + stripe.api_key = STRIPE_SECRET_KEY + + if not STRIPE_SECRET_KEY: + raise HTTPException(status_code=500, detail="Stripe secret key not configured.") + + user: Optional[UserModel] = UserModel.get_by_id(orm, request.state.session.user_id) + if not user or not user.billing_email: + raise HTTPException(status_code=400, detail="User email is required to create a subscription.") + + org: Optional[OrgModel] = OrgModel.get_by_id(orm, org_id) + + if not org: + raise HTTPException(status_code=404, detail="Organization not found") + + if not org.is_user_admin_or_owner(request.state.session.user_id): + raise HTTPException( + status_code=403, detail="User does not have permission to upgrade this organization." + ) + + if org.subscription_id and org.prem_status != PremStatus.free: + try: + subscription = stripe.Subscription.retrieve(org.subscription_id) + if subscription.status in ['active', 'trialing']: + raise HTTPException(status_code=400, detail="Organization already has an active subscription") + except stripe.error.StripeError: + logger.warning(f"Could not retrieve subscription {org.subscription_id} for org {org.id}") + pass + + if not body.discount_code: + raise HTTPException(status_code=400, detail="Discount code is required for free subscription") + + try: + # Resolve the discount code + coupon, promotion_code_id = await _resolve_discount_code(body.discount_code) + + if not coupon: + raise HTTPException(status_code=400, detail="Invalid discount code") + + if coupon.percent_off != 100: + raise HTTPException(status_code=400, detail="This endpoint only supports 100% off discounts") + + # Create a customer for this subscription + customer = stripe.Customer.create( + email=user.billing_email, metadata={'org_id': str(org.id), 'user_id': str(user.id)} + ) + + # Create the subscription with the 100% off discount + subscription_params = { + 'customer': customer.id, + 'items': [{'price': body.price_id}], + 'metadata': {'org_id': str(org.id)}, + } + + # Apply the discount + if promotion_code_id: + subscription_params['discounts'] = [{'promotion_code': promotion_code_id}] + else: + subscription_params['discounts'] = [{'coupon': body.discount_code}] + + subscription = stripe.Subscription.create(**subscription_params) + + # Update organization with subscription details + update_org_subscription(orm, org, subscription.id) + + orm.commit() + + logger.info(f"Created free subscription {subscription.id} for org {org_id} with 100% off discount") + + return CreateFreeSubscriptionResponse( + message="Subscription created successfully with 100% off discount. No payment required.", + subscription_id=subscription.id, + org_id=str(org.id), + ) + + except HTTPException: + raise + except stripe.error.StripeError as e: + orm.rollback() + logger.error(f"Stripe error creating free subscription for org {org_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Stripe error: {str(e)}") + except Exception as e: + orm.rollback() + logger.error(f"Unexpected error creating free subscription for org {org_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}") + + +async def cancel_subscription( + *, + request: Request, + org_id: str, + body: CancelSubscriptionBody, + orm: Session = Depends(get_orm_session), +) -> StatusResponse: + """ + Cancel a Stripe subscription for an organization immediately. + """ + stripe.api_key = STRIPE_SECRET_KEY + + if not STRIPE_SECRET_KEY: + raise HTTPException(status_code=500, detail="Stripe secret key not configured.") + + user: Optional[UserModel] = UserModel.get_by_id(orm, request.state.session.user_id) + if not user: # Minimal check, primary auth is via endpoint protection + raise HTTPException(status_code=401, detail="User not authenticated.") + + org: Optional[OrgModel] = OrgModel.get_by_id(orm, org_id) + + if not org: + raise HTTPException(status_code=404, detail="Organization not found") + + if not org.is_user_admin_or_owner(request.state.session.user_id): + raise HTTPException( + status_code=403, + detail="User does not have permission to manage this organization's subscription.", + ) + + if not org.subscription_id: + raise HTTPException(status_code=400, detail="Organization does not have an active subscription.") + + if org.subscription_id != body.subscription_id: + raise HTTPException(status_code=400, detail="Subscription ID mismatch.") + + try: + # Add idempotency key to prevent duplicate cancellation requests + idempotency_key = f"cancel_{org.id}_{body.subscription_id}_{int(time.time())}" + stripe.Subscription.modify( + body.subscription_id, cancel_at_period_end=True, idempotency_key=idempotency_key + ) + + logger.info(f"Subscription {body.subscription_id} set to cancel at period end for org {org_id}") + + return StatusResponse( + message="Subscription will be cancelled at the end of the current billing period." + ) + + except stripe.error.StripeError as e: + orm.rollback() + logger.error( + "Stripe error cancelling subscription %s for org %s: %s", body.subscription_id, org_id, str(e) + ) + raise HTTPException( + status_code=500, + detail=( + "Stripe error: Could not cancel subscription. " + "Please try again later or contact support if the issue persists." + ), + ) + except Exception as e: + orm.rollback() + logger.error( + "Unexpected error cancelling subscription %s for org %s: %s", body.subscription_id, org_id, str(e) + ) + raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}") + + +async def reactivate_subscription( + *, + request: Request, + org_id: str, + orm: Session = Depends(get_orm_session), +) -> StatusResponse: + """ + Reactivate a subscription that was set to cancel at period end. + """ + stripe.api_key = STRIPE_SECRET_KEY + + if not STRIPE_SECRET_KEY: + raise HTTPException(status_code=500, detail="Stripe secret key not configured.") + + user: Optional[UserModel] = UserModel.get_by_id(orm, request.state.session.user_id) + if not user: + raise HTTPException(status_code=401, detail="User not authenticated.") + + org: Optional[OrgModel] = OrgModel.get_by_id(orm, org_id) + + if not org: + raise HTTPException(status_code=404, detail="Organization not found") + + if not org.is_user_admin_or_owner(request.state.session.user_id): + raise HTTPException( + status_code=403, + detail="User does not have permission to manage this organization's subscription.", + ) + + if not org.subscription_id: + raise HTTPException(status_code=400, detail="Organization does not have an active subscription.") + + try: + subscription = stripe.Subscription.retrieve(org.subscription_id) + + if not subscription.cancel_at_period_end: + raise HTTPException(status_code=400, detail="Subscription is not set to cancel.") + + # Add idempotency key to prevent duplicate reactivation requests + idempotency_key = f"reactivate_{org.id}_{org.subscription_id}_{int(time.time())}" + stripe.Subscription.modify( + org.subscription_id, cancel_at_period_end=False, idempotency_key=idempotency_key + ) + + logger.info(f"Subscription {org.subscription_id} reactivated for org {org_id}") + + return StatusResponse( + message=( + "Subscription reactivated successfully. " + "You will continue to be billed at the next billing cycle." + ) + ) + + except stripe.error.StripeError as e: + logger.error( + f"Stripe error reactivating subscription {org.subscription_id} for org {org_id}: {str(e)}" + ) + raise HTTPException( + status_code=500, + detail=( + "Stripe error: Could not reactivate subscription. Please try again later or contact support." + ), + ) + except Exception as e: + logger.error( + f"Unexpected error reactivating subscription {org.subscription_id} for org {org_id}: {str(e)}" + ) + raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}") + + +class UpdateSubscriptionBody(pydantic.BaseModel): + price_id: Optional[str] = None + proration_behavior: Optional[str] = "create_prorations" # create_prorations, always_invoice, none + payment_behavior: Optional[str] = "allow_incomplete" # allow_incomplete, error_if_incomplete + + +class CustomerPortalResponse(pydantic.BaseModel): + url: str + + +class PreviewMemberAddResponse(pydantic.BaseModel): + immediate_charge: float # Amount in dollars + next_period_charge: float # Amount in dollars per billing period + billing_interval: str + period_end: Optional[str] = None + currency: str = "usd" + + +async def preview_member_add_cost( + *, + request: Request, + org_id: str, + orm: Session = Depends(get_orm_session), +) -> PreviewMemberAddResponse: + """ + Preview the cost of adding a new member to the subscription. + Uses Stripe's upcoming invoice API to get exact proration amounts. + """ + stripe.api_key = STRIPE_SECRET_KEY + + if not STRIPE_SECRET_KEY: + raise HTTPException(status_code=500, detail="Stripe secret key not configured.") + + user: Optional[UserModel] = UserModel.get_by_id(orm, request.state.session.user_id) + if not user: + raise HTTPException(status_code=401, detail="User not authenticated.") + + org: Optional[OrgModel] = OrgModel.get_by_id(orm, org_id) + + if not org: + raise HTTPException(status_code=404, detail="Organization not found") + + if not org.is_user_member(request.state.session.user_id): + raise HTTPException( + status_code=403, + detail="User does not have permission to view this organization's billing.", + ) + + if not org.subscription_id: + raise HTTPException(status_code=400, detail="Organization does not have an active subscription.") + + try: + # Get the current subscription + subscription = stripe.Subscription.retrieve(org.subscription_id, expand=["items.data.price.product"]) + + # Find the seat item + seat_item = None + for item in subscription.get('items', {}).get('data', []): + price = item.get('price', {}) + if price.get('id') == STRIPE_SUBSCRIPTION_PRICE_ID: + seat_item = item + break + + if not seat_item: + raise HTTPException(status_code=500, detail="Could not find seat pricing in subscription") + + current_quantity = seat_item.get('quantity', 1) + price_data = seat_item.get('price', {}) + + # Get the upcoming invoice to see current period charges + upcoming_invoice = stripe.Invoice.create_preview( + customer=subscription.customer, + subscription=subscription.id, + subscription_details={ + 'items': [ + { + 'id': seat_item.get('id'), + 'quantity': current_quantity + 1, # Preview with one additional seat + } + ], + 'proration_behavior': 'create_prorations', + }, + ) + + # Calculate the immediate charge by finding proration line items + # The recommended way to get only the prorations is to look for line items + # where parent.subscription_item_details.proration is true + immediate_charge_cents = 0 + + # Get the line items from the preview invoice + for line_item in upcoming_invoice.lines.data: + parent = line_item.get('parent', {}) + if parent and parent.get('type') == 'subscription_item_details': + subscription_item_details = parent.get('subscription_item_details', {}) + # Check if this is a proration line item + if subscription_item_details.get('proration', False): + # Add the proration amount (could be positive for upgrade or negative for downgrade) + immediate_charge_cents += line_item.get('amount', 0) + + immediate_charge = max(0, immediate_charge_cents / 100) # Convert to dollars + + # Get the regular price per billing period + unit_amount = price_data.get('unit_amount', 0) + next_period_charge = unit_amount / 100 # Convert to dollars + + # Get billing interval + recurring = price_data.get('recurring', {}) + interval = recurring.get('interval', 'month') + interval_count = recurring.get('interval_count', 1) + + if interval_count > 1: + billing_interval = f"{interval_count} {interval}s" + else: + billing_interval = interval + + # Get period end date + period_end = subscription.get('current_period_end') + period_end_str = None + if period_end: + from datetime import datetime + + period_end_str = datetime.fromtimestamp(period_end).isoformat() + + return PreviewMemberAddResponse( + immediate_charge=immediate_charge, + next_period_charge=next_period_charge, + billing_interval=billing_interval, + period_end=period_end_str, + currency=price_data.get('currency', 'usd'), + ) + + except stripe.error.StripeError as e: + logger.error(f"Stripe error previewing member add cost for org {org_id}: {str(e)}") + # Return a fallback calculation if Stripe API fails + return PreviewMemberAddResponse( + immediate_charge=0, + next_period_charge=40, # Default price + billing_interval="month", + period_end=None, + currency="usd", + ) + except Exception as e: + logger.error(f"Unexpected error previewing member add cost for org {org_id}: {str(e)}") + raise HTTPException(status_code=500, detail="Failed to preview billing changes.") + + +class SubscriptionDetailResponse(pydantic.BaseModel): + subscription_id: str + status: str + current_period_start: int + current_period_end: int + price_id: Optional[str] = None + product_name: Optional[str] = None + quantity: Optional[int] = None + + +async def get_subscription_detail( + *, + request: Request, + org_id: str, + orm: Session = Depends(get_orm_session), +) -> SubscriptionDetailResponse: + """ + Fetch current subscription details from Stripe for refreshing billing data. + """ + stripe.api_key = STRIPE_SECRET_KEY + + if not STRIPE_SECRET_KEY: + raise HTTPException(status_code=500, detail="Stripe secret key not configured.") + + user: Optional[UserModel] = UserModel.get_by_id(orm, request.state.session.user_id) + if not user: + raise HTTPException(status_code=401, detail="User not authenticated.") + + org: Optional[OrgModel] = OrgModel.get_by_id(orm, org_id) + + if not org: + raise HTTPException(status_code=404, detail="Organization not found") + + if not org.is_user_admin_or_owner(request.state.session.user_id): + raise HTTPException( + status_code=403, + detail="User does not have permission to view this organization's subscription.", + ) + + if not org.subscription_id: + raise HTTPException(status_code=400, detail="Organization does not have an active subscription.") + + try: + # Get current subscription details from Stripe (same pattern as BillingDashboardView) + subscription = stripe.Subscription.retrieve(org.subscription_id, expand=["items.data.price.product"]) + + # Get product info if available + product_name = None + price_id = None + quantity = None + + # Use the utility function to get period dates + period_start, period_end = extract_subscription_period_dates(subscription) + + # Get product and quantity info from items + items = subscription.get('items', {}) + if items and items.get('data') and len(items['data']) > 0: + first_item = items['data'][0] + if first_item.get('price'): + price_id = first_item['price']['id'] + quantity = first_item.get('quantity') + + if first_item['price'].get('product'): + # The product object is already expanded + product_data = first_item['price'].get('product', {}) + product_name = product_data.get('name') + + if period_start and period_end: + logger.info(f"Successfully retrieved period info for subscription {org.subscription_id}") + else: + logger.warning( + f"Could not find billing period dates in Stripe subscription {org.subscription_id}" + ) + raise HTTPException(status_code=500, detail="Subscription period information not available") + + return SubscriptionDetailResponse( + subscription_id=subscription.id, + status=subscription.status, + current_period_start=period_start, + current_period_end=period_end, + price_id=price_id, + product_name=product_name, + quantity=quantity, + ) + + except stripe.error.StripeError as e: + logger.error(f"Stripe error fetching subscription {org.subscription_id} for org {org_id}: {str(e)}") + raise HTTPException( + status_code=500, detail=f"Stripe error: Could not fetch subscription details. {str(e)}" + ) + except Exception as e: + logger.error( + f"Unexpected error fetching subscription {org.subscription_id} for org {org_id}: {str(e)}" + ) + raise HTTPException(status_code=500, detail="Failed to fetch subscription details. Please try again.") + + +async def update_subscription( + *, + request: Request, + org_id: str, + body: UpdateSubscriptionBody, + orm: Session = Depends(get_orm_session), +) -> StatusResponse: + """ + Update an existing subscription (change plan, billing, etc.) using Stripe's API. + This provides in-app subscription management without redirecting to Stripe's portal. + """ + stripe.api_key = STRIPE_SECRET_KEY + + if not STRIPE_SECRET_KEY: + raise HTTPException(status_code=500, detail="Stripe secret key not configured.") + + user: Optional[UserModel] = UserModel.get_by_id(orm, request.state.session.user_id) + if not user: + raise HTTPException(status_code=401, detail="User not authenticated.") + + org: Optional[OrgModel] = OrgModel.get_by_id(orm, org_id) + + if not org: + raise HTTPException(status_code=404, detail="Organization not found") + + if not org.is_user_admin_or_owner(request.state.session.user_id): + raise HTTPException( + status_code=403, + detail="User does not have permission to manage this organization's subscription.", + ) + + if not org.subscription_id: + raise HTTPException(status_code=400, detail="Organization does not have an active subscription.") + + try: + # Get current subscription details + current_subscription = stripe.Subscription.retrieve(org.subscription_id) + + if current_subscription.status not in ['active', 'trialing']: + raise HTTPException( + status_code=400, + detail=f"Cannot update subscription with status: {current_subscription.status}", + ) + + # Check if subscription is scheduled to cancel + if current_subscription.get('cancel_at_period_end'): + raise HTTPException( + status_code=400, + detail="Your subscription is scheduled to cancel. Updates are not allowed for cancelled subscriptions.", + ) + + update_params = { + 'proration_behavior': body.proration_behavior, + 'payment_behavior': body.payment_behavior, + } + + # Add idempotency key to prevent duplicate updates + idempotency_key = f"update_{org.id}_{org.subscription_id}_{int(time.time())}" + + # If changing the plan/price + if body.price_id: + # Get the current subscription item + subscription_items = current_subscription.items.data + if not subscription_items: + raise HTTPException(status_code=400, detail="No subscription items found") + + current_item = subscription_items[0] # Assuming single item subscription + + # Update the subscription item with new price + update_params['items'] = [ + { + 'id': current_item.id, + 'price': body.price_id, + } + ] + + # Update the subscription + stripe.Subscription.modify( + org.subscription_id, + idempotency_key=idempotency_key, + **update_params, + ) + + logger.info(f"Subscription {org.subscription_id} updated for org {org_id}") + + # Determine the response message based on what was updated + if body.price_id: + message = "Subscription plan updated successfully." + if body.proration_behavior == "always_invoice": + message += " You will be charged/credited for the prorated amount immediately." + elif body.proration_behavior == "create_prorations": + message += " Prorated charges will be applied to your next invoice." + else: + message = "Subscription updated successfully." + + return StatusResponse(message=message) + + except stripe.error.StripeError as e: + logger.error(f"Stripe error updating subscription {org.subscription_id} for org {org_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Stripe error: Could not update subscription. {str(e)}") + except Exception as e: + logger.error( + f"Unexpected error updating subscription {org.subscription_id} for org {org_id}: {str(e)}" + ) + raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}") + + +async def create_customer_portal_session( + *, + request: Request, + org_id: str, + orm: Session = Depends(get_orm_session), +) -> CustomerPortalResponse: + """ + Create a Stripe Customer Portal session for advanced subscription management. + This is a fallback option for complex billing scenarios. + """ + stripe.api_key = STRIPE_SECRET_KEY + + if not STRIPE_SECRET_KEY: + raise HTTPException(status_code=500, detail="Stripe secret key not configured.") + + user: Optional[UserModel] = UserModel.get_by_id(orm, request.state.session.user_id) + if not user: + raise HTTPException(status_code=401, detail="User not authenticated.") + + org: Optional[OrgModel] = OrgModel.get_by_id(orm, org_id) + + if not org: + raise HTTPException(status_code=404, detail="Organization not found") + + if not org.is_user_admin_or_owner(request.state.session.user_id): + raise HTTPException( + status_code=403, + detail="User does not have permission to manage this organization's subscription.", + ) + + if not org.subscription_id: + raise HTTPException(status_code=400, detail="Organization does not have an active subscription.") + + try: + # Get the customer ID from the subscription + subscription = stripe.Subscription.retrieve(org.subscription_id) + customer_id = subscription.customer + + # Create customer portal session + portal_session = stripe.billing_portal.Session.create( + customer=customer_id, return_url=f"{APP_URL}/settings/organization" + ) + + return CustomerPortalResponse(url=portal_session.url) + + except stripe.error.StripeError as e: + logger.error(f"Stripe error creating customer portal for org {org_id}: {str(e)}") + raise HTTPException( + status_code=500, detail=f"Stripe error: Could not create customer portal session. {str(e)}" + ) + except Exception as e: + logger.error(f"Unexpected error creating customer portal for org {org_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}") + + +async def get_stripe_pricing( + *, + request: Request, + org_id: str, + orm: Session = Depends(get_orm_session), +) -> dict: + """Get current Stripe pricing information including seat and usage pricing.""" + if not _validate_and_set_stripe_key("get_stripe_pricing"): + raise HTTPException(status_code=500, detail="Stripe configuration error") + + # Log all price ID status for debugging + _validate_stripe_price_ids("get_stripe_pricing") + + user: Optional[UserModel] = UserModel.get_by_id(orm, request.state.session.user_id) + if not user: + raise HTTPException(status_code=401, detail="User not authenticated.") + + org: Optional[OrgModel] = OrgModel.get_by_id(orm, org_id) + if not org or not org.is_user_member(request.state.session.user_id): + raise HTTPException(status_code=403, detail="Access denied.") + + try: + # Get seat pricing + seat_price_id = os.getenv("STRIPE_SUBSCRIPTION_PRICE_ID") + if not seat_price_id: + raise HTTPException(status_code=500, detail="Stripe seat price ID not configured") + + seat_price = stripe.Price.retrieve(seat_price_id) + + # Extract seat price using robust method + from ..services.billing_service import billing_service + + seat_price_amount = billing_service._extract_price_amount(seat_price, seat_price_id) + if seat_price_amount is None: + logger.warning(f"Seat price {seat_price_id} has no valid pricing amount, using fallback") + raise HTTPException(status_code=500, detail="Seat price amount not available") + + pricing_data = { + "seat": { + "priceId": seat_price_id, + "amount": int(round(seat_price_amount)), # Amount in cents (rounded to whole cents) + "currency": seat_price.currency, + "interval": seat_price.recurring.interval if seat_price.recurring else "one_time", + "interval_count": seat_price.recurring.interval_count if seat_price.recurring else None, + } + } + + # Get usage pricing + token_price_id = STRIPE_TOKEN_PRICE_ID + span_price_id = STRIPE_SPAN_PRICE_ID + + if token_price_id: + try: + token_price = stripe.Price.retrieve(token_price_id, expand=['currency_options', 'tiers']) + token_price_amount = billing_service._extract_price_amount(token_price, token_price_id) + if token_price_amount is not None: + pricing_data["tokens"] = { + "priceId": token_price_id, + "amount": token_price_amount, # Amount in cents + "currency": token_price.currency, + "unit_size": token_price.transform_quantity.divide_by + if token_price.transform_quantity + else 1000, + "display_unit": "thousand tokens", + } + else: + logger.warning( + f"Token price {token_price_id} has no valid pricing amount, using fallback" + ) + # Use fallback values when Stripe price has no amount + pricing_data["tokens"] = { + "priceId": None, # Set to None since price is not usable + "amount": 0.02, # $0.0002 = 0.02 cents (fractional cents) + "currency": "usd", + "unit_size": 1000, + "display_unit": "thousand tokens", + } + except (stripe.error.StripeError, ValueError) as e: + logger.warning(f"Failed to fetch token price from Stripe: {e}") + # Use fallback + pricing_data["tokens"] = { + "priceId": None, + "amount": 0.02, # $0.0002 = 0.02 cents (fractional cents) + "currency": "usd", + "unit_size": 1000, + "display_unit": "thousand tokens", + } + + if span_price_id: + try: + span_price = stripe.Price.retrieve(span_price_id, expand=['currency_options', 'tiers']) + span_price_amount = billing_service._extract_price_amount(span_price, span_price_id) + if span_price_amount is not None: + pricing_data["spans"] = { + "priceId": span_price_id, + "amount": span_price_amount, # Amount in cents + "currency": span_price.currency, + "unit_size": span_price.transform_quantity.divide_by + if span_price.transform_quantity + else 1000, + "display_unit": "thousand spans", + } + else: + logger.warning(f"Span price {span_price_id} has no valid pricing amount, using fallback") + # Use fallback values when Stripe price has no amount + pricing_data["spans"] = { + "priceId": None, # Set to None since price is not usable + "amount": 0.01, # $0.0001 = 0.01 cents (fractional cents) + "currency": "usd", + "unit_size": 1000, + "display_unit": "thousand spans", + } + except (stripe.error.StripeError, ValueError) as e: + logger.warning(f"Failed to fetch span price from Stripe: {e}") + # Use fallback + pricing_data["spans"] = { + "priceId": None, + "amount": 0.01, # $0.0001 = 0.01 cents (fractional cents) + "currency": "usd", + "unit_size": 1000, + "display_unit": "thousand spans", + } + + return pricing_data + + except stripe.error.StripeError as e: + logger.error(f"Failed to fetch pricing from Stripe: {e}") + raise HTTPException(status_code=500, detail="Failed to fetch pricing information") + + +def get_org_invites_for_org( + *, + request: Request, + org_id: str, + orm: Session = Depends(get_orm_session), +) -> list[OrgInviteDetailResponse]: + """Get all pending invites for an organization (admin/owner only).""" + org = OrgModel.get_by_id(orm, org_id) + if not org or not org.is_user_admin_or_owner(request.state.session.user_id): + raise HTTPException(status_code=404, detail="Organization not found") + + # Query all invites for this org + invites = orm.query(OrgInviteModel).filter(OrgInviteModel.org_id == org_id).all() + + logger.debug("get_org_invites_for_org: Found %d total invites for org %s", len(invites), org_id) + + result = [] + for invite in invites: + logger.debug( + "Processing invite: inviter_id=%s, invitee_email=%s, role=%s", + invite.inviter_id, + invite.invitee_email, + invite.role, + ) + invitee_email = invite.invitee_email + + # Check if this user is already a member of the org + already_member = ( + orm.query(UserOrgModel) + .filter( + func.lower(UserOrgModel.user_email) == invitee_email.lower(), UserOrgModel.org_id == org_id + ) + .first() + ) + + # Skip this invite if user is already a member + if already_member: + logger.debug("Skipping invite for %s - already a member of org", invitee_email) + continue + + # Get inviter's actual email from inviter_id + inviter_user = UserModel.get_by_id(orm, invite.inviter_id) + + # Check if the invitee exists in our system using ORM + user_exists = False + existing_user = ( + orm.query(UserModel) + .join(AuthUserModel, UserModel.id == AuthUserModel.id) + .filter(func.lower(AuthUserModel.email) == invitee_email.lower()) + .first() + ) + + if not existing_user: + # Also check regular email field + existing_user = ( + orm.query(UserModel).filter(func.lower(UserModel.email) == invitee_email.lower()).first() + ) + + user_exists = existing_user is not None + + result.append( + OrgInviteDetailResponse( + invitee_email=invitee_email, + inviter_email=inviter_user.billing_email if inviter_user else "Unknown", + role=invite.role.value if hasattr(invite.role, 'value') else invite.role, + org_id=str(invite.org_id), + org_name=invite.org_name, + created_at=getattr(invite, 'created_at', None), + user_exists=user_exists, + ) + ) + + orm.commit() + return result + + +def revoke_org_invite( + *, + request: Request, + org_id: str, + email: str, + orm: Session = Depends(get_orm_session), +) -> StatusResponse: + """Revoke an invitation.""" + org = OrgModel.get_by_id(orm, org_id) + if not org or not org.is_user_admin_or_owner(request.state.session.user_id): + raise HTTPException(status_code=404, detail="Organization not found") + + invite = ( + orm.query(OrgInviteModel) + .filter(func.lower(OrgInviteModel.invitee_email) == email.lower(), OrgInviteModel.org_id == org_id) + .first() + ) + + if not invite: + raise HTTPException(status_code=404, detail="Invitation not found") + + orm.delete(invite) + orm.commit() + logger.debug("Invitation revoked for %s in org %s", email, org_id) + + return StatusResponse(message="Invitation revoked successfully") diff --git a/app/api/agentops/opsboard/views/projects.py b/app/api/agentops/opsboard/views/projects.py new file mode 100644 index 000000000..bb6f1fbc6 --- /dev/null +++ b/app/api/agentops/opsboard/views/projects.py @@ -0,0 +1,188 @@ +import uuid +from fastapi import Request, Depends, HTTPException + +from agentops.common.orm import get_orm_session, Session +from agentops.api.models.metrics import TraceCountsModel + +from ..models import OrgModel, ProjectModel, Environment +from ..schemas import ( + StatusResponse, + ProjectSummaryResponse, + ProjectResponse, + ProjectCreateSchema, + ProjectUpdateSchema, +) + + +async def get_projects( + *, + request: Request, + orm: Session = Depends(get_orm_session), +) -> list[ProjectSummaryResponse]: + """ + Get all projects the user has access to across all organizations they belong to. + Includes organization information with each project. + + Optimized version that reduces unnecessary data loading. + """ + # Use a more efficient query that only loads what we need for the response + projects = ProjectModel.get_all_for_user_optimized(orm, request.state.session.user_id) + + # Only fetch trace counts if we have projects + if projects: + _projects_counts = await TraceCountsModel.select( + filters={'project_ids': [str(project.id) for project in projects]} + ) + projects_counts: dict[str, int] = {str(p.project_id): p for p in _projects_counts} + else: + projects_counts = {} + + project_responses = [] + for project in projects: + response = ProjectSummaryResponse.model_validate(project) + + # add trace metrics to the response + if counts := projects_counts.get(str(project.id)): + response.span_count = counts.span_count + response.trace_count = counts.trace_count + + project_responses.append(response) + + return project_responses + + +def get_project( + *, + request: Request, + project_id: str, + orm: Session = Depends(get_orm_session), +) -> ProjectResponse: + """ + Get a specific project by ID. + User must be a member of the project's organization. + """ + project = ProjectModel.get_by_id(orm, project_id) + + if not project or not project.org.is_user_member(request.state.session.user_id): + raise HTTPException(status_code=404, detail="Project not found") + + project.org.set_current_user(request.state.session.user_id) + return ProjectResponse.model_validate(project) + + +def create_project( + *, + request: Request, + orm: Session = Depends(get_orm_session), + body: ProjectCreateSchema, +) -> ProjectResponse: + """ + Create a new project in an organization. + User must be an admin or owner of the organization. + """ + org = OrgModel.get_by_id(orm, body.org_id) + + if not org or not org.is_user_admin_or_owner(request.state.session.user_id): + raise HTTPException(status_code=404, detail="Organization not found") + + if org.max_project_count and not org.current_project_count < org.max_project_count: + raise HTTPException(status_code=403, detail="Organization has reached it's project limit") + + environment = Environment(body.environment) if body.environment else Environment.development + project = ProjectModel( + name=body.name, + org_id=body.org_id, + environment=environment, + ) + + orm.add(project) + orm.commit() + + # explicitly load the project so we have all context needed for the response + project = ProjectModel.get_by_id(orm, project.id) + project.org.set_current_user(request.state.session.user_id) + return ProjectResponse.model_validate(project) + + +def update_project( + *, + request: Request, + project_id: str, + orm: Session = Depends(get_orm_session), + body: ProjectUpdateSchema, +) -> ProjectResponse: + """ + Update a project's name or environment. + User must be an admin or owner of the organization. + """ + project = ProjectModel.get_by_id(orm, project_id) + + if not project: + raise HTTPException(status_code=404, detail="Project not found") + + if not project.org.is_user_admin_or_owner(request.state.session.user_id): + raise HTTPException(status_code=403, detail="You don't have permission to update this project") + + if body.name is not None: + project.name = body.name + + if body.environment is not None: + try: + project.environment = Environment(body.environment) + except ValueError: + raise HTTPException(status_code=400, detail="Invalid environment") + + orm.commit() + + # reload project cuz it's more flexible than calling orm.refresh with args + project = ProjectModel.get_by_id(orm, project.id) + project.org.set_current_user(request.state.session.user_id) + return ProjectResponse.model_validate(project) + + +def delete_project( + *, + request: Request, + project_id: str, + orm: Session = Depends(get_orm_session), +) -> StatusResponse: + """ + Delete a project. + User must be an owner of the organization. + """ + project = ProjectModel.get_by_id(orm, project_id) + + if not project: + raise HTTPException(status_code=404, detail="Project not found") + + if not project.org.is_user_owner(request.state.session.user_id): + raise HTTPException(status_code=403, detail="Only organization owners can delete projects") + + orm.delete(project) + orm.commit() + + return StatusResponse(message="Project deleted successfully") + + +def regenerate_api_key( + *, + request: Request, + project_id: str, + orm: Session = Depends(get_orm_session), +) -> ProjectResponse: + """ + Regenerate the API key for a project. + User must be an admin or owner of the organization. + """ + project = ProjectModel.get_by_id(orm, project_id) + + if not project or not project.org.is_user_admin_or_owner(request.state.session.user_id): + raise HTTPException(status_code=404, detail="Project not found") + + project.api_key = str(uuid.uuid4()) + orm.commit() + + # reload project cuz it's more flexible than calling orm.refresh with args + project = ProjectModel.get_by_id(orm, project.id) + project.org.set_current_user(request.state.session.user_id) + return ProjectResponse.model_validate(project) diff --git a/app/api/agentops/opsboard/views/user_invites.svg b/app/api/agentops/opsboard/views/user_invites.svg new file mode 100644 index 000000000..4bb1f51a1 --- /dev/null +++ b/app/api/agentops/opsboard/views/user_invites.svg @@ -0,0 +1 @@ +
Yes
No
No
Yes
Admin/Owner invites user
Create org_invites record
inviter_id: admin's ID
invitee_email: new user's email
Send Supabase OTP email
should_create_user: true
User receives magic link email
User clicks email link
User exists
in Supabase?
Sign user in
Create new user account
+ sign in
Database trigger creates
default personal org
Redirect to /settings/organizations?invite=org_id
User sees pending invitations
User clicks 'Accept' button
accept_org_invite endpoint
Find invite record
by invitee_email + org_id
Invite found?
404: Invitation not found
Create user_orgs record
Delete org_invites record
āœ… User added to organization
 \ No newline at end of file diff --git a/app/api/agentops/opsboard/views/users.py b/app/api/agentops/opsboard/views/users.py new file mode 100644 index 000000000..9d952e344 --- /dev/null +++ b/app/api/agentops/opsboard/views/users.py @@ -0,0 +1,70 @@ +from typing import Optional +from fastapi import Request, Depends + +from agentops.common.orm import get_orm_session, Session + +from ..models import UserModel +from ..schemas import StatusResponse, UserResponse, UserUpdateSchema + + +def get_user( + *, + request: Request, + orm: Session = Depends(get_orm_session), +) -> UserResponse: + """ + Get all details for the authenticated user. + """ + # TODO I kinda want to return only a subset of the available fields on most + # requests, but really it's just the billing address I don't think we should + # be sending around all the time. + user: Optional[UserModel] = UserModel.get_by_id(orm, request.state.session.user_id) + assert user, "User not found" + + # Create the response, using billing_email (from auth.users) if available + # This ensures we return the canonical email from auth.users + response = UserResponse.model_validate(user) + if user.billing_email: + response.email = user.billing_email + + return response + + +def update_user( + *, + request: Request, + orm: Session = Depends(get_orm_session), + body: UserUpdateSchema, +) -> UserResponse: + """ + Update the authenticated user's details. + """ + user: Optional[UserModel] = UserModel.get_by_id(orm, request.state.session.user_id) + assert user, "User not found" + + update_dict = body.model_dump(exclude_unset=True, exclude_none=True) + for key, value in update_dict.items(): + setattr(user, key, value) + + orm.commit() + + # re-fetch user with relationships loaded instead of using refresh with args + user = UserModel.get_by_id(orm, request.state.session.user_id) + return UserResponse.model_validate(user) + + +def update_user_survey_complete( + *, + request: Request, + orm: Session = Depends(get_orm_session), +) -> StatusResponse: + """ + Mark the authenticated user's survey as complete. + """ + user: Optional[UserModel] = UserModel.get_by_id(orm, request.state.session.user_id) + assert user, "User not found" + + user.mark_survey_complete() + orm.commit() + + return StatusResponse(message="User survey marked complete") diff --git a/app/api/agentops/public/__int__.py b/app/api/agentops/public/__int__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/api/agentops/public/agent/__init__.py b/app/api/agentops/public/agent/__init__.py new file mode 100644 index 000000000..d8380b0bc --- /dev/null +++ b/app/api/agentops/public/agent/__init__.py @@ -0,0 +1 @@ +# these are the public views for interacting with hosted agents \ No newline at end of file diff --git a/app/api/agentops/public/agent/base.py b/app/api/agentops/public/agent/base.py new file mode 100644 index 000000000..cefffc388 --- /dev/null +++ b/app/api/agentops/public/agent/base.py @@ -0,0 +1,70 @@ +from typing import TypeVar +from abc import ABC +import uuid +import pydantic +from fastapi import Request, HTTPException, Depends +from agentops.common.route_config import BaseView +from agentops.common.orm import Session, get_orm_session +from agentops.api.auth import JWTPayload, verify_jwt +from agentops.opsboard.models import BaseProjectModel, ProjectModel, SparseProjectModel +from agentops.deploy.models import HostingProjectModel + + +class BaseResponse(pydantic.BaseModel): + """ + Base response model for all agent API responses. + """ + + model_config = pydantic.ConfigDict( + from_attributes=True, + ) + + +TBaseResponse = TypeVar("TBaseResponse", bound=BaseResponse) + + +class BaseAgentAPIView(BaseView, ABC): + """ + Base view for agent API endpoints. + This class can be extended to create specific views for different endpoints. + """ + + @classmethod + async def create(cls, request: Request) -> "BaseAgentAPIView": + """Create an instance of the view with the request.""" + # we use a constructor to allow us to execute async methods on creation + instance = await super().create(request=request) + return instance + + +class AuthenticatedByKeyAgentAPIView(BaseAgentAPIView, ABC): + """ + Base view for api_key authenticated agent API endpoints. + """ + + def _validate_api_key(self, api_key: str) -> None: + """Validate the API key format.""" + if not api_key: + raise HTTPException(status_code=400, detail="api_key is required") + + try: + uuid.UUID(api_key) + except ValueError: + raise HTTPException(status_code=400, detail="Invalid api_key format") + + async def get_project(self, orm: Session = Depends(get_orm_session)) -> ProjectModel: + """Get full project model for authenticated use cases via API key.""" + # Extract API key from request state (set by middleware) + api_key = getattr(self.request.state, 'api_key', None) + self._validate_api_key(api_key) + project = ProjectModel.get_by_api_key(orm, api_key) + return project + + async def get_hosted_project(self, orm: Session = Depends(get_orm_session)) -> HostingProjectModel: + """Get hosted project for authenticated use cases via API key.""" + # For API key auth, hosted project is the same as regular project + api_key = getattr(self.request.state, 'api_key', None) + self._validate_api_key(api_key) + project = ProjectModel.get_by_api_key(orm, api_key) + hosted_project = HostingProjectModel.get_by_id(orm, project.id) + return hosted_project \ No newline at end of file diff --git a/app/api/agentops/public/agent/job.py b/app/api/agentops/public/agent/job.py new file mode 100644 index 000000000..ab12e6c53 --- /dev/null +++ b/app/api/agentops/public/agent/job.py @@ -0,0 +1,100 @@ +import pydantic +from fastapi import Depends, HTTPException +from agentops.common.orm import Session, get_orm_session +from .base import AuthenticatedByKeyAgentAPIView, BaseResponse +from jockey.backend.models.job import Job +from agentops.deploy.views.deploy import InitiateRunView +from agentops.deploy.schemas import RunJobRequest +from typing import Any, Dict + + +class JobRequest(pydantic.BaseModel): + inputs: Dict[str, Any] = pydantic.Field(default_factory=dict) + + +class JobResponse(BaseResponse): + id: str + agent_id: str + job: str + + @pydantic.field_validator("id", "agent_id", mode="before") + @classmethod + def validate_uuid(cls, v): + return str(v) + + @pydantic.field_validator("job", mode="before") + @classmethod + def to_string(cls, v) -> str: + return v["job"].to_string() + + +class KickoffRunView(AuthenticatedByKeyAgentAPIView): + __name__ = "Start an agent run" + __doc__ = """ + Endpoint will queue an agent run for an agent with the API key used to authenticate. + """ + + async def __call__(self, body: JobRequest, orm: Session = Depends(get_orm_session)) -> JobResponse: + job = await self.start_run(body=body, orm=orm) + return JobResponse.model_validate(job) + + async def start_run(self, body: JobRequest, orm: Session) -> Job: + project = await self.get_project(orm=orm) + run_request = RunJobRequest(inputs=body.inputs, callback_url=body.callback_url) + + initiate_run_view = InitiateRunView() + initiate_run_view.request = self.request + deployment_response = await initiate_run_view.__call__( + project_id=str(project.id), + body=run_request, + orm=orm + ) + + job = Job( + name=f"agent-job-{deployment_response.job_id}", + image_url="", + namespace="", + ) + + return JobResponse( + id=deployment_response.job_id, + agent_id=project.id, + job=job + ) + +class JobStatusView(AuthenticatedByKeyAgentAPIView): + __name__ = "Get Job" + __doc__ = """ + Get details about the current project. + + This endpoint will always return the project associated with the `API_KEY` used for authentication. + """ + + async def __call__(self, orm: Session = Depends(get_orm_session)) -> JobResponse: + job = await self.get_job(orm=orm) + return JobResponse.model_validate(job) + + async def get_job(self, orm: Session) -> Job: + """Get job details - implement based on your requirements.""" + # This is a placeholder implementation + # You'll need to implement this based on how you want to retrieve job information + raise NotImplementedError("get_job method not implemented") + + +class JobHistoryView(AuthenticatedByKeyAgentAPIView): + __name__ = "Get Project" + __doc__ = """ + Get details about the current project. + + This endpoint will always return the project associated with the `API_KEY` used for authentication. + """ + + async def __call__(self, orm: Session = Depends(get_orm_session)) -> JobResponse: + project = await self.get_project(orm=orm) + return JobResponse.model_validate(project) + + async def get_project(self, orm: Session) -> Job: + """Get project details - implement based on your requirements.""" + # This is a placeholder implementation + # You'll need to implement this based on how you want to retrieve project information + raise NotImplementedError("get_project method not implemented") \ No newline at end of file diff --git a/app/api/agentops/public/app.py b/app/api/agentops/public/app.py new file mode 100644 index 000000000..016d0cad2 --- /dev/null +++ b/app/api/agentops/public/app.py @@ -0,0 +1,22 @@ +from fastapi import FastAPI, APIRouter + +from agentops.common.middleware import ( + CacheControlMiddleware, + DefaultContentTypeMiddleware, + ExceptionMiddleware, +) +from agentops.common.route_config import register_routes + +from .routes import route_config + +__all__ = ["app"] + +app = FastAPI(title="AgentOps Public API") + +app.add_middleware(DefaultContentTypeMiddleware) +app.add_middleware(CacheControlMiddleware) +app.add_middleware(ExceptionMiddleware) + +router = APIRouter(prefix="/v1") +register_routes(router, route_config, prefix="/public/v1") +app.include_router(router) diff --git a/app/api/agentops/public/routes.py b/app/api/agentops/public/routes.py new file mode 100644 index 000000000..aad87b1b1 --- /dev/null +++ b/app/api/agentops/public/routes.py @@ -0,0 +1,59 @@ +from agentops.common.route_config import RouteConfig +from .agent.job import KickoffRunView +from .v1.auth import AccessTokenView +from .v1.projects import ProjectView +from .v1.traces import TraceView, TraceMetricsView +from .v1.spans import SpanView, SpanMetricsView + +__all__ = ["route_config"] + + +route_config: list[RouteConfig] = [ + # auth routes + RouteConfig( + name='get_access_token', + path="/auth/access_token", + endpoint=AccessTokenView, + methods=["POST"], + ), + + # obserability routes + RouteConfig( + name='get_project', + path="/project", + endpoint=ProjectView, + methods=["GET"], + ), + RouteConfig( + name='get_trace', + path="/traces/{trace_id}", + endpoint=TraceView, + methods=["GET"], + ), + RouteConfig( + name='get_trace_metrics', + path="/traces/{trace_id}/metrics", + endpoint=TraceMetricsView, + methods=["GET"], + ), + RouteConfig( + name='get_span', + path="/spans/{span_id}", + endpoint=SpanView, + methods=["GET"], + ), + RouteConfig( + name='get_span_metrics', + path="/spans/{span_id}/metrics", + endpoint=SpanMetricsView, + methods=["GET"], + ), + + # agent routes + RouteConfig( + name='kickoff_run', + path="/agent/run", + endpoint=KickoffRunView, + methods=["POST"], + ), +] diff --git a/app/api/agentops/public/v1/__init__.py b/app/api/agentops/public/v1/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/api/agentops/public/v1/auth.py b/app/api/agentops/public/v1/auth.py new file mode 100644 index 000000000..77d646aa3 --- /dev/null +++ b/app/api/agentops/public/v1/auth.py @@ -0,0 +1,31 @@ +import pydantic +from fastapi import Depends +from agentops.api.auth import JWT_EXPIRATION_DAYS, generate_jwt +from agentops.common.orm import Session, get_orm_session +from .base import UnauthenticatedPublicAPIView, BaseResponse + + +class AuthTokenRequest(pydantic.BaseModel): + api_key: str + + +class AuthTokenResponse(BaseResponse): + bearer: str + + +class AccessTokenView(UnauthenticatedPublicAPIView): + __name__ = "Get Access Token" + __doc__ = f""" + Convert an `API_KEY` to a bearer token for use with other endpoints. + + All requests using this token will be scoped to the project associated with the + provided `API_KEY`. This token is valid for {JWT_EXPIRATION_DAYS} days. + """ + + async def __call__( + self, body: AuthTokenRequest, orm: Session = Depends(get_orm_session) + ) -> AuthTokenResponse: + project = await self.get_project(api_key=body.api_key, orm=orm) + return AuthTokenResponse( + bearer=generate_jwt(project=project), + ) diff --git a/app/api/agentops/public/v1/base.py b/app/api/agentops/public/v1/base.py new file mode 100644 index 000000000..3046e663c --- /dev/null +++ b/app/api/agentops/public/v1/base.py @@ -0,0 +1,106 @@ +from typing import TypeVar +from abc import ABC +import uuid +import pydantic +from fastapi import Request, HTTPException, Depends +from agentops.common.route_config import BaseView +from agentops.common.orm import Session, get_orm_session +from agentops.api.auth import JWTPayload, verify_jwt +from agentops.opsboard.models import BaseProjectModel, ProjectModel, SparseProjectModel + + +class BaseResponse(pydantic.BaseModel): + """ + Base response model for all API responses. + """ + + model_config = pydantic.ConfigDict( + from_attributes=True, + ) + + +TBaseResponse = TypeVar("TBaseResponse", bound=BaseResponse) + + +class BasePublicAPIView(BaseView, ABC): + """ + Base view for public API endpoints. + This class can be extended to create specific views for different endpoints. + """ + + def _verify_project_has_access(self, project: BaseProjectModel) -> None: + """Check if project has access to this endpoint (not on free plan).""" + if not project: + raise HTTPException(status_code=404, detail="Project not found") + + """Hobby/free plan access to the MCP server. + TODO: When this code is uncommented to block free plan access again, + also uncomment the test: test_get_access_token_free_plan_blocked + if project.is_freeplan: + raise HTTPException( + status_code=403, detail="This endpoint is not available for free plan projects." + ) + """ + + @classmethod + async def create(cls, request: Request) -> "BasePublicAPIView": + """Create an instance of the view with the request.""" + # we use a constructor to allow us to execute async methods on creation + instance = await super().create(request=request) + return instance + + +class UnauthenticatedPublicAPIView(BasePublicAPIView, ABC): + """ + Base view for public API endpoints. + """ + + def _validate_api_key(self, api_key: str) -> None: + """Validate the API key format.""" + if not api_key: + raise HTTPException(status_code=400, detail="api_key is required") + + try: + uuid.UUID(api_key) + except ValueError: + raise HTTPException(status_code=400, detail="Invalid api_key format") + + async def get_project(self, *, api_key: str, orm: Session = Depends(get_orm_session)) -> ProjectModel: + """Retrieves the full project model via API key authentication.""" + self._validate_api_key(api_key) + project = ProjectModel.get_by_api_key(orm, api_key) + self._verify_project_has_access(project) + return project + + +class AuthenticatedPublicAPIView(BasePublicAPIView, ABC): + """ + Base view for authenticated public API endpoints. + """ + + def _get_auth_payload(self) -> JWTPayload: + """Extract and verify JWT payload from the request headers.""" + auth_header: str = self.request.headers.get("Authorization") + + if not auth_header or not auth_header.startswith("Bearer "): + raise HTTPException(status_code=400, detail="Missing or invalid Authorization header") + + bearer: str = auth_header.split(" ")[1] + try: + return verify_jwt(bearer) + except Exception: + raise HTTPException(status_code=400, detail="Invalid Bearer token") + + async def get_sparse_project(self) -> SparseProjectModel: + """Get sparse project for authenticated use cases via JWT.""" + payload: JWTPayload = self._get_auth_payload() + project = SparseProjectModel.from_auth_payload(payload) + self._verify_project_has_access(project) + return project + + async def get_project(self, orm: Session = Depends(get_orm_session)) -> ProjectModel: + """Get full project model for authenticated use cases via JWT.""" + sparse_project = await self.get_sparse_project() + project = ProjectModel.get_by_id(orm, sparse_project.id) + self._verify_project_has_access(project) + return project diff --git a/app/api/agentops/public/v1/projects.py b/app/api/agentops/public/v1/projects.py new file mode 100644 index 000000000..d43b3c600 --- /dev/null +++ b/app/api/agentops/public/v1/projects.py @@ -0,0 +1,28 @@ +import pydantic +from fastapi import Depends +from agentops.common.orm import Session, get_orm_session +from .base import AuthenticatedPublicAPIView, BaseResponse + + +class ProjectResponse(BaseResponse): + id: str + name: str + environment: str + + @pydantic.field_validator("id", mode="before") + @classmethod + def validate_uuid(cls, v): + return str(v) + + +class ProjectView(AuthenticatedPublicAPIView): + __name__ = "Get Project" + __doc__ = """ + Get details about the current project. + + This endpoint will always return the project associated with the `API_KEY` used for authentication. + """ + + async def __call__(self, orm: Session = Depends(get_orm_session)) -> ProjectResponse: + project = await self.get_project(orm=orm) + return ProjectResponse.model_validate(project) diff --git a/app/api/agentops/public/v1/spans.py b/app/api/agentops/public/v1/spans.py new file mode 100644 index 000000000..f3c37dc9a --- /dev/null +++ b/app/api/agentops/public/v1/spans.py @@ -0,0 +1,88 @@ +from typing import Optional, Any +from datetime import datetime +import pydantic +from fastapi import HTTPException +from agentops.common.otel import otel_attributes_to_nested +from agentops.api.models.traces import SpanModel +from agentops.api.models.span_metrics import SpanMetricsResponse +from .base import AuthenticatedPublicAPIView, BaseResponse + + +class BaseSpanView(AuthenticatedPublicAPIView): + """ + Base view for span-related API endpoints. + This class can be extended to create specific views for different span endpoints. + """ + + async def get_span(self, span_id: str) -> SpanModel: + project = await self.get_sparse_project() + + if not span_id: + raise HTTPException(status_code=400, detail="span_id is required") + + spans = await SpanModel.select( + filters={ + "span_id": span_id, + } + ) + + if not len(spans): + raise HTTPException(status_code=404, detail="Span not found") + + span = spans[0] + if not span.project_id == str(project.id): + raise HTTPException(status_code=404, detail="Span not found") + + return span + + +class SpanResponse(BaseResponse): + span_id: str + parent_span_id: Optional[str] = None + + span_name: str + span_kind: str + service_name: str + + start_time: str + end_time: str + duration: int + status_code: str + status_message: Optional[str] = None + + attributes: dict[str, Any] = pydantic.Field(default_factory=dict) + resource_attributes: dict[str, Any] = pydantic.Field(default_factory=dict) + span_attributes: dict[str, Any] = pydantic.Field(default_factory=dict) + + @pydantic.field_validator('start_time', 'end_time', mode='before') + @classmethod + def format_datetime(cls, v: datetime) -> str: + return v.isoformat() + + @pydantic.field_validator('attributes', 'resource_attributes', 'span_attributes', mode='before') + @classmethod + def format_attributes(cls, v: dict[str, str]) -> dict[str, Any]: + return otel_attributes_to_nested(v) + + +class SpanView(BaseSpanView): + __name__ = "Get Span" + __doc__ = """ + Get all details about a span, including the full attribute payloads. + """ + + async def __call__(self, span_id: str) -> SpanResponse: + span = await self.get_span(span_id) + return SpanResponse.model_validate(span) + + +class SpanMetricsView(BaseSpanView): + __name__ = "Get Span Metrics" + __doc__ = """ + Get metrics for a span. + """ + + async def __call__(self, span_id: str) -> SpanMetricsResponse: + # use the internal trace metrics cuz it's easier. + span = await self.get_span(span_id) + return SpanMetricsResponse.from_span_with_metrics(span) diff --git a/app/api/agentops/public/v1/traces.py b/app/api/agentops/public/v1/traces.py new file mode 100644 index 000000000..28cc12193 --- /dev/null +++ b/app/api/agentops/public/v1/traces.py @@ -0,0 +1,80 @@ +from typing import Optional +from datetime import datetime +import pydantic +from fastapi import HTTPException +from agentops.api.models.traces import TraceModel +from agentops.api.models.span_metrics import TraceMetricsResponse +from .base import AuthenticatedPublicAPIView, BaseResponse + + +class BaseTraceView(AuthenticatedPublicAPIView): + """ + Base view for trace-related API endpoints. + This class can be extended to create specific views for different trace endpoints. + """ + + async def get_trace(self, trace_id: str) -> TraceModel: + project = await self.get_sparse_project() + + if not trace_id: + raise HTTPException(status_code=400, detail="trace_id is required") + + trace = await TraceModel.select( + filters={ + "trace_id": trace_id, + } + ) + + if not trace or not len(trace.spans): + raise HTTPException(status_code=404, detail="Trace not found") + + if not trace.project_id == str(project.id): + raise HTTPException(status_code=404, detail="Trace not found") + + return trace + + +class TraceResponse(BaseResponse): + class SpanSummaryResponse(BaseResponse): + span_id: str + parent_span_id: Optional[str] + span_name: str + span_kind: str + start_time: str + end_time: str + duration: int + status_code: str + status_message: str + + @pydantic.field_validator('start_time', 'end_time', mode='before') + @classmethod + def format_datetime(cls, v: datetime) -> str: + return v.isoformat() + + trace_id: str + project_id: str + tags: list[str] + spans: list[SpanSummaryResponse] + + +class TraceView(BaseTraceView): + __name__ = "Get Trace" + __doc__ = """ + Get details about a trace with summarized information about its spans. + """ + + async def __call__(self, trace_id: str) -> TraceResponse: + trace = await self.get_trace(trace_id) + return TraceResponse.model_validate(trace) + + +class TraceMetricsView(BaseTraceView): + __name__ = "Get Trace Metrics" + __doc__ = """ + Get aggregated metrics data for a trace. + """ + + async def __call__(self, trace_id: str) -> TraceMetricsResponse: + # use the internal trace metrics cuz it's easier. + trace = await self.get_trace(trace_id) + return TraceMetricsResponse.from_trace_with_metrics(trace) diff --git a/app/api/billing_flowchart.svg b/app/api/billing_flowchart.svg new file mode 100644 index 000000000..934cf5371 --- /dev/null +++ b/app/api/billing_flowchart.svg @@ -0,0 +1 @@ +
No
Yes
Secret Admin Action
Invite sent
Remove member
Invite sent
Remove member
Under limit
Over limit
Legacy sub exists
User Creates Organization
Owner marked as is_paid=true
Org status: free
User wants to upgrade?
Free Plan
ā€¢ Max 3 users
ā€¢ Max 3 projects
ā€¢ Limited features
User selects plan & quantity
in frontend
šŸ”‘ Lifetime Pro
Manual DB Update:
ā€¢ prem_status = 'pro'
ā€¢ subscription_id = NULL
create_checkout_session()
Stripe Checkout
User pays for initial seats
(e.g., $120 for 3 seats)
Stripe webhook
subscription.created
update_org_subscription()
ā€¢ Mark ALL members as paid
ā€¢ Set prem_status = 'pro'
ā€¢ Set subscription_id
Active Subscription
Usage tracking begins
šŸŽ Lifetime Pro Active
ā€¢ Unlimited features
ā€¢ No billing cycles
ā€¢ No Stripe integration
Org management events
Lifetime org events
invite_to_org()
Email with magic link
accept_org_invite()
ā€¢ New member: is_paid=true
ā€¢ Update Stripe quantity
Proration charge
for partial month
remove_from_org()
ā€¢ Delete user_org record
ā€¢ Update Stripe quantity
Proration credit
for partial month
invite_to_org()
Email with magic link
accept_org_invite()
ā€¢ New member: is_paid=true
ā€¢ NO Stripe update (subscription_id=NULL)
remove_from_org()
ā€¢ Delete user_org record
ā€¢ NO Stripe update (subscription_id=NULL)
Monthly Billing Cycle
End of subscription period
Calculate Monthly Bill
Seat Costs
current_member_count Ɨ $40
Usage Costs
ā€¢ Tokens: quantity Ć· 1000 Ɨ $0.02
ā€¢ Spans: quantity Ɨ $0.001
Generate Stripe Invoice
create_billing_period_snapshot()
Store in database
Customer charged
automatically
User invites others
Free user joins
is_paid=false
Invitation blocked
Must upgrade first
Legacy transition?
Schedule new subscription
to start when legacy ends
Legacy expires
New subscription activates
šŸ’Ž Lifetime Billing
ā€¢ No monthly charges
ā€¢ No usage billing
ā€¢ Unlimited everything
ā€¢ Zero cost forever
 \ No newline at end of file diff --git a/app/api/docs/clickhouse_orm.md b/app/api/docs/clickhouse_orm.md new file mode 100644 index 000000000..104f67ac1 --- /dev/null +++ b/app/api/docs/clickhouse_orm.md @@ -0,0 +1,261 @@ +# Custom Clickhouse ORM Documentation + +## Overview + +This custom ORM provides a Pydantic-based interface to Clickhouse databases, offering strong typing, async query execution, and flexible query building. It consists of two main model types: + +1. `ClickhouseModel` - Base model for single table queries with filtering and search support +2. `ClickhouseAggregatedModel` - Model for executing multiple parallel queries + +## `ClickhouseModel` + +### Purpose + +Provides a standardized interface for querying Clickhouse tables with support for filtering, field selection, and pagination. + +### Key Features + +- Automatic parameter binding and SQL injection prevention +- Type-safe query results via Pydantic models +- Flexible field selection and filtering +- String-based search functionality across multiple fields +- Clean SQL generation without unnecessary clauses +- Pagination support (limit/offset) +- Async execution + +### Configuration + +When creating a model that inherits from `ClickhouseModel`, define these class variables: + +```python +class MyModel(ClickhouseModel): + # Required: The Clickhouse table name + table_name = "my_table" + + # Field mapping: DB column names to Python attribute names + selectable_fields = { + "Id": "id", # Maps DB column "Id" to Python attr "id" + "Timestamp": "timestamp", + "ProjectId": "project_id" + } + + # Filterable fields with operators + filterable_fields = { + # Python attr name: (comparison operator, DB column name) + "project_id": ("=", "ProjectId"), + "start_time": (">=", "Timestamp"), + "end_time": ("<=", "Timestamp") + } + + # Searchable fields (string pattern matching) + searchable_fields = { + # Python attr name: (search operator, DB column name) + "name": ("ILIKE", "UserName"), + "description": ("ILIKE", "Description") + } + + # Define model attributes that match your selectable_fields + id: str + timestamp: datetime + project_id: str +``` + +### Usage Examples + +#### Basic Query + +```python +# Get all records for a project +results = await MyModel.select(filters={"project_id": "abc123"}) +``` + +#### With Pagination + +```python +# Get the first 20 records, ordered by timestamp +results = await MyModel.select( + filters={"project_id": "abc123"}, + order_by="timestamp DESC", + limit=20 +) + +# Get the next 20 +results = await MyModel.select( + filters={"project_id": "abc123"}, + order_by="timestamp DESC", + limit=20, + offset=20 +) +``` + +#### With Date Range + +```python +# Get records in a date range +results = await MyModel.select(filters={ + "project_id": "abc123", + "start_time": datetime(2023, 1, 1), + "end_time": datetime(2023, 1, 31) +}) +``` + +#### With Search + +```python +# Search for records containing "authentication" in searchable fields +results = await MyModel.select( + filters={"project_id": "abc123"}, + search="authentication" +) + +# The search is applied to all fields defined in searchable_fields +# Wildcards (%) are automatically added for LIKE/ILIKE searches if not present +# Search conditions are combined with OR (matches any field) +``` + +#### Combining Filters and Search + +```python +# Filter by project and date range, then search within those results +results = await MyModel.select( + filters={ + "project_id": "abc123", + "start_time": datetime(2023, 1, 1), + "end_time": datetime(2023, 1, 31) + }, + search="error", + limit=50 +) +``` + +## `ClickhouseAggregatedModel` + +### Purpose + +Allows combining results from multiple `ClickhouseModel` queries into a single aggregated model. It executes all queries concurrently for better performance. + +### Key Features + +- Parallel query execution +- Results aggregation into a single model +- Type safety through Pydantic validation + +### Configuration + +```python +class MyAggregatedModel(ClickhouseAggregatedModel): + # List of model classes to query + aggregated_models = (ModelA, ModelB, ModelC) + + # Define how to store the results + model_a_results: list[ModelA] = pydantic.Field(default_factory=list) + model_b_results: list[ModelB] = pydantic.Field(default_factory=list) + model_c_results: list[ModelC] = pydantic.Field(default_factory=list) + + # Custom constructor to handle results from each model + def __init__(self, model_a_data, model_b_data, model_c_data): + super().__init__( + model_a_results=[ModelA(**row) for row in model_a_data], + model_b_results=[ModelB(**row) for row in model_b_data], + model_c_results=[ModelC(**row) for row in model_c_data] + ) +``` + +### Usage Examples + +```python +# Get data from multiple models with shared filters and search +aggregate = await MyAggregatedModel.select( + filters={ + "project_id": "abc123", + "start_time": datetime(2023, 1, 1), + "end_time": datetime(2023, 1, 31) + }, + search="important" +) + +# Access the results +for item in aggregate.model_a_results: + print(item.id) +``` + +## Extending the ORM + +### Custom Field Mappings + +For more complex field conversions, use Pydantic validators: + +```python +class ModelWithValidation(ClickhouseModel): + # ... configuration ... + + # Create a status field based on status_code + @pydantic.field_validator('status_code', check_fields=False, mode='before') + @classmethod + def uppercase_status(cls, v: str) -> str: + return v.upper() + + # Create a computed property + @property + def is_error(self) -> bool: + return self.status_code == "ERROR" +``` + +## Best Practices + +1. **Type Safety**: Always define proper types for model attributes to leverage Pydantic's validation + +2. **Query Optimization**: Use appropriate filters and limit results for better performance + +3. **Field Selection**: Only select the fields you need + +4. **Model Composition**: Use the aggregated model for related data that's frequently queried together + +5. **Error Handling**: Handle database exceptions appropriately + +```python +try: + results = await MyModel.select(filters={"project_id": project_id}) +except Exception as e: + # Handle Clickhouse exceptions + logger.error(f"Database error: {e}") + raise HttpException(500, "Database error occurred") +``` + +## SQL Generation + +The ORM generates clean SQL without unnecessary clauses: + +1. WHERE clauses are only included when conditions exist +2. Search conditions are joined with OR (any field can match) +3. Multiple filter conditions are joined with AND (all conditions must match) + +Example SQL generated: + +```sql +SELECT Id as id, Name as name, Timestamp as timestamp +FROM users +WHERE ProjectId = %(project_id)s AND Timestamp >= %(start_time)s +ORDER BY timestamp DESC +LIMIT 20 +``` + +With search: + +```sql +SELECT Id as id, Name as name, Timestamp as timestamp +FROM users +WHERE (ProjectId = %(project_id)s) AND (Name ILIKE %(search_name)s OR Description ILIKE %(search_description)s) +LIMIT 50 +``` + +## Implementation Details + +This ORM uses `clickhouse_connect` for async communication with Clickhouse. Under the hood, it: + +1. Converts model definitions to parameterized SQL +2. Executes queries asynchronously +3. Maps result rows to Pydantic model instances +4. Handles type conversion and validation + +For advanced use cases, refer to the implementation in `api/agentops/api/db/clickhouse/models.py`. \ No newline at end of file diff --git a/app/api/fly.toml b/app/api/fly.toml new file mode 100644 index 000000000..6cd5e5896 --- /dev/null +++ b/app/api/fly.toml @@ -0,0 +1,28 @@ +# fly.toml app configuration file generated for agentops-server-next on 2024-03-18T12:59:35-07:00 +# +# See https://fly.io/docs/reference/configuration/ for information about how to use this file. +# + +app = 'agentops-server-next' +primary_region = 'sjc' +swap_size_mb = 512 + +[build] + builder = 'paketobuildpacks/builder:base' + +[env] + PORT = '8000' + +[http_service] + internal_port = 8000 + force_https = true + auto_stop_machines = true + auto_start_machines = true + min_machines_running = 1 + processes = ['app'] + +[deploy] + wait_timeout = "10m" + +[[vm]] + size = 'performance-4x' diff --git a/app/api/jockey b/app/api/jockey new file mode 120000 index 000000000..40bd4c058 --- /dev/null +++ b/app/api/jockey @@ -0,0 +1 @@ +../deploy/jockey \ No newline at end of file diff --git a/app/api/justfile b/app/api/justfile new file mode 100644 index 000000000..b20add9f4 --- /dev/null +++ b/app/api/justfile @@ -0,0 +1,15 @@ +# Default recipe to run when just is called without arguments +default: + @just --list + +# Run the API server locally using uvicorn +run: + uv run -m dotenv -f .env.dev run -- uvicorn agentops.api.app:app --host 0.0.0.0 --port 8000 + +# Run the API server with uvicorn's development server +dev: + uv run -m dotenv -f .env.dev run -- uvicorn agentops.api.app:app --host 0.0.0.0 --port 8000 --reload + +# Generate a development JWT token for testing +dev-token project_id: + @uv run python -c "from agentops.api.auth import generate_dev_token; print(generate_dev_token('{{project_id}}'))" diff --git a/app/api/openapi-spec-v2.yaml b/app/api/openapi-spec-v2.yaml new file mode 100644 index 000000000..78f9aee69 --- /dev/null +++ b/app/api/openapi-spec-v2.yaml @@ -0,0 +1,318 @@ +openapi: 3.0.3 +info: + title: AgentOps API + description: API for managing sessions, agents, threads, and events. + version: 2.0.0 +servers: + - url: https://api.agentops.ai + description: Production server +paths: + /reauthorize_jwt: + post: + summary: Reauthorize a JWT token + operationId: reauthorizeJWT + security: + - ApiKeyAuth: [] + responses: + '200': + description: Success + content: + application/json: + schema: + type: object + properties: + status: + type: string + jwt: + type: string + '400': + description: Bad request + content: + application/json: + schema: + type: object + properties: + message: + type: string + '401': + description: Unauthorized + content: + application/json: + schema: + type: string + /create_session: + post: + summary: Create a new session + operationId: createSession + security: + - ApiKeyAuth: [] + requestBody: + required: true + content: + application/json: + schema: + type: object + properties: + id: + type: string + format: uuid + init_timestamp: + type: string + format: date-time + end_timestamp: + type: string + format: date-time + end_state: + type: string + nullable: true + end_state_reason: + type: string + nullable: true + tags: + type: array + items: + type: string + nullable: true + host_env: + type: object + nullable: true + required: + - session_id + responses: + '200': + description: Session created successfully + content: + application/json: + schema: + type: object + properties: + status: + type: string + jwt: + type: string + '400': + description: Bad request + content: + application/json: + schema: + type: object + properties: + message: + type: string + '401': + description: Unauthorized + content: + application/json: + schema: + type: string + /update_session: + post: + summary: Update an existing session + operationId: updateSession + security: + - BearerAuth: [] + requestBody: + required: true + content: + application/json: + schema: + type: object + properties: + id: + type: string + format: uuid + init_timestamp: + type: string + format: date-time + nullable: true + end_timestamp: + type: string + format: date-time + nullable: true + end_state: + type: string + nullable: true + end_state_reason: + type: string + nullable: true + tags: + type: array + items: + type: string + nullable: true + host_env: + type: object + nullable: true + required: + - session_id + responses: + '200': + description: Session updated successfully + content: + application/json: + schema: + type: object + properties: + status: + type: string + token_cost: + type: string + '400': + description: Bad request + content: + application/json: + schema: + type: object + properties: + message: + type: string + '401': + description: Unauthorized + content: + application/json: + schema: + type: string + /create_agent: + post: + summary: Create a new agent + operationId: createAgent + security: + - BearerAuth: [] + responses: + '200': + description: Agent created successfully + content: + application/json: + schema: + type: string + '400': + description: Bad request + content: + application/json: + schema: + type: object + properties: + message: + type: string + '401': + description: Unauthorized + content: + application/json: + schema: + type: string + /create_thread: + post: + summary: Create a new thread for an existing session + operationId: createThread + security: + - BearerAuth: [] + responses: + '200': + description: Thread created successfully + content: + application/json: + schema: + type: string + '400': + description: Bad request + content: + application/json: + schema: + type: object + properties: + message: + type: string + '401': + description: Unauthorized + content: + application/json: + schema: + type: string + /create_events: + post: + summary: Create multiple event types in a session + operationId: createEvents + security: + - BearerAuth: [] + responses: + '200': + description: Events created successfully + content: + application/json: + schema: + type: string + '400': + description: Bad request + content: + application/json: + schema: + type: object + properties: + message: + type: string + '401': + description: Unauthorized + content: + application/json: + schema: + type: string + /update_events: + post: + summary: Update multiple events in a session + operationId: updateEvents + security: + - BearerAuth: [] + responses: + '200': + description: Events updated successfully + content: + application/json: + schema: + type: string + '400': + description: Bad request + content: + application/json: + schema: + type: object + properties: + message: + type: string + '401': + description: Unauthorized + content: + application/json: + schema: + type: string + /developer_errors: + post: + summary: Post a developer error + operationId: postDeveloperError + security: + - ApiKeyAuth: [] + responses: + '200': + description: Developer error posted successfully + content: + application/json: + schema: + type: string + '400': + description: Bad request + content: + application/json: + schema: + type: object + properties: + message: + type: string +components: + securitySchemes: + ApiKeyAuth: + type: apiKey + in: header + name: X-Agentops-Api-Key + BearerAuth: + type: http + scheme: bearer + bearerFormat: JWT diff --git a/app/api/openapi-spec.yaml b/app/api/openapi-spec.yaml new file mode 100644 index 000000000..f651bfc18 --- /dev/null +++ b/app/api/openapi-spec.yaml @@ -0,0 +1,193 @@ +openapi: 3.0.3 +info: + title: AgentOps API + description: API for managing sessions, agents, threads, and events. + version: 1.0.0 +servers: + - url: http://localhost:8000 + description: Development server + - url: https://api.agentops.ai + description: Production server +paths: + /health: + get: + summary: Health Check + responses: + '200': + description: Server Up + content: + application/json: + schema: + type: string + /sessions: + post: + summary: Create or Update a Session + requestBody: + required: true + content: + application/json: + schema: + $ref: '#/components/schemas/Session' + responses: + '200': + description: Success + content: + application/json: + schema: + type: string + '500': + description: Error + content: + application/json: + schema: + $ref: '#/components/schemas/Error' + /agents: + post: + summary: Create or Update an Agent + requestBody: + required: true + content: + application/json: + schema: + $ref: '#/components/schemas/Agent' + responses: + '200': + description: Success + content: + application/json: + schema: + type: string + '500': + description: Error + content: + application/json: + schema: + $ref: '#/components/schemas/Error' + /threads: + post: + summary: Create or Update a Thread + requestBody: + required: true + content: + application/json: + schema: + $ref: '#/components/schemas/Thread' + responses: + '200': + description: Success + content: + application/json: + schema: + type: string + '500': + description: Error + content: + application/json: + schema: + $ref: '#/components/schemas/Error' + /events: + post: + summary: Create or Update an Event + requestBody: + required: true + content: + application/json: + schema: + $ref: '#/components/schemas/Event' + responses: + '200': + description: Success + content: + application/json: + schema: + type: string + '500': + description: Error + content: + application/json: + schema: + $ref: '#/components/schemas/Error' +components: + securitySchemes: + AgentopsAuth: + type: apiKey + in: header + name: X-Agentops-Auth + schemas: + Session: + type: object + properties: + session: + type: object + properties: + session_id: + type: string + init_timestamp: + type: string + end_timestamp: + type: string + tags: + type: array + items: + type: string + end_state: + type: string + end_state_reason: + type: string + video: + type: string + host_env: + type: string + Agent: + type: object + properties: + agent: + type: object + properties: + id: + type: string + session_id: + type: string + name: + type: string + logs: + type: array + items: + type: string + Thread: + type: object + properties: + threads: + type: object + properties: + id: + type: string + session_id: + type: string + agent_id: + type: string + Event: + type: object + properties: + session_id: + type: string + events: + type: array + items: + type: object + properties: + event_type: + type: string + init_timestamp: + type: string + end_timestamp: + type: string + # Additional properties based on event type + Error: + type: object + properties: + error: + type: string + +security: + - AgentopsAuth: [] diff --git a/app/api/pyproject.toml b/app/api/pyproject.toml new file mode 100644 index 000000000..e1aa6e4bf --- /dev/null +++ b/app/api/pyproject.toml @@ -0,0 +1,96 @@ +[build-system] +requires = ["hatchling"] +build-backend = "hatchling.build" + +[project] +name = "AgentOps-API" +version = "1.0.0" +description = "AgentOps API" +requires-python = ">=3.12,<3.13" +authors = [ + { name = "Alex Reibman", email = "areibman@gmail.com" }, + { name = "Shawn Qiu", email = "siyangqiu@gmail.com" }, + { name = "Braelyn Boynton", email = "bboynton97@gmail.com" }, + { name = "Howard Gil", email = "howardbgil@gmail.com" }, + { name = "Constantin Teodorescu", email = "teocns@gmail.com" }, +] +dependencies = [ + "fastapi>=0.110.0", + "uvicorn[standard]>=0.27.0", + "httpx>=0.27.0", + "python-dotenv>=1.0.0", + "Werkzeug>=3.0.3", + "tokencost>=0.1.17", + "sentry-sdk>=1.39.1", + "jsonschema", + "pyjwt>=2.8.0", + "termcolor>=2.0.0", + "uvloop>=0.19.0", + "httpcore>=1.0.5", + "supabase>=2.12.0", + "opentelemetry-semantic-conventions>=0.43b0", + "opentelemetry-semantic-conventions-ai>=0.4.2", + "clickhouse-connect>=0.8.15", + "clickhouse-driver>=0.2.9", + "dotenv>=0.9.9", + "opentelemetry-api>=1.30.0", + "opentelemetry-sdk>=1.30.0", + "psycopg-pool>=3.2.6", + "psycopg[binary]>=3.2.5", + "pydantic>=2.10.6", + "boto3>=1.37.22", + "redis>=5.2.1", + "jinja2>=3.1.6", + "sqlalchemy>=2.0.40", + "greenlet>=3.1.1", + "stripe", + "jockey", +] + +[tool.uv.sources] +jockey = { path = "jockey", editable = true } + +[dependency-groups] +dev = [ + "pytest>=8.0.0", # Testing framework with good async support + "pytest-depends", # For testing complex agent workflows + "pytest-asyncio", # Async test support for testing concurrent agent operations + "pytest-mock", # Mocking capabilities for isolating agent components + "pyfakefs", # File system testing + "pytest-recording", # Alternative to pytest-vcr with better Python 3.x support + # TODO: Use release version after vcrpy is released with this fix. + "vcrpy @ git+https://github.com/kevin1024/vcrpy.git@5f1b20c4ca4a18c1fc8cfe049d7df12ca0659c9b", + # "agentops @ git+https://github.com/AgentOps-AI/agentops.git@bd621f1ae76f0881aa05d780d70054d8a5caee07", + # Code quality and type checking + "python-dotenv", # Environment management for secure testing + # Agent integration testing + "pytest-sugar>=1.0.0", + "pdbpp>=0.10.3", + "pytest-env>=1.1.5", + "pyinstrument>=5.0.1", +] + +[tool.hatch.metadata] +allow-direct-references = true + +[tool.hatch.build.targets.wheel] +packages = ["agentops"] + +[tool.pytest.ini_options] +asyncio_mode = "auto" +asyncio_default_fixture_loop_scope = "session" +testpaths = ["tests"] +addopts = "--tb=short -p no:warnings -s --import-mode=importlib --ignore=tests/integration" +faulthandler_timeout = 30 +timeout = 60 +disable_socket = true +pythonpath = ["../deploy"] + +[tool.pytest_env] +# https://github.com/pytest-dev/pytest-env +JWT_SECRET_KEY = "test" + +[tool.mypy] +plugins = ["pydantic.mypy"] + + diff --git a/app/api/redis_server/Dockerfile b/app/api/redis_server/Dockerfile new file mode 100644 index 000000000..c5df5ce9b --- /dev/null +++ b/app/api/redis_server/Dockerfile @@ -0,0 +1,10 @@ +FROM redis:7-alpine + +# define persistent volume for redis data +VOLUME ["/data"] + +# set working directory to the data directory +WORKDIR /data + +# launch redis server +CMD ["redis-server"] \ No newline at end of file diff --git a/app/api/run.py b/app/api/run.py new file mode 100644 index 000000000..30c2e96da --- /dev/null +++ b/app/api/run.py @@ -0,0 +1,43 @@ +import asyncio +import logging +import sys +from pathlib import Path + +import uvicorn +from dotenv import load_dotenv +from tokencost import update_token_costs + +# HACK to add deploy directory to Python path for jockey imports +deploy_path = Path(__file__).parent.parent / "deploy" +if deploy_path.exists(): + sys.path.insert(0, str(deploy_path)) + + +load_dotenv() +from agentops.app import app + + +async def update_tokencosts_periodically(): + while True: + logging.info("Updating Token Costs") + await update_token_costs() + await asyncio.sleep(3600) + + +async def run_server(): + # Start the token cost update task + update_tokencosts_task = asyncio.create_task(update_tokencosts_periodically()) + + # Configure uvicorn server + config = uvicorn.Config(app=app, host="0.0.0.0", port=8000, reload=True, log_level="info") + + # Create and start the server + server = uvicorn.Server(config) + await server.serve() + + # Wait for the token cost update task + await update_tokencosts_task + + +if __name__ == "__main__": + asyncio.run(run_server()) diff --git a/app/api/sql/otel_traces_improved.sql b/app/api/sql/otel_traces_improved.sql new file mode 100644 index 000000000..6cc58633b --- /dev/null +++ b/app/api/sql/otel_traces_improved.sql @@ -0,0 +1,76 @@ +TRUNCATE TABLE otel_traces_legacy; + +CREATE TABLE otel_traces +( + Timestamp DateTime64(9) CODEC(Delta(8), ZSTD(1)), + project_id String MATERIALIZED ResourceAttributes['agentops.project.id'], + TraceId String CODEC(ZSTD(1)), + SpanId String CODEC(ZSTD(1)), + ParentSpanId String CODEC(ZSTD(1)), + TraceState String CODEC(ZSTD(1)), + SpanName LowCardinality(String) CODEC(ZSTD(1)), + SpanKind LowCardinality(String) CODEC(ZSTD(1)), + ServiceName LowCardinality(String) CODEC(ZSTD(1)), + ResourceAttributes Map(LowCardinality(String), String) CODEC(ZSTD(1)), + ScopeName String CODEC(ZSTD(1)), + ScopeVersion String CODEC(ZSTD(1)), + SpanAttributes Map(LowCardinality(String), String) CODEC(ZSTD(1)), + Duration UInt64 CODEC(ZSTD(1)), + StatusCode LowCardinality(String) CODEC(ZSTD(1)), + StatusMessage String CODEC(ZSTD(1)), + Events Nested ( + Timestamp DateTime64(9), + Name LowCardinality(String), + Attributes Map(LowCardinality(String), String) + ) CODEC(ZSTD(1)), + Links Nested ( + TraceId String, + SpanId String, + TraceState String, + Attributes Map(LowCardinality(String), String) + ) CODEC(ZSTD(1)), + INDEX idx_trace_id TraceId TYPE bloom_filter(0.001) GRANULARITY 16, + INDEX idx_span_id SpanId TYPE bloom_filter(0.01) GRANULARITY 32, + INDEX idx_project_id project_id TYPE bloom_filter(0.001) GRANULARITY 16 +) ENGINE = MergeTree() +PARTITION BY toYYYYMM(Timestamp) +ORDER BY (project_id, Timestamp) -- Changed to optimize for project_id filtering +SETTINGS index_granularity = 8192 + + +----- + +INSERT INTO otel_traces_legacy ( + Timestamp, + TraceId, + SpanId, + ParentSpanId, + TraceState, + SpanName, + SpanKind, + ServiceName, + ResourceAttributes, + ScopeName, + ScopeVersion, + SpanAttributes, + Duration, + StatusCode, + StatusMessage, +) +SELECT + Timestamp, + TraceId, + SpanId, + ParentSpanId, + TraceState, + SpanName, + SpanKind, + ServiceName, + ResourceAttributes, + ScopeName, + ScopeVersion, + SpanAttributes, + toUInt64(Duration) AS Duration, -- Convert Int64 to UInt64 + StatusCode, + StatusMessage +FROM otel_traces LIMIT 3 diff --git a/app/api/sql/use_cases.sql b/app/api/sql/use_cases.sql new file mode 100644 index 000000000..087c64d0b --- /dev/null +++ b/app/api/sql/use_cases.sql @@ -0,0 +1,36 @@ +-- Add the indexes +SELECT + TraceId, + Timestamp as timestamp, + StatusCode as status_code, + ifNull(SpanAttributes['gen_ai.usage.prompt_tokens'], 0) as prompt_tokens, + ifNull(SpanAttributes['gen_ai.usage.completion_tokens'], 0) as completion_tokens, + ifNull(SpanAttributes['gen_ai.usage.total_tokens'], 0) as total_tokens, + ifNull(SpanAttributes['gen_ai.request.model'], '') as request_model, + ifNull(SpanAttributes['gen_ai.response.model'], '') as response_model, + ifNull(SpanAttributes['gen_ai.llm.model'], '') as gen_ai_llm_model, + ifNull(SpanAttributes['llm.model'], '') as llm_model, + ifNull(SpanAttributes['gen_ai.system'], '') as system + FROM otel_traces + WHERE (project_id = '6183afc9-5fc8-47a0-b1c4-a4d589d0866e') + ORDER BY Timestamp ASC + + + SELECT + min(if(Duration > 0, Duration, null)) as min_duration, + max(if(Duration > 0, Duration, null)) as max_duration, + avg(if(Duration > 0, Duration, null)) as avg_duration, + sum(if(Duration > 0, Duration, null)) as total_duration, + count() as span_count, + count(DISTINCT TraceId) as trace_count + FROM otel_traces + WHERE (project_id = '6183afc9-5fc8-47a0-b1c4-a4d589d0866e') + + + SELECT + TraceId, + sum(Duration) as trace_duration + FROM otel_traces + WHERE (project_id = '6183afc9-5fc8-47a0-b1c4-a4d589d0866e') + GROUP BY TraceId + ORDER BY trace_duration ASC diff --git a/app/api/tests/__init__.py b/app/api/tests/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/api/tests/_conftest/__init__.py b/app/api/tests/_conftest/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/api/tests/_conftest/app.py b/app/api/tests/_conftest/app.py new file mode 100644 index 000000000..6254acafe --- /dev/null +++ b/app/api/tests/_conftest/app.py @@ -0,0 +1,21 @@ +import pytest +from httpx import ASGITransport + + +__all__ = [ + "async_app_client", +] + + +@pytest.fixture +async def async_app_client(event_loop): + from httpx import AsyncClient + + from agentops.app import app + + client = AsyncClient( + transport=ASGITransport(app=app), + base_url="http://test", + ) + yield client + await client.aclose() # Properly close the client diff --git a/app/api/tests/_conftest/billing.py b/app/api/tests/_conftest/billing.py new file mode 100644 index 000000000..31626e8f2 --- /dev/null +++ b/app/api/tests/_conftest/billing.py @@ -0,0 +1,193 @@ +import pytest +from datetime import datetime, timezone, timedelta +from unittest.mock import MagicMock +from agentops.opsboard.models import BillingPeriod, OrgModel, UserOrgModel, OrgRoles, PremStatus +from .billing_constants import ( + STRIPE_SUBSCRIPTION_ID_DEFAULT, + STRIPE_CUSTOMER_ID_DEFAULT, + STRIPE_PRICE_ID_CURRENT, + STRIPE_PRICE_ID_LEGACY, + STRIPE_ITEM_ID_DEFAULT, + SEAT_PRICE_DEFAULT, +) + + +@pytest.fixture +def billing_period_factory(): + """Factory for creating billing periods with unique, predictable dates.""" + counter = 0 + + def create_period(org_id, **kwargs): + nonlocal counter + counter += 1 + + # Use year 2025 + counter to ensure uniqueness and avoid past dates + base_date = datetime(2025, 1, 1, tzinfo=timezone.utc) + timedelta(days=counter * 2) + + defaults = { + 'period_start': base_date, + 'period_end': base_date + timedelta(days=1), + 'seat_cost': 0, + 'seat_count': 0, + 'usage_costs': {}, + 'usage_quantities': {}, + 'total_cost': 0, + 'status': 'pending', + } + defaults.update(kwargs) + + return BillingPeriod(org_id=org_id, **defaults) + + return create_period + + +@pytest.fixture +def mock_stripe_subscription(): + """Centralized Stripe subscription mock with consistent behavior.""" + mock_sub = MagicMock() + mock_sub.id = STRIPE_SUBSCRIPTION_ID_DEFAULT + mock_sub.customer = STRIPE_CUSTOMER_ID_DEFAULT + mock_sub.status = "active" + mock_sub.cancel_at_period_end = False + + # Use dynamic timestamps to avoid hardcoded values + now = datetime.now() + mock_sub.current_period_start = int(now.timestamp()) + mock_sub.current_period_end = int((now + timedelta(days=30)).timestamp()) + + # Standard subscription item + mock_item = { + 'id': STRIPE_ITEM_ID_DEFAULT, + 'price': { + 'id': STRIPE_PRICE_ID_CURRENT, # Matches STRIPE_SUBSCRIPTION_PRICE_ID + 'unit_amount': SEAT_PRICE_DEFAULT, # Amount in cents + 'currency': 'usd', + 'recurring': {'usage_type': 'licensed', 'interval': 'month', 'interval_count': 1}, + }, + 'quantity': 2, + } + + mock_sub.items = MagicMock() + mock_sub.items.data = [mock_item] + + def mock_get(key, default=None): + if key == 'cancel_at_period_end': + return mock_sub.cancel_at_period_end + elif key == 'items': + return {'data': mock_sub.items.data} + elif key == 'current_period_end': + return mock_sub.current_period_end + elif key == 'current_period_start': + return mock_sub.current_period_start + elif key == 'status': + return mock_sub.status + return default + + mock_sub.get = mock_get + return mock_sub + + +@pytest.fixture +def mock_stripe_subscription_legacy(): + """Specialized mock for legacy subscription tests.""" + mock_sub = MagicMock() + mock_sub.id = "sub_legacy_123" + mock_sub.customer = STRIPE_CUSTOMER_ID_DEFAULT + mock_sub.status = "active" + mock_sub.cancel_at_period_end = False + + now = datetime.now() + mock_sub.current_period_start = int(now.timestamp()) + mock_sub.current_period_end = int((now + timedelta(days=30)).timestamp()) + + # Legacy subscription with old price ID + legacy_item = { + 'id': 'si_legacy_123', + 'price': { + 'id': STRIPE_PRICE_ID_LEGACY, # Different from current + 'product': {'name': 'Legacy Seat Plan'}, + }, + 'quantity': 1, + } + mock_sub.items = MagicMock() + mock_sub.items.data = [legacy_item] + + def mock_get(key, default=None): + if key == 'cancel_at_period_end': + return mock_sub.cancel_at_period_end + elif key == 'items': + return {'data': mock_sub.items.data} + elif key == 'current_period_end': + return mock_sub.current_period_end + elif key == 'current_period_start': + return mock_sub.current_period_start + elif key == 'status': + return mock_sub.status + return default + + mock_sub.get = mock_get + return mock_sub + + +@pytest.fixture +def org_factory(): + """Factory for creating organizations with different configurations.""" + created_orgs = [] + + def create_org(orm_session, owner_user, **kwargs): + defaults = { + 'name': f"Test Org {len(created_orgs) + 1}", + 'prem_status': PremStatus.free, + 'subscription_id': None, + } + defaults.update(kwargs) + + org = OrgModel(**defaults) + orm_session.add(org) + orm_session.flush() + + # Add owner relationship + owner_member = UserOrgModel( + user_id=owner_user.id, + org_id=org.id, + role=OrgRoles.owner, + user_email=owner_user.email, + is_paid=defaults['prem_status'] == PremStatus.pro, + ) + orm_session.add(owner_member) + orm_session.flush() + + created_orgs.append(org) + return org + + return create_org + + +@pytest.fixture +def test_pro_org(orm_session, test_user, org_factory): + """Standard pro organization for billing tests.""" + return org_factory( + orm_session, + test_user, + name="Test Pro Org", + prem_status=PremStatus.pro, + subscription_id=STRIPE_SUBSCRIPTION_ID_DEFAULT, + ) + + +@pytest.fixture +def test_free_org(orm_session, test_user, org_factory): + """Standard free organization for testing upgrades.""" + return org_factory(orm_session, test_user, name="Test Free Org", prem_status=PremStatus.free) + + +def assert_billing_error(exception_info, expected_code, expected_message_fragment): + """Standard assertion for billing-related errors.""" + assert exception_info.value.status_code == expected_code + assert expected_message_fragment in str(exception_info.value.detail) + + +def assert_stripe_error_handling(exception_info): + """Standard assertion for Stripe API error handling.""" + assert exception_info.value.status_code == 500 + assert "Stripe API error" in exception_info.value.detail diff --git a/app/api/tests/_conftest/billing_constants.py b/app/api/tests/_conftest/billing_constants.py new file mode 100644 index 000000000..9c3c0fad3 --- /dev/null +++ b/app/api/tests/_conftest/billing_constants.py @@ -0,0 +1,19 @@ +# Stripe Test IDs +STRIPE_SUBSCRIPTION_ID_DEFAULT = "sub_test123" +STRIPE_CUSTOMER_ID_DEFAULT = "cus_test123" +STRIPE_PRICE_ID_CURRENT = "price_test123" +STRIPE_PRICE_ID_LEGACY = "price_legacy_old_123" +STRIPE_ITEM_ID_DEFAULT = "si_test123" + +# Pricing (in cents) +SEAT_PRICE_DEFAULT = 4000 # $40.00 +SEAT_PRICE_PREMIUM = 5000 # $50.00 +TOKEN_COST_SAMPLE = 150 # Sample token cost +SPAN_COST_SAMPLE = 50 # Sample span cost + +# Usage Quantities +TOKEN_QUANTITY_SAMPLE = 750000 +SPAN_QUANTITY_SAMPLE = 50 + +# Timestamps (Unix timestamps for consistency) +FUTURE_TIMESTAMP = 1735689600 # 2025-01-01 diff --git a/app/api/tests/_conftest/clickhouse.py b/app/api/tests/_conftest/clickhouse.py new file mode 100644 index 000000000..55a2db0a2 --- /dev/null +++ b/app/api/tests/_conftest/clickhouse.py @@ -0,0 +1,279 @@ +import os +import subprocess +import time +from pathlib import Path +import pytest +from .common import REPO_ROOT, is_github_actions, get_free_port + + +# these vars are also hard-coded inside the `clickhouse_server` Dockerfile and the +# github actions workflow +TEST_CLICKHOUSE_HOST = "localhost" +TEST_CLICKHOUSE_PORT = get_free_port(8123) +TEST_CLICKHOUSE_HTTP_PORT = get_free_port(9000) +TEST_CLICKHOUSE_DATABASE = "otel_2" # this has to be the same as prod because the schema has it hard-coded +TEST_CLICKHOUSE_USER = "default" +TEST_CLICKHOUSE_PASSWORD = "clickhouse" + +CLICKHOUSE_MIGRATIONS_DIR = REPO_ROOT / 'clickhouse' / 'migrations' +CLICKHOUSE_DOCKER_IMAGE_PATH = Path(__file__).parent / "clickhouse_server" / "Dockerfile" +CLICKHOUSE_DOCKER_CONTAINER_NAME = "agentops-test-clickhouse" + +__all__ = [ + 'clickhouse_verify_test_environment', + 'clickhouse_setup_db_server', + 'clickhouse_client', + 'async_clickhouse_client', +] + + +@pytest.fixture(scope="session", autouse=True) +def clickhouse_verify_test_environment(): + """Verify we don't have access to production credentials before running tests.""" + message = "%s environment variable is set! This risks connecting to production." + assert not os.environ.get('CLICKHOUSE_HOST'), message % "CLICKHOUSE_HOST" + assert not os.environ.get('CLICKHOUSE_PORT'), message % "CLICKHOUSE_PORT" + assert not os.environ.get('CLICKHOUSE_DATABASE'), message % "CLICKHOUSE_DATABASE" + assert not os.environ.get('CLICKHOUSE_USER'), message % "CLICKHOUSE_USER" + assert not os.environ.get('CLICKHOUSE_PASSWORD'), message % "CLICKHOUSE_PASSWORD" + + +def clickhouse_start_docker(): + """Start the Docker container for ClickHouse.""" + print("Starting ClickHouse Docker container...") + + # Clean up any existing container + subprocess.run(['docker', 'stop', CLICKHOUSE_DOCKER_CONTAINER_NAME], check=False) + subprocess.run(['docker', 'rm', CLICKHOUSE_DOCKER_CONTAINER_NAME], check=False) + + # Build the Docker image + build_command = [ + 'docker', + 'build', + '-t', + CLICKHOUSE_DOCKER_CONTAINER_NAME, + '-f', + str(CLICKHOUSE_DOCKER_IMAGE_PATH), + str(CLICKHOUSE_DOCKER_IMAGE_PATH.parent), + ] + print(' '.join(build_command)) + subprocess.run(build_command, check=True) + + # Run the container + run_command = [ + 'docker', + 'run', + '-d', + '--name', + CLICKHOUSE_DOCKER_CONTAINER_NAME, + '-p', + f'{TEST_CLICKHOUSE_PORT}:8123', + '-p', + f'{TEST_CLICKHOUSE_HTTP_PORT}:9000', + CLICKHOUSE_DOCKER_CONTAINER_NAME, + ] + print(' '.join(run_command)) + subprocess.run(run_command, check=True) + + +def clickhouse_stop_docker(): + """Stop the Docker container.""" + print("Stopping ClickHouse Docker container...") + subprocess.run(['docker', 'stop', CLICKHOUSE_DOCKER_CONTAINER_NAME], check=True) + + +def clickhouse_verify_connection(client): + """Verify the connection to the database uses the test environment.""" + + def _get_auth_header(username: str, password: str) -> str: + from base64 import b64encode + + # from clickhouse_connect/driver/httpclient.py:126 + return 'Basic ' + b64encode(f'{username}:{password}'.encode()).decode() + + assert TEST_CLICKHOUSE_HOST in client.url + assert str(TEST_CLICKHOUSE_PORT) in client.url + assert client.database == TEST_CLICKHOUSE_DATABASE + assert client.headers['Authorization'] == _get_auth_header(TEST_CLICKHOUSE_USER, TEST_CLICKHOUSE_PASSWORD) + + +async def clickhouse_run_migrations(client): + """Run database schema initialization and migrations.""" + print("Running ClickHouse migrations...") + + # Basic setup + # extracted from prod with: + # SELECT concat('SET ', name, ' = \'', value, '\';') as settings FROM system.settings WHERE changed = 1 FORMAT TSVRaw; + setup_query = """ +SET min_joined_block_size_bytes = '524288'; +SET max_insert_threads = '2'; +SET max_insert_delayed_streams_for_parallel_write = '50'; +SET max_threads = '5'; +SET use_concurrency_control = '0'; +SET use_hedged_requests = '0'; +SET s3_skip_empty_files = '0'; +SET distributed_foreground_insert = '1'; +SET insert_distributed_sync = '1'; +SET alter_sync = '0'; +SET replication_alter_partitions_sync = '0'; +SET allow_suspicious_types_in_group_by = '1'; +SET allow_suspicious_types_in_order_by = '1'; +SET enable_memory_bound_merging_of_aggregation_results = '1'; +SET merge_tree_use_v1_object_and_dynamic_serialization = '1'; +SET do_not_merge_across_partitions_select_final = '0'; +SET log_queries = '1'; +SET log_queries_probability = '1'; +SET http_response_headers = '{}'; +SET max_http_get_redirects = '10'; +SET send_progress_in_http_headers = '1'; +SET http_headers_progress_interval_ms = '60000'; +SET query_plan_join_swap_table = '0'; +SET enable_zstd_qat_codec = '0'; +SET query_profiler_real_time_period_ns = '0'; +SET max_bytes_before_external_group_by = '8589934592'; +SET max_bytes_before_external_sort = '8589934592'; +SET max_result_rows = '500000'; +SET result_overflow_mode = 'break'; +SET join_algorithm = 'default'; +SET max_memory_usage = '17179869184'; +SET backup_restore_keeper_max_retries = '20'; +SET backup_restore_keeper_retry_max_backoff_ms = '60000'; +SET backup_restore_failure_after_host_disconnected_for_seconds = '0'; +SET backup_restore_keeper_max_retries_while_initializing = '0'; +SET backup_restore_keeper_max_retries_while_handling_error = '0'; +SET backup_restore_finish_timeout_after_error_sec = '0'; +SET enable_job_stack_trace = '0'; +SET cancel_http_readonly_queries_on_client_close = '1'; +SET least_greatest_legacy_null_behavior = '1'; +SET max_table_size_to_drop = '1000000000000'; +SET max_partition_size_to_drop = '1000000000000'; +SET default_table_engine = 'ReplicatedMergeTree'; +SET mutations_sync = '0'; +SET validate_mutation_query = '0'; +SET optimize_trivial_insert_select = '0'; +SET max_size_to_preallocate_for_aggregation = '100000000'; +SET max_size_to_preallocate_for_joins = '100000000'; +SET database_replicated_allow_only_replicated_engine = '1'; +SET database_replicated_allow_replicated_engine_arguments = '2'; +SET cloud_mode = '1'; +SET cloud_mode_engine = '2'; +SET distributed_ddl_output_mode = 'none_only_active'; +SET distributed_ddl_entry_format_version = '6'; +SET query_plan_merge_filters = '1'; +SET async_insert_max_data_size = '10485760'; +SET async_insert_busy_timeout_max_ms = '1000'; +SET async_insert_busy_timeout_ms = '1000'; +SET enable_filesystem_cache = '1'; +SET filesystem_cache_name = 's3diskWithCache'; +SET enable_filesystem_cache_on_write_operations = '1'; +SET filesystem_cache_skip_download_if_exceeds_per_query_cache_write_limit = '1'; +SET skip_download_if_exceeds_query_cache = '1'; +SET filesystem_cache_boundary_alignment = '0'; +SET load_marks_asynchronously = '1'; +SET allow_prefetched_read_pool_for_remote_filesystem = '1'; +SET filesystem_prefetch_max_memory_usage = '1717986918'; +SET filesystem_prefetches_limit = '200'; +SET compatibility = '24.10'; +SET insert_keeper_max_retries = '20'; +SET cluster_for_parallel_replicas = 'default'; +SET parallel_replicas_local_plan = '0'; +SET push_external_roles_in_interserver_queries = '0'; +--SET shared_merge_tree_sync_parts_on_partition_operations = '1'; +SET allow_experimental_materialized_postgresql_table = '0'; +SET enable_deflate_qpl_codec = '0'; +SET date_time_input_format = 'best_effort'; + """ + for command in setup_query.split(';'): + try: + client.command(command) + except Exception as e: + if "Empty query" in str(e): + continue + raise e + + # Find and run migration files + migration_files = sorted(CLICKHOUSE_MIGRATIONS_DIR.glob('*.sql')) + print(f"Running {len(migration_files)} migrations...") + + for migration_file in migration_files: + print(f"Running migration: {os.path.basename(migration_file)}") + with open(migration_file) as f: + sql = f.read() + # run commands one at a time cuz that's how it be in Clickhouse + for command in sql.split(';'): + try: + client.command(command) + except Exception as e: + if "Empty query" in str(e): + continue + raise e + + print("Migrations complete!") + + +@pytest.fixture(scope="session", autouse=True) +async def clickhouse_setup_db_server(): + """Configure test database server and connection.""" + from agentops.api.db.clickhouse_client import ConnectionConfig, get_clickhouse + + # Override environment variables for test + ConnectionConfig.host = TEST_CLICKHOUSE_HOST + ConnectionConfig.port = TEST_CLICKHOUSE_PORT + ConnectionConfig.database = TEST_CLICKHOUSE_DATABASE + ConnectionConfig.username = TEST_CLICKHOUSE_USER + ConnectionConfig.password = TEST_CLICKHOUSE_PASSWORD + ConnectionConfig.secure = False + + if not is_github_actions(): + clickhouse_start_docker() + + print(f"Waiting for ClickHouse to be ready at {TEST_CLICKHOUSE_HOST}:{TEST_CLICKHOUSE_PORT}...") + + # Wait for ClickHouse to be available + for attempt in range(30): + try: + # Use clickhouse_connect directly for the health check + client = get_clickhouse() + client.command("SELECT 1") + print("ClickHouse is ready!") + break + except Exception: + print('.', end='', flush=True) + time.sleep(2) + else: + raise Exception("Failed to connect to ClickHouse after multiple attempts") + + # Get clickhouse client and verify connection + client = get_clickhouse() + clickhouse_verify_connection(client) + + # Run migrations + await clickhouse_run_migrations(client) + + try: + yield + finally: + if not is_github_actions(): + clickhouse_stop_docker() + + +@pytest.fixture(scope="function") +async def clickhouse_client(): + """Fixture to provide a clickhouse client for tests.""" + from agentops.api.db.clickhouse_client import get_clickhouse + + client = get_clickhouse() + clickhouse_verify_connection(client) + + yield client + + +@pytest.fixture(scope="function") +async def async_clickhouse_client(): + """Fixture to provide an async clickhouse client for tests.""" + from agentops.api.db.clickhouse_client import get_async_clickhouse + + client = await get_async_clickhouse() + clickhouse_verify_connection(client.client) + + yield client diff --git a/app/api/tests/_conftest/clickhouse_server/Dockerfile b/app/api/tests/_conftest/clickhouse_server/Dockerfile new file mode 100644 index 000000000..96dea130d --- /dev/null +++ b/app/api/tests/_conftest/clickhouse_server/Dockerfile @@ -0,0 +1,17 @@ +FROM clickhouse/clickhouse-server:24.12 + +# Set environment variables +# TODO I dont think user/pass actually modify the install, but they do reference +# the actual values we see inside the container +ENV CLICKHOUSE_USER=default +ENV CLICKHOUSE_PASSWORD=clickhouse +ENV CLICKHOUSE_DB=otel_2 + +# Expose ports +EXPOSE 8123 +EXPOSE 9000 + +# Add healthcheck +HEALTHCHECK --interval=10s --timeout=5s --retries=5 \ + CMD wget --no-verbose --tries=1 --spider http://localhost:8123/ping || exit 1 + diff --git a/app/api/tests/_conftest/common.py b/app/api/tests/_conftest/common.py new file mode 100644 index 000000000..10cc4579e --- /dev/null +++ b/app/api/tests/_conftest/common.py @@ -0,0 +1,34 @@ +import os +import socket +from pathlib import Path + +# the root of the repository +REPO_ROOT = Path(__file__).parent.parent.parent.parent +APP_DIR = REPO_ROOT / 'api' + +__all__ = [ + 'REPO_ROOT', + 'APP_DIR', + 'is_github_actions', + 'get_free_port', +] + + +def is_github_actions(): + """Check if we're running in GitHub Actions CI.""" + return os.environ.get('GITHUB_ACTIONS') == 'true' + + +def get_free_port(start_port: int) -> int: + """Get a free port starting from start_port, incrementing by 1.""" + if is_github_actions(): + # postgres will already be running by the time we get here in CI + return start_port + + while True: + with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: + try: + s.bind(('localhost', start_port)) + return start_port + except OSError: + start_port += 1 diff --git a/app/api/tests/_conftest/projects.py b/app/api/tests/_conftest/projects.py new file mode 100644 index 000000000..7eb2c90be --- /dev/null +++ b/app/api/tests/_conftest/projects.py @@ -0,0 +1,134 @@ +import pytest +from sqlalchemy import orm + +from agentops.opsboard.models import ( + OrgModel, + UserOrgModel, + ProjectModel, + OrgRoles, + Environment, + PremStatus, +) + +__all__ = [ + 'test_org', + 'test_org_prem', + 'test_user_org_member', + 'test_user_org_owner', + 'test_user_org_owner_prem', + 'test_project', +] + + +@pytest.fixture +async def test_org(orm_session) -> OrgModel: + """Create a test organization with no membership.""" + # Create an org + org = OrgModel(name="Test Org for Projects") + orm_session.add(org) + orm_session.flush() # Use flush instead of commit to keep transaction open + + # Return the org + return org + + +@pytest.fixture +async def test_org_prem(orm_session) -> OrgModel: + """Create a test organization with no membership.""" + # Create an org + org = OrgModel( + name="Test Premium Org for Projects", + prem_status=PremStatus.pro, + ) + orm_session.add(org) + orm_session.flush() # Use flush instead of commit to keep transaction open + + # Return the org + return org + + +@pytest.fixture +async def test_user_org_member(orm_session, test_org, test_user) -> OrgModel: + """Create a user-org relationship with member role.""" + # Create a user-org relationship with the test user as member + user_org = UserOrgModel( + user_id=test_user.id, + org_id=test_org.id, + role=OrgRoles.developer, + user_email=test_user.email, + ) + orm_session.add(user_org) + orm_session.commit() + + # Return the org with users loaded + org = orm_session.query(OrgModel).options(orm.joinedload(OrgModel.users)).filter_by(id=test_org.id).one() + + return org + + +@pytest.fixture +async def test_user_org_owner(orm_session, test_org, test_user) -> OrgModel: + """Create a user-org relationship with owner role.""" + # Create a user-org relationship with the test user as owner + user_org = UserOrgModel( + user_id=test_user.id, + org_id=test_org.id, + role=OrgRoles.owner, + user_email=test_user.email, + ) + orm_session.add(user_org) + orm_session.commit() # Commit to ensure persistence + + # Return the org with users loaded + org = orm_session.query(OrgModel).options(orm.joinedload(OrgModel.users)).filter_by(id=test_org.id).one() + + return org + + +@pytest.fixture +async def test_user_org_owner_prem(orm_session, test_org_prem, test_user) -> OrgModel: + """Create a user-org relationship with owner role and premium plan.""" + # Create a user-org relationship with the test user as owner + user_org = UserOrgModel( + user_id=test_user.id, + org_id=test_org_prem.id, + role=OrgRoles.owner, + user_email=test_user.email, + ) + orm_session.add(user_org) + orm_session.commit() + + # Return the org with users loaded + org = ( + orm_session.query(OrgModel) + .options(orm.joinedload(OrgModel.users)) + .filter_by(id=test_org_prem.id) + .one() + ) + + return org + + +@pytest.fixture +async def test_project(orm_session, test_user_org_owner) -> ProjectModel: + """Create a test project for the test organization with owner relationship.""" + # We use test_user_org_owner which gives us an org with the test user as owner + org = test_user_org_owner + + project = ProjectModel( + name="Test Project", + org_id=org.id, + environment=Environment.development, + ) + orm_session.add(project) + orm_session.commit() # Commit to ensure persistence + + # Return the project with org relationship loaded + project = ( + orm_session.query(ProjectModel) + .options(orm.joinedload(ProjectModel.org).joinedload(OrgModel.users)) + .filter_by(id=project.id) + .one() + ) + + return project diff --git a/app/api/tests/_conftest/supabase.py b/app/api/tests/_conftest/supabase.py new file mode 100644 index 000000000..5f8658eef --- /dev/null +++ b/app/api/tests/_conftest/supabase.py @@ -0,0 +1,290 @@ +import os +import subprocess +from pathlib import Path +import pytest +from .common import is_github_actions, get_free_port + + +# these vars are also hard-coded inside the `supabase_server` Dockerfile and the +# github actions workflow +TEST_SUPABASE_HOST = "localhost" +TEST_SUPABASE_PORT = get_free_port(5432) +TEST_SUPABASE_NAME = "test_db" +TEST_SUPABASE_USER = "postgres" +TEST_SUPABASE_PASSWORD = "postgres" + +SUPABASE_DOCKER_IMAGE_PATH = Path(__file__).parent / "supabase_server" / "Dockerfile" +SUPABASE_DOCKER_CONTAINER_NAME = "agentops-test-supabase" + +__all__ = [ + 'supabase_verify_test_environment', + 'supabase_setup_db_server', + 'db_session', + 'orm_session', +] + + +@pytest.fixture(scope="session", autouse=True) +def supabase_verify_test_environment(): + """Verify we don't have access to production credentials before running tests.""" + message = "%s environment variable is set! This risks connecting to production." + assert not os.environ.get('SUPABASE_HOST'), message % "SUPABASE_HOST" + assert not os.environ.get('SUPABASE_PORT'), message % "SUPABASE_PORT" + assert not os.environ.get('SUPABASE_DATABASE'), message % "SUPABASE_DATABASE" + assert not os.environ.get('SUPABASE_USER'), message % "SUPABASE_USER" + assert not os.environ.get('SUPABASE_PASSWORD'), message % "SUPABASE_PASSWORD" + + +def supabase_start_docker(): + """Start the Docker container for PostgreSQL.""" + print("Starting Supabase/Postgres Docker container...") + + subprocess.run(['docker', 'stop', SUPABASE_DOCKER_CONTAINER_NAME], check=False) + subprocess.run(['docker', 'rm', SUPABASE_DOCKER_CONTAINER_NAME], check=False) + subprocess.run( + [ + 'docker', + 'build', + '-t', + SUPABASE_DOCKER_CONTAINER_NAME, + '-f', + str(SUPABASE_DOCKER_IMAGE_PATH), + str(SUPABASE_DOCKER_IMAGE_PATH.parent), + ], + check=True, + ) + subprocess.run( + [ + 'docker', + 'run', + '-d', + '--name', + SUPABASE_DOCKER_CONTAINER_NAME, + '-p', + f'{TEST_SUPABASE_PORT}:5432', + SUPABASE_DOCKER_CONTAINER_NAME, + ], + check=True, + ) + + +def supabase_stop_docker(): + """Stop the Docker container.""" + print("Stopping Supabase/Postgres Docker container...") + subprocess.run(['docker', 'stop', SUPABASE_DOCKER_CONTAINER_NAME], check=True) + + +def supabase_verify_connection(conn): + """Verify the connection to the database uses the test environment.""" + assert conn.info.host == TEST_SUPABASE_HOST + assert conn.info.port == TEST_SUPABASE_PORT + assert conn.info.dbname == TEST_SUPABASE_NAME + assert conn.info.user == TEST_SUPABASE_USER + assert conn.info.password == TEST_SUPABASE_PASSWORD + + +async def supabase_run_migrations(conn): + """Run database schema initialization and migrations.""" + + print("Running Supabase migrations...") + with conn.cursor() as cur: + # we need to do some stuff to get the new database to match what we expect + # in Supabase. Some of these `SET`s might not be necessary, but they don't hurt. + setup_query = """ + SET statement_timeout = 0; + SET lock_timeout = 0; + SET idle_in_transaction_session_timeout = 0; + SET client_encoding = 'UTF8'; + SET standard_conforming_strings = on; + SET search_path TO public; + SET check_function_bodies = false; + SET xmloption = content; + SET client_min_messages = warning; + SET row_security = off; + + -- Create essential extensions + CREATE EXTENSION IF NOT EXISTS pg_stat_statements; + CREATE EXTENSION IF NOT EXISTS "uuid-ossp"; + CREATE EXTENSION IF NOT EXISTS pgcrypto; + + -- Create auth schema and dummy JWT function + CREATE OR REPLACE FUNCTION auth.jwt() RETURNS jsonb AS $$ + BEGIN + RETURN '{"role": "authenticated", "sub": "00000000-0000-0000-0000-000000000000"}'::jsonb; + END; + $$ LANGUAGE plpgsql; + + -- the production bucket table differs from the one in the docker image + -- so we drop it and recreate it + DROP TABLE IF EXISTS storage.buckets CASCADE; + CREATE TABLE IF NOT EXISTS storage.buckets ( + id text NOT NULL, + name text NOT NULL, + owner uuid, + created_at timestamp with time zone DEFAULT now(), + updated_at timestamp with time zone DEFAULT now(), + public boolean DEFAULT false, + avif_autodetection boolean DEFAULT false, + file_size_limit bigint, + allowed_mime_types text[], + CONSTRAINT buckets_pkey PRIMARY KEY (id) + ); + + -- create two test users in the auth.users table so that we can reference them + -- TODO move these to be inside the test_user, test_user2, and test_user3 fixtures + -- so that it's obvious they are dependencies + INSERT INTO auth.users ( + id, + instance_id, + aud, + role, + email, + encrypted_password, + confirmed_at, + created_at, + updated_at + ) VALUES ( + '00000000-0000-0000-0000-000000000000', + '00000000-0000-0000-0000-000000000000', + 'authenticated', + 'authenticated', + 'test@example.com', + '$2a$10$abcdefghijklmnopqrstuvwxyz0123456789', + NOW(), + NOW(), + NOW() + ), ( + '00000000-0000-0000-0000-000000000001', + '00000000-0000-0000-0000-000000000000', + 'authenticated', + 'authenticated', + 'test2@example.com', + '$2a$10$abcdefghijklmnopqrstuvwxyz0123456789', + NOW(), + NOW(), + NOW() + ), ( + '00000000-0000-0000-0000-000000000002', + '00000000-0000-0000-0000-000000000000', + 'authenticated', + 'authenticated', + 'test3@example.com', + '$2a$10$abcdefghijklmnopqrstuvwxyz0123456789', + NOW(), + NOW(), + NOW() + ); + """ + cur.execute(setup_query) + + # migration files sorted by name + migrations_dir = Path(__file__).parents[3] / 'supabase' / 'migrations' + migration_files = sorted(migrations_dir.glob('*.sql')) + + print(f"Running {len(migration_files)} migrations...") + + for migration_file in migration_files: + print(f"Running migration: {os.path.basename(migration_file)}") + with open(migration_file) as f: + sql = f.read() + cur.execute(sql) + + # update public.orgs to have a `subscription_id TEXT DEFAULT ''` because this is in + # prod, but not in the schema migrations. + orgs_subscription_id_query = """ + ALTER TABLE public.orgs + ADD COLUMN IF NOT EXISTS subscription_id TEXT DEFAULT ''; + """ + cur.execute(orgs_subscription_id_query) + + conn.commit() # must commit transaction to apply changes + print("Migrations complete!") + + +@pytest.fixture(scope="session", autouse=True) +async def supabase_setup_db_server(): + """Configure test database server and connection.""" + import time + import psycopg + from agentops.common.postgres import get_connection, close_connection, ConnectionConfig + + # Close any existing connections (sweaty) + close_connection() + + if not is_github_actions(): + supabase_start_docker() + + # NOTE: we do not need to save or restore these variables as the tests will run + # and then we'll be done + ConnectionConfig.host = TEST_SUPABASE_HOST + ConnectionConfig.port = TEST_SUPABASE_PORT + ConnectionConfig.database = TEST_SUPABASE_NAME + ConnectionConfig.user = TEST_SUPABASE_USER + ConnectionConfig.password = TEST_SUPABASE_PASSWORD + + print(f"Waiting for PostgreSQL to be ready at {ConnectionConfig.host}:{ConnectionConfig.port}...") + + for attempt in range(30): + try: + # Use psycopg directly for the health check + conn = psycopg.connect(ConnectionConfig.to_connection_string()) + with conn.cursor() as cur: + cur.execute("SELECT 1") + conn.close() + print("PostgreSQL is ready!") + break + except Exception: + print('.', end='', flush=True) + time.sleep(2) + else: + raise Exception("Failed to connect to PostgreSQL after multiple attempts") + + pool = get_connection() + with pool.connection() as conn: + # double-check connection info (sweaty) + supabase_verify_connection(conn) + + # run migrations once for the session + await supabase_run_migrations(conn) + + yield + + if not is_github_actions(): + supabase_stop_docker() + + +@pytest.fixture(scope="session") +async def db_session(): + """Session fixture providing a database connection.""" + from agentops.common.postgres import get_connection, close_connection + + print("Creating database connection...") + pool = get_connection() + with pool.connection() as conn: + try: + # double-check connection uses test creds (sweaty) + supabase_verify_connection(conn) + + yield conn + except Exception as e: + print(f"Error during database session: {str(e)}") + conn.rollback() + finally: + close_connection() + + +@pytest.fixture(scope="session") +async def orm_session(): + """Fixture to provide an orm session for tests.""" + # does not automatically commit or rollback + from agentops.common.orm import get_orm_session + + session = next(get_orm_session()) + + # double-check connection uses test creds (sweaty) + conn = session.connection() + supabase_verify_connection(conn.connection.driver_connection) + + yield session + + session.close() diff --git a/app/api/tests/_conftest/supabase_server/Dockerfile b/app/api/tests/_conftest/supabase_server/Dockerfile new file mode 100644 index 000000000..8b9badc0a --- /dev/null +++ b/app/api/tests/_conftest/supabase_server/Dockerfile @@ -0,0 +1,13 @@ +FROM supabase/postgres:15.1.0.103 + +# Set environment variables +ENV POSTGRES_USER=postgres +ENV POSTGRES_PASSWORD=postgres +ENV POSTGRES_DB=test_db + +# Expose port +EXPOSE 5432 + +# Add healthcheck +HEALTHCHECK --interval=5s --timeout=5s --retries=5 \ + CMD ["pg_isready", "-U", "postgres", "-p", "5432"] \ No newline at end of file diff --git a/app/api/tests/_conftest/users.py b/app/api/tests/_conftest/users.py new file mode 100644 index 000000000..e51258012 --- /dev/null +++ b/app/api/tests/_conftest/users.py @@ -0,0 +1,73 @@ +import pytest +import uuid +from sqlalchemy.orm import Session +from agentops.opsboard.models import UserModel + +__all__ = [ + "test_user", + "test_user2", + "test_user3", +] + + +@pytest.fixture(scope="session") +async def test_user(orm_session: Session) -> UserModel: + """Create a test user that persists for the entire test session. + This user corresponds to the first auth.users entry with ID 00000000-0000-0000-0000-000000000000.""" + + user_id = uuid.UUID("00000000-0000-0000-0000-000000000000") + + # Check if user already exists + existing_user = orm_session.query(UserModel).filter_by(id=user_id).first() + if existing_user: + return existing_user + + # Create a new test user + user = UserModel(id=user_id, full_name="Test User", email="test@example.com", survey_is_complete=False) + + orm_session.add(user) + orm_session.commit() + + return user + + +@pytest.fixture(scope="session") +async def test_user2(orm_session: Session) -> UserModel: + """Create a second test user that persists for the entire test session. + This user corresponds to the second auth.users entry with ID 00000000-0000-0000-0000-000000000001.""" + + user_id = uuid.UUID("00000000-0000-0000-0000-000000000001") + + # Check if user already exists + existing_user = orm_session.query(UserModel).filter_by(id=user_id).first() + if existing_user: + return existing_user + + # Create a new test user + user = UserModel(id=user_id, full_name="Test User 2", email="test2@example.com", survey_is_complete=False) + + orm_session.add(user) + orm_session.commit() + + return user + + +@pytest.fixture(scope="session") +async def test_user3(orm_session: Session) -> UserModel: + """Create a third test user that persists for the entire test session. + This user corresponds to a third auth.users entry with ID 00000000-0000-0000-0000-000000000002.""" + + user_id = uuid.UUID("00000000-0000-0000-0000-000000000002") + + # Check if user already exists + existing_user = orm_session.query(UserModel).filter_by(id=user_id).first() + if existing_user: + return existing_user + + # Create a new test user + user = UserModel(id=user_id, full_name="Test User 3", email="test3@example.com", survey_is_complete=False) + + orm_session.add(user) + orm_session.commit() + + return user diff --git a/app/api/tests/api/test_auth.py b/app/api/tests/api/test_auth.py new file mode 100644 index 000000000..268985fb6 --- /dev/null +++ b/app/api/tests/api/test_auth.py @@ -0,0 +1,177 @@ +import pytest +import jwt +from datetime import datetime, timedelta +from unittest.mock import patch, MagicMock + +from agentops.api.auth import ( + JWTPayload, + generate_jwt, + verify_jwt, + get_jwt_token, + JWT_ALGO, + _generate_jwt_timestamp, +) +from agentops.api.environment import JWT_SECRET_KEY +from fastapi import HTTPException + + +@pytest.fixture +def jwt_secret(): + """Get the JWT secret from environment variables""" + return JWT_SECRET_KEY + + +@pytest.fixture +def mock_project(): + """Mock a project model for testing""" + mock = MagicMock() + mock.id = "test-project-id" + mock.api_key = "test-api-key" + mock.org.prem_status.value = "premium" + return mock + + +@pytest.fixture +def valid_jwt_payload(): + """Create a valid JWT payload for testing""" + return JWTPayload( + exp=_generate_jwt_timestamp(), + aud="authenticated", + project_id="test-project-id", + project_prem_status="premium", + api_key="test-api-key", + ) + + +@pytest.fixture +def expired_jwt_payload(): + """Create an expired JWT payload for testing""" + return JWTPayload( + exp=int((datetime.now() - timedelta(hours=1)).timestamp()), + aud="authenticated", + project_id="test-project-id", + project_prem_status="premium", + api_key="test-api-key", + ) + + +class TestJWTPayload: + """Tests for the JWTPayload class""" + + def test_jwt_payload_asdict(self, valid_jwt_payload): + """Test that asdict returns a properly formatted dictionary""" + payload_dict = valid_jwt_payload.asdict() + assert "exp" in payload_dict + assert "api_key" in payload_dict + assert payload_dict["project_id"] == "test-project-id" + assert payload_dict["project_prem_status"] == "premium" + assert payload_dict["aud"] == "authenticated" + + # Dev flag should not be in dict by default + assert "dev" not in payload_dict + + def test_jwt_payload_asdict_with_dev(self, valid_jwt_payload): + """Test that asdict includes dev flag when set""" + valid_jwt_payload.dev = True + payload_dict = valid_jwt_payload.asdict() + assert "dev" in payload_dict + assert payload_dict["dev"] is True + + def test_jwt_payload_from_project(self, mock_project): + """Test creating JWT payload from a project model""" + payload = JWTPayload.from_project(mock_project) + assert payload.project_id == "test-project-id" + assert payload.project_prem_status == "premium" + assert payload.api_key == "test-api-key" + assert payload.aud == "authenticated" + assert isinstance(payload.exp, int) + assert payload.dev is False + + def test_jwt_payload_from_project_with_dev(self, mock_project): + """Test creating JWT payload from a project model with dev flag""" + payload = JWTPayload.from_project(mock_project, dev=True) + assert payload.dev is True + + +class TestJWTGeneration: + """Tests for JWT generation functions""" + + def test_generate_jwt(self, mock_project, jwt_secret): + """Test generating a JWT token from a project""" + token = generate_jwt(mock_project) + assert isinstance(token, str) + + # Decode the token and verify contents + decoded = jwt.decode(token, jwt_secret, algorithms=[JWT_ALGO], audience="authenticated") + assert decoded["project_id"] == "test-project-id" + assert decoded["project_prem_status"] == "premium" + assert decoded["api_key"] == "test-api-key" + assert "exp" in decoded + + def test_verify_jwt_valid(self, valid_jwt_payload, jwt_secret): + """Test that a valid JWT token can be verified""" + # Generate a token manually + token = jwt.encode(valid_jwt_payload.asdict(), jwt_secret, algorithm=JWT_ALGO) + + # Verify the token + payload = verify_jwt(token) + assert isinstance(payload, JWTPayload) + assert payload.project_id == "test-project-id" + assert payload.project_prem_status == "premium" + + def test_verify_jwt_expired(self, expired_jwt_payload, jwt_secret): + """Test that an expired JWT token raises an error""" + # Generate an expired token + token = jwt.encode(expired_jwt_payload.asdict(), jwt_secret, algorithm=JWT_ALGO) + + # Verify the token - should raise ExpiredSignatureError + with pytest.raises(jwt.ExpiredSignatureError): + verify_jwt(token) + + def test_verify_jwt_invalid_audience(self, valid_jwt_payload, jwt_secret): + """Test that a JWT with invalid audience raises an error""" + # Create payload with wrong audience + valid_jwt_payload.aud = "wrong-audience" + token = jwt.encode(valid_jwt_payload.asdict(), jwt_secret, algorithm=JWT_ALGO) + + # Verify the token - should raise InvalidAudienceError + with pytest.raises(jwt.InvalidAudienceError): + verify_jwt(token) + + +class TestJWTDependency: + """Tests for the get_jwt_token dependency""" + + async def test_get_jwt_token_valid(self, valid_jwt_payload, jwt_secret): + """Test that a valid JWT token can be extracted from headers""" + # Generate a token manually + token = jwt.encode(valid_jwt_payload.asdict(), jwt_secret, algorithm=JWT_ALGO) + + # Create authorization header + authorization = f"Bearer {token}" + + # Get JWT token from header + with patch('agentops.api.auth.verify_jwt', return_value=valid_jwt_payload): + payload = await get_jwt_token(authorization) + assert payload == valid_jwt_payload + + async def test_get_jwt_token_missing_header(self): + """Test that missing authorization header raises an error""" + with pytest.raises(HTTPException) as exc_info: + await get_jwt_token(None) + assert exc_info.value.status_code == 401 + assert "Authorization header missing" in exc_info.value.detail + + async def test_get_jwt_token_invalid_format(self): + """Test that invalid format raises an error""" + with pytest.raises(HTTPException) as exc_info: + await get_jwt_token("InvalidFormat") + assert exc_info.value.status_code == 401 + assert "Invalid token format" in exc_info.value.detail + + async def test_get_jwt_token_invalid_scheme(self): + """Test that invalid scheme raises an error""" + with pytest.raises(HTTPException) as exc_info: + await get_jwt_token("Basic token123") + assert exc_info.value.status_code == 401 + assert "Invalid authentication scheme" in exc_info.value.detail diff --git a/app/api/tests/api/test_storage.py b/app/api/tests/api/test_storage.py new file mode 100644 index 000000000..f5ed25643 --- /dev/null +++ b/app/api/tests/api/test_storage.py @@ -0,0 +1,226 @@ +import pytest +from io import BytesIO +from unittest.mock import patch, MagicMock, AsyncMock +from fastapi import HTTPException, status, Request + +from agentops.api.storage import BaseObjectUploadView, ObjectUploadResponse +from agentops.api.environment import ( + SUPABASE_URL, +) + + +@pytest.fixture +def mock_jwt_payload(): + """Mock JWT payload for testing""" + return { + 'project_id': 'test-project-123', + 'project_prem_status': 'premium', + 'api_key': 'test-api-key', + 'aud': 'authenticated', + 'exp': 1234567890, + } + + +@pytest.fixture +def mock_s3_client(): + """Mock S3 client for testing""" + client = MagicMock() + client.upload_fileobj = MagicMock() + return client + + +@pytest.fixture +def mock_request(): + """Mock FastAPI Request for testing""" + request = MagicMock(spec=Request) + + # Create a proper async iterator for the stream method + async def async_stream_generator(chunks): + for chunk in chunks: + yield chunk + + # Default stream that will be overridden in individual tests + request.stream = AsyncMock(return_value=async_stream_generator([])) + return request + + +class ConcreteObjectUploadView(BaseObjectUploadView): + """Concrete implementation for testing BaseObjectUploadView""" + + bucket_name = "test-bucket" + + @property + def filename(self) -> str: + return f"test-file-{self.token['project_id']}.txt" + + +class TestBaseObjectUploadView: + """Tests for the BaseObjectUploadView class""" + + def test_bucket_name_assertion(self, mock_jwt_payload, mock_request): + """Test that bucket_name assertion works""" + view = ConcreteObjectUploadView(mock_request) + view.bucket_name = None + + async def async_stream_generator(): + for chunk in [b'test content']: + yield chunk + + mock_request.stream = lambda: async_stream_generator() + + with pytest.raises(AssertionError, match="`bucket_name` must be provided"): + import asyncio + + asyncio.run(view(token=mock_jwt_payload)) + + @pytest.mark.asyncio + async def test_successful_upload(self, mock_jwt_payload, mock_s3_client, mock_request): + """Test successful file upload""" + view = ConcreteObjectUploadView(mock_request) + + # Mock request stream + test_content = b'test file content' + + async def async_stream_generator(): + for chunk in [test_content]: + yield chunk + + mock_request.stream = lambda: async_stream_generator() + + with patch('agentops.api.storage.get_s3_client', return_value=mock_s3_client): + response = await view(token=mock_jwt_payload) + + assert isinstance(response, ObjectUploadResponse) + assert response.size == len(test_content) + assert ( + response.url + == f"{SUPABASE_URL}/storage/v1/object/public/test-bucket/test-file-test-project-123.txt" + ) + + # Verify S3 upload was called + mock_s3_client.upload_fileobj.assert_called_once() + args = mock_s3_client.upload_fileobj.call_args[0] + assert isinstance(args[0], BytesIO) + assert args[1] == "test-bucket" + assert args[2] == "test-file-test-project-123.txt" + + @pytest.mark.asyncio + async def test_file_size_limit_exceeded(self, mock_jwt_payload, mock_request): + """Test that files exceeding size limit are rejected""" + view = ConcreteObjectUploadView(mock_request) + view.max_size = 10 # Set very small limit + + # Mock request stream with large content + large_content = b'x' * 20 # Exceeds 10 byte limit + + async def async_stream_generator(): + for chunk in [large_content]: + yield chunk + + mock_request.stream = lambda: async_stream_generator() + + with pytest.raises(HTTPException) as exc_info: + await view(token=mock_jwt_payload) + + assert exc_info.value.status_code == status.HTTP_413_REQUEST_ENTITY_TOO_LARGE + assert "File size exceeds the maximum limit" in exc_info.value.detail + + @pytest.mark.asyncio + async def test_chunked_upload(self, mock_jwt_payload, mock_s3_client, mock_request): + """Test that chunked uploads work correctly""" + view = ConcreteObjectUploadView(mock_request) + + # Mock request stream with multiple chunks + chunks = [b'chunk1', b'chunk2', b'chunk3'] + + async def async_stream_generator(): + for chunk in chunks: + yield chunk + + mock_request.stream = lambda: async_stream_generator() + + with patch('agentops.api.storage.get_s3_client', return_value=mock_s3_client): + response = await view(token=mock_jwt_payload) + + assert response.size == sum(len(chunk) for chunk in chunks) + + # Verify the complete content was uploaded + uploaded_content = mock_s3_client.upload_fileobj.call_args[0][0] + uploaded_content.seek(0) + assert uploaded_content.read() == b''.join(chunks) + + @pytest.mark.asyncio + async def test_chunked_upload_size_limit(self, mock_jwt_payload, mock_request): + """Test size limit enforcement with chunked uploads""" + view = ConcreteObjectUploadView(mock_request) + view.max_size = 15 + + # Create chunks that exceed limit when combined + chunks = [b'chunk1', b'chunk2', b'chunk3'] # Total: 18 bytes + + async def async_stream_generator(): + for chunk in chunks: + yield chunk + + mock_request.stream = lambda: async_stream_generator() + + with pytest.raises(HTTPException) as exc_info: + await view(token=mock_jwt_payload) + + assert exc_info.value.status_code == status.HTTP_413_REQUEST_ENTITY_TOO_LARGE + + def test_public_url_generation(self, mock_jwt_payload, mock_request): + """Test that public URL is generated correctly""" + view = ConcreteObjectUploadView(mock_request) + view.token = mock_jwt_payload + + expected_url = f"{SUPABASE_URL}/storage/v1/object/public/test-bucket/test-file-test-project-123.txt" + assert view.public_url == expected_url + + def test_filename_property_abstract(self, mock_request): + """Test that filename property must be implemented""" + + class IncompleteView(BaseObjectUploadView): + bucket_name = "test" + # Missing filename property implementation - inherits ellipsis (...) from base + + view = IncompleteView(mock_request) + view.token = {'project_id': 'test'} + + # The ellipsis (...) in the base class returns None (property implementation issue) + # This test verifies that subclasses should implement their own filename property + result = view.filename + assert result is None, "Incomplete view returns None from base class ellipsis property" + + @pytest.mark.asyncio + async def test_upload_body_method(self, mock_jwt_payload, mock_s3_client, mock_request): + """Test the upload_body method directly""" + view = ConcreteObjectUploadView(mock_request) + view.token = mock_jwt_payload + view.client = mock_s3_client + + test_body = BytesIO(b'test content') + await view.upload_body(test_body) + + mock_s3_client.upload_fileobj.assert_called_once_with( + test_body, "test-bucket", "test-file-test-project-123.txt" + ) + + +class TestObjectUploadResponse: + """Tests for the ObjectUploadResponse model""" + + def test_object_upload_response_creation(self): + """Test creating ObjectUploadResponse""" + response = ObjectUploadResponse(url="https://example.com/file.txt", size=1024) + + assert response.url == "https://example.com/file.txt" + assert response.size == 1024 + + def test_object_upload_response_serialization(self): + """Test that ObjectUploadResponse can be serialized""" + response = ObjectUploadResponse(url="https://example.com/file.txt", size=1024) + + # Should be able to convert to dict (for JSON serialization) + response_dict = response.model_dump() + assert response_dict == {"url": "https://example.com/file.txt", "size": 1024} diff --git a/app/api/tests/api/test_stripe_webhooks.py b/app/api/tests/api/test_stripe_webhooks.py new file mode 100644 index 000000000..972757511 --- /dev/null +++ b/app/api/tests/api/test_stripe_webhooks.py @@ -0,0 +1,566 @@ +""" +Tests for Stripe webhook handlers. + +This test suite validates the fix for the reference ID issue where legacy subscriptions +sunset via scripts/sunset_legacy_subscriptions.py could create checkout sessions with +missing client_reference_id, causing webhook processing failures. + +The tests follow the same patterns as other billing tests and validate the fallback +mechanism that uses org_id from metadata when client_reference_id is missing. +""" + +import pytest +from unittest.mock import patch, MagicMock +from datetime import datetime, timedelta +from fastapi import HTTPException +import stripe + +# Import shared billing fixtures +pytest_plugins = ["tests._conftest.billing"] + +from agentops.api.routes.v4.stripe_webhooks import ( + handle_checkout_completed, + handle_subscription_updated, +) +from agentops.opsboard.models import ( + OrgModel, + UserOrgModel, + BillingAuditLog, + PremStatus, + OrgRoles, +) + + +# Mock stripe at module level to prevent API key errors +stripe.api_key = 'sk_test_mock' + + +@pytest.fixture(autouse=True) +def mock_stripe_config(): + """Mock Stripe configuration for all tests.""" + with ( + patch('agentops.api.environment.STRIPE_SECRET_KEY', 'sk_test_123'), + patch('agentops.api.environment.STRIPE_SUBSCRIPTION_PRICE_ID', 'price_test123'), + patch('agentops.api.routes.v4.stripe_webhooks.STRIPE_SUBSCRIPTION_PRICE_ID', 'price_test123'), + patch.dict( + 'os.environ', + {'STRIPE_SECRET_KEY': 'sk_test_123', 'STRIPE_SUBSCRIPTION_PRICE_ID': 'price_test123'}, + ), + ): + yield + + +@pytest.fixture +def test_org_with_subscription(orm_session, test_user): + """Create a test organization with an active subscription.""" + org = OrgModel(name="Test Org", prem_status=PremStatus.pro, subscription_id="sub_test_123") + orm_session.add(org) + orm_session.flush() + + # Add owner member + owner_member = UserOrgModel( + user_id=test_user.id, org_id=org.id, role=OrgRoles.owner, user_email=test_user.email, is_paid=True + ) + orm_session.add(owner_member) + orm_session.flush() + + return org + + +@pytest.fixture +def test_free_org(orm_session, test_user): + """Create a test organization without a subscription.""" + org = OrgModel(name="Test Free Org", prem_status=PremStatus.free, subscription_id=None) + orm_session.add(org) + orm_session.flush() + + # Add owner member + owner_member = UserOrgModel( + user_id=test_user.id, org_id=org.id, role=OrgRoles.owner, user_email=test_user.email, is_paid=False + ) + orm_session.add(owner_member) + orm_session.flush() + + return org + + +@pytest.fixture +def mock_checkout_event(): + """Create a mock Stripe checkout.session.completed event.""" + event = MagicMock() + event.id = "evt_test_123" + event.type = "checkout.session.completed" + event.data = MagicMock() + event.data.object = { + "id": "cs_test_session_123", + "subscription": "sub_new_123", + "client_reference_id": None, # This will be set per test + "metadata": {}, # This will be set per test + } + return event + + +@pytest.fixture +def mock_subscription_event(): + """Create a mock Stripe subscription.updated event.""" + event = MagicMock() + event.id = "evt_test_subscription_123" + event.type = "subscription.updated" + event.data = MagicMock() + event.data.object = { + "id": "sub_test_123", + "status": "active", + "current_period_end": int((datetime.now() + timedelta(days=30)).timestamp()), + "cancel_at_period_end": False, + "items": {"data": [{"id": "si_test_123", "quantity": 1, "price": {"id": "price_test123"}}]}, + } + return event + + +@pytest.fixture +def mock_legacy_subscription_event(): + """Create a mock Stripe subscription.updated event for legacy subscription.""" + event = MagicMock() + event.id = "evt_test_legacy_123" + event.type = "subscription.updated" + event.data = MagicMock() + event.data.object = { + "id": "sub_legacy_123", + "status": "active", + "current_period_end": int((datetime.now() + timedelta(days=30)).timestamp()), + "cancel_at_period_end": False, + "items": { + "data": [ + { + "id": "si_legacy_123", + "quantity": 1, + "price": { + "id": "price_legacy_old_123", # Different from current price ID + "product": {"name": "Legacy Seat Plan"}, + }, + } + ] + }, + } + return event + + +class TestStripeWebhooks: + """Test Stripe webhook handlers.""" + + @pytest.mark.asyncio + @patch('agentops.api.routes.v4.stripe_webhooks.is_event_processed') + @patch('agentops.api.routes.v4.stripe_webhooks.mark_event_processed') + @patch('agentops.api.routes.v4.stripe_webhooks.log_webhook_metric') + @patch('stripe.Subscription.retrieve') + async def test_checkout_completed_with_client_reference_id( + self, + mock_stripe_retrieve, + mock_log_metric, + mock_mark_processed, + mock_is_processed, + orm_session, + test_free_org, + mock_checkout_event, + mock_stripe_subscription, + ): + """Test successful checkout completion with client_reference_id present.""" + mock_is_processed.return_value = False + mock_mark_processed.return_value = None + mock_stripe_retrieve.return_value = mock_stripe_subscription + + # Set the client_reference_id to the org ID + mock_checkout_event.data.object["client_reference_id"] = str(test_free_org.id) + + result = await handle_checkout_completed(mock_checkout_event, orm_session) + + # Verify the org was updated + orm_session.refresh(test_free_org) + assert test_free_org.subscription_id == "sub_new_123" + assert test_free_org.prem_status == PremStatus.pro + + # Verify owner was marked as paid + owner = ( + orm_session.query(UserOrgModel) + .filter(UserOrgModel.org_id == test_free_org.id, UserOrgModel.role == OrgRoles.owner) + .first() + ) + assert owner.is_paid is True + + mock_mark_processed.assert_called_once_with(mock_checkout_event.id, orm_session) + + @pytest.mark.asyncio + @patch('agentops.api.routes.v4.stripe_webhooks.is_event_processed') + @patch('agentops.api.routes.v4.stripe_webhooks.mark_event_processed') + @patch('agentops.api.routes.v4.stripe_webhooks.log_webhook_metric') + @patch('stripe.Subscription.retrieve') + async def test_checkout_completed_missing_reference_id_with_metadata_fallback( + self, + mock_stripe_retrieve, + mock_log_metric, + mock_mark_processed, + mock_is_processed, + orm_session, + test_free_org, + mock_checkout_event, + mock_stripe_subscription, + ): + """Test checkout completion when client_reference_id is missing but org_id is in metadata.""" + mock_is_processed.return_value = False + mock_mark_processed.return_value = None + mock_stripe_retrieve.return_value = mock_stripe_subscription + + # Simulate the scenario where client_reference_id is missing but org_id is in metadata + mock_checkout_event.data.object["client_reference_id"] = None + mock_checkout_event.data.object["metadata"] = {"org_id": str(test_free_org.id)} + + result = await handle_checkout_completed(mock_checkout_event, orm_session) + + # Verify the org was updated despite missing client_reference_id + orm_session.refresh(test_free_org) + assert test_free_org.subscription_id == "sub_new_123" + assert test_free_org.prem_status == PremStatus.pro + + # Verify owner was marked as paid + owner = ( + orm_session.query(UserOrgModel) + .filter(UserOrgModel.org_id == test_free_org.id, UserOrgModel.role == OrgRoles.owner) + .first() + ) + assert owner.is_paid is True + + mock_mark_processed.assert_called_once_with(mock_checkout_event.id, orm_session) + + # Verify that the Stripe subscription was retrieved to validate the purchase + mock_stripe_retrieve.assert_called_once_with("sub_new_123", expand=['items']) + + # This test specifically validates the fix for the reference ID issue + # The warning should be logged when using metadata fallback (captured in test output) + + @pytest.mark.asyncio + @patch('agentops.api.routes.v4.stripe_webhooks.is_event_processed') + @patch('agentops.api.routes.v4.stripe_webhooks.log_webhook_metric') + async def test_checkout_completed_missing_reference_id_and_metadata( + self, mock_log_metric, mock_is_processed, orm_session, test_free_org, mock_checkout_event + ): + """Test checkout completion when both client_reference_id and org_id metadata are missing.""" + mock_is_processed.return_value = False + + # Simulate the scenario where both client_reference_id and org_id metadata are missing + mock_checkout_event.data.object["client_reference_id"] = None + mock_checkout_event.data.object["metadata"] = {} + + result = await handle_checkout_completed(mock_checkout_event, orm_session) + + # Should return early without processing + assert result is None + + # Verify metric was logged for missing reference ID + mock_log_metric.assert_called_once_with( + "checkout.session.completed", + "missing_reference_id", + {"session_id": "cs_test_session_123", "subscription_id": "sub_new_123"}, + ) + + # Verify org was not updated + orm_session.refresh(test_free_org) + assert test_free_org.subscription_id is None + assert test_free_org.prem_status == PremStatus.free + + @pytest.mark.asyncio + @patch('agentops.api.routes.v4.stripe_webhooks.is_event_processed') + @patch('agentops.api.routes.v4.stripe_webhooks.log_webhook_metric') + @patch('stripe.Subscription.retrieve') + async def test_checkout_completed_org_not_found( + self, + mock_stripe_retrieve, + mock_log_metric, + mock_is_processed, + orm_session, + mock_checkout_event, + mock_stripe_subscription, + ): + """Test checkout completion when org is not found.""" + mock_is_processed.return_value = False + mock_stripe_retrieve.return_value = mock_stripe_subscription + + # Set client_reference_id to a non-existent org ID + mock_checkout_event.data.object["client_reference_id"] = "00000000-0000-0000-0000-000000000000" + + result = await handle_checkout_completed(mock_checkout_event, orm_session) + + # Verify metric was logged for org not found + mock_log_metric.assert_called_once_with( + "checkout.session.completed", + "org_not_found", + { + "client_reference_id": "00000000-0000-0000-0000-000000000000", + "subscription_id": "sub_new_123", + "session_id": "cs_test_session_123", + }, + ) + + @pytest.mark.asyncio + @patch('agentops.api.routes.v4.stripe_webhooks.is_event_processed') + @patch('agentops.api.routes.v4.stripe_webhooks.mark_event_processed') + @patch('agentops.api.routes.v4.stripe_webhooks.log_webhook_metric') + @patch('stripe.Subscription.retrieve') + async def test_checkout_completed_duplicate_processing( + self, + mock_stripe_retrieve, + mock_log_metric, + mock_mark_processed, + mock_is_processed, + orm_session, + test_org_with_subscription, + mock_checkout_event, + mock_stripe_subscription, + ): + """Test checkout completion when org already has the same subscription.""" + mock_is_processed.return_value = False + mock_stripe_retrieve.return_value = mock_stripe_subscription + + # Set up scenario where org already has this subscription + test_org_with_subscription.subscription_id = "sub_new_123" + orm_session.commit() + + mock_checkout_event.data.object["client_reference_id"] = str(test_org_with_subscription.id) + mock_checkout_event.data.object["subscription"] = "sub_new_123" + + result = await handle_checkout_completed(mock_checkout_event, orm_session) + + # Should return early due to duplicate subscription + assert result is None + + # Should not call mark_event_processed since it's a duplicate + mock_mark_processed.assert_not_called() + + # Should log the duplicate processing + mock_log_metric.assert_called_once_with( + "checkout.session.completed", + "duplicate_processing", + {"org_id": str(test_org_with_subscription.id), "subscription_id": "sub_new_123"}, + ) + + @pytest.mark.asyncio + @patch('agentops.api.routes.v4.stripe_webhooks.is_event_processed') + @patch('agentops.api.routes.v4.stripe_webhooks.mark_event_processed') + @patch('stripe.Subscription.modify') + @patch('agentops.api.routes.v4.stripe_webhooks.send_legacy_billing_notification') + async def test_subscription_updated_legacy_subscription_sunset( + self, + mock_send_notification, + mock_stripe_modify, + mock_mark_processed, + mock_is_processed, + orm_session, + test_org_with_subscription, + mock_legacy_subscription_event, + ): + """Test subscription updated webhook handling legacy subscription that should be sunset.""" + mock_is_processed.return_value = False + # Mock single Stripe modify call to succeed + mock_stripe_modify.return_value = MagicMock(id="sub_legacy_123") + + # Make sure the notification mock doesn't raise any exceptions or interfere with session + async def mock_notification(*args, **kwargs): + # Do nothing, don't call orm.commit() or any other session operations + pass + + mock_send_notification.side_effect = mock_notification + + # Set up org with legacy subscription + test_org_with_subscription.subscription_id = "sub_legacy_123" + orm_session.commit() + + mock_legacy_subscription_event.data.object["id"] = "sub_legacy_123" + + # Debug: print the subscription data that will be processed + subscription_data = mock_legacy_subscription_event.data.object + print(f"DEBUG: Subscription data - id: {subscription_data.get('id')}") + print(f"DEBUG: Subscription data - status: {subscription_data.get('status')}") + print( + f"DEBUG: Subscription data - cancel_at_period_end: {subscription_data.get('cancel_at_period_end')}" + ) + items = subscription_data.get('items', {}).get('data', []) + for i, item in enumerate(items): + price = item.get('price', {}) + print( + f"DEBUG: Item {i} - price_id: {price.get('id')}, product_name: {price.get('product', {}).get('name')}" + ) + + # Ensure the mock returns the expected subscription data + # The function uses event.data.object directly, not a Stripe API call + try: + result = await handle_subscription_updated(mock_legacy_subscription_event, orm_session) + print(f"DEBUG: handle_subscription_updated returned: {result}") + except Exception as e: + print(f"DEBUG: Exception in handle_subscription_updated: {e}") + import traceback + + traceback.print_exc() + raise + + # Verify Stripe subscription was modified to cancel at period end + mock_stripe_modify.assert_called() + call_args = mock_stripe_modify.call_args_list[0] + assert call_args[0][0] == "sub_legacy_123" # subscription_id + assert call_args[1]["cancel_at_period_end"] is True + assert "billing_model_change" in call_args[1]["metadata"]["cancellation_reason"] + + # Explicitly flush and commit all pending changes + orm_session.flush() + orm_session.commit() + + # Query audit logs with more debugging + all_audit_logs = ( + orm_session.query(BillingAuditLog) + .filter(BillingAuditLog.org_id == test_org_with_subscription.id) + .all() + ) + print(f"DEBUG: Found {len(all_audit_logs)} audit logs for org {test_org_with_subscription.id}") + for log in all_audit_logs: + print(f"DEBUG: Audit log - action: {log.action}, details: {log.details}") + + # Verify audit log was created + audit_log = ( + orm_session.query(BillingAuditLog) + .filter( + BillingAuditLog.org_id == test_org_with_subscription.id, + BillingAuditLog.action == 'legacy_subscription_sunset', + ) + .first() + ) + assert audit_log is not None, f"No audit log found for org {test_org_with_subscription.id}" + assert audit_log.details["subscription_id"] == "sub_legacy_123" + + # Verify notification was sent + mock_send_notification.assert_called_once() + + mock_mark_processed.assert_called_once_with(mock_legacy_subscription_event.id, orm_session) + + @pytest.mark.asyncio + @patch('agentops.api.routes.v4.stripe_webhooks.is_event_processed') + @patch('agentops.api.routes.v4.stripe_webhooks.mark_event_processed') + async def test_subscription_updated_current_subscription( + self, + mock_mark_processed, + mock_is_processed, + orm_session, + test_org_with_subscription, + mock_subscription_event, + ): + """Test subscription updated webhook for current (non-legacy) subscription.""" + mock_is_processed.return_value = False + + result = await handle_subscription_updated(mock_subscription_event, orm_session) + + # Should process normally without legacy subscription handling + mock_mark_processed.assert_called_once_with(mock_subscription_event.id, orm_session) + + @pytest.mark.asyncio + @patch('agentops.api.routes.v4.stripe_webhooks.is_event_processed') + @patch('agentops.api.routes.v4.stripe_webhooks.log_webhook_metric') + async def test_subscription_updated_org_not_found( + self, mock_log_metric, mock_is_processed, orm_session, mock_subscription_event + ): + """Test subscription updated webhook when org is not found.""" + mock_is_processed.return_value = False + + # Set subscription ID that doesn't match any org + mock_subscription_event.data.object["id"] = "sub_nonexistent_123" + + result = await handle_subscription_updated(mock_subscription_event, orm_session) + + # Should return early + assert result is None + + @pytest.mark.asyncio + @patch('agentops.api.routes.v4.stripe_webhooks.is_event_processed') + async def test_event_already_processed(self, mock_is_processed, orm_session, mock_checkout_event): + """Test that already processed events are skipped.""" + mock_is_processed.return_value = True + + result = await handle_checkout_completed(mock_checkout_event, orm_session) + + assert result == {"status": "already_processed"} + + +class TestWebhookEdgeCases: + """Test edge cases and error scenarios for webhook handlers.""" + + @pytest.mark.asyncio + @patch('agentops.api.routes.v4.stripe_webhooks.is_event_processed') + @patch('agentops.api.routes.v4.stripe_webhooks.mark_event_processed') + @patch('agentops.api.routes.v4.stripe_webhooks.log_webhook_metric') + async def test_checkout_completed_empty_metadata_org_id( + self, + mock_log_metric, + mock_mark_processed, + mock_is_processed, + orm_session, + test_free_org, + mock_checkout_event, + ): + """Test checkout completion when org_id in metadata is empty string.""" + mock_is_processed.return_value = False + + # Simulate the scenario where client_reference_id is missing and org_id is empty + mock_checkout_event.data.object["client_reference_id"] = None + mock_checkout_event.data.object["metadata"] = {"org_id": ""} + + result = await handle_checkout_completed(mock_checkout_event, orm_session) + + # Should return early without processing due to empty org_id + assert result is None + + # Verify metric was logged for missing reference ID + mock_log_metric.assert_called_once_with( + "checkout.session.completed", + "missing_reference_id", + {"session_id": "cs_test_session_123", "subscription_id": "sub_new_123"}, + ) + + @pytest.mark.asyncio + @patch('agentops.api.routes.v4.stripe_webhooks.is_event_processed') + @patch('agentops.api.routes.v4.stripe_webhooks.mark_event_processed') + async def test_checkout_completed_missing_subscription_id( + self, mock_mark_processed, mock_is_processed, orm_session, test_free_org, mock_checkout_event + ): + """Test checkout completion when subscription_id is missing.""" + mock_is_processed.return_value = False + + # Set up valid client_reference_id but missing subscription + mock_checkout_event.data.object["client_reference_id"] = str(test_free_org.id) + mock_checkout_event.data.object["subscription"] = None + + result = await handle_checkout_completed(mock_checkout_event, orm_session) + + # Should return early without processing + assert result is None + + # Verify org was not updated + orm_session.refresh(test_free_org) + assert test_free_org.subscription_id is None + assert test_free_org.prem_status == PremStatus.free + + @pytest.mark.asyncio + @patch('agentops.api.routes.v4.stripe_webhooks.is_event_processed') + async def test_checkout_completed_stripe_error_handling( + self, mock_is_processed, orm_session, test_free_org, mock_checkout_event + ): + """Test that Stripe errors are properly logged and handled.""" + mock_is_processed.return_value = False + + # Set up valid data + mock_checkout_event.data.object["client_reference_id"] = str(test_free_org.id) + + # Simulate a Stripe error during processing + with patch('stripe.Subscription.retrieve') as mock_retrieve: + mock_retrieve.side_effect = stripe.error.StripeError("Test Stripe error") + + with pytest.raises(HTTPException) as exc_info: + await handle_checkout_completed(mock_checkout_event, orm_session) + + assert exc_info.value.status_code == 500 + assert "Stripe API error" in exc_info.value.detail diff --git a/app/api/tests/auth/test_public_routes.py b/app/api/tests/auth/test_public_routes.py new file mode 100644 index 000000000..1583ecfe4 --- /dev/null +++ b/app/api/tests/auth/test_public_routes.py @@ -0,0 +1,232 @@ +""" +Tests for the security features of the auth module. +This covers both the rate limiter and security header validations. +""" + +import pytest +from unittest.mock import patch, MagicMock +from fastapi import Request, HTTPException + +from agentops.auth.views import _validate_request, public_route +from agentops.common import rate_limit +from agentops.common.environment import APP_URL, API_DOMAIN, RATE_LIMIT_COUNT, REDIS_HOST, REDIS_PORT +from agentops.common.route_config import BaseView + +# Mark to skip rate limit tests when Redis is not available +redis_required = pytest.mark.skipif( + not (REDIS_HOST and REDIS_PORT), + reason="Rate limit tests require Redis (REDIS_HOST and REDIS_PORT env vars)" +) + + +@pytest.fixture +def mock_request(): + """Create a mock request with appropriate headers for testing.""" + mock = MagicMock(spec=Request) + mock.headers = { + "x-forwarded-for": "192.168.0.1", + "x-forwarded-host": API_DOMAIN, + "origin": APP_URL, + "referer": f"{APP_URL}/signin", + "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/91.0.4472.124", + } + return mock + + +@pytest.fixture(autouse=True) +def clear_rate_limits(): + """ + Clear rate limit data for test IPs before and after tests. + Note: This fixture will run even if Redis is not available, + but the rate_limit.clear() calls will be no-ops in that case. + """ + test_ips = [ + "192.168.0.1", # Main test IP + "192.168.0.2", # Secondary test IP + ] + for ip in test_ips: + rate_limit.clear(ip) + yield + for ip in test_ips: + rate_limit.clear(ip) + + +@patch("agentops.auth.views.API_URL", "http://localhost:8000") +def test_localhost_bypass(mock_request): + """Test that localhost requests bypass all security checks.""" + # Should not raise exceptions even with bad headers + mock_request.headers = { + "x-forwarded-for": "", # This would normally trigger an error + } + _validate_request(mock_request) # Should not raise exceptions + + +@patch("agentops.auth.views.API_URL", "https://api.agentops.ai") +def test_header_validations(mock_request): + """Test that requests with invalid headers are rejected.""" + ip = "192.168.0.1" + mock_request.headers["x-forwarded-for"] = ip + rate_limit.clear(ip) # Ensure no rate limiting interference + + # Test 2.1: Missing IP + mock_request.headers.pop("x-forwarded-for") + with pytest.raises(HTTPException) as exc_info: + _validate_request(mock_request) + assert exc_info.value.status_code == 500 + + # Test 2.2: Invalid host + mock_request.headers["x-forwarded-for"] = ip + mock_request.headers["x-forwarded-host"] = "evil-site.com" + with pytest.raises(HTTPException) as exc_info: + _validate_request(mock_request) + assert exc_info.value.status_code == 500 + + # Test 2.3: Invalid origin + mock_request.headers["x-forwarded-host"] = API_DOMAIN + mock_request.headers["origin"] = "https://evil-site.com" + with pytest.raises(HTTPException) as exc_info: + _validate_request(mock_request) + assert exc_info.value.status_code == 500 + + # Test 2.4: Invalid referrer + mock_request.headers["origin"] = APP_URL + mock_request.headers["referer"] = "https://evil-site.com/page" + with pytest.raises(HTTPException) as exc_info: + _validate_request(mock_request) + assert exc_info.value.status_code == 500 + + # Test 2.5: Missing user agent + mock_request.headers["referer"] = f"{APP_URL}/signin" + mock_request.headers.pop("user-agent") + with pytest.raises(HTTPException) as exc_info: + _validate_request(mock_request) + assert exc_info.value.status_code == 500 + + +@redis_required +@patch("agentops.auth.views.API_URL", "https://api.agentops.ai") +def test_rate_limiting_basic(mock_request): + """Test that the rate limiter blocks requests after the limit is exceeded.""" + ip = "192.168.0.1" + mock_request.headers["x-forwarded-for"] = ip + + # Clear any existing data + rate_limit.clear(ip) + + # Verify initial state + assert rate_limit.get_count(ip) == 0 + assert not rate_limit.is_blocked(ip) + + # Make requests up to the limit + for i in range(RATE_LIMIT_COUNT): + _validate_request(mock_request) + assert rate_limit.get_count(ip) == i + 1 + assert not rate_limit.is_blocked(ip) + + # The next request should exceed the limit + with pytest.raises(HTTPException) as exc_info: + _validate_request(mock_request) + assert exc_info.value.status_code == 429 + assert rate_limit.is_blocked(ip) + + +@redis_required +@patch("agentops.auth.views.API_URL", "https://api.agentops.ai") +def test_rate_limit_ip_isolation(): + """Test that different IPs have separate rate limits.""" + ip1 = "192.168.0.1" + ip2 = "192.168.0.2" + + # Create two requests with different IPs + request1 = MagicMock(spec=Request) + request1.headers = { + "x-forwarded-for": ip1, + "x-forwarded-host": API_DOMAIN, + "origin": APP_URL, + "referer": f"{APP_URL}/signin", + "user-agent": "Mozilla/5.0 Chrome/91.0.4472.124", + } + + request2 = MagicMock(spec=Request) + request2.headers = { + "x-forwarded-for": ip2, + "x-forwarded-host": API_DOMAIN, + "origin": APP_URL, + "referer": f"{APP_URL}/signin", + "user-agent": "Mozilla/5.0 Chrome/91.0.4472.124", + } + + # Exceed the limit for the first IP + for _ in range(RATE_LIMIT_COUNT + 1): + rate_limit.record_interaction(ip1) + + # Verify the first IP is blocked + assert rate_limit.is_blocked(ip1) + with pytest.raises(HTTPException) as exc_info: + _validate_request(request1) + assert exc_info.value.status_code == 429 + + # But the second IP should not be blocked + assert not rate_limit.is_blocked(ip2) + _validate_request(request2) # Should not raise exceptions + + +@patch("agentops.auth.views.API_URL", "https://api.agentops.ai") +def test_public_route_decorator(): + """Test that the public_route decorator properly marks functions and validates requests.""" + + # Check that the decorator properly marks functions + @public_route + async def test_view(request): + return "test response" + + # Verify the function is marked as public + assert hasattr(test_view, "is_public") + assert test_view.is_public is True + + +@patch("agentops.auth.views.API_URL", "https://api.agentops.ai") +def test_public_route_decorator_class_based_view(): + """Test that the public_route decorator properly works with class-based views.""" + + # Test with a class-based view + @public_route + class TestView(BaseView): + async def __call__(self): + return "test class response" + + # Verify the class __call__ method is marked as public + assert hasattr(TestView.__call__, "is_public") + assert TestView.__call__.is_public is True + + # Test that the decorator validates requests properly for class-based views + mock_request = MagicMock(spec=Request) + mock_request.headers = { + "x-forwarded-for": "192.168.0.1", + "x-forwarded-host": API_DOMAIN, + "origin": APP_URL, + "referer": f"{APP_URL}/signin", + "user-agent": "Mozilla/5.0 Chrome/91.0.4472.124", + } + + # Create an instance and test validation + view_instance = TestView(mock_request) + + # The wrapped __call__ method should validate the request + with patch('agentops.auth.views._validate_request') as mock_validate: + import asyncio + asyncio.run(view_instance()) + # Verify that _validate_request was called with the instance's request + mock_validate.assert_called_once_with(mock_request) + + +@patch("agentops.auth.views.API_URL", "https://api.agentops.ai") +def test_public_route_decorator_invalid_class(): + """Test that the public_route decorator raises TypeError for non-BaseView classes.""" + + # Should raise TypeError when decorating a non-BaseView class + with pytest.raises(TypeError, match="must inherit from BaseView"): + @public_route + class BadView: + async def __call__(self): + return "invalid" diff --git a/app/api/tests/common/__init__.py b/app/api/tests/common/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/api/tests/common/test_freeplan.py b/app/api/tests/common/test_freeplan.py new file mode 100644 index 000000000..6d6e106c7 --- /dev/null +++ b/app/api/tests/common/test_freeplan.py @@ -0,0 +1,419 @@ +from datetime import datetime, timedelta, timezone +from unittest.mock import patch + +from agentops.common.freeplan import FreePlanFilteredResponse, freeplan_clamp_datetime, freeplan_clamp_start_time, freeplan_clamp_end_time + + +class SimpleResponse(FreePlanFilteredResponse): + _freeplan_exclude = ('field1', 'field2') + + field1: str + field2: int + field3: str + + +class NestedResponse(FreePlanFilteredResponse): + regular_field: str + nested_field: SimpleResponse + + +class MaxLinesResponse(FreePlanFilteredResponse): + _freeplan_maxlines = {'multiline_field': 3} + + multiline_field: str + regular_field: str + + +class MaxItemsResponse(FreePlanFilteredResponse): + _freeplan_maxitems = {'list_field': 3} + + list_field: list[str] + regular_field: str + + +class CombinedResponse(FreePlanFilteredResponse): + _freeplan_exclude = ('excluded_field',) + _freeplan_maxlines = {'multiline_field': 2} + _freeplan_maxitems = {'list_field': 2} + + excluded_field: str + multiline_field: str + list_field: list[str] + regular_field: str + + +def test_freeplan_exclude(): + """Test that fields listed in _freeplan_exclude are excluded when freeplan_truncated is True.""" + response = SimpleResponse(field1="value1", field2=123, field3="value3") + + # When freeplan_truncated is False, all fields should be included + response.freeplan_truncated = False + result = response.model_dump() + assert result == { + "field1": "value1", + "field2": 123, + "field3": "value3", + "freeplan_truncated": False, + } + + # When freeplan_truncated is True, excluded fields should be empty + response.freeplan_truncated = True + result = response.model_dump() + assert result == { + "field1": "", # String fields become empty strings + "field2": 0, # Int fields become 0 + "field3": "value3", + "freeplan_truncated": True, + } + + +def test_nested_models(): + """Test that nested models are handled correctly.""" + nested = SimpleResponse(field1="nested1", field2=456, field3="nested3") + response = NestedResponse(regular_field="regular", nested_field=nested) + + # When freeplan_truncated is False, all fields should be included + response.freeplan_truncated = False + result = response.model_dump() + assert result == { + "regular_field": "regular", + "nested_field": { + "field1": "nested1", + "field2": 456, + "field3": "nested3", + "freeplan_truncated": False, + }, + "freeplan_truncated": False, + } + + # When freeplan_truncated is True on both the parent and nested model, + # the nested model should apply its own filtering rules + response.freeplan_truncated = True + response.nested_field.freeplan_truncated = True + result = response.model_dump() + + assert result["regular_field"] == "regular" + assert result["freeplan_truncated"] == True + assert "nested_field" in result + + # The nested field should have its own fields filtered according to its rules + assert result["nested_field"]["field1"] == "" + assert result["nested_field"]["field2"] == 0 + assert result["nested_field"]["field3"] == "nested3" + assert result["nested_field"]["freeplan_truncated"] == True + + +def test_maxlines_truncation(): + """Test that fields listed in _freeplan_maxlines are truncated when freeplan_truncated is True.""" + multiline_text = "line1\nline2\nline3\nline4\nline5" + response = MaxLinesResponse(multiline_field=multiline_text, regular_field="regular") + + # When freeplan_truncated is False, all lines should be included + response.freeplan_truncated = False + result = response.model_dump() + assert result == { + "multiline_field": multiline_text, + "regular_field": "regular", + "freeplan_truncated": False, + } + + # When freeplan_truncated is True, multiline field should be truncated to max_lines + response.freeplan_truncated = True + result = response.model_dump() + assert result == { + "multiline_field": "line1\nline2\nline3", # Only first 3 lines + "regular_field": "regular", + "freeplan_truncated": True, + } + + +def test_maxitems_truncation(): + """Test that fields listed in _freeplan_maxitems are truncated when freeplan_truncated is True.""" + test_list = ["item1", "item2", "item3", "item4", "item5"] + response = MaxItemsResponse(list_field=test_list, regular_field="regular") + + # When freeplan_truncated is False, all items should be included + response.freeplan_truncated = False + result = response.model_dump() + assert result == { + "list_field": test_list, + "regular_field": "regular", + "freeplan_truncated": False, + } + + # When freeplan_truncated is True, list field should be truncated to max_items + response.freeplan_truncated = True + result = response.model_dump() + assert result == { + "list_field": ["item1", "item2", "item3"], # Only first 3 items + "regular_field": "regular", + "freeplan_truncated": True, + } + + +def test_combined_exclude_maxlines_and_maxitems(): + """Test that exclude, maxlines, and maxitems features all work together.""" + multiline_text = "line1\nline2\nline3\nline4" + test_list = ["item1", "item2", "item3", "item4"] + response = CombinedResponse( + excluded_field="excluded", + multiline_field=multiline_text, + list_field=test_list, + regular_field="regular" + ) + + # When freeplan_truncated is True, excluded fields should be empty, + # multiline fields should be truncated, and list fields should be truncated + response.freeplan_truncated = True + result = response.model_dump() + assert result == { + "excluded_field": "", # Excluded field + "multiline_field": "line1\nline2", # Truncated to 2 lines + "list_field": ["item1", "item2"], # Truncated to 2 items + "regular_field": "regular", + "freeplan_truncated": True, + } + + +class TestFreePlanClampDatetime: + """Tests for the freeplan_clamp_datetime function.""" + + def test_date_before_cutoff(self): + """Test that dates before the cutoff are returned as is.""" + now = datetime.now(timezone.utc) + days_cutoff = 30 # Stand-in value for tests + # Test date older than cutoff (further in the past) + old_date = now - timedelta(days=days_cutoff + 10) + + # When date is before cutoff (older), it should return the cutoff date + result = freeplan_clamp_datetime(old_date, days_cutoff) + expected = now - timedelta(days=days_cutoff) + + # Verify the result is within a small tolerance of the expected value + # (to account for tiny time differences during test execution) + assert abs((result - expected).total_seconds()) < 1 + + def test_date_after_cutoff(self): + """Test that dates after the cutoff are returned as is.""" + now = datetime.now(timezone.utc) + days_cutoff = 30 # Stand-in value for tests + # Test date newer than cutoff (more recent) + recent_date = now - timedelta(days=days_cutoff - 5) + + # When date is after cutoff (newer), it should return the original date + result = freeplan_clamp_datetime(recent_date, days_cutoff) + + # Should return the original date, not the cutoff + assert result == recent_date + + def test_date_at_cutoff(self): + """Test that dates exactly at the cutoff are returned as is.""" + now = datetime.now(timezone.utc) + days_cutoff = 30 # Stand-in value for tests + cutoff_date = now - timedelta(days=days_cutoff) + + result = freeplan_clamp_datetime(cutoff_date, days_cutoff) + + # Should return the exact cutoff date (allowing for microsecond differences) + assert abs((result - cutoff_date).total_seconds()) < 0.001 + + @patch('agentops.common.freeplan.datetime') + def test_with_mocked_time(self, mock_datetime): + """Test with a mocked current time to ensure reliable comparison.""" + # Fix the current time + fixed_now = datetime(2023, 1, 15, tzinfo=timezone.utc) + mock_datetime.now.return_value = fixed_now + + # Set cutoff days to 30 for this test + cutoff_days = 30 + # Expected cutoff date + cutoff = fixed_now - timedelta(days=cutoff_days) + + # Test with date before cutoff (older) + old_date = fixed_now - timedelta(days=cutoff_days + 10) + assert freeplan_clamp_datetime(old_date, cutoff_days) == cutoff + + # Test with date after cutoff (newer) + recent_date = fixed_now - timedelta(days=cutoff_days - 10) + assert freeplan_clamp_datetime(recent_date, cutoff_days) == recent_date + + +class TestFreePlanClampStartTime: + """Tests for the freeplan_clamp_start_time function.""" + + def test_start_time_is_none(self): + """Test that None start_time returns cutoff and modified=True.""" + days_cutoff = 30 + result, modified = freeplan_clamp_start_time(None, days_cutoff) + + # Should return cutoff datetime + expected_cutoff = datetime.now(timezone.utc) - timedelta(days=days_cutoff) + assert abs((result - expected_cutoff).total_seconds()) < 1 + + # Should be marked as modified since None was converted to cutoff + assert modified is True + + def test_start_time_before_cutoff(self): + """Test that start_time before cutoff is clamped and modified=True.""" + now = datetime.now(timezone.utc) + days_cutoff = 30 + # Date older than cutoff (further in the past) + old_start_time = now - timedelta(days=days_cutoff + 10) + + result, modified = freeplan_clamp_start_time(old_start_time, days_cutoff) + + # Should return cutoff, not the original old date + expected_cutoff = now - timedelta(days=days_cutoff) + assert abs((result - expected_cutoff).total_seconds()) < 1 + + # Should be marked as modified since it was clamped + assert modified is True + + def test_start_time_after_cutoff(self): + """Test that start_time after cutoff is not clamped and modified=False.""" + now = datetime.now(timezone.utc) + days_cutoff = 30 + # Date newer than cutoff (more recent) + recent_start_time = now - timedelta(days=days_cutoff - 5) + + result, modified = freeplan_clamp_start_time(recent_start_time, days_cutoff) + + # Should return the original date unchanged + assert result == recent_start_time + + # Should not be marked as modified since no clamping occurred + assert modified is False + + def test_start_time_at_cutoff(self): + """Test that start_time exactly at cutoff is not modified.""" + now = datetime.now(timezone.utc) + days_cutoff = 30 + cutoff_start_time = now - timedelta(days=days_cutoff) + + result, modified = freeplan_clamp_start_time(cutoff_start_time, days_cutoff) + + # Should return a date very close to the cutoff date (allowing for timing differences) + assert abs((result - cutoff_start_time).total_seconds()) < 1 + + # The timing precision issue means this might be marked as modified due to microsecond differences + # So we'll accept either outcome for this edge case + assert modified in [True, False] + + @patch('agentops.common.freeplan.datetime') + def test_start_time_with_mocked_time(self, mock_datetime): + """Test start_time with mocked current time for reliable comparison.""" + # Fix the current time + fixed_now = datetime(2023, 1, 15, tzinfo=timezone.utc) + mock_datetime.now.return_value = fixed_now + + cutoff_days = 30 + cutoff = fixed_now - timedelta(days=cutoff_days) + + # Test None case + result, modified = freeplan_clamp_start_time(None, cutoff_days) + assert result == cutoff + assert modified is True + + # Test old date case + old_date = fixed_now - timedelta(days=cutoff_days + 5) + result, modified = freeplan_clamp_start_time(old_date, cutoff_days) + assert result == cutoff + assert modified is True + + # Test recent date case + recent_date = fixed_now - timedelta(days=cutoff_days - 5) + result, modified = freeplan_clamp_start_time(recent_date, cutoff_days) + assert result == recent_date + assert modified is False + + +class TestFreePlanClampEndTime: + """Tests for the freeplan_clamp_end_time function.""" + + def test_end_time_is_none(self): + """Test that None end_time returns current time and modified=True.""" + days_cutoff = 30 + + # Capture current time before the call + before_call = datetime.now(timezone.utc) + result, modified = freeplan_clamp_end_time(None, days_cutoff) + after_call = datetime.now(timezone.utc) + + # Should return current time (within reasonable bounds) + assert before_call <= result <= after_call + + # Should be marked as modified since None was converted to current time + assert modified is True + + def test_end_time_before_cutoff(self): + """Test that end_time before cutoff is clamped and modified=True.""" + now = datetime.now(timezone.utc) + days_cutoff = 30 + # Date older than cutoff (further in the past) + old_end_time = now - timedelta(days=days_cutoff + 10) + + result, modified = freeplan_clamp_end_time(old_end_time, days_cutoff) + + # Should return cutoff, not the original old date + expected_cutoff = now - timedelta(days=days_cutoff) + assert abs((result - expected_cutoff).total_seconds()) < 1 + + # Should be marked as modified since it was clamped + assert modified is True + + def test_end_time_after_cutoff(self): + """Test that end_time after cutoff is not clamped and modified=False.""" + now = datetime.now(timezone.utc) + days_cutoff = 30 + # Date newer than cutoff (more recent) + recent_end_time = now - timedelta(days=days_cutoff - 5) + + result, modified = freeplan_clamp_end_time(recent_end_time, days_cutoff) + + # Should return the original date unchanged + assert result == recent_end_time + + # Should not be marked as modified since no clamping occurred + assert modified is False + + def test_end_time_at_cutoff(self): + """Test that end_time exactly at cutoff is not modified.""" + now = datetime.now(timezone.utc) + days_cutoff = 30 + cutoff_end_time = now - timedelta(days=days_cutoff) + + result, modified = freeplan_clamp_end_time(cutoff_end_time, days_cutoff) + + # Should return a date very close to the cutoff date (allowing for timing differences) + assert abs((result - cutoff_end_time).total_seconds()) < 1 + + # The timing precision issue means this might be marked as modified due to microsecond differences + # So we'll accept either outcome for this edge case + assert modified in [True, False] + + @patch('agentops.common.freeplan.datetime') + def test_end_time_with_mocked_time(self, mock_datetime): + """Test end_time with mocked current time for reliable comparison.""" + # Fix the current time + fixed_now = datetime(2023, 1, 15, tzinfo=timezone.utc) + mock_datetime.now.return_value = fixed_now + + cutoff_days = 30 + cutoff = fixed_now - timedelta(days=cutoff_days) + + # Test None case - should return current time + result, modified = freeplan_clamp_end_time(None, cutoff_days) + assert result == fixed_now + assert modified is True + + # Test old date case - should be clamped to cutoff + old_date = fixed_now - timedelta(days=cutoff_days + 5) + result, modified = freeplan_clamp_end_time(old_date, cutoff_days) + assert result == cutoff + assert modified is True + + # Test recent date case - should not be clamped + recent_date = fixed_now - timedelta(days=cutoff_days - 5) + result, modified = freeplan_clamp_end_time(recent_date, cutoff_days) + assert result == recent_date + assert modified is False diff --git a/app/api/tests/common/test_lifespan.py b/app/api/tests/common/test_lifespan.py new file mode 100644 index 000000000..2e671a943 --- /dev/null +++ b/app/api/tests/common/test_lifespan.py @@ -0,0 +1,180 @@ +import pytest +from unittest.mock import AsyncMock, MagicMock, patch + +from agentops.common.lifespan import lifespan + + +class TestLifespan: + """Tests for the lifespan context manager.""" + + @pytest.mark.asyncio + async def test_lifespan_normal_flow(self): + """Test that lifespan yields control and closes all connections on exit.""" + # Create a mock FastAPI app + mock_app = MagicMock() + + # Mock all the close functions + with ( + patch('agentops.common.lifespan.close_postgres') as mock_close_postgres, + patch('agentops.common.lifespan.close_clickhouse_clients') as mock_close_clickhouse, + patch('agentops.common.lifespan.close_supabase_clients') as mock_close_supabase, + ): + # Make the async close functions return coroutines + mock_close_clickhouse.return_value = AsyncMock()() + mock_close_supabase.return_value = AsyncMock()() + + # Use the lifespan context manager + async with lifespan(mock_app) as _: + # Verify we're in the startup phase + # (The function should yield here) + pass + + # After exiting the context, all cleanup functions should be called + mock_close_postgres.assert_called_once() + mock_close_clickhouse.assert_called_once() + mock_close_supabase.assert_called_once() + + @pytest.mark.asyncio + async def test_lifespan_postgres_error_handling(self): + """Test that lifespan continues cleanup even if PostgreSQL close fails.""" + mock_app = MagicMock() + + with ( + patch('agentops.common.lifespan.close_postgres') as mock_close_postgres, + patch('agentops.common.lifespan.close_clickhouse_clients') as mock_close_clickhouse, + patch('agentops.common.lifespan.close_supabase_clients') as mock_close_supabase, + patch('agentops.common.lifespan.logger') as mock_logger, + ): + # Make PostgreSQL close raise an exception + mock_close_postgres.side_effect = Exception("PostgreSQL connection error") + + # Make the async close functions return coroutines + mock_close_clickhouse.return_value = AsyncMock()() + mock_close_supabase.return_value = AsyncMock()() + + async with lifespan(mock_app): + pass + + # Verify error was logged + mock_logger.error.assert_any_call("Error closing PostgreSQL: PostgreSQL connection error") + + # Verify other cleanup functions were still called + mock_close_clickhouse.assert_called_once() + mock_close_supabase.assert_called_once() + + @pytest.mark.asyncio + async def test_lifespan_clickhouse_error_handling(self): + """Test that lifespan continues cleanup even if ClickHouse close fails.""" + mock_app = MagicMock() + + with ( + patch('agentops.common.lifespan.close_postgres') as mock_close_postgres, + patch('agentops.common.lifespan.close_clickhouse_clients') as mock_close_clickhouse, + patch('agentops.common.lifespan.close_supabase_clients') as mock_close_supabase, + patch('agentops.common.lifespan.logger') as mock_logger, + ): + # Make ClickHouse close raise an exception + async def raise_clickhouse_error(): + raise Exception("ClickHouse connection error") + + mock_close_clickhouse.side_effect = raise_clickhouse_error + mock_close_supabase.return_value = AsyncMock()() + + async with lifespan(mock_app): + pass + + # Verify error was logged + mock_logger.error.assert_any_call("Error closing ClickHouse: ClickHouse connection error") + + # Verify other cleanup functions were still called + mock_close_postgres.assert_called_once() + mock_close_supabase.assert_called_once() + + @pytest.mark.asyncio + async def test_lifespan_supabase_error_handling(self): + """Test that lifespan handles Supabase close errors gracefully.""" + mock_app = MagicMock() + + with ( + patch('agentops.common.lifespan.close_postgres') as mock_close_postgres, + patch('agentops.common.lifespan.close_clickhouse_clients') as mock_close_clickhouse, + patch('agentops.common.lifespan.close_supabase_clients') as mock_close_supabase, + patch('agentops.common.lifespan.logger') as mock_logger, + ): + # Make Supabase close raise an exception + async def raise_supabase_error(): + raise Exception("Supabase client error") + + mock_close_clickhouse.return_value = AsyncMock()() + mock_close_supabase.side_effect = raise_supabase_error + + async with lifespan(mock_app): + pass + + # Verify error was logged + mock_logger.error.assert_any_call("Error closing Supabase: Supabase client error") + + # Verify other cleanup functions were still called + mock_close_postgres.assert_called_once() + mock_close_clickhouse.assert_called_once() + + @pytest.mark.asyncio + async def test_lifespan_all_errors(self): + """Test that lifespan handles errors from all cleanup functions.""" + mock_app = MagicMock() + + with ( + patch('agentops.common.lifespan.close_postgres') as mock_close_postgres, + patch('agentops.common.lifespan.close_clickhouse_clients') as mock_close_clickhouse, + patch('agentops.common.lifespan.close_supabase_clients') as mock_close_supabase, + patch('agentops.common.lifespan.logger') as mock_logger, + ): + # Make all close functions raise exceptions + mock_close_postgres.side_effect = Exception("PostgreSQL error") + + async def raise_clickhouse_error(): + raise Exception("ClickHouse error") + + async def raise_supabase_error(): + raise Exception("Supabase error") + + mock_close_clickhouse.side_effect = raise_clickhouse_error + mock_close_supabase.side_effect = raise_supabase_error + + async with lifespan(mock_app): + pass + + # Verify all errors were logged + mock_logger.error.assert_any_call("Error closing PostgreSQL: PostgreSQL error") + mock_logger.error.assert_any_call("Error closing ClickHouse: ClickHouse error") + mock_logger.error.assert_any_call("Error closing Supabase: Supabase error") + + # Verify all cleanup functions were attempted + mock_close_postgres.assert_called_once() + mock_close_clickhouse.assert_called_once() + mock_close_supabase.assert_called_once() + + @pytest.mark.asyncio + async def test_lifespan_logging(self): + """Test that lifespan logs startup and shutdown messages.""" + mock_app = MagicMock() + + with ( + patch('agentops.common.lifespan.close_postgres'), + patch('agentops.common.lifespan.close_clickhouse_clients') as mock_close_clickhouse, + patch('agentops.common.lifespan.close_supabase_clients') as mock_close_supabase, + patch('agentops.common.lifespan.logger') as mock_logger, + ): + # Make the async close functions return coroutines + mock_close_clickhouse.return_value = AsyncMock()() + mock_close_supabase.return_value = AsyncMock()() + + async with lifespan(mock_app): + # Verify startup message was logged + mock_logger.info.assert_called_with("Starting up AgentOps API...") + + # Verify shutdown messages were logged + mock_logger.info.assert_any_call("Shutting down AgentOps API...") + mock_logger.info.assert_any_call("PostgreSQL connections closed") + mock_logger.info.assert_any_call("ClickHouse connections closed") + mock_logger.info.assert_any_call("Supabase clients closed") diff --git a/app/api/tests/common/test_orm_require_loaded.py b/app/api/tests/common/test_orm_require_loaded.py new file mode 100644 index 000000000..4769acd6d --- /dev/null +++ b/app/api/tests/common/test_orm_require_loaded.py @@ -0,0 +1,235 @@ +import pytest +import uuid +from sqlalchemy import Column, String, ForeignKey, Integer, create_engine +from sqlalchemy.orm import relationship, selectinload, joinedload, sessionmaker, DeclarativeBase + +from agentops.common.orm import require_loaded + + +class ModelBase(DeclarativeBase): + """Separate base for testing to avoid conflicts with main BaseModel.""" + pass + + +class AuthorModel(ModelBase): + """Test model representing an author for integration testing.""" + __tablename__ = "test_authors" + + id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4())) + name = Column(String, nullable=False) + + # Relationship to books + books = relationship("BookModel", back_populates="author", lazy="raise") + + @require_loaded("books") + def get_book_count(self): + """Method that requires books to be loaded.""" + return len(self.books) + + @require_loaded("books") + def get_book_titles(self): + """Method that requires books to be loaded to access titles.""" + return [book.title for book in self.books] + + +class BookModel(ModelBase): + """Test model representing a book for integration testing.""" + __tablename__ = "test_books" + + id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4())) + title = Column(String, nullable=False) + page_count = Column(Integer, default=100) + author_id = Column(String, ForeignKey("test_authors.id")) + + # Relationship to author + author = relationship("AuthorModel", back_populates="books", lazy="raise") + + @require_loaded("author") + def get_author_name(self): + """Method that requires author to be loaded.""" + return self.author.name + + +class TestRequireLoadedIntegration: + """Integration tests for the require_loaded decorator using real database operations.""" + + @pytest.fixture(scope="function") + def session(self): + """Create an in-memory SQLite session for testing.""" + engine = create_engine("sqlite:///:memory:", echo=False) + Session = sessionmaker(bind=engine) + session = Session() + + # Create tables + ModelBase.metadata.create_all(bind=engine) + + yield session + + session.close() + + @pytest.fixture(autouse=True) + def setup_test_data(self, session): + """Set up test data for each test.""" + # Create test author + self.author = AuthorModel(id=str(uuid.uuid4()), name="Test Author") + session.add(self.author) + + # Create test books + self.book1 = BookModel( + id=str(uuid.uuid4()), + title="Book One", + page_count=200, + author_id=self.author.id + ) + self.book2 = BookModel( + id=str(uuid.uuid4()), + title="Book Two", + page_count=150, + author_id=self.author.id + ) + session.add(self.book1) + session.add(self.book2) + session.commit() + + # Store IDs before expunging + self.author_id = self.author.id + self.book1_id = self.book1.id + self.book2_id = self.book2.id + + # Clear session to ensure fresh loads + session.expunge_all() + + def test_require_loaded_succeeds_with_preloaded_relationship(self, session): + """Test that decorator succeeds when relationship is preloaded.""" + # Load author with books preloaded + author = ( + session.query(AuthorModel) + .options(selectinload(AuthorModel.books)) + .filter_by(id=self.author_id) + .first() + ) + + # Should work because books are preloaded + book_count = author.get_book_count() + assert book_count == 2 + + book_titles = author.get_book_titles() + assert "Book One" in book_titles + assert "Book Two" in book_titles + + def test_require_loaded_fails_without_preloaded_relationship(self, session): + """Test that decorator fails when relationship is not preloaded.""" + # Load author WITHOUT preloading books + author = session.query(AuthorModel).filter_by(id=self.author_id).first() + + # Should fail because books are not preloaded (lazy="raise" by default) + with pytest.raises(RuntimeError, match="relationship 'books' not loaded for AuthorModel"): + author.get_book_count() + + def test_require_loaded_with_joinedload_succeeds(self, session): + """Test that decorator succeeds with joinedload.""" + # Load author with books using joinedload + author = ( + session.query(AuthorModel) + .options(joinedload(AuthorModel.books)) + .filter_by(id=self.author_id) + .first() + ) + + # Should work because books are loaded + book_count = author.get_book_count() + assert book_count == 2 + + def test_require_loaded_reverse_relationship(self, session): + """Test decorator on reverse relationship (book -> author).""" + # Load book with author preloaded + book = ( + session.query(BookModel) + .options(selectinload(BookModel.author)) + .filter_by(id=self.book1_id) + .first() + ) + + # Should work because author is preloaded + author_name = book.get_author_name() + assert author_name == "Test Author" + + def test_require_loaded_reverse_relationship_fails_without_preload(self, session): + """Test decorator fails on reverse relationship without preload.""" + # Load book WITHOUT preloading author + book = session.query(BookModel).filter_by(id=self.book1_id).first() + + # Should fail because author is not preloaded + with pytest.raises(RuntimeError, match="relationship 'author' not loaded for BookModel"): + book.get_author_name() + + def test_require_loaded_with_multiple_fields(self, session): + """Test decorator with multiple required fields.""" + # Test the decorator with multiple fields on existing model + @require_loaded("books") + def get_detailed_info(self): + # This method requires books to be loaded + return f"Author {self.name} has {len(self.books)} books" + + # Monkey patch the method onto AuthorModel for this test + AuthorModel.get_detailed_info = get_detailed_info + + # Load author with books preloaded + author = ( + session.query(AuthorModel) + .options(selectinload(AuthorModel.books)) + .filter_by(id=self.author_id) + .first() + ) + + # Should work because books relationship is loaded + info = author.get_detailed_info() + assert "Author Test Author has 2 books" == info + + # Clean up the monkey patch + delattr(AuthorModel, 'get_detailed_info') + + def test_require_loaded_handles_empty_relationships(self, session): + """Test decorator handles empty but loaded relationships correctly.""" + # Create author with no books + author_no_books = AuthorModel(id=str(uuid.uuid4()), name="Author No Books") + session.add(author_no_books) + session.commit() + + # Store ID before expunging + author_no_books_id = author_no_books.id + session.expunge_all() + + # Load with books preloaded (but empty) + author = ( + session.query(AuthorModel) + .options(selectinload(AuthorModel.books)) + .filter_by(id=author_no_books_id) + .first() + ) + + # Should work even with empty relationship + book_count = author.get_book_count() + assert book_count == 0 + + book_titles = author.get_book_titles() + assert book_titles == [] + + def test_require_loaded_preserves_method_signature(self, session): + """Test that decorator preserves original method signature and behavior.""" + # Load author with books preloaded + author = ( + session.query(AuthorModel) + .options(selectinload(AuthorModel.books)) + .filter_by(id=self.author_id) + .first() + ) + + # Verify the decorated method works correctly + assert callable(author.get_book_count) + assert author.get_book_count.__name__ == "get_book_count" + + # Verify it returns the expected type and value + count = author.get_book_count() + assert isinstance(count, int) + assert count == 2 \ No newline at end of file diff --git a/app/api/tests/common/test_otel.py b/app/api/tests/common/test_otel.py new file mode 100644 index 000000000..4283808fe --- /dev/null +++ b/app/api/tests/common/test_otel.py @@ -0,0 +1,236 @@ +from agentops.common.otel import otel_attributes_to_nested + + +class TestOtelAttributesToNested: + """Tests for the otel_attributes_to_nested function.""" + + def test_simple_nested_attributes(self): + """Test basic nested attribute conversion.""" + attributes = {"foo.bar": "value1", "foo.baz": "value2", "top": "level"} + + result = otel_attributes_to_nested(attributes) + + assert result == {"foo": {"bar": "value1", "baz": "value2"}, "top": "level"} + + def test_array_attributes(self): + """Test conversion of attributes with numeric indices to arrays.""" + attributes = { + "items.0.name": "first", + "items.0.value": "100", + "items.1.name": "second", + "items.1.value": "200", + } + + result = otel_attributes_to_nested(attributes) + + assert result == {"items": [{"name": "first", "value": "100"}, {"name": "second", "value": "200"}]} + + def test_mixed_nested_and_arrays(self): + """Test complex structure with both nested objects and arrays.""" + attributes = { + "user.name": "John", + "user.tags.0": "admin", + "user.tags.1": "developer", + "user.metadata.age": "30", + "user.metadata.city": "NYC", + } + + result = otel_attributes_to_nested(attributes) + + assert result == { + "user": {"name": "John", "tags": ["admin", "developer"], "metadata": {"age": "30", "city": "NYC"}} + } + + def test_sparse_array(self): + """Test that sparse arrays are filled with None values.""" + attributes = {"array.0": "first", "array.5": "sixth"} + + result = otel_attributes_to_nested(attributes) + + assert result == {"array": ["first", None, None, None, None, "sixth"]} + + def test_string_terminal_value_skip(self): + """Test that we skip attributes when trying to set a key on a string value.""" + attributes = { + "field": "string_value", + "field.subfield": "should_be_skipped", # Can't add subfield to a string + "field.another.deep": "also_skipped", + } + + result = otel_attributes_to_nested(attributes) + + # Only the first string value should be set + assert result == {"field": "string_value"} + + def test_type_mismatch_string_key_on_list(self): + """Test that string keys on lists are skipped.""" + attributes = { + "field.0": "array_item", + "field.invalid": "should_be_skipped", # String key on what should be a list + } + + result = otel_attributes_to_nested(attributes) + + # Only the valid array item should be set + assert result == {"field": ["array_item"]} + + def test_type_mismatch_int_key_on_dict(self): + """Test that integer keys on dicts are skipped.""" + attributes = { + "field.name": "dict_value", + "field.0": "should_be_skipped", # Integer key on what should be a dict + } + + result = otel_attributes_to_nested(attributes) + + # Only the valid dict entry should be set + assert result == {"field": {"name": "dict_value"}} + + def test_deep_nesting(self): + """Test deeply nested structures.""" + attributes = {"a.b.c.d.e.f": "deep_value", "a.b.c.d.e.g": "another_deep", "a.b.x": "sibling"} + + result = otel_attributes_to_nested(attributes) + + assert result == { + "a": {"b": {"c": {"d": {"e": {"f": "deep_value", "g": "another_deep"}}}, "x": "sibling"}} + } + + def test_legacy_gen_ai_prompt_conversion(self): + """Test that legacy gen_ai.prompt string format is converted to indexed format.""" + attributes = {"gen_ai.prompt": "What is the weather today?", "gen_ai.model": "gpt-4"} + + result = otel_attributes_to_nested(attributes) + + assert result == { + "gen_ai": { + "prompt": [{"content": "What is the weather today?", "role": "user"}], + "model": "gpt-4", + } + } + + def test_indexed_gen_ai_prompt_not_converted(self): + """Test that properly indexed gen_ai.prompt is not modified.""" + attributes = { + "gen_ai.prompt.0.content": "Hello", + "gen_ai.prompt.0.role": "user", + "gen_ai.prompt.1.content": "Hi there!", + "gen_ai.prompt.1.role": "assistant", + } + + result = otel_attributes_to_nested(attributes) + + assert result == { + "gen_ai": { + "prompt": [ + {"content": "Hello", "role": "user"}, + {"content": "Hi there!", "role": "assistant"}, + ] + } + } + + def test_gen_ai_non_string_prompt_not_converted(self): + """Test that gen_ai.prompt that's already an object/array is not converted.""" + # First, let's build a structure where gen_ai.prompt is already an array + attributes = {"gen_ai.prompt.0": "already_indexed"} + + result = otel_attributes_to_nested(attributes) + + # Should not apply legacy conversion since it's already indexed + assert result == {"gen_ai": {"prompt": ["already_indexed"]}} + + def test_empty_attributes(self): + """Test that empty attributes dict returns empty result.""" + result = otel_attributes_to_nested({}) + assert result == {} + + def test_single_level_attributes(self): + """Test attributes with no nesting.""" + attributes = {"field1": "value1", "field2": "value2", "field3": "value3"} + + result = otel_attributes_to_nested(attributes) + + assert result == attributes + + def test_numeric_string_keys_not_converted(self): + """Test that numeric strings that aren't at array positions stay as strings.""" + attributes = { + "map.123": "value", # This should create a dict with string key "123" + "array.0": "item", # This should create an array + } + + result = otel_attributes_to_nested(attributes) + + assert result == {"map": {"123": "value"}, "array": ["item"]} + + def test_conflicting_paths_first_wins(self): + """Test that when paths conflict, the first one processed wins.""" + attributes = { + "field.sub": "string_value", + "field.sub.nested": "should_be_skipped", # Can't nest under string + } + + result = otel_attributes_to_nested(attributes) + + assert result == {"field": {"sub": "string_value"}} + + def test_complex_real_world_example(self): + """Test a complex real-world example with OpenTelemetry span attributes.""" + attributes = { + "gen_ai.prompt.0.content": "Write a function", + "gen_ai.prompt.0.role": "user", + "gen_ai.completion.0.content": "def hello(): pass", + "gen_ai.completion.0.role": "assistant", + "gen_ai.model": "gpt-4", + "gen_ai.usage.prompt_tokens": "10", + "gen_ai.usage.completion_tokens": "5", + "llm.is_streaming": "false", + "span.kind": "CLIENT", + "error.message": "none", + "tags.0": "production", + "tags.1": "v2", + } + + result = otel_attributes_to_nested(attributes) + + assert result == { + "gen_ai": { + "prompt": [{"content": "Write a function", "role": "user"}], + "completion": [{"content": "def hello(): pass", "role": "assistant"}], + "model": "gpt-4", + "usage": {"prompt_tokens": "10", "completion_tokens": "5"}, + }, + "llm": {"is_streaming": "false"}, + "span": {"kind": "CLIENT"}, + "error": {"message": "none"}, + "tags": ["production", "v2"], + } + + def test_edge_case_existing_string_in_path(self): + """Test handling when trying to traverse through an existing string value.""" + attributes = { + "a.b": "string", + "a.b.c.d": "should_skip", # Can't traverse through string at a.b + } + + result = otel_attributes_to_nested(attributes) + + assert result == {"a": {"b": "string"}} + + def test_multiple_legacy_prompts(self): + """Test multiple gen_ai attributes with legacy format.""" + attributes = { + "gen_ai.prompt": "User question here", + "gen_ai.completion": "AI response here", # This won't be converted, only prompt + "other.field": "value", + } + + result = otel_attributes_to_nested(attributes) + + assert result == { + "gen_ai": { + "prompt": [{"content": "User question here", "role": "user"}], + "completion": "AI response here", # Not converted + }, + "other": {"field": "value"}, + } diff --git a/app/api/tests/conftest.py b/app/api/tests/conftest.py new file mode 100644 index 000000000..c24a1b030 --- /dev/null +++ b/app/api/tests/conftest.py @@ -0,0 +1,12 @@ +from pathlib import Path +from dotenv import load_dotenv + +# Load test environment before importing anything else +load_dotenv(Path(__file__).parent.parent / "tests/.env", override=True) + +from ._conftest.common import * +from ._conftest.app import * +from ._conftest.supabase import * +from ._conftest.clickhouse import * +from ._conftest.users import * +from ._conftest.projects import * diff --git a/app/api/tests/db/__init__.py b/app/api/tests/db/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/api/tests/db/clickhouse/__init__.py b/app/api/tests/db/clickhouse/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/api/tests/db/clickhouse/test_model_query_builder.py b/app/api/tests/db/clickhouse/test_model_query_builder.py new file mode 100644 index 000000000..a510f5faa --- /dev/null +++ b/app/api/tests/db/clickhouse/test_model_query_builder.py @@ -0,0 +1,252 @@ +import re +from typing import ClassVar +from agentops.api.db.clickhouse.models import ClickhouseModel, SelectFields, FilterDict, SearchFields + + +def normalize_sql(sql: str) -> str: + """Normalize SQL string for exact comparison. + + This preserves the actual SQL format while handling things like + trailing semicolons and consistent spacing. + """ + # Remove extra spaces and newlines + return re.sub(r'\s+', ' ', sql.strip()) + + +class TestModel(ClickhouseModel): + """Test model for query builder tests""" + + table_name: ClassVar[str] = "test_table" + selectable_fields: ClassVar[SelectFields] = { + "Id": "id", + "Name": "name", + "Age": "age", + "ProjectId": "project_id", + "Timestamp": "timestamp", + } + filterable_fields: ClassVar[FilterDict] = { + "id": ("=", "Id"), + "min_age": (">=", "Age"), + "max_age": ("<=", "Age"), + "project_id": ("=", "ProjectId"), + "start_time": (">=", "Timestamp"), + "end_time": ("<=", "Timestamp"), + } + searchable_fields: ClassVar[SearchFields] = { + "name": ("ILIKE", "Name"), + "project_id": ("LIKE", "ProjectId"), + } + + +class TestModelWithStringFields(ClickhouseModel): + """Test model with string selectable fields""" + + table_name: ClassVar[str] = "test_table_string" + selectable_fields: ClassVar[SelectFields] = "*" + + +class TestModelWithListFields(ClickhouseModel): + """Test model with list selectable fields""" + + table_name: ClassVar[str] = "test_table_list" + selectable_fields: ClassVar[SelectFields] = ["Id", "Name", "Age"] + + +def test_get_select_clause_dict(): + """Test _get_select_clause with dictionary fields""" + select_clause = TestModel._get_select_clause() + # The exact order must match the order in the class definition + expected = "Id as id, Name as name, Age as age, ProjectId as project_id, Timestamp as timestamp" + assert select_clause == expected + + +def test_get_select_clause_string(): + """Test _get_select_clause with string fields""" + select_clause = TestModelWithStringFields._get_select_clause() + assert select_clause == "*" + + +def test_get_select_clause_list(): + """Test _get_select_clause with list fields""" + select_clause = TestModelWithListFields._get_select_clause() + assert select_clause == "Id, Name, Age" + + +def test_get_select_clause_override(): + """Test _get_select_clause with overridden fields""" + select_clause = TestModel._get_select_clause(fields=["Id", "Name"]) + assert select_clause == "Id, Name" + + +def test_get_where_clause_empty(): + """Test _get_where_clause with empty filters""" + where_clause, params = TestModel._get_where_clause() + assert where_clause == "" + assert params == {} + + +def test_get_where_clause_single_filter(): + """Test _get_where_clause with a single filter""" + where_clause, params = TestModel._get_where_clause(id="123") + assert where_clause == "Id = %(id)s" + assert params == {"id": "123"} + + +def test_get_where_clause_multiple_filters(): + """Test _get_where_clause with multiple filters""" + where_clause, params = TestModel._get_where_clause(project_id="abc", min_age=18, max_age=65) + + # Only the fields we provided should be in the result + assert where_clause == "Age >= %(min_age)s AND Age <= %(max_age)s AND ProjectId = %(project_id)s" + assert params == {"min_age": 18, "max_age": 65, "project_id": "abc"} + + +def test_get_search_clause_empty(): + """Test _get_search_clause with no search term""" + search_clause, params = TestModel._get_search_clause() + assert search_clause == "" + assert params == {} + + +def test_get_search_clause_with_term(): + """Test _get_search_clause with a search term""" + search_clause, params = TestModel._get_search_clause(search_term="test") + + # Order based on TestModel.searchable_fields + assert search_clause == "Name ILIKE %(search_name)s OR ProjectId LIKE %(search_project_id)s" + assert params == {"search_name": "%test%", "search_project_id": "%test%"} + + +def test_get_select_query_basic(): + """Test _get_select_query with basic parameters""" + query, params = TestModel._get_select_query() + + normalized_query = normalize_sql(query) + # Order matches the order in TestModel.selectable_fields + expected_query = normalize_sql( + "SELECT Id as id, Name as name, Age as age, ProjectId as project_id, Timestamp as timestamp FROM test_table" + ) + assert normalized_query == expected_query + assert params == {} + + +def test_get_select_query_string_fields(): + """Test _get_select_query with string selectable fields""" + query, params = TestModelWithStringFields._get_select_query() + + normalized_query = normalize_sql(query) + assert normalized_query == "SELECT * FROM test_table_string" + assert params == {} + + +def test_get_select_query_list_fields(): + """Test _get_select_query with list selectable fields""" + query, params = TestModelWithListFields._get_select_query() + + normalized_query = normalize_sql(query) + assert normalized_query == "SELECT Id, Name, Age FROM test_table_list" + assert params == {} + + +def test_get_select_query_with_filters(): + """Test _get_select_query with filters""" + query, params = TestModel._get_select_query(filters={"id": "123"}) + + normalized_query = normalize_sql(query) + expected_query = normalize_sql( + "SELECT Id as id, Name as name, Age as age, ProjectId as project_id, Timestamp as timestamp FROM test_table WHERE Id = %(id)s" + ) + assert normalized_query == expected_query + assert params == {"id": "123"} + + +def test_get_select_query_with_search(): + """Test _get_select_query with search term""" + query, params = TestModel._get_select_query(search="test") + + normalized_query = normalize_sql(query) + expected_query = normalize_sql( + "SELECT Id as id, Name as name, Age as age, ProjectId as project_id, Timestamp as timestamp FROM test_table WHERE Name ILIKE %(search_name)s OR ProjectId LIKE %(search_project_id)s" + ) + assert normalized_query == expected_query + assert params == {"search_name": "%test%", "search_project_id": "%test%"} + + +def test_get_select_query_with_filters_and_search(): + """Test _get_select_query with both filters and search""" + query, params = TestModel._get_select_query(filters={"id": "123"}, search="test") + + normalized_query = normalize_sql(query) + # Verify the order in both the select fields and the search fields + expected_query = normalize_sql( + "SELECT Id as id, Name as name, Age as age, ProjectId as project_id, Timestamp as timestamp FROM test_table WHERE (Id = %(id)s) AND (Name ILIKE %(search_name)s OR ProjectId LIKE %(search_project_id)s)" + ) + assert normalized_query == expected_query + assert params == {"id": "123", "search_name": "%test%", "search_project_id": "%test%"} + + +def test_get_select_query_with_order_by(): + """Test _get_select_query with order_by parameter""" + query, params = TestModel._get_select_query(order_by="Timestamp DESC") + + normalized_query = normalize_sql(query) + expected_query = normalize_sql( + "SELECT Id as id, Name as name, Age as age, ProjectId as project_id, Timestamp as timestamp FROM test_table ORDER BY Timestamp DESC" + ) + assert normalized_query == expected_query + assert params == {} + + +def test_get_select_query_with_limit(): + """Test _get_select_query with limit parameter""" + query, params = TestModel._get_select_query(limit=10) + + normalized_query = normalize_sql(query) + expected_query = normalize_sql( + "SELECT Id as id, Name as name, Age as age, ProjectId as project_id, Timestamp as timestamp FROM test_table LIMIT 10" + ) + assert normalized_query == expected_query + assert params == {} + + +def test_get_select_query_with_offset(): + """Test _get_select_query with offset parameter""" + query, params = TestModel._get_select_query(offset=20) + + normalized_query = normalize_sql(query) + expected_query = normalize_sql( + "SELECT Id as id, Name as name, Age as age, ProjectId as project_id, Timestamp as timestamp FROM test_table OFFSET 20" + ) + assert normalized_query == expected_query + assert params == {} + + +def test_get_select_query_complete(): + """Test _get_select_query with all parameters""" + query, params = TestModel._get_select_query( + fields=["Id", "Name", "Age"], + filters={"project_id": "abc123", "min_age": 21}, + search="test", + order_by="Age DESC", + limit=10, + offset=20, + ) + + normalized_query = normalize_sql(query) + # Match the exact ordering as defined in the model's class variables + expected_query = normalize_sql(""" + SELECT Id, Name, Age + FROM test_table + WHERE (Age >= %(min_age)s AND ProjectId = %(project_id)s) + AND (Name ILIKE %(search_name)s OR ProjectId LIKE %(search_project_id)s) + ORDER BY Age DESC + LIMIT 10 + OFFSET 20 + """) + assert normalized_query == expected_query + assert params == { + "project_id": "abc123", + "min_age": 21, + "search_name": "%test%", + "search_project_id": "%test%", + } diff --git a/app/api/tests/deploy/__init__.py b/app/api/tests/deploy/__init__.py new file mode 100644 index 000000000..e9bf83ace --- /dev/null +++ b/app/api/tests/deploy/__init__.py @@ -0,0 +1 @@ +# Deploy tests package \ No newline at end of file diff --git a/app/api/tests/deploy/test_deployment_integration.py b/app/api/tests/deploy/test_deployment_integration.py new file mode 100644 index 000000000..4686b44da --- /dev/null +++ b/app/api/tests/deploy/test_deployment_integration.py @@ -0,0 +1,690 @@ +"""Integration tests for deployment API endpoints using direct view calls.""" + +import pytest +from unittest.mock import Mock, patch +from fastapi import HTTPException + +from agentops.deploy.models import HostingProjectModel +from agentops.opsboard.models import ProjectModel +from agentops.deploy.views.deploy import ( + CreateUpdateSecretView, + ListSecretsView, + InitiateDeploymentView, + DeploymentStatusView, + DeploymentHistoryView, +) +from agentops.deploy.schemas import CreateSecretRequest + + +@pytest.fixture +def mock_hosting_project(): + """Mock hosting project model.""" + hosting_project = Mock(spec=HostingProjectModel) + hosting_project.id = "project-123" + hosting_project.namespace = "test-namespace" + hosting_project.app_name = "test-app" + hosting_project.git_url = "https://github.com/test/repo" + hosting_project.git_branch = "main" + hosting_project.entrypoint = "main.py" + hosting_project.github_oath_access_token = "token123" + hosting_project.pack_name = "FASTAPI" # Default pack for tests + return hosting_project + + +@pytest.fixture +def mock_project(): + """Mock project model.""" + project = Mock(spec=ProjectModel) + project.id = "project-123" + project.name = "Test Project" + project.org = Mock() + project.org.is_user_member.return_value = True + return project + + +@pytest.fixture(scope="session") +def mock_request(): + """Create a mock request with a session user_id.""" + from unittest.mock import MagicMock + from fastapi import Request + + request = MagicMock(spec=Request) + request.state.session.user_id = "00000000-0000-0000-0000-000000000001" + return request + + +class TestDeploymentSecretsAPI: + """Test the deployment secrets API endpoints.""" + + @patch('agentops.deploy.views.deploy.delete_secret') + @patch('agentops.deploy.views.deploy.create_secret') + async def test_create_secret_success( + self, + mock_create, + mock_delete, + mock_request, + orm_session, + mock_hosting_project, + mock_project, + ): + """Test creating a secret via view function.""" + # Setup mocks + mock_delete.return_value = True + mock_create.return_value = Mock() + + with ( + patch.object(HostingProjectModel, 'get_by_id', return_value=mock_hosting_project), + patch.object(ProjectModel, 'get_by_id', return_value=mock_project), + ): + # Create the view and call it directly + view = CreateUpdateSecretView(mock_request) + body = CreateSecretRequest(name="DATABASE_URL", value="postgresql://localhost:5432/test") + + response = await view( + project_id="project-123", + body=body, + orm=orm_session, + ) + + assert response.success is True + assert response.message == "Successfully created secret" + + @patch('agentops.deploy.views.deploy.list_secrets') + async def test_list_secrets_success( + self, mock_list_secrets, mock_request, orm_session, mock_hosting_project, mock_project + ): + """Test listing secrets via view function.""" + # Setup mocks + mock_list_secrets.return_value = ["DATABASE_URL", "API_KEY"] + + with ( + patch.object(HostingProjectModel, 'get_by_id', return_value=mock_hosting_project), + patch.object(ProjectModel, 'get_by_id', return_value=mock_project), + ): + # Create the view and call it directly + view = ListSecretsView(mock_request) + + response = await view( + project_id="project-123", + orm=orm_session, + ) + + assert len(response.secrets) == 2 + secret_names = [secret.name for secret in response.secrets] + assert "DATABASE_URL" in secret_names + assert "API_KEY" in secret_names + + async def test_deployment_not_found(self, mock_request, orm_session): + """Test view response when deployment doesn't exist.""" + with patch.object(ProjectModel, 'get_by_id', return_value=None): + # Create the view and call it directly + view = ListSecretsView(mock_request) + + with pytest.raises(HTTPException) as exc_info: + await view( + project_id="00000000-0000-0000-0000-000000000000", + orm=orm_session, + ) + + assert exc_info.value.status_code == 404 + assert "Project not found" in str(exc_info.value.detail) + + +class TestDeploymentManagementAPI: + """Test the deployment management API endpoints.""" + + @patch('agentops.deploy.views.deploy.queue_task') + @patch('agentops.deploy.views.deploy.list_secrets') + async def test_initiate_deployment_success( + self, + mock_list_secrets, + mock_queue, + mock_request, + orm_session, + mock_hosting_project, + mock_project, + ): + """Test initiating a deployment via view function.""" + # Setup mocks + mock_list_secrets.return_value = ["DATABASE_URL"] + mock_queue.return_value = "job-456" + + with ( + patch.object(HostingProjectModel, 'get_by_id', return_value=mock_hosting_project), + patch.object(ProjectModel, 'get_by_id', return_value=mock_project), + ): + # Create the view and call it directly + view = InitiateDeploymentView(mock_request) + + response = await view( + project_id="project-123", + orm=orm_session, + ) + + assert response.success is True + assert response.message == "Deployment initiated successfully" + assert response.job_id == "job-456" + + @patch('agentops.deploy.views.deploy.get_task_events') + async def test_deployment_status_success( + self, mock_get_events, mock_request, orm_session, mock_hosting_project, mock_project + ): + """Test getting deployment status via view function.""" + from datetime import datetime + from enum import Enum + + class MockStatus(Enum): + SUCCESS = "success" + + # Setup mocks + mock_events = [ + Mock( + event_type="build", + status=MockStatus.SUCCESS, + message="Build completed", + timestamp=datetime.fromisoformat("2024-01-01T00:00:00"), + ), + ] + mock_get_events.return_value = mock_events + + with ( + patch.object(HostingProjectModel, 'get_by_id', return_value=mock_hosting_project), + patch.object(ProjectModel, 'get_by_id', return_value=mock_project), + ): + # Create the view and call it directly + view = DeploymentStatusView(mock_request) + + response = await view( + project_id="project-123", + job_id="test-job-123", + orm=orm_session, + ) + + assert len(response.events) == 1 + assert response.events[0].type == "build" + assert response.events[0].status == "success" + assert response.events[0].message == "Build completed" + + @patch('agentops.deploy.views.deploy.get_task_events') + async def test_deployment_status_with_start_date( + self, mock_get_events, mock_request, orm_session, mock_hosting_project, mock_project + ): + """Test getting deployment status with start date filter via view function.""" + from datetime import datetime + + # Setup mocks + mock_get_events.return_value = [] + + with ( + patch.object(HostingProjectModel, 'get_by_id', return_value=mock_hosting_project), + patch.object(ProjectModel, 'get_by_id', return_value=mock_project), + ): + # Create the view and call it directly + view = DeploymentStatusView(mock_request) + start_date = datetime.fromisoformat("2024-01-01T12:00:00") + + response = await view( + project_id="project-123", + job_id="test-job-456", + start_date=start_date, + orm=orm_session, + ) + + assert len(response.events) == 0 + + +class TestViewValidation: + """Test view validation and error handling.""" + + @patch('agentops.deploy.views.deploy.create_secret') + @patch('agentops.deploy.views.deploy.delete_secret') + async def test_create_secret_kubernetes_error( + self, + mock_delete, + mock_create, + mock_request, + orm_session, + mock_hosting_project, + mock_project, + ): + """Test creating a secret when Kubernetes operations fail.""" + # Setup mocks + mock_delete.return_value = True + mock_create.side_effect = Exception("Kubernetes API error") + + with ( + patch.object(HostingProjectModel, 'get_by_id', return_value=mock_hosting_project), + patch.object(ProjectModel, 'get_by_id', return_value=mock_project), + ): + # Create the view and call it directly + view = CreateUpdateSecretView(mock_request) + body = CreateSecretRequest(name="DATABASE_URL", value="postgresql://localhost:5432/test") + + # The view should let the exception bubble up + with pytest.raises(Exception) as exc_info: + await view( + project_id="project-123", + body=body, + orm=orm_session, + ) + + assert "Kubernetes API error" in str(exc_info.value) + + +class TestDeploymentHistoryAPI: + """Test the deployment history API endpoint.""" + + @patch('agentops.deploy.views.deploy.get_task_status') + @patch('agentops.deploy.views.deploy.get_tasks') + async def test_deployment_history_success( + self, + mock_get_tasks, + mock_get_status, + mock_request, + orm_session, + mock_hosting_project, + mock_project, + ): + """Test getting deployment history via view function.""" + from enum import Enum + + class MockStatus(Enum): + SUCCESS = "success" + RUNNING = "running" + + # Setup mock jobs + mock_jobs = [ + { + "job_id": "job-123", + "project_id": "project-123", + "namespace": "test-namespace", + "queued_at": "2024-01-01T10:00:00", + "config": {}, + }, + { + "job_id": "job-456", + "project_id": "project-123", + "namespace": "test-namespace", + "queued_at": "2024-01-01T11:00:00", + "config": {}, + }, + ] + mock_get_tasks.return_value = mock_jobs + + # Setup mock status for each job (get_task_status returns BaseEvent) + def mock_status_side_effect(job_id): + if job_id == "job-123": + return Mock( + status=MockStatus.SUCCESS, + message="Deployment completed successfully", + ) + elif job_id == "job-456": + return Mock( + status=MockStatus.RUNNING, + message="Deployment in progress", + ) + return None + + mock_get_status.side_effect = mock_status_side_effect + + with ( + patch.object(HostingProjectModel, 'get_by_id', return_value=mock_hosting_project), + patch.object(ProjectModel, 'get_by_id', return_value=mock_project), + ): + # Create the view and call it directly + view = DeploymentHistoryView(mock_request) + + response = await view( + project_id="project-123", + orm=orm_session, + ) + + # Verify response + assert len(response.jobs) == 2 + + # Check first job + job1 = response.jobs[0] + assert job1.id == "job-123" + assert job1.queued_at == "2024-01-01T10:00:00" + assert job1.status == "success" + assert job1.message == "Deployment completed successfully" + + # Check second job + job2 = response.jobs[1] + assert job2.id == "job-456" + assert job2.queued_at == "2024-01-01T11:00:00" + assert job2.status == "running" + assert job2.message == "Deployment in progress" + + @patch('agentops.deploy.views.deploy.get_task_status') + @patch('agentops.deploy.views.deploy.get_tasks') + async def test_deployment_history_no_events( + self, + mock_get_tasks, + mock_get_status, + mock_request, + orm_session, + mock_hosting_project, + mock_project, + ): + """Test deployment history when jobs have no events.""" + # Setup mock jobs + mock_jobs = [ + { + "job_id": "job-789", + "project_id": "project-123", + "namespace": "test-namespace", + "queued_at": "2024-01-01T12:00:00", + "config": {}, + }, + ] + mock_get_tasks.return_value = mock_jobs + mock_get_status.return_value = None # No events + + with ( + patch.object(HostingProjectModel, 'get_by_id', return_value=mock_hosting_project), + patch.object(ProjectModel, 'get_by_id', return_value=mock_project), + ): + # Create the view and call it directly + view = DeploymentHistoryView(mock_request) + + response = await view( + project_id="project-123", + orm=orm_session, + ) + + # Verify response + assert len(response.jobs) == 1 + job = response.jobs[0] + assert job.id == "job-789" + assert job.queued_at == "2024-01-01T12:00:00" + assert job.status == "unknown" + assert job.message == "" + + @patch('agentops.deploy.views.deploy.get_tasks') + async def test_deployment_history_empty_jobs( + self, + mock_get_tasks, + mock_request, + orm_session, + mock_hosting_project, + mock_project, + ): + """Test deployment history when no jobs exist.""" + mock_get_tasks.return_value = [] # No jobs + + with ( + patch.object(HostingProjectModel, 'get_by_id', return_value=mock_hosting_project), + patch.object(ProjectModel, 'get_by_id', return_value=mock_project), + ): + # Create the view and call it directly + view = DeploymentHistoryView(mock_request) + + response = await view( + project_id="project-123", + orm=orm_session, + ) + + # Verify response + assert len(response.jobs) == 0 + + +class TestDeploymentPacksAPI: + """Test deployment pack functionality in API endpoints.""" + + @pytest.fixture + def mock_project_with_api_key(self): + """Mock project model with API key.""" + project = Mock(spec=ProjectModel) + project.id = "project-123" + project.name = "Test Project" + project.api_key = "test-api-key-123" + project.org = Mock() + project.org.is_user_member.return_value = True + return project + + def test_hosting_project_deployment_config_with_fastapi_pack(self, mock_project_with_api_key): + """Test that FASTAPI pack creates correct deployment config.""" + from jockey import DeploymentConfig + from agentops.deploy.models import HostingProjectModel + + # Create hosting project with FASTAPI pack + hosting_project = HostingProjectModel() + hosting_project.id = "project-123" + hosting_project.pack_name = "FASTAPI" + hosting_project.git_url = "https://github.com/test/repo" + hosting_project.git_branch = "main" + hosting_project.entrypoint = "main.py" + hosting_project.github_oath_access_token = "token123" + hosting_project.watch_path = None + hosting_project.user_callback_url = None + hosting_project.project = mock_project_with_api_key + + # Mock list_secrets to return empty list + with patch('jockey.list_secrets', return_value=[]): + config = hosting_project.deployment_config + + # Verify FASTAPI pack defaults are applied + assert config.dockerfile_template == "fastapi-agent" + assert config.ports == [8000] + assert config.build_files == {} + assert config.namespace == "project-123" # namespace property returns str(id) + assert config.project_id == "project-123" + + def test_hosting_project_deployment_config_with_crewai_pack(self, mock_project_with_api_key): + """Test that CREWAI pack creates correct deployment config.""" + from jockey import DeploymentConfig + from agentops.deploy.models import HostingProjectModel + + # Create hosting project with CREWAI pack + hosting_project = HostingProjectModel() + hosting_project.id = "project-123" + hosting_project.pack_name = "CREWAI" + hosting_project.git_url = "https://github.com/test/repo" + hosting_project.git_branch = "main" + hosting_project.entrypoint = "main.py" + hosting_project.github_oath_access_token = "token123" + hosting_project.watch_path = "src/" + hosting_project.user_callback_url = None + hosting_project.project = mock_project_with_api_key + + # Mock list_secrets to return empty list + with patch('jockey.list_secrets', return_value=[]): + config = hosting_project.deployment_config + + # Verify CREWAI pack defaults are applied + assert config.dockerfile_template == "crewai-agent" + assert config.ports == [8080] + assert isinstance(config.build_files, dict) # Should have build files + assert config.namespace == "project-123" # namespace property returns str(id) + assert config.project_id == "project-123" + assert config.watch_path == "src/" + + def test_hosting_project_deployment_config_with_crewai_job_pack(self, mock_project_with_api_key): + """Test that CREWAI_JOB pack creates correct deployment config.""" + from jockey import DeploymentConfig + from agentops.deploy.models import HostingProjectModel + + # Create hosting project with CREWAI_JOB pack + hosting_project = HostingProjectModel() + hosting_project.id = "project-123" + hosting_project.pack_name = "CREWAI_JOB" + hosting_project.git_url = "https://github.com/test/repo" + hosting_project.git_branch = "main" + hosting_project.entrypoint = "main.py" + hosting_project.github_oath_access_token = "token123" + hosting_project.watch_path = "src/" + hosting_project.user_callback_url = None + hosting_project.project = mock_project_with_api_key + + # Mock list_secrets to return empty list + with patch('jockey.list_secrets', return_value=[]): + config = hosting_project.deployment_config + + # Verify CREWAI_JOB pack defaults are applied + assert config.dockerfile_template == "crewai-job" + assert config.ports == [] # No ports for job execution + assert isinstance(config.build_files, dict) # Should have build files + assert config.namespace == "project-123" # namespace property returns str(id) + assert config.project_id == "project-123" + + def test_hosting_project_deployment_config_with_none_pack_fallback(self, mock_project_with_api_key): + """Test that None pack_name falls back to FASTAPI.""" + from jockey import DeploymentConfig + from agentops.deploy.models import HostingProjectModel + + # Create hosting project with None pack_name + hosting_project = HostingProjectModel() + hosting_project.id = "project-123" + hosting_project.pack_name = None + hosting_project.git_url = "https://github.com/test/repo" + hosting_project.git_branch = "main" + hosting_project.entrypoint = "main.py" + hosting_project.github_oath_access_token = "token123" + hosting_project.watch_path = None + hosting_project.user_callback_url = None + hosting_project.project = mock_project_with_api_key + + # Mock list_secrets to return empty list + with patch('jockey.list_secrets', return_value=[]): + config = hosting_project.deployment_config + + # Should fall back to FASTAPI defaults + assert config.dockerfile_template == "fastapi-agent" + assert config.ports == [8000] + assert config.build_files == {} + + def test_hosting_project_deployment_config_with_invalid_pack_raises_error(self, mock_project_with_api_key): + """Test that invalid pack_name raises ValueError.""" + from jockey import DeploymentConfig + from agentops.deploy.models import HostingProjectModel + + # Create hosting project with invalid pack_name + hosting_project = HostingProjectModel() + hosting_project.id = "project-123" + hosting_project.pack_name = "INVALID_PACK" + hosting_project.git_url = "https://github.com/test/repo" + hosting_project.git_branch = "main" + hosting_project.entrypoint = "main.py" + hosting_project.github_oath_access_token = "token123" + hosting_project.watch_path = None + hosting_project.user_callback_url = None + hosting_project.project = mock_project_with_api_key + + # Mock list_secrets to return empty list + with patch('jockey.list_secrets', return_value=[]): + with pytest.raises(ValueError, match="Invalid deployment pack name: INVALID_PACK"): + config = hosting_project.deployment_config + + @patch('agentops.deploy.views.deploy.queue_task') + async def test_initiate_deployment_with_crewai_pack( + self, + mock_queue, + mock_request, + orm_session, + mock_project_with_api_key, + ): + """Test that deployment uses correct pack configuration.""" + # Setup hosting project with CREWAI pack + hosting_project = HostingProjectModel() + hosting_project.id = "project-123" + hosting_project.pack_name = "CREWAI" + hosting_project.git_url = "https://github.com/test/repo" + hosting_project.git_branch = "main" + hosting_project.entrypoint = "main.py" + hosting_project.github_oath_access_token = "token123" + hosting_project.watch_path = "src/" + hosting_project.user_callback_url = None + hosting_project.project = mock_project_with_api_key + + # Setup mocks + mock_queue.return_value = "job-456" + + with ( + patch.object(HostingProjectModel, 'get_by_id', return_value=hosting_project), + patch.object(ProjectModel, 'get_by_id', return_value=mock_project_with_api_key), + patch('jockey.list_secrets', return_value=["DATABASE_URL"]), + ): + # Create the view and call it directly + view = InitiateDeploymentView(mock_request) + + response = await view( + project_id="project-123", + orm=orm_session, + ) + + # Verify response + assert response.success is True + assert response.message == "Deployment initiated successfully" + assert response.job_id == "job-456" + + # Verify queue_task was called with correct config + mock_queue.assert_called_once() + call_args = mock_queue.call_args + config = call_args[1]["config"] # Get config from kwargs + + # Should have CREWAI pack defaults + assert config.dockerfile_template == "crewai-agent" + assert config.ports == [8080] + assert isinstance(config.build_files, dict) + assert len(config.build_files) > 0 # CREWAI should have build files + + @patch('agentops.deploy.views.deploy.queue_task') + async def test_initiate_deployment_preserves_user_overrides( + self, + mock_queue, + mock_request, + orm_session, + mock_project_with_api_key, + ): + """Test that user-provided fields override pack defaults.""" + # Setup hosting project with custom settings + hosting_project = HostingProjectModel() + hosting_project.id = "project-123" + hosting_project.pack_name = "FASTAPI" + hosting_project.git_url = "https://github.com/test/custom-repo" + hosting_project.git_branch = "feature-branch" + hosting_project.entrypoint = "custom_main.py" + hosting_project.github_oath_access_token = "custom-token" + hosting_project.watch_path = "custom/path/" + hosting_project.user_callback_url = "https://custom-callback.com" + hosting_project.project = mock_project_with_api_key + + # Setup mocks + mock_queue.return_value = "job-789" + + with ( + patch.object(HostingProjectModel, 'get_by_id', return_value=hosting_project), + patch.object(ProjectModel, 'get_by_id', return_value=mock_project_with_api_key), + patch('jockey.list_secrets', return_value=["API_KEY"]), + ): + # Create the view and call it directly + view = InitiateDeploymentView(mock_request) + + response = await view( + project_id="project-123", + orm=orm_session, + ) + + # Verify response + assert response.success is True + + # Verify config has pack defaults but user overrides + mock_queue.assert_called_once() + call_args = mock_queue.call_args + config = call_args[1]["config"] # Get config from kwargs + + # Pack defaults + assert config.dockerfile_template == "fastapi-agent" + assert config.ports == [8000] + assert config.build_files == {} + + # User overrides + assert config.repository_url == "https://github.com/test/custom-repo" + assert config.branch == "feature-branch" + assert config.entrypoint == "custom_main.py" + assert config.github_access_token == "custom-token" + assert config.watch_path == "custom/path/" + assert config.callback_url == "https://custom-callback.com" + assert config.secret_names == ["API_KEY"] + assert config.agentops_api_key == "test-api-key-123" diff --git a/app/api/tests/fixtures/log_spans.json b/app/api/tests/fixtures/log_spans.json new file mode 100644 index 000000000..ef0fc0c91 --- /dev/null +++ b/app/api/tests/fixtures/log_spans.json @@ -0,0 +1,226 @@ +[ + { + "body": "\u001b[31mThis is red text\u001b[0m\n", + "severity_number": 9, + "severity_text": "INFO", + "attributes": { + "raw": true, + "preserve_color": true, + "code.filepath": "/Users/beyond/agentops/agentops/log_capture.py", + "code.function": "write", + "code.lineno": 234 + }, + "dropped_attributes": 0, + "timestamp": "2025-01-31T12:29:57.187259Z", + "observed_timestamp": "2025-01-31T12:29:57.187309Z", + "trace_id": "0x00000000000000000000000000000000", + "span_id": "0x0000000000000000", + "trace_flags": 0, + "resource": { + "attributes": { + "telemetry.sdk.language": "python", + "telemetry.sdk.name": "opentelemetry", + "telemetry.sdk.version": "1.29.0", + "service.name": "agentops", + "session.id": "8685cc2c-0d9e-496c-96b3-d7b54c6894e5" + }, + "schema_url": "" + } + }, + { + "body": "\u001b[34mBlue\u001b[0m and \u001b[32mgreen\u001b[0m mixed\n", + "severity_number": 9, + "severity_text": "INFO", + "attributes": { + "raw": true, + "preserve_color": true, + "code.filepath": "/Users/beyond/agentops/agentops/log_capture.py", + "code.function": "write", + "code.lineno": 234 + }, + "dropped_attributes": 0, + "timestamp": "2025-01-31T12:29:57.187540Z", + "observed_timestamp": "2025-01-31T12:29:57.187555Z", + "trace_id": "0x00000000000000000000000000000000", + "span_id": "0x0000000000000000", + "trace_flags": 0, + "resource": { + "attributes": { + "telemetry.sdk.language": "python", + "telemetry.sdk.name": "opentelemetry", + "telemetry.sdk.version": "1.29.0", + "service.name": "agentops", + "session.id": "8685cc2c-0d9e-496c-96b3-d7b54c6894e5" + }, + "schema_url": "" + } + }, + { + "body": "\u001b[1;31mBold red\u001b[0m and \u001b[3;34mitalic blue\u001b[0m\n", + "severity_number": 9, + "severity_text": "INFO", + "attributes": { + "raw": true, + "preserve_color": true, + "code.filepath": "/Users/beyond/agentops/agentops/log_capture.py", + "code.function": "write", + "code.lineno": 234 + }, + "dropped_attributes": 0, + "timestamp": "2025-01-31T12:29:57.187719Z", + "observed_timestamp": "2025-01-31T12:29:57.187728Z", + "trace_id": "0x00000000000000000000000000000000", + "span_id": "0x0000000000000000", + "trace_flags": 0, + "resource": { + "attributes": { + "telemetry.sdk.language": "python", + "telemetry.sdk.name": "opentelemetry", + "telemetry.sdk.version": "1.29.0", + "service.name": "agentops", + "session.id": "8685cc2c-0d9e-496c-96b3-d7b54c6894e5" + }, + "schema_url": "" + } + }, + { + "body": "\u001b[31mDirect red ANSI\u001b[0m\n", + "severity_number": 9, + "severity_text": "INFO", + "attributes": { + "raw": true, + "preserve_color": true, + "code.filepath": "/Users/beyond/agentops/agentops/log_capture.py", + "code.function": "write", + "code.lineno": 234 + }, + "dropped_attributes": 0, + "timestamp": "2025-01-31T12:29:57.187750Z", + "observed_timestamp": "2025-01-31T12:29:57.187755Z", + "trace_id": "0x00000000000000000000000000000000", + "span_id": "0x0000000000000000", + "trace_flags": 0, + "resource": { + "attributes": { + "telemetry.sdk.language": "python", + "telemetry.sdk.name": "opentelemetry", + "telemetry.sdk.version": "1.29.0", + "service.name": "agentops", + "session.id": "8685cc2c-0d9e-496c-96b3-d7b54c6894e5" + }, + "schema_url": "" + } + }, + { + "body": "\u001b[34mBlue\u001b[0m and \u001b[32mgreen\u001b[0m mixed ANSI\n", + "severity_number": 9, + "severity_text": "INFO", + "attributes": { + "raw": true, + "preserve_color": true, + "code.filepath": "/Users/beyond/agentops/agentops/log_capture.py", + "code.function": "write", + "code.lineno": 234 + }, + "dropped_attributes": 0, + "timestamp": "2025-01-31T12:29:57.187770Z", + "observed_timestamp": "2025-01-31T12:29:57.187775Z", + "trace_id": "0x00000000000000000000000000000000", + "span_id": "0x0000000000000000", + "trace_flags": 0, + "resource": { + "attributes": { + "telemetry.sdk.language": "python", + "telemetry.sdk.name": "opentelemetry", + "telemetry.sdk.version": "1.29.0", + "service.name": "agentops", + "session.id": "8685cc2c-0d9e-496c-96b3-d7b54c6894e5" + }, + "schema_url": "" + } + }, + { + "body": "\u001b[1;31mBold red ANSI\u001b[0m\n", + "severity_number": 9, + "severity_text": "INFO", + "attributes": { + "raw": true, + "preserve_color": true, + "code.filepath": "/Users/beyond/agentops/agentops/log_capture.py", + "code.function": "write", + "code.lineno": 234 + }, + "dropped_attributes": 0, + "timestamp": "2025-01-31T12:29:57.187789Z", + "observed_timestamp": "2025-01-31T12:29:57.187793Z", + "trace_id": "0x00000000000000000000000000000000", + "span_id": "0x0000000000000000", + "trace_flags": 0, + "resource": { + "attributes": { + "telemetry.sdk.language": "python", + "telemetry.sdk.name": "opentelemetry", + "telemetry.sdk.version": "1.29.0", + "service.name": "agentops", + "session.id": "8685cc2c-0d9e-496c-96b3-d7b54c6894e5" + }, + "schema_url": "" + } + }, + { + "body": "\u001b[35mMagenta error\u001b[0m\n", + "severity_number": 17, + "severity_text": "ERROR", + "attributes": { + "raw": true, + "preserve_color": true, + "code.filepath": "/Users/beyond/agentops/agentops/log_capture.py", + "code.function": "write", + "code.lineno": 254 + }, + "dropped_attributes": 0, + "timestamp": "2025-01-31T12:29:57.187814Z", + "observed_timestamp": "2025-01-31T12:29:57.187822Z", + "trace_id": "0x00000000000000000000000000000000", + "span_id": "0x0000000000000000", + "trace_flags": 0, + "resource": { + "attributes": { + "telemetry.sdk.language": "python", + "telemetry.sdk.name": "opentelemetry", + "telemetry.sdk.version": "1.29.0", + "service.name": "agentops", + "session.id": "8685cc2c-0d9e-496c-96b3-d7b54c6894e5" + }, + "schema_url": "" + } + }, + { + "body": "\u001b[33mYellow warning\u001b[0m\n", + "severity_number": 17, + "severity_text": "ERROR", + "attributes": { + "raw": true, + "preserve_color": true, + "code.filepath": "/Users/beyond/agentops/agentops/log_capture.py", + "code.function": "write", + "code.lineno": 254 + }, + "dropped_attributes": 0, + "timestamp": "2025-01-31T12:29:57.187833Z", + "observed_timestamp": "2025-01-31T12:29:57.187836Z", + "trace_id": "0x00000000000000000000000000000000", + "span_id": "0x0000000000000000", + "trace_flags": 0, + "resource": { + "attributes": { + "telemetry.sdk.language": "python", + "telemetry.sdk.name": "opentelemetry", + "telemetry.sdk.version": "1.29.0", + "service.name": "agentops", + "session.id": "8685cc2c-0d9e-496c-96b3-d7b54c6894e5" + }, + "schema_url": "" + } + } +] diff --git a/app/api/tests/interactors/test_span_handlers.py b/app/api/tests/interactors/test_span_handlers.py new file mode 100644 index 000000000..1723e2165 --- /dev/null +++ b/app/api/tests/interactors/test_span_handlers.py @@ -0,0 +1,146 @@ +from unittest.mock import patch + +import pytest +from opentelemetry.semconv._incubating.attributes.gen_ai_attributes import ( + GEN_AI_OPERATION_NAME, + GEN_AI_REQUEST_MODEL, + GEN_AI_RESPONSE_MODEL, + GEN_AI_SYSTEM, + GenAiOperationNameValues, +) + +from agentops.api.encoders.spans import SpanAttributeEncoder +from agentops.api.interactors.spans import ( + GEN_AI_TOOL_CALL_ID, + GEN_AI_TOOL_NAME, + LEGACY_EMBEDDING, + LEGACY_LLM, + LEGACY_SYSTEM, + LOG_MESSAGE, + LOG_SEVERITY, + AgentopsGenAISpanSubtype, + AgentopsSpanType, + classify_gen_ai_span_subtype, + classify_span, + handle_gen_ai_span, +) + + +@pytest.mark.asyncio +async def test_classify_span_gen_ai(): + """Test that Gen AI spans are correctly classified.""" + # Test with legacy ai.system attribute + span = {"attributes": {LEGACY_SYSTEM: "openai"}} + assert await classify_span(span) == AgentopsSpanType.GEN_AI + + # Test with legacy ai.llm attribute + span = {"attributes": {LEGACY_LLM: "gpt-4"}} + assert await classify_span(span) == AgentopsSpanType.GEN_AI + + # Test with legacy ai.embedding attribute + span = {"attributes": {LEGACY_EMBEDDING: "text-embedding-ada-002"}} + assert await classify_span(span) == AgentopsSpanType.GEN_AI + + # Test with gen_ai.system attribute + span = {"attributes": {GEN_AI_SYSTEM: "openai"}} + assert await classify_span(span) == AgentopsSpanType.GEN_AI + + # Test with gen_ai.operation.name attribute + span = {"attributes": {GEN_AI_OPERATION_NAME: "chat"}} + assert await classify_span(span) == AgentopsSpanType.GEN_AI + + # Test with gen_ai.request.model attribute + span = {"attributes": {GEN_AI_REQUEST_MODEL: "gpt-4"}} + assert await classify_span(span) == AgentopsSpanType.GEN_AI + + # Test with gen_ai.response.model attribute + span = {"attributes": {GEN_AI_RESPONSE_MODEL: "gpt-4"}} + assert await classify_span(span) == AgentopsSpanType.GEN_AI + + +@pytest.mark.asyncio +async def test_classify_span_log(): + """Test that log spans are correctly classified.""" + # Test with log.severity attribute + span = {"attributes": {LOG_SEVERITY: "INFO"}} + assert await classify_span(span) == AgentopsSpanType.LOG + + # Test with log.message attribute + span = {"attributes": {LOG_MESSAGE: "Test message"}} + assert await classify_span(span) == AgentopsSpanType.LOG + + +@pytest.mark.asyncio +async def test_classify_span_session_update(): + """Test that session update spans are correctly classified.""" + # Test with no relevant attributes + span = {"attributes": {"other": "value"}} + assert await classify_span(span) == AgentopsSpanType.SESSION_UPDATE + + +@pytest.mark.asyncio +async def test_classify_gen_ai_span_subtype(): + """Test that Gen AI span subtypes are correctly classified.""" + # Test tool span + span = {"attributes": {GEN_AI_TOOL_NAME: "calculator"}} + assert await classify_gen_ai_span_subtype(span) == AgentopsGenAISpanSubtype.TOOL + + span = {"attributes": {GEN_AI_TOOL_CALL_ID: "call_123"}} + assert await classify_gen_ai_span_subtype(span) == AgentopsGenAISpanSubtype.TOOL + + # Test chat span + span = {"attributes": {GEN_AI_OPERATION_NAME: GenAiOperationNameValues.CHAT.value}} + assert await classify_gen_ai_span_subtype(span) == AgentopsGenAISpanSubtype.CHAT + + # Test completion span + span = {"attributes": {GEN_AI_OPERATION_NAME: GenAiOperationNameValues.TEXT_COMPLETION.value}} + assert await classify_gen_ai_span_subtype(span) == AgentopsGenAISpanSubtype.COMPLETION + + # Test embedding span + span = {"attributes": {GEN_AI_OPERATION_NAME: GenAiOperationNameValues.EMBEDDINGS.value}} + assert await classify_gen_ai_span_subtype(span) == AgentopsGenAISpanSubtype.EMBEDDING + + span = {"attributes": {LEGACY_EMBEDDING: "text-embedding-ada-002"}} + assert await classify_gen_ai_span_subtype(span) == AgentopsGenAISpanSubtype.EMBEDDING + + # Test default + span = {"attributes": {GEN_AI_SYSTEM: "openai"}} + assert await classify_gen_ai_span_subtype(span) == AgentopsGenAISpanSubtype.GENERIC + + +@pytest.mark.asyncio +async def test_handle_gen_ai_span(): + """Test that Gen AI spans are correctly handled.""" + session_id = "test-session" + span = { + "agent_id": "test-agent", + "trace_id": "test-trace", + "span_id": "test-span", + "parent_span_id": "test-parent", + "name": "test-span", + "kind": "client", + "start_time": "2023-01-01T00:00:00Z", + "end_time": "2023-01-01T00:00:01Z", + "attributes": { + GEN_AI_SYSTEM: "openai", + GEN_AI_OPERATION_NAME: GenAiOperationNameValues.CHAT.value, + GEN_AI_REQUEST_MODEL: "gpt-4", + }, + } + + # Mock the SpanAttributeEncoder.encode method + with patch.object(SpanAttributeEncoder, 'encode', return_value=b"encoded"): + span_data = await handle_gen_ai_span(span, session_id) + + assert span_data["session_id"] == session_id + assert span_data["agent_id"] == span["agent_id"] + assert span_data["trace_id"] == span["trace_id"] + assert span_data["span_id"] == span["span_id"] + assert span_data["parent_span_id"] == span["parent_span_id"] + assert span_data["name"] == span["name"] + assert span_data["kind"] == span["kind"] + assert span_data["start_time"] == span["start_time"] + assert span_data["end_time"] == span["end_time"] + assert span_data["attributes"] == b"encoded" + assert span_data["span_type"] == AgentopsSpanType.GEN_AI + assert span_data["span_subtype"] == AgentopsGenAISpanSubtype.CHAT diff --git a/app/api/tests/opsboard/conftest.py b/app/api/tests/opsboard/conftest.py new file mode 100644 index 000000000..ca773bd29 --- /dev/null +++ b/app/api/tests/opsboard/conftest.py @@ -0,0 +1,13 @@ +import pytest +import uuid + + +@pytest.fixture(scope="session") +def mock_request(): + """Create a mock request with a session user_id.""" + from unittest.mock import MagicMock + from fastapi import Request + + request = MagicMock(spec=Request) + request.state.session.user_id = uuid.UUID("00000000-0000-0000-0000-000000000000") + return request diff --git a/app/api/tests/opsboard/models/__init__.py b/app/api/tests/opsboard/models/__init__.py new file mode 100644 index 000000000..fb49d104d --- /dev/null +++ b/app/api/tests/opsboard/models/__init__.py @@ -0,0 +1 @@ +# Test directory for opsboard models diff --git a/app/api/tests/opsboard/models/test_billing_models.py b/app/api/tests/opsboard/models/test_billing_models.py new file mode 100644 index 000000000..07eb9ad9d --- /dev/null +++ b/app/api/tests/opsboard/models/test_billing_models.py @@ -0,0 +1,943 @@ +import pytest +import uuid +from datetime import datetime, timezone, timedelta +from sqlalchemy.exc import IntegrityError + +from agentops.opsboard.models import BillingAuditLog, BillingPeriod, OrgModel + +# Import shared billing fixtures +pytest_plugins = ["tests._conftest.billing"] +from tests._conftest.billing_constants import ( + TOKEN_COST_SAMPLE, + SPAN_COST_SAMPLE, + TOKEN_QUANTITY_SAMPLE, + SPAN_QUANTITY_SAMPLE, +) + + +@pytest.fixture +def test_billing_period(orm_session, test_org, billing_period_factory): + """Create a test billing period for testing.""" + billing_period = billing_period_factory( + test_org.id, + seat_cost=8000, # $80 in cents + seat_count=2, + usage_costs={"tokens": TOKEN_COST_SAMPLE, "spans": SPAN_COST_SAMPLE}, + usage_quantities={"tokens": TOKEN_QUANTITY_SAMPLE, "spans": SPAN_QUANTITY_SAMPLE}, + total_cost=8200, + status='pending', + ) + orm_session.add(billing_period) + orm_session.flush() + return billing_period + + +@pytest.fixture +def test_billing_audit_log(orm_session, test_org, test_user): + """Create a test billing audit log for testing.""" + try: + audit_log = BillingAuditLog( + org_id=test_org.id, + user_id=test_user.id, + action='member_licensed', + details={ + 'member_id': str(test_user.id), + 'member_email': 'test@example.com', + 'before_seat_count': 1, + 'after_seat_count': 2, + }, + ) + orm_session.add(audit_log) + orm_session.flush() + return audit_log + except Exception: + orm_session.rollback() + raise + + +@pytest.fixture(autouse=True) +def ensure_clean_session(orm_session): + """Ensure clean session state before each test.""" + try: + # Check if session has pending rollback + if orm_session.in_transaction() and orm_session.is_active: + if hasattr(orm_session, '_transaction') and orm_session._transaction.is_active: + # Session is in a good state + pass + yield + except Exception: + orm_session.rollback() + raise + finally: + # Cleanup after test + try: + if orm_session.in_transaction(): + orm_session.rollback() + except Exception: + pass + + +class TestBillingPeriod: + """Test cases for BillingPeriod model.""" + + def test_billing_period_creation(self, orm_session, test_org): + """Test creating a new billing period.""" + period_start = datetime(2024, 2, 1, tzinfo=timezone.utc) + period_end = datetime(2024, 2, 29, tzinfo=timezone.utc) + + billing_period = BillingPeriod( + org_id=test_org.id, + period_start=period_start, + period_end=period_end, + seat_cost=4000, + seat_count=1, + total_cost=4000, + ) + + orm_session.add(billing_period) + orm_session.commit() + + # Verify it was created + assert billing_period.id is not None + assert billing_period.org_id == test_org.id + assert billing_period.period_start == period_start + assert billing_period.period_end == period_end + + def test_billing_period_required_fields(self, orm_session, test_org, billing_period_factory): + """Test billing period with all required fields.""" + billing_period = billing_period_factory( + test_org.id, + seat_cost=0, + seat_count=0, + total_cost=0, + ) + + orm_session.add(billing_period) + orm_session.commit() + + assert billing_period.id is not None + + def test_billing_period_default_values(self, orm_session, test_org, billing_period_factory): + """Test billing period default field values.""" + billing_period = billing_period_factory(test_org.id) + + orm_session.add(billing_period) + orm_session.commit() + + # Check defaults + assert billing_period.seat_cost == 0 + assert billing_period.seat_count == 0 + assert billing_period.usage_costs == {} + assert billing_period.usage_quantities == {} + assert billing_period.total_cost == 0 + assert billing_period.status == 'pending' + assert billing_period.stripe_invoice_id is None + assert billing_period.invoiced_at is None + assert billing_period.created_at is not None + + def test_billing_period_usage_costs_json_field(self, orm_session, test_org, billing_period_factory): + """Test usage_costs JSONB field stores and retrieves data correctly.""" + usage_costs = {"tokens": 120, "spans": 45, "custom_metric": 25} + + billing_period = billing_period_factory( + test_org.id, + usage_costs=usage_costs, + total_cost=190, + ) + + orm_session.add(billing_period) + orm_session.commit() + + # Retrieve and verify JSON data + retrieved_period = orm_session.query(BillingPeriod).filter_by(id=billing_period.id).one() + assert retrieved_period.usage_costs == usage_costs + + def test_billing_period_usage_quantities_json_field(self, orm_session, test_org, billing_period_factory): + """Test usage_quantities JSONB field stores and retrieves data correctly.""" + usage_quantities = {"tokens": 6000000, "spans": 4500, "api_calls": 150} + + billing_period = billing_period_factory( + test_org.id, + usage_quantities=usage_quantities, + total_cost=0, + ) + + orm_session.add(billing_period) + orm_session.commit() + + # Retrieve and verify JSON data + retrieved_period = orm_session.query(BillingPeriod).filter_by(id=billing_period.id).one() + assert retrieved_period.usage_quantities == usage_quantities + + def test_billing_period_seat_cost_calculation(self, orm_session, test_org, billing_period_factory): + """Test seat_cost field stores cost in cents.""" + billing_period = billing_period_factory( + test_org.id, + seat_cost=15000, # $150.00 in cents + seat_count=3, + total_cost=15000, + ) + + orm_session.add(billing_period) + orm_session.commit() + + assert billing_period.seat_cost == 15000 + assert billing_period.seat_count == 3 + + def test_billing_period_total_cost_calculation(self, orm_session, test_org, billing_period_factory): + """Test total_cost field calculation.""" + billing_period = billing_period_factory( + test_org.id, + seat_cost=8000, + usage_costs={"tokens": 200, "spans": 75}, + total_cost=8275, # 8000 + 200 + 75 + ) + + orm_session.add(billing_period) + orm_session.commit() + + assert billing_period.total_cost == 8275 + + def test_billing_period_status_values(self, orm_session, test_org, billing_period_factory): + """Test billing period status field accepts valid values.""" + valid_statuses = ['pending', 'invoiced', 'paid', 'failed'] + + for status in valid_statuses: + billing_period = billing_period_factory( + test_org.id, + status=status, + total_cost=0, + ) + + orm_session.add(billing_period) + orm_session.flush() + + assert billing_period.status == status + + orm_session.delete(billing_period) + orm_session.flush() + + def test_billing_period_datetime_fields(self, orm_session, test_org, billing_period_factory): + """Test datetime fields are properly handled.""" + now = datetime.now(timezone.utc) + + period_start = datetime(2024, 10, 15, tzinfo=timezone.utc) + period_end = datetime(2024, 10, 16, tzinfo=timezone.utc) + invoiced_at = datetime(2024, 11, 1, tzinfo=timezone.utc) + + billing_period = billing_period_factory( + test_org.id, + period_start=period_start, + period_end=period_end, + invoiced_at=invoiced_at, + total_cost=0, + ) + + orm_session.add(billing_period) + orm_session.commit() + + assert billing_period.period_start == period_start + assert billing_period.period_end == period_end + assert billing_period.invoiced_at == invoiced_at + + # Just verify created_at was set automatically and is a reasonable timestamp + assert billing_period.created_at is not None + assert isinstance(billing_period.created_at, datetime) + # Verify it's within the last hour (very generous range) + one_hour_ago = datetime.now(timezone.utc) - timedelta(hours=1) + one_hour_future = datetime.now(timezone.utc) + timedelta(hours=1) + + if billing_period.created_at.tzinfo is None: + created_at_utc = billing_period.created_at.replace(tzinfo=timezone.utc) + else: + created_at_utc = billing_period.created_at + + assert one_hour_ago <= created_at_utc <= one_hour_future + + def test_billing_period_foreign_key_relationship(self, orm_session, test_org, billing_period_factory): + """Test billing period foreign key to organization.""" + billing_period = billing_period_factory( + test_org.id, + total_cost=0, + ) + + orm_session.add(billing_period) + orm_session.commit() + + # Verify foreign key relationship + assert billing_period.org_id == test_org.id + + def test_billing_period_unique_constraint(self, orm_session, test_org, billing_period_factory): + """Test unique constraint on org_id and period_start.""" + period_start = datetime(2024, 12, 15, tzinfo=timezone.utc) + period_end = datetime(2024, 12, 16, tzinfo=timezone.utc) + + # Create first billing period + billing_period1 = billing_period_factory( + test_org.id, period_start=period_start, period_end=period_end, total_cost=0 + ) + orm_session.add(billing_period1) + orm_session.commit() + + # Try to create second billing period with same org_id and period_start + billing_period2 = BillingPeriod( + org_id=test_org.id, + period_start=period_start, # Same period_start + period_end=datetime(2025, 1, 1, tzinfo=timezone.utc), # Different period_end + total_cost=0, + ) + orm_session.add(billing_period2) + + # Should raise IntegrityError due to unique constraint + with pytest.raises(IntegrityError): + orm_session.commit() + + # Rollback the failed transaction to cleanup + orm_session.rollback() + + def test_billing_period_query_by_org( + self, orm_session, test_org, test_billing_period, billing_period_factory + ): + """Test querying billing periods by organization.""" + # Create another org to ensure we only get periods for the specific org + other_org = OrgModel(name="Other Test Org") + orm_session.add(other_org) + orm_session.flush() + + other_period = billing_period_factory( + other_org.id, + total_cost=0, + ) + orm_session.add(other_period) + orm_session.commit() + + # Query periods for test_org only, filter by the specific fixture period + periods = ( + orm_session.query(BillingPeriod) + .filter(BillingPeriod.org_id == test_org.id, BillingPeriod.id == test_billing_period.id) + .all() + ) + + assert len(periods) == 1 + assert periods[0].id == test_billing_period.id + + def test_billing_period_query_by_date_range(self, orm_session, test_org, billing_period_factory): + """Test querying billing periods by date range.""" + # Create periods for different months with very specific dates + jan_start = datetime(2025, 3, 15, tzinfo=timezone.utc) + jan_end = datetime(2025, 3, 16, tzinfo=timezone.utc) + + feb_start = datetime(2025, 4, 15, tzinfo=timezone.utc) + feb_end = datetime(2025, 4, 16, tzinfo=timezone.utc) + + jan_period = billing_period_factory( + test_org.id, period_start=jan_start, period_end=jan_end, total_cost=0 + ) + + feb_period = billing_period_factory( + test_org.id, period_start=feb_start, period_end=feb_end, total_cost=0 + ) + + orm_session.add_all([jan_period, feb_period]) + orm_session.commit() + + # Query periods ending before April 1st - should only get the March period + cutoff_date = datetime(2025, 4, 1, tzinfo=timezone.utc) + early_periods = ( + orm_session.query(BillingPeriod) + .filter( + BillingPeriod.org_id == test_org.id, + BillingPeriod.period_end < cutoff_date, + BillingPeriod.id.in_([jan_period.id, feb_period.id]), # Only check our test records + ) + .all() + ) + + assert len(early_periods) == 1 + assert early_periods[0].id == jan_period.id + + def test_billing_period_stripe_invoice_id_field(self, orm_session, test_org, billing_period_factory): + """Test stripe_invoice_id field stores Stripe invoice reference.""" + stripe_invoice_id = "in_1234567890abcdef" + + billing_period = billing_period_factory( + test_org.id, + stripe_invoice_id=stripe_invoice_id, + total_cost=0, + ) + + orm_session.add(billing_period) + orm_session.commit() + + assert billing_period.stripe_invoice_id == stripe_invoice_id + + def test_billing_period_invoiced_at_timestamp(self, orm_session, test_org, billing_period_factory): + """Test invoiced_at timestamp field.""" + invoiced_at = datetime(2025, 6, 1, 12, 30, 45, tzinfo=timezone.utc) + + billing_period = billing_period_factory( + test_org.id, + invoiced_at=invoiced_at, + status='invoiced', + total_cost=0, + ) + + orm_session.add(billing_period) + orm_session.commit() + + assert billing_period.invoiced_at == invoiced_at + + def test_billing_period_auto_created_at(self, orm_session, test_org, billing_period_factory): + """Test created_at field is automatically set.""" + before_creation = datetime.now(timezone.utc) + + billing_period = billing_period_factory( + test_org.id, + total_cost=0, + ) + + orm_session.add(billing_period) + orm_session.commit() + + # Just verify created_at was set automatically and is a reasonable timestamp + assert billing_period.created_at is not None + assert isinstance(billing_period.created_at, datetime) + # Verify it's within the last hour (very generous range) + one_hour_ago = datetime.now(timezone.utc) - timedelta(hours=1) + one_hour_future = datetime.now(timezone.utc) + timedelta(hours=1) + + if billing_period.created_at.tzinfo is None: + created_at_utc = billing_period.created_at.replace(tzinfo=timezone.utc) + else: + created_at_utc = billing_period.created_at + + assert one_hour_ago <= created_at_utc <= one_hour_future + + +class TestBillingAuditLog: + """Test cases for BillingAuditLog model.""" + + def test_billing_audit_log_creation(self, orm_session, test_org, test_user): + """Test creating a new billing audit log entry.""" + # Ensure session is clean before test + try: + audit_log = BillingAuditLog( + org_id=test_org.id, + user_id=test_user.id, + action='member_licensed', + details={'member_id': str(test_user.id)}, + ) + + orm_session.add(audit_log) + orm_session.commit() + + assert audit_log.id is not None + assert audit_log.org_id == test_org.id + assert audit_log.user_id == test_user.id + except Exception: + # Rollback on any error to clean up session + orm_session.rollback() + raise + + def test_billing_audit_log_required_fields(self, orm_session, test_org, test_user): + """Test billing audit log with all required fields.""" + audit_log = BillingAuditLog( + org_id=test_org.id, user_id=test_user.id, action='seats_updated', details={} + ) + + orm_session.add(audit_log) + orm_session.commit() + + assert audit_log.id is not None + assert audit_log.action == 'seats_updated' + assert audit_log.details == {} + + def test_billing_audit_log_auto_id_generation(self, orm_session, test_org, test_user): + """Test audit log ID is automatically generated.""" + audit_log = BillingAuditLog( + org_id=test_org.id, user_id=test_user.id, action='member_unlicensed', details={'test': 'data'} + ) + + # ID should be None before adding to session + assert audit_log.id is None + + orm_session.add(audit_log) + orm_session.commit() + + # ID should be generated after commit + assert audit_log.id is not None + assert isinstance(audit_log.id, uuid.UUID) + + def test_billing_audit_log_foreign_key_org(self, orm_session, test_org, test_user): + """Test foreign key relationship to organization.""" + audit_log = BillingAuditLog( + org_id=test_org.id, user_id=test_user.id, action='test_action', details={} + ) + + orm_session.add(audit_log) + orm_session.commit() + + assert audit_log.org_id == test_org.id + + def test_billing_audit_log_foreign_key_user(self, orm_session, test_org, test_user): + """Test foreign key relationship to user.""" + audit_log = BillingAuditLog( + org_id=test_org.id, user_id=test_user.id, action='test_action', details={} + ) + + orm_session.add(audit_log) + orm_session.commit() + + assert audit_log.user_id == test_user.id + + def test_billing_audit_log_action_field(self, orm_session, test_org, test_user): + """Test action field stores different action types.""" + actions = [ + 'member_licensed', + 'member_unlicensed', + 'seats_updated', + 'subscription_created', + 'subscription_cancelled', + ] + + for action in actions: + audit_log = BillingAuditLog( + org_id=test_org.id, user_id=test_user.id, action=action, details={'action_type': action} + ) + + orm_session.add(audit_log) + orm_session.flush() + + assert audit_log.action == action + + orm_session.delete(audit_log) + orm_session.flush() + + def test_billing_audit_log_details_json_field(self, orm_session, test_org, test_user): + """Test details JSON field stores complex data.""" + complex_details = { + 'member_id': str(test_user.id), + 'member_email': 'test@example.com', + 'before_seat_count': 2, + 'after_seat_count': 3, + 'changed_by': 'admin@example.com', + 'timestamp': '2024-01-01T12:00:00Z', + 'metadata': {'ip_address': '192.168.1.1', 'user_agent': 'Mozilla/5.0...'}, + } + + audit_log = BillingAuditLog( + org_id=test_org.id, user_id=test_user.id, action='member_licensed', details=complex_details + ) + + orm_session.add(audit_log) + orm_session.commit() + + # Retrieve and verify JSON data + retrieved_log = orm_session.query(BillingAuditLog).filter_by(id=audit_log.id).one() + assert retrieved_log.details == complex_details + + def test_billing_audit_log_auto_created_at(self, orm_session, test_org, test_user): + """Test created_at field is automatically set.""" + try: + before_creation = datetime.now(timezone.utc) + + audit_log = BillingAuditLog( + org_id=test_org.id, user_id=test_user.id, action='test_action', details={} + ) + + orm_session.add(audit_log) + orm_session.commit() + + # Just verify created_at was set automatically and is a reasonable timestamp + assert audit_log.created_at is not None + assert isinstance(audit_log.created_at, datetime) + # Verify it's within the last hour (very generous range) + one_hour_ago = datetime.now(timezone.utc) - timedelta(hours=1) + one_hour_future = datetime.now(timezone.utc) + timedelta(hours=1) + + if audit_log.created_at.tzinfo is None: + created_at_utc = audit_log.created_at.replace(tzinfo=timezone.utc) + else: + created_at_utc = audit_log.created_at + + assert one_hour_ago <= created_at_utc <= one_hour_future + except Exception: + orm_session.rollback() + raise + + def test_billing_audit_log_member_licensed_action(self, orm_session, test_org, test_user): + """Test audit log for member licensed action.""" + details = { + 'member_id': str(test_user.id), + 'member_email': test_user.email, + 'new_seat_count': 2, + 'updated_by': 'admin@example.com', + } + + audit_log = BillingAuditLog( + org_id=test_org.id, user_id=test_user.id, action='member_licensed', details=details + ) + + orm_session.add(audit_log) + orm_session.commit() + + assert audit_log.action == 'member_licensed' + assert audit_log.details['member_id'] == str(test_user.id) + + def test_billing_audit_log_member_unlicensed_action(self, orm_session, test_org, test_user): + """Test audit log for member unlicensed action.""" + details = { + 'member_id': str(test_user.id), + 'member_email': test_user.email, + 'new_seat_count': 1, + 'updated_by': 'admin@example.com', + } + + audit_log = BillingAuditLog( + org_id=test_org.id, user_id=test_user.id, action='member_unlicensed', details=details + ) + + orm_session.add(audit_log) + orm_session.commit() + + assert audit_log.action == 'member_unlicensed' + assert audit_log.details['new_seat_count'] == 1 + + def test_billing_audit_log_seats_updated_action(self, orm_session, test_org, test_user): + """Test audit log for seats updated action.""" + details = { + 'before_seat_count': 2, + 'after_seat_count': 5, + 'change_reason': 'bulk_member_addition', + 'updated_by': str(test_user.id), + } + + audit_log = BillingAuditLog( + org_id=test_org.id, user_id=test_user.id, action='seats_updated', details=details + ) + + orm_session.add(audit_log) + orm_session.commit() + + assert audit_log.action == 'seats_updated' + assert audit_log.details['before_seat_count'] == 2 + assert audit_log.details['after_seat_count'] == 5 + + def test_billing_audit_log_query_by_org(self, orm_session, test_org, test_user, test_billing_audit_log): + """Test querying audit logs by organization.""" + # Create another org to ensure we only get logs for the specific org + other_org = OrgModel(name="Other Test Org") + orm_session.add(other_org) + orm_session.flush() + + other_log = BillingAuditLog( + org_id=other_org.id, user_id=test_user.id, action='other_action', details={} + ) + orm_session.add(other_log) + orm_session.commit() + + # Query logs for test_org only + logs = orm_session.query(BillingAuditLog).filter_by(org_id=test_org.id).all() + + assert len(logs) == 1 + assert logs[0].id == test_billing_audit_log.id + + def test_billing_audit_log_query_by_user( + self, orm_session, test_org, test_user, test_user2, test_billing_audit_log + ): + """Test querying audit logs by user.""" + try: + # Use test_user2 fixture instead of creating a new user + + other_log = BillingAuditLog( + org_id=test_org.id, user_id=test_user2.id, action='other_action', details={} + ) + orm_session.add(other_log) + orm_session.commit() + + # Query logs for test_user only, specifically filter by our test fixture + logs = ( + orm_session.query(BillingAuditLog) + .filter( + BillingAuditLog.user_id == test_user.id, BillingAuditLog.id == test_billing_audit_log.id + ) + .all() + ) + + assert len(logs) == 1 + assert logs[0].id == test_billing_audit_log.id + except Exception: + orm_session.rollback() + raise + + def test_billing_audit_log_query_by_action(self, orm_session, test_org, test_user): + """Test querying audit logs by action type.""" + try: + # Create logs with different actions + licensed_log = BillingAuditLog( + org_id=test_org.id, user_id=test_user.id, action='member_licensed', details={} + ) + + unlicensed_log = BillingAuditLog( + org_id=test_org.id, user_id=test_user.id, action='member_unlicensed', details={} + ) + + orm_session.add_all([licensed_log, unlicensed_log]) + orm_session.commit() + + # Query only licensed actions, filter by our specific test records + licensed_logs = ( + orm_session.query(BillingAuditLog) + .filter( + BillingAuditLog.action == 'member_licensed', + BillingAuditLog.org_id == test_org.id, + BillingAuditLog.id.in_([licensed_log.id, unlicensed_log.id]), + ) + .all() + ) + + assert len(licensed_logs) == 1 + assert licensed_logs[0].id == licensed_log.id + except Exception: + orm_session.rollback() + raise + + def test_billing_audit_log_query_by_date_range(self, orm_session, test_org, test_user): + """Test querying audit logs by date range.""" + try: + from datetime import timedelta + from sqlalchemy import text + + # Create logs at different times + old_log = BillingAuditLog( + org_id=test_org.id, user_id=test_user.id, action='old_action', details={} + ) + orm_session.add(old_log) + orm_session.commit() + + # Manually set an older created_at time using proper SQLAlchemy text() + old_time = datetime.now(timezone.utc) - timedelta(days=30) + orm_session.execute( + text("UPDATE billing_audit_logs SET created_at = :old_time WHERE id = :log_id"), + {"old_time": old_time, "log_id": str(old_log.id)}, + ) + orm_session.commit() + + new_log = BillingAuditLog( + org_id=test_org.id, user_id=test_user.id, action='new_action', details={} + ) + orm_session.add(new_log) + orm_session.commit() + + # Query logs from the last week, filter by our specific test records + cutoff_date = datetime.now(timezone.utc) - timedelta(days=7) + recent_logs = ( + orm_session.query(BillingAuditLog) + .filter( + BillingAuditLog.created_at >= cutoff_date, + BillingAuditLog.org_id == test_org.id, + BillingAuditLog.id.in_([old_log.id, new_log.id]), + ) + .all() + ) + + assert len(recent_logs) == 1 + assert recent_logs[0].id == new_log.id + except Exception: + orm_session.rollback() + raise + + def test_billing_audit_log_details_before_after_structure(self, orm_session, test_org, test_user): + """Test audit log details contain before/after values.""" + details = { + 'before': {'seat_count': 2, 'licensed_members': ['user1@example.com', 'user2@example.com']}, + 'after': { + 'seat_count': 3, + 'licensed_members': ['user1@example.com', 'user2@example.com', 'user3@example.com'], + }, + 'changed_by': 'admin@example.com', + } + + audit_log = BillingAuditLog( + org_id=test_org.id, user_id=test_user.id, action='seats_updated', details=details + ) + + orm_session.add(audit_log) + orm_session.commit() + + assert 'before' in audit_log.details + assert 'after' in audit_log.details + assert audit_log.details['before']['seat_count'] == 2 + assert audit_log.details['after']['seat_count'] == 3 + + def test_billing_audit_log_multiple_entries_same_org(self, orm_session, test_org, test_user): + """Test multiple audit log entries for same organization.""" + logs = [] + for i in range(5): + log = BillingAuditLog( + org_id=test_org.id, user_id=test_user.id, action=f'action_{i}', details={'step': i} + ) + logs.append(log) + + orm_session.add_all(logs) + orm_session.commit() + + # Query all logs for the org + org_logs = orm_session.query(BillingAuditLog).filter_by(org_id=test_org.id).all() + + assert len(org_logs) == 5 + for log in org_logs: + assert log.org_id == test_org.id + + +class TestBillingModelIntegration: + """Test cases for billing model integration scenarios.""" + + def test_billing_period_with_audit_logs(self, orm_session, test_org, test_user, billing_period_factory): + """Test billing period creation generates appropriate audit logs.""" + try: + # Create billing period + billing_period = billing_period_factory( + test_org.id, + seat_cost=8000, + total_cost=8000, + ) + orm_session.add(billing_period) + orm_session.commit() + + # Create related audit log + audit_log = BillingAuditLog( + org_id=test_org.id, + user_id=test_user.id, + action='billing_period_created', + details={ + 'period_id': str(billing_period.id), + 'period_start': billing_period.period_start.isoformat(), + 'total_cost': billing_period.total_cost, + }, + ) + orm_session.add(audit_log) + orm_session.commit() + + # Verify they're linked through org_id + period_logs = orm_session.query(BillingAuditLog).filter_by(org_id=test_org.id).all() + assert len(period_logs) == 1 + assert period_logs[0].details['period_id'] == str(billing_period.id) + except Exception: + orm_session.rollback() + raise + + def test_billing_data_consistency(self, orm_session, test_org, test_user, billing_period_factory): + """Test data consistency between billing period and audit logs.""" + try: + # Create billing period + billing_period = billing_period_factory( + test_org.id, + seat_count=3, + seat_cost=12000, + total_cost=12000, + ) + orm_session.add(billing_period) + orm_session.commit() + + # Create audit log with matching data + audit_log = BillingAuditLog( + org_id=test_org.id, + user_id=test_user.id, + action='billing_snapshot_created', + details={ + 'period_id': str(billing_period.id), + 'seat_count': billing_period.seat_count, + 'seat_cost': billing_period.seat_cost, + 'total_cost': billing_period.total_cost, + }, + ) + orm_session.add(audit_log) + orm_session.commit() + + # Verify data consistency + assert audit_log.details['seat_count'] == billing_period.seat_count + assert audit_log.details['seat_cost'] == billing_period.seat_cost + assert audit_log.details['total_cost'] == billing_period.total_cost + except Exception: + orm_session.rollback() + raise + + def test_billing_models_cascade_delete(self, orm_session, test_org, test_user, billing_period_factory): + """Test that billing records prevent organization deletion (foreign key constraint).""" + try: + # Create billing period and audit log + billing_period = billing_period_factory( + test_org.id, + total_cost=0, + ) + + audit_log = BillingAuditLog( + org_id=test_org.id, user_id=test_user.id, action='test_action', details={} + ) + + orm_session.add_all([billing_period, audit_log]) + orm_session.commit() + + # Try to delete the organization - should fail due to foreign key constraint + # This is the expected behavior for billing records (audit trail preservation) + orm_session.delete(test_org) + + with pytest.raises(IntegrityError): + orm_session.commit() + + # Rollback the failed transaction + orm_session.rollback() + + # Verify billing records still exist + remaining_periods = orm_session.query(BillingPeriod).filter_by(id=billing_period.id).all() + remaining_logs = orm_session.query(BillingAuditLog).filter_by(id=audit_log.id).all() + + assert len(remaining_periods) == 1 + assert len(remaining_logs) == 1 + except Exception: + orm_session.rollback() + raise + + def test_billing_models_org_relationship_integrity( + self, orm_session, test_org, test_user, billing_period_factory + ): + """Test referential integrity with organization model.""" + try: + # Create billing records + billing_period = billing_period_factory( + test_org.id, + total_cost=0, + ) + + audit_log = BillingAuditLog( + org_id=test_org.id, user_id=test_user.id, action='test_action', details={} + ) + + orm_session.add_all([billing_period, audit_log]) + orm_session.commit() + + # Verify they reference the correct organization + assert billing_period.org_id == test_org.id + assert audit_log.org_id == test_org.id + + # Try to create billing record with non-existent org_id + fake_org_id = uuid.uuid4() + invalid_period = BillingPeriod( + org_id=fake_org_id, + period_start=datetime(2025, 12, 15, tzinfo=timezone.utc), + period_end=datetime(2025, 12, 16, tzinfo=timezone.utc), + total_cost=0, + ) + + orm_session.add(invalid_period) + + # Should raise IntegrityError due to foreign key constraint + with pytest.raises(IntegrityError): + orm_session.commit() + + # Rollback the failed transaction + orm_session.rollback() + except Exception: + orm_session.rollback() + raise diff --git a/app/api/tests/opsboard/services/__init__.py b/app/api/tests/opsboard/services/__init__.py new file mode 100644 index 000000000..7e147cf10 --- /dev/null +++ b/app/api/tests/opsboard/services/__init__.py @@ -0,0 +1 @@ +# Test directory for opsboard services diff --git a/app/api/tests/opsboard/services/test_billing_service.py b/app/api/tests/opsboard/services/test_billing_service.py new file mode 100644 index 000000000..e5ddffc62 --- /dev/null +++ b/app/api/tests/opsboard/services/test_billing_service.py @@ -0,0 +1,621 @@ +import pytest +from unittest.mock import patch, MagicMock +from datetime import datetime, timedelta +from decimal import Decimal +import os + +from agentops.opsboard.services.billing_service import BillingService +from agentops.opsboard.models import ProjectModel, BillingPeriod +from agentops.common.usage_tracking import UsageType + + +# Mock Stripe environment variables for testing +@pytest.fixture(autouse=True) +def mock_stripe_env_vars(): + with ( + patch.dict( + os.environ, + { + 'STRIPE_SECRET_KEY': 'sk_test_mock_key', + 'STRIPE_SUBSCRIPTION_PRICE_ID': 'price_test_subscription', + 'STRIPE_TOKEN_PRICE_ID': 'price_test_token', + 'STRIPE_SPAN_PRICE_ID': 'price_test_span', + }, + ), + patch('stripe.Account.retrieve'), + ): + yield + + +@pytest.fixture +def billing_service(): + """Create a billing service instance for testing.""" + # Mock the Stripe validation to avoid API calls during initialization + with patch('stripe.Account.retrieve'): + return BillingService() + + +@pytest.fixture +def mock_stripe_price(): + """Mock Stripe price object.""" + mock_price = MagicMock() + mock_price.unit_amount = 2000 # $20.00 in cents + mock_price.transform_quantity = None + return mock_price + + +@pytest.fixture +def mock_clickhouse_client(): + """Mock ClickHouse client for usage queries.""" + mock_client = MagicMock() + mock_result = MagicMock() + mock_result.result_rows = [ + (1000, 82000) # span_count, total_tokens (50000+25000+5000+2000) + ] + mock_client.query.return_value = mock_result + return mock_client + + +class TestBillingService: + """Test cases for BillingService class.""" + + def test_init(self): + """Test BillingService initialization.""" + service = BillingService() + + assert service._pricing_cache is None + assert service._cache_timestamp is None + assert service._cache_duration == 3600 # 1 hour + assert service._usage_cache == {} + assert service._usage_cache_ttl == 300 # 5 minutes + + def test_should_refresh_cache_when_no_cache(self, billing_service): + """Test _should_refresh_cache returns True when no cache exists.""" + # Ensure no cache exists + billing_service._pricing_cache = None + billing_service._cache_timestamp = None + + assert billing_service._should_refresh_cache() is True + + def test_should_refresh_cache_when_cache_expired(self, billing_service): + """Test _should_refresh_cache returns True when cache is expired.""" + # Set cache with expired timestamp + billing_service._pricing_cache = {"test": "data"} + billing_service._cache_timestamp = datetime.now() - timedelta(seconds=3700) # Older than 1 hour + + assert billing_service._should_refresh_cache() is True + + def test_should_refresh_cache_when_cache_valid(self, billing_service): + """Test _should_refresh_cache returns False when cache is still valid.""" + # Set cache with recent timestamp + billing_service._pricing_cache = {"test": "data"} + billing_service._cache_timestamp = datetime.now() - timedelta(seconds=1800) # 30 minutes ago + + assert billing_service._should_refresh_cache() is False + + @patch('agentops.opsboard.services.billing_service.STRIPE_SPAN_PRICE_ID', 'price_span123') + @patch('agentops.opsboard.services.billing_service.STRIPE_TOKEN_PRICE_ID', 'price_token123') + @patch('stripe.Price.retrieve') + def test_get_usage_pricing_with_stripe_success(self, mock_price_retrieve, billing_service): + """Test get_usage_pricing successfully fetches from Stripe.""" + # Clear cache to ensure fresh call + billing_service._pricing_cache = None + billing_service._cache_timestamp = None + + # Mock Stripe price objects + token_price = MagicMock() + token_price.unit_amount = 2 # $0.02 in cents for 1000 tokens + token_price.unit_amount_decimal = None + token_price.custom_unit_amount = None + token_price.tiers = None + token_price.currency_options = None + token_price.transform_quantity = MagicMock() + token_price.transform_quantity.divide_by = 1000 + + span_price = MagicMock() + span_price.unit_amount = 100 # $1.00 in cents per span + span_price.unit_amount_decimal = None + span_price.custom_unit_amount = None + span_price.tiers = None + span_price.currency_options = None + span_price.transform_quantity = None + + mock_price_retrieve.side_effect = [token_price, span_price] + + pricing = billing_service.get_usage_pricing() + + assert UsageType.TOKENS in pricing + assert UsageType.SPANS in pricing + + # Check token pricing - unit_amount 2 becomes 2/100 = 0.02 dollars + token_config = pricing[UsageType.TOKENS] + assert token_config['price_per_unit'] == Decimal('0.02') + assert token_config['unit_size'] == 1000 + assert token_config['display_unit'] == 'thousand tokens' + assert token_config['stripe_price_id'] == 'price_token123' + + # Check span pricing + span_config = pricing[UsageType.SPANS] + assert span_config['price_per_unit'] == Decimal('1.00') + assert span_config['unit_size'] == 1000 + assert span_config['display_unit'] == 'thousand spans' + assert span_config['stripe_price_id'] == 'price_span123' + + @patch('stripe.Price.retrieve') + def test_get_usage_pricing_with_stripe_error(self, mock_price_retrieve, billing_service): + """Test get_usage_pricing falls back to defaults when Stripe fails.""" + import stripe + + mock_price_retrieve.side_effect = stripe.error.StripeError("API Error") + + pricing = billing_service.get_usage_pricing() + + # Should return default values + assert UsageType.TOKENS in pricing + assert UsageType.SPANS in pricing + + token_config = pricing[UsageType.TOKENS] + assert token_config['price_per_unit'] == Decimal('0.0002') + assert token_config['unit_size'] == 1000 + assert token_config['display_unit'] == 'thousand tokens' + + span_config = pricing[UsageType.SPANS] + assert span_config['price_per_unit'] == Decimal('0.0001') + assert span_config['unit_size'] == 1000 + assert span_config['display_unit'] == 'thousand spans' + + @patch('agentops.opsboard.services.billing_service.STRIPE_SPAN_PRICE_ID', 'price_span123') + @patch('agentops.opsboard.services.billing_service.STRIPE_TOKEN_PRICE_ID', 'price_token123') + def test_get_usage_pricing_with_env_vars(self, billing_service): + """Test get_usage_pricing uses environment variable price IDs.""" + # Clear cache to ensure fresh call + billing_service._pricing_cache = None + billing_service._cache_timestamp = None + + with patch('stripe.Price.retrieve') as mock_retrieve: + token_price = MagicMock() + token_price.unit_amount = 5 + token_price.unit_amount_decimal = None + token_price.custom_unit_amount = None + token_price.tiers = None + token_price.currency_options = None + token_price.transform_quantity = None + + span_price = MagicMock() + span_price.unit_amount = 150 + span_price.unit_amount_decimal = None + span_price.custom_unit_amount = None + span_price.tiers = None + span_price.currency_options = None + span_price.transform_quantity = None + + mock_retrieve.side_effect = [token_price, span_price] + + billing_service.get_usage_pricing() + + # Verify that Stripe was called with the environment variable price IDs + assert mock_retrieve.call_count == 2 + mock_retrieve.assert_any_call('price_token123', expand=['currency_options', 'tiers']) + mock_retrieve.assert_any_call('price_span123', expand=['currency_options', 'tiers']) + + def test_get_usage_pricing_returns_cached_values(self, billing_service): + """Test get_usage_pricing returns cached values when cache is valid.""" + # Set up valid cache + cached_pricing = { + UsageType.TOKENS: {'price_per_unit': Decimal('0.01'), 'unit_size': 1000}, + UsageType.SPANS: {'price_per_unit': Decimal('0.002'), 'unit_size': 1}, + } + billing_service._pricing_cache = cached_pricing + billing_service._cache_timestamp = datetime.now() + + with patch('stripe.Price.retrieve') as mock_retrieve: + pricing = billing_service.get_usage_pricing() + + # Should return cached values without calling Stripe + assert pricing == cached_pricing + mock_retrieve.assert_not_called() + + @patch('agentops.opsboard.services.billing_service.STRIPE_SUBSCRIPTION_PRICE_ID', 'price_sub123') + @patch('stripe.Price.retrieve') + def test_get_seat_price_from_stripe_success(self, mock_price_retrieve, billing_service): + """Test get_seat_price successfully fetches from Stripe.""" + mock_price = MagicMock() + mock_price.unit_amount = 5000 # $50.00 in cents + mock_price.unit_amount_decimal = None + mock_price.custom_unit_amount = None + mock_price.tiers = None + mock_price.currency_options = None + mock_price.recurring = MagicMock() + mock_price.recurring.usage_type = 'licensed' + + mock_price_retrieve.return_value = mock_price + + seat_price = billing_service.get_seat_price() + + assert seat_price == 5000 + mock_price_retrieve.assert_called_once_with('price_sub123', expand=['currency_options', 'tiers']) + + @patch('stripe.Price.retrieve') + def test_get_seat_price_stripe_error_fallback(self, mock_price_retrieve, billing_service): + """Test get_seat_price falls back to environment variable when Stripe fails.""" + import stripe + + mock_price_retrieve.side_effect = stripe.error.StripeError("API Error") + + with patch.dict(os.environ, {'STRIPE_SEAT_PRICE_CENTS': '6000'}): + seat_price = billing_service.get_seat_price() + + assert seat_price == 6000 + + @patch.dict('os.environ', {'STRIPE_SEAT_PRICE_CENTS': '5000'}) + def test_get_seat_price_from_env_var(self, billing_service): + """Test get_seat_price uses environment variable when no Stripe config.""" + # No STRIPE_SUBSCRIPTION_PRICE_ID set + with patch.dict(os.environ, {}, clear=True): + os.environ['STRIPE_SEAT_PRICE_CENTS'] = '5000' + seat_price = billing_service.get_seat_price() + + assert seat_price == 5000 + + @patch('agentops.opsboard.services.billing_service.get_clickhouse') + async def test_get_usage_for_period_success( + self, mock_get_clickhouse, billing_service, orm_session, test_org, mock_clickhouse_client + ): + """Test get_usage_for_period successfully queries ClickHouse.""" + # Create test projects for the org + project1 = ProjectModel(name="Test Project 1", org_id=test_org.id) + project2 = ProjectModel(name="Test Project 2", org_id=test_org.id) + orm_session.add_all([project1, project2]) + orm_session.flush() + + # Mock ClickHouse response + mock_get_clickhouse.return_value = mock_clickhouse_client + + period_start = datetime(2024, 1, 1) + period_end = datetime(2024, 1, 31) + + result = await billing_service.get_usage_for_period( + orm_session, str(test_org.id), period_start, period_end + ) + + assert result == {'tokens': 82000, 'spans': 1000} # 50000+25000+5000+2000 tokens, 1000 spans + mock_clickhouse_client.query.assert_called_once() + + async def test_get_usage_for_period_no_projects(self, billing_service, orm_session, test_org): + """Test get_usage_for_period returns empty when org has no projects.""" + period_start = datetime(2024, 1, 1) + period_end = datetime(2024, 1, 31) + + result = await billing_service.get_usage_for_period( + orm_session, str(test_org.id), period_start, period_end + ) + + assert result == {} + + @patch('agentops.opsboard.services.billing_service.get_clickhouse') + async def test_get_usage_for_period_clickhouse_error( + self, mock_get_clickhouse, billing_service, orm_session, test_org + ): + """Test get_usage_for_period handles ClickHouse errors gracefully.""" + # Create test project + project = ProjectModel(name="Test Project", org_id=test_org.id) + orm_session.add(project) + orm_session.flush() + + # Mock ClickHouse to raise an error + mock_client = MagicMock() + mock_client.query.side_effect = Exception("ClickHouse connection failed") + mock_get_clickhouse.return_value = mock_client + + period_start = datetime(2024, 1, 1) + period_end = datetime(2024, 1, 31) + + result = await billing_service.get_usage_for_period( + orm_session, str(test_org.id), period_start, period_end + ) + + assert result == {} + + async def test_get_usage_for_period_uses_cache(self, billing_service, orm_session, test_org): + """Test get_usage_for_period returns cached data when available.""" + from datetime import timezone + + period_start = datetime(2024, 1, 1) + period_end = datetime(2024, 1, 31) + + # Convert to UTC as the implementation does + period_start_utc = period_start.replace(tzinfo=timezone.utc) + period_end_utc = period_end.replace(tzinfo=timezone.utc) + + cache_key = f"{test_org.id}:{period_start_utc.isoformat()}:{period_end_utc.isoformat()}:all" + + # Set cache data + cached_data = {'tokens': 5000, 'spans': 100} + billing_service._usage_cache[cache_key] = (cached_data, datetime.now()) + + result = await billing_service.get_usage_for_period( + orm_session, str(test_org.id), period_start, period_end + ) + + assert result == cached_data + + async def test_get_usage_for_period_cache_expiry( + self, billing_service, orm_session, test_org, mock_clickhouse_client + ): + """Test get_usage_for_period refreshes data when cache is expired.""" + from datetime import timezone + + period_start = datetime(2024, 1, 1) + period_end = datetime(2024, 1, 31) + + # Convert to UTC as the implementation does + period_start_utc = period_start.replace(tzinfo=timezone.utc) + period_end_utc = period_end.replace(tzinfo=timezone.utc) + + cache_key = f"{test_org.id}:{period_start_utc.isoformat()}:{period_end_utc.isoformat()}:all" + + # Set expired cache data + expired_data = {'tokens': 1000, 'spans': 50} + expired_time = datetime.now() - timedelta(seconds=400) # Older than 5 minutes + billing_service._usage_cache[cache_key] = (expired_data, expired_time) + + with patch('agentops.opsboard.services.billing_service.get_clickhouse') as mock_get_clickhouse: + mock_get_clickhouse.return_value = mock_clickhouse_client + + # Create test project + project = ProjectModel(name="Test Project", org_id=test_org.id) + orm_session.add(project) + orm_session.flush() + + result = await billing_service.get_usage_for_period( + orm_session, str(test_org.id), period_start, period_end + ) + + # Should get fresh data, not expired cache + assert result == {'tokens': 82000, 'spans': 1000} + + async def test_calculate_usage_costs_tokens(self, billing_service): + """Test calculate_usage_costs correctly calculates token costs.""" + # Mock pricing + billing_service._pricing_cache = { + UsageType.TOKENS: {'price_per_unit': Decimal('0.0002'), 'unit_size': 1000} + } + billing_service._cache_timestamp = datetime.now() + + usage_quantities = {'tokens': 5000000} # 5M tokens + + result = await billing_service.calculate_usage_costs(usage_quantities) + + # 5M tokens / 1000 units * $0.0002 = $1.00 = 100 cents + assert result == {'tokens': 100} + + async def test_calculate_usage_costs_spans(self, billing_service): + """Test calculate_usage_costs correctly calculates span costs.""" + # Mock pricing + billing_service._pricing_cache = { + UsageType.SPANS: {'price_per_unit': Decimal('0.0001'), 'unit_size': 1000} + } + billing_service._cache_timestamp = datetime.now() + + usage_quantities = {'spans': 1000000} # 1M spans + + result = await billing_service.calculate_usage_costs(usage_quantities) + + # 1M spans / 1000 units * $0.0001 = $0.10 = 10 cents + assert result == {'spans': 10} + + async def test_calculate_usage_costs_mixed_usage(self, billing_service): + """Test calculate_usage_costs handles multiple usage types.""" + # Mock pricing + billing_service._pricing_cache = { + UsageType.TOKENS: {'price_per_unit': Decimal('0.0002'), 'unit_size': 1000}, + UsageType.SPANS: {'price_per_unit': Decimal('0.0001'), 'unit_size': 1000}, + } + billing_service._cache_timestamp = datetime.now() + + usage_quantities = {'tokens': 2000000, 'spans': 500000} + + result = await billing_service.calculate_usage_costs(usage_quantities) + + # Tokens: 2M / 1000 * $0.0002 = $0.40 = 40 cents + # Spans: 500K / 1000 * $0.0001 = $0.05 = 5 cents + assert result == {'tokens': 40, 'spans': 5} + + async def test_calculate_usage_costs_unknown_usage_type(self, billing_service): + """Test calculate_usage_costs ignores unknown usage types.""" + # Mock pricing + billing_service._pricing_cache = { + UsageType.TOKENS: {'price_per_unit': Decimal('0.0002'), 'unit_size': 1000} + } + billing_service._cache_timestamp = datetime.now() + + usage_quantities = {'tokens': 1000000, 'unknown_type': 500} + + result = await billing_service.calculate_usage_costs(usage_quantities) + + # Should only calculate known types + assert result == {'tokens': 20} + assert 'unknown_type' not in result + + async def test_calculate_usage_costs_zero_quantities(self, billing_service): + """Test calculate_usage_costs handles zero quantities.""" + # Mock pricing + billing_service._pricing_cache = { + UsageType.TOKENS: {'price_per_unit': Decimal('0.0002'), 'unit_size': 1000}, + UsageType.SPANS: {'price_per_unit': Decimal('0.0001'), 'unit_size': 1000}, + } + billing_service._cache_timestamp = datetime.now() + + usage_quantities = {'tokens': 0, 'spans': 0} + + result = await billing_service.calculate_usage_costs(usage_quantities) + + # With minimum charge threshold, zero quantities return empty dict + assert result == {} + + async def test_create_billing_period_snapshot_success( + self, billing_service, orm_session, test_org, test_user, test_user2, test_user3 + ): + """Test create_billing_period_snapshot creates a complete snapshot.""" + # Set up org with paid members using existing test user fixtures + from agentops.opsboard.models import UserOrgModel, OrgRoles + + # Create 3 paid member relationships using existing test users + test_users = [test_user, test_user2, test_user3] + + for user in test_users: + user_org = UserOrgModel( + user_id=user.id, + org_id=test_org.id, + role=OrgRoles.developer, + user_email=user.email, + is_paid=True, + ) + orm_session.add(user_org) + + orm_session.flush() + + # Mock the get_usage_for_period method + with ( + patch.object(billing_service, 'get_usage_for_period') as mock_get_usage, + patch.object(billing_service, 'calculate_usage_costs') as mock_calc_costs, + patch.object(billing_service, 'get_seat_price') as mock_seat_price, + ): + mock_get_usage.return_value = {'tokens': 1000000, 'spans': 500} + mock_calc_costs.return_value = {'tokens': 20, 'spans': 50} + mock_seat_price.return_value = 4000 # $40 per seat + + period_start = datetime(2024, 1, 1) + period_end = datetime(2024, 1, 31) + + result = await billing_service.create_billing_period_snapshot( + orm_session, test_org, period_start, period_end + ) + + assert isinstance(result, BillingPeriod) + assert result.org_id == test_org.id + assert result.period_start == period_start + assert result.period_end == period_end + assert result.seat_cost == 12000 # 3 seats * $40 + assert result.seat_count == 3 + assert result.usage_costs == {'tokens': 20, 'spans': 50} + assert result.usage_quantities == {'tokens': 1000000, 'spans': 500} + assert result.total_cost == 12070 # 12000 + 20 + 50 + assert result.status == 'pending' + + async def test_create_billing_period_snapshot_no_usage( + self, billing_service, orm_session, test_org, test_user + ): + """Test create_billing_period_snapshot works with zero usage.""" + # Set up org with one paid member using existing test user fixture + from agentops.opsboard.models import UserOrgModel, OrgRoles + + user_org = UserOrgModel( + user_id=test_user.id, + org_id=test_org.id, + role=OrgRoles.owner, + user_email=test_user.email, + is_paid=True, + ) + orm_session.add(user_org) + orm_session.flush() + + with ( + patch.object(billing_service, 'get_usage_for_period') as mock_get_usage, + patch.object(billing_service, 'calculate_usage_costs') as mock_calc_costs, + patch.object(billing_service, 'get_seat_price') as mock_seat_price, + ): + mock_get_usage.return_value = {} + mock_calc_costs.return_value = {} + mock_seat_price.return_value = 4000 + + period_start = datetime(2024, 1, 1) + period_end = datetime(2024, 1, 31) + + result = await billing_service.create_billing_period_snapshot( + orm_session, test_org, period_start, period_end + ) + + assert result.seat_cost == 4000 + assert result.usage_costs == {} + assert result.total_cost == 4000 + + async def test_create_billing_period_snapshot_multiple_seats( + self, billing_service, orm_session, test_org, test_user, test_user2, test_user3 + ): + """Test create_billing_period_snapshot calculates multiple seat costs correctly.""" + # Set up org with multiple paid members using existing test user fixtures + from agentops.opsboard.models import UserOrgModel, OrgRoles + + # Create 3 paid member relationships using existing test users (can't reuse same user for same org) + test_users = [test_user, test_user2, test_user3] + + for user in test_users: + user_org = UserOrgModel( + user_id=user.id, + org_id=test_org.id, + role=OrgRoles.developer, + user_email=user.email, + is_paid=True, + ) + orm_session.add(user_org) + + orm_session.flush() + + with ( + patch.object(billing_service, 'get_usage_for_period') as mock_get_usage, + patch.object(billing_service, 'calculate_usage_costs') as mock_calc_costs, + patch.object(billing_service, 'get_seat_price') as mock_seat_price, + ): + mock_get_usage.return_value = {'tokens': 500000} + mock_calc_costs.return_value = {'tokens': 10} + mock_seat_price.return_value = 3500 # $35 per seat + + period_start = datetime(2024, 1, 1) + period_end = datetime(2024, 1, 31) + + result = await billing_service.create_billing_period_snapshot( + orm_session, test_org, period_start, period_end + ) + + assert result.seat_cost == 10500 # 3 seats * $35 + assert result.seat_count == 3 + assert result.total_cost == 10510 # 10500 + 10 + + async def test_create_billing_period_snapshot_commits_to_db( + self, billing_service, orm_session, test_org, test_user + ): + """Test create_billing_period_snapshot commits the billing period to database.""" + # Set up org with one paid member using existing test user fixture + from agentops.opsboard.models import UserOrgModel, OrgRoles + + user_org = UserOrgModel( + user_id=test_user.id, + org_id=test_org.id, + role=OrgRoles.owner, + user_email=test_user.email, + is_paid=True, + ) + orm_session.add(user_org) + orm_session.flush() + + with ( + patch.object(billing_service, 'get_usage_for_period') as mock_get_usage, + patch.object(billing_service, 'calculate_usage_costs') as mock_calc_costs, + patch.object(billing_service, 'get_seat_price') as mock_seat_price, + ): + mock_get_usage.return_value = {} + mock_calc_costs.return_value = {} + mock_seat_price.return_value = 4000 + + period_start = datetime(2024, 1, 1) + period_end = datetime(2024, 1, 31) + + result = await billing_service.create_billing_period_snapshot( + orm_session, test_org, period_start, period_end + ) + + # Verify it was added to the session and committed + billing_period_in_db = orm_session.query(BillingPeriod).filter_by(id=result.id).first() + assert billing_period_in_db is not None + assert billing_period_in_db.org_id == test_org.id diff --git a/app/api/tests/opsboard/test_auth_user_model.py b/app/api/tests/opsboard/test_auth_user_model.py new file mode 100644 index 000000000..94e718b79 --- /dev/null +++ b/app/api/tests/opsboard/test_auth_user_model.py @@ -0,0 +1,94 @@ +import pytest +import uuid +from sqlalchemy.orm import Session +from agentops.opsboard.models import AuthUserModel, UserModel + + +@pytest.fixture(scope="function") +async def auth_user(orm_session: Session, test_user: UserModel) -> AuthUserModel: + """Get the auth user corresponding to the test user.""" + # Get the auth user that corresponds to our test user + auth_user = orm_session.get(AuthUserModel, test_user.id) + + if not auth_user: + # This should not happen with proper test setup since auth users should be seeded + raise RuntimeError(f"No auth user found for test user ID {test_user.id}. Check seed data.") + + return auth_user + + +class TestAuthUserModel: + """Test cases for the AuthUserModel.""" + + async def test_auth_user_creation(self, auth_user: AuthUserModel): + """Test that AuthUserModel can be created successfully.""" + assert auth_user.id is not None + assert auth_user.email == "test@example.com" # Matches the seeded auth user email + assert str(auth_user.id) == "00000000-0000-0000-0000-000000000000" # From test_user fixture + + async def test_auth_user_model_table_schema(self, auth_user: AuthUserModel): + """Test that AuthUserModel maps to correct table and schema.""" + assert auth_user.__tablename__ == "users" + assert auth_user.__table_args__["schema"] == "auth" + + async def test_billing_email_property_with_auth_user(self, orm_session: Session, test_user: UserModel): + """Test that billing_email property returns email from auth.users table.""" + # Refresh the user to ensure the relationship is loaded + orm_session.refresh(test_user) + + # The billing_email should come from auth.users, not public.users + # Note: The actual auth email will depend on what's seeded for this test user ID + assert test_user.billing_email is not None # Should have an auth email + assert test_user.email == "test@example.com" # From test_user fixture + # If auth email is different from public email, test that + if test_user.billing_email != test_user.email: + assert test_user.billing_email != test_user.email + + async def test_billing_email_property_without_auth_user(self, orm_session: Session, test_user: UserModel): + """Test billing_email property when auth user has null email.""" + # Get the auth user and temporarily modify its email to None for testing + auth_user = test_user.auth_user + original_email = auth_user.email + + try: + # Temporarily modify the auth user's email in memory only (not persisted) + # This simulates the case where auth.users.email is NULL + object.__setattr__(auth_user, 'email', None) + + # billing_email should return None when auth email is null + assert test_user.billing_email is None + assert test_user.email == "test@example.com" # public email remains from fixture + + finally: + # Restore original email + object.__setattr__(auth_user, 'email', original_email) + + async def test_auth_user_relationship_lazy_loading(self, orm_session: Session, test_user: UserModel): + """Test that the auth_user relationship works with lazy loading.""" + # Get user without explicitly loading auth_user relationship + user = orm_session.get(UserModel, test_user.id) + + # Accessing auth_user should trigger lazy load + assert user.auth_user is not None + # The auth email should exist (specific value depends on seed data) + assert user.auth_user.email is not None + + async def test_auth_user_model_columns(self, auth_user: AuthUserModel): + """Test that AuthUserModel has the expected columns.""" + # Check that the model has the basic columns we expect + assert hasattr(auth_user, 'id') + assert hasattr(auth_user, 'email') + assert hasattr(auth_user, 'created_at') + + # Verify column types are as expected + assert isinstance(auth_user.id, uuid.UUID) + assert isinstance(auth_user.email, str) + + async def test_auth_user_model_read_only(self, auth_user: AuthUserModel): + """Test that AuthUserModel prevents modifications.""" + # Test that we can read the auth user + assert auth_user.email is not None + + # Test that attempting to modify a persistent auth user raises an error + with pytest.raises(RuntimeError, match="AuthUserModel is read-only"): + auth_user.email = "modified@example.com" \ No newline at end of file diff --git a/app/api/tests/opsboard/test_billing_integration.py b/app/api/tests/opsboard/test_billing_integration.py new file mode 100644 index 000000000..ff64e0be3 --- /dev/null +++ b/app/api/tests/opsboard/test_billing_integration.py @@ -0,0 +1,1053 @@ +import pytest +from unittest.mock import patch, MagicMock +from datetime import datetime, timezone, timedelta +from fastapi import HTTPException +import stripe + +from agentops.opsboard.services.billing_service import billing_service + + +def get_org_owner_id(org): + """Helper to get the owner user ID from an organization.""" + for user_org in org.users: + if user_org.role == OrgRoles.owner: + return user_org.user_id + return None + + +def setup_mock_request_auth(mock_request, user_id): + """Helper to ensure mock_request has proper authentication setup.""" + if not hasattr(mock_request, 'state'): + mock_request.state = MagicMock() + if not hasattr(mock_request.state, 'session'): + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = user_id + + +from agentops.opsboard.views.billing import BillingDashboardView +from agentops.opsboard.views.orgs import update_member_licenses, UpdateMemberLicensesBody +from agentops.opsboard.models import ( + OrgModel, + UserOrgModel, + BillingPeriod, + BillingAuditLog, + PremStatus, + OrgRoles, + ProjectModel, +) + +# Import shared billing fixtures +pytest_plugins = ["tests._conftest.billing"] + + +# Mock stripe at module level to prevent API key errors +stripe.api_key = 'sk_test_mock' + + +@pytest.fixture(autouse=True) +def ensure_clean_session(orm_session): + """Ensure clean session state before each test.""" + try: + # Check if session has pending rollback + if orm_session.in_transaction() and orm_session.is_active: + if hasattr(orm_session, '_transaction') and orm_session._transaction.is_active: + # Session is in a good state + pass + yield + except Exception: + orm_session.rollback() + raise + finally: + # Cleanup after test + try: + if orm_session.in_transaction(): + orm_session.rollback() + except Exception: + pass + + +@pytest.fixture +def test_billing_members(orm_session, test_pro_org, test_user2, test_user3): + """Create test members for billing integration tests.""" + members = [] + + # Use existing test users to avoid foreign key constraints + test_users = [test_user2, test_user3] + + for i, user in enumerate(test_users): + member = UserOrgModel( + user_id=user.id, + org_id=test_pro_org.id, + role=OrgRoles.developer, + user_email=user.email, + is_paid=i < 1, # First one is paid, second one is not + ) + orm_session.add(member) + members.append(member) + + orm_session.flush() + return members + + +@pytest.fixture(autouse=True) +def mock_stripe_config(): + """Mock Stripe configuration for all tests.""" + with ( + patch('agentops.opsboard.views.orgs.STRIPE_SECRET_KEY', 'sk_test_123'), + patch('agentops.opsboard.views.orgs.STRIPE_SUBSCRIPTION_PRICE_ID', 'price_test123'), + patch('agentops.api.environment.STRIPE_SECRET_KEY', 'sk_test_123'), + patch('agentops.api.environment.STRIPE_SUBSCRIPTION_PRICE_ID', 'price_test123'), + patch.dict( + 'os.environ', + {'STRIPE_SECRET_KEY': 'sk_test_123', 'STRIPE_SUBSCRIPTION_PRICE_ID': 'price_test123'}, + ), + ): + yield + + +class TestBillingIntegration: + """Integration tests for the billing system components.""" + + @patch('stripe.Subscription.modify') + @patch('stripe.Subscription.retrieve') + async def test_full_billing_workflow_new_member_join( + self, + mock_stripe_retrieve, + mock_stripe_modify, + mock_request, + orm_session, + test_pro_org, + test_billing_members, + mock_stripe_subscription, + ): + """Test complete billing workflow when a new member joins and gets licensed.""" + setup_mock_request_auth(mock_request, get_org_owner_id(test_pro_org)) + mock_stripe_retrieve.return_value = mock_stripe_subscription + + unlicensed_member = next(m for m in test_billing_members if not m.is_paid) + + # Step 1: License the member + body = UpdateMemberLicensesBody(add=[str(unlicensed_member.user_id)], remove=[]) + + license_result = await update_member_licenses( + request=mock_request, org_id=str(test_pro_org.id), body=body, orm=orm_session + ) + + # Verify licensing worked + assert license_result.paid_members_count == 3 # Owner + 1 existing + newly added + + # Step 2: Check audit log was created + audit_logs = ( + orm_session.query(BillingAuditLog) + .filter_by(org_id=test_pro_org.id, action='member_licensed') + .all() + ) + assert len(audit_logs) == 1 + assert audit_logs[0].details['member_id'] == str(unlicensed_member.user_id) + + # Step 3: Verify Stripe was called + mock_stripe_modify.assert_called_once() + call_args = mock_stripe_modify.call_args + assert call_args[1]['items'][0]['quantity'] == 3 + + @patch('stripe.Subscription.modify') + @patch('stripe.Subscription.retrieve') + async def test_full_billing_workflow_member_removal( + self, + mock_stripe_retrieve, + mock_stripe_modify, + mock_request, + orm_session, + test_pro_org, + test_billing_members, + mock_stripe_subscription, + ): + """Test complete billing workflow when a member is removed and unlicensed.""" + setup_mock_request_auth(mock_request, get_org_owner_id(test_pro_org)) + mock_stripe_retrieve.return_value = mock_stripe_subscription + + licensed_member = next(m for m in test_billing_members if m.is_paid) + + # Step 1: Remove member license + body = UpdateMemberLicensesBody(add=[], remove=[str(licensed_member.user_id)]) + + license_result = await update_member_licenses( + request=mock_request, org_id=str(test_pro_org.id), body=body, orm=orm_session + ) + + # Verify unlicensing worked + assert license_result.paid_members_count == 1 # Only owner remains + + # Step 2: Check audit log was created + audit_logs = ( + orm_session.query(BillingAuditLog) + .filter_by(org_id=test_pro_org.id, action='member_unlicensed') + .all() + ) + assert len(audit_logs) == 1 + + # Step 3: Verify member is marked as unpaid (need to refresh from DB) + orm_session.refresh(licensed_member) + assert licensed_member.is_paid is False + + async def test_billing_period_snapshot_creation_integration( + self, orm_session, test_pro_org, test_billing_members + ): + """Test creating billing period snapshots integrates with usage tracking.""" + # Create some projects for usage data + project = ProjectModel(name="Test Project", org_id=test_pro_org.id) + orm_session.add(project) + orm_session.flush() + + period_start = datetime(2024, 1, 1, tzinfo=timezone.utc) + period_end = datetime(2024, 1, 31, tzinfo=timezone.utc) + + with ( + patch.object(billing_service, 'get_usage_for_period') as mock_get_usage, + patch.object(billing_service, 'calculate_usage_costs') as mock_calc_costs, + patch.object(billing_service, 'get_seat_price') as mock_seat_price, + ): + mock_get_usage.return_value = {"tokens": 1000000, "spans": 500} + mock_calc_costs.return_value = {"tokens": 20, "spans": 50} + mock_seat_price.return_value = 4000 + + billing_period = await billing_service.create_billing_period_snapshot( + orm_session, test_pro_org, period_start, period_end + ) + + # Verify the snapshot + assert billing_period.org_id == test_pro_org.id + assert billing_period.seat_count == 2 # Owner + 1 paid member + assert billing_period.seat_cost == 8000 # 2 * 4000 + assert billing_period.usage_quantities == {"tokens": 1000000, "spans": 500} + assert billing_period.usage_costs == {"tokens": 20, "spans": 50} + assert billing_period.total_cost == 8070 # 8000 + 20 + 50 + + # Verify it's in the database + saved_period = orm_session.query(BillingPeriod).filter_by(id=billing_period.id).first() + assert saved_period is not None + + async def test_billing_dashboard_reflects_member_changes( + self, mock_request, orm_session, test_pro_org, test_billing_members + ): + """Test billing dashboard shows updated costs after member licensing changes.""" + setup_mock_request_auth(mock_request, get_org_owner_id(test_pro_org)) + dashboard_view = BillingDashboardView(mock_request) + + with ( + patch.object(billing_service, 'get_usage_for_period', return_value={"tokens": 500000}), + patch.object(billing_service, 'calculate_usage_costs', return_value={"tokens": 100}), + patch.object(billing_service, 'get_seat_price', return_value=5000), + ): + result = await dashboard_view(org_id=str(test_pro_org.id), orm=orm_session) + + # Extract response data if wrapped in JSONResponse + if hasattr(result, 'body'): + import json + + result = json.loads(result.body.decode()) + + # Verify dashboard reflects current state + assert result['current_period']['seat_count'] == 2 # Owner + 1 paid member + assert result['current_period']['seat_cost'] == 10000 # 2 * 5000 + assert result['current_period']['usage_costs'] == {"tokens": 100} + assert result['current_period']['total_cost'] == 10100 # 10000 + 100 + + async def test_billing_audit_logs_track_all_changes( + self, mock_request, orm_session, test_pro_org, test_billing_members, billing_period_factory + ): + """Test audit logs are created for all billing-related changes.""" + setup_mock_request_auth(mock_request, get_org_owner_id(test_pro_org)) + # Create billing period + billing_period = billing_period_factory( + test_pro_org.id, + total_cost=8000, + ) + orm_session.add(billing_period) + orm_session.commit() + + # Create audit log for period creation + audit_log = BillingAuditLog( + org_id=test_pro_org.id, + user_id=mock_request.state.session.user_id, + action='billing_period_created', + details={'period_id': str(billing_period.id), 'total_cost': billing_period.total_cost}, + ) + orm_session.add(audit_log) + orm_session.commit() + + # Verify audit trail + all_logs = orm_session.query(BillingAuditLog).filter_by(org_id=test_pro_org.id).all() + assert len(all_logs) >= 1 + + period_creation_log = next((log for log in all_logs if log.action == 'billing_period_created'), None) + assert period_creation_log is not None + assert period_creation_log.details['period_id'] == str(billing_period.id) + + @patch('stripe.Subscription.modify') + @patch('stripe.Subscription.retrieve') + async def test_stripe_integration_member_licensing( + self, + mock_stripe_retrieve, + mock_stripe_modify, + mock_request, + orm_session, + test_pro_org, + test_billing_members, + mock_stripe_subscription, + ): + """Test Stripe subscription updates when member licensing changes.""" + setup_mock_request_auth(mock_request, get_org_owner_id(test_pro_org)) + mock_stripe_retrieve.return_value = mock_stripe_subscription + + # Test multiple operations + unlicensed_member = next(m for m in test_billing_members if not m.is_paid) + licensed_member = next(m for m in test_billing_members if m.is_paid) + + # Operation 1: Add member + body1 = UpdateMemberLicensesBody(add=[str(unlicensed_member.user_id)], remove=[]) + + await update_member_licenses( + request=mock_request, org_id=str(test_pro_org.id), body=body1, orm=orm_session + ) + + # Operation 2: Remove member + body2 = UpdateMemberLicensesBody(add=[], remove=[str(licensed_member.user_id)]) + + await update_member_licenses( + request=mock_request, org_id=str(test_pro_org.id), body=body2, orm=orm_session + ) + + # Verify Stripe was called twice with correct quantities + assert mock_stripe_modify.call_count == 2 + + # First call should increase quantity + first_call = mock_stripe_modify.call_args_list[0] + assert first_call[1]['items'][0]['quantity'] == 3 # Added one + + # Second call should decrease quantity + second_call = mock_stripe_modify.call_args_list[1] + assert second_call[1]['items'][0]['quantity'] == 2 # Removed one + + async def test_usage_cost_calculation_integration(self, orm_session, test_pro_org, test_billing_members): + """Test usage cost calculation integrates with billing service and ClickHouse.""" + # Create project for usage + project = ProjectModel(name="Usage Test Project", org_id=test_pro_org.id) + orm_session.add(project) + orm_session.flush() + + # Mock ClickHouse response + with patch('agentops.opsboard.services.billing_service.get_clickhouse') as mock_clickhouse: + mock_client = MagicMock() + mock_result = MagicMock() + mock_result.result_rows = [(1000, 82000)] # span_count, total_tokens (50000+25000+5000+2000) + mock_client.query.return_value = mock_result + mock_clickhouse.return_value = mock_client + + period_start = datetime(2024, 1, 1) + period_end = datetime(2024, 1, 31) + + # Get usage data + usage_data = await billing_service.get_usage_for_period( + orm_session, str(test_pro_org.id), period_start, period_end + ) + + # Calculate costs + costs = await billing_service.calculate_usage_costs(usage_data) + + # Verify integration + assert usage_data == {'tokens': 82000, 'spans': 1000} # Total from mock data + assert isinstance(costs, dict) + assert 'tokens' in costs or 'spans' in costs # At least one cost type + + async def test_billing_error_handling_integration( + self, mock_request, orm_session, test_pro_org, test_billing_members, mock_stripe_subscription + ): + """Test error handling across billing service, views, and models.""" + setup_mock_request_auth(mock_request, get_org_owner_id(test_pro_org)) + # Test scenario: Stripe fails during member licensing + with ( + patch('stripe.Subscription.retrieve') as mock_retrieve, + patch('stripe.Subscription.modify') as mock_modify, + ): + # Ensure the mock subscription has the correct price ID to pass legacy check + mock_stripe_subscription.items.data[0]['price']['id'] = 'price_test123' + mock_retrieve.return_value = mock_stripe_subscription + + # Make Stripe fail + mock_modify.side_effect = stripe.error.StripeError("Card declined") + + unlicensed_member = next(m for m in test_billing_members if not m.is_paid) + + body = UpdateMemberLicensesBody(add=[str(unlicensed_member.user_id)], remove=[]) + + # Should raise HTTPException from Stripe error + with pytest.raises(HTTPException) as excinfo: + await update_member_licenses( + request=mock_request, org_id=str(test_pro_org.id), body=body, orm=orm_session + ) + + # Verify error is properly handled + assert excinfo.value.status_code == 500 + assert "Failed to update subscription" in excinfo.value.detail + + # Verify the error was logged + # Since the transaction raises an exception, the database changes are rolled back + # and we can't easily verify the state without complex session management + + async def test_billing_cache_integration(self, orm_session, test_pro_org, test_billing_members): + """Test billing service caching works correctly with real data.""" + # Create project + project = ProjectModel(name="Cache Test Project", org_id=test_pro_org.id) + orm_session.add(project) + orm_session.flush() + + period_start = datetime(2024, 1, 1) + period_end = datetime(2024, 1, 31) + + with patch('agentops.opsboard.services.billing_service.get_clickhouse') as mock_clickhouse: + mock_client = MagicMock() + mock_result = MagicMock() + mock_result.result_rows = [(500, 40000)] # span_count, total_tokens (25000+12000+2000+1000) + mock_client.query.return_value = mock_result + mock_clickhouse.return_value = mock_client + + # First call should hit ClickHouse + usage_data1 = await billing_service.get_usage_for_period( + orm_session, str(test_pro_org.id), period_start, period_end + ) + + # Second call should use cache + usage_data2 = await billing_service.get_usage_for_period( + orm_session, str(test_pro_org.id), period_start, period_end + ) + + # Verify caching worked + assert usage_data1 == usage_data2 + assert mock_client.query.call_count == 1 # Only called once due to caching + + @patch('stripe.Subscription.modify') + @patch('stripe.Subscription.retrieve') + async def test_concurrent_member_licensing_operations( + self, + mock_stripe_retrieve, + mock_stripe_modify, + mock_request, + orm_session, + test_pro_org, + test_billing_members, + mock_stripe_subscription, + ): + """Test concurrent member licensing operations don't cause data corruption.""" + setup_mock_request_auth(mock_request, get_org_owner_id(test_pro_org)) + mock_stripe_retrieve.return_value = mock_stripe_subscription + + # This test simulates what would happen with concurrent operations + # In practice, the with_for_update() lock should prevent issues + + unlicensed_member = next(m for m in test_billing_members if not m.is_paid) + + body = UpdateMemberLicensesBody(add=[str(unlicensed_member.user_id)], remove=[]) + + # Simulate first operation + result1 = await update_member_licenses( + request=mock_request, org_id=str(test_pro_org.id), body=body, orm=orm_session + ) + + # Verify state is consistent + assert result1.paid_members_count == 3 + + # Verify database state + updated_member = orm_session.query(UserOrgModel).filter_by(user_id=unlicensed_member.user_id).first() + assert updated_member.is_paid is True + + +class TestBillingWorkflows: + """Test common billing workflows end-to-end.""" + + async def test_org_upgrade_to_pro_workflow(self, mock_request, orm_session, test_user): + """Test complete workflow of upgrading an org to pro status.""" + # Create free org + free_org = OrgModel(name="Free Org", prem_status=PremStatus.free) + orm_session.add(free_org) + orm_session.flush() + + # Add user as owner + user_org = UserOrgModel( + user_id=test_user.id, + org_id=free_org.id, + role=OrgRoles.owner, + user_email=test_user.email, + is_paid=False, + ) + orm_session.add(user_org) + orm_session.flush() + + # Simulate upgrade process + free_org.prem_status = PremStatus.pro + free_org.subscription_id = "sub_new_upgrade" + user_org.is_paid = True + orm_session.commit() + + # Verify upgrade + assert free_org.prem_status == PremStatus.pro + assert free_org.subscription_id is not None + assert user_org.is_paid is True + + async def test_monthly_billing_period_closure_workflow( + self, orm_session, test_pro_org, test_billing_members + ): + """Test monthly billing period closure and snapshot creation.""" + # Create project for usage + project = ProjectModel(name="Monthly Test Project", org_id=test_pro_org.id) + orm_session.add(project) + orm_session.flush() + + # Set up billing period + period_start = datetime(2024, 1, 1, tzinfo=timezone.utc) + period_end = datetime(2024, 1, 31, tzinfo=timezone.utc) + + with ( + patch.object(billing_service, 'get_usage_for_period') as mock_usage, + patch.object(billing_service, 'calculate_usage_costs') as mock_costs, + patch.object(billing_service, 'get_seat_price') as mock_price, + ): + mock_usage.return_value = {"tokens": 2000000, "spans": 1000} + mock_costs.return_value = {"tokens": 40, "spans": 100} + mock_price.return_value = 4000 + + # Create snapshot (simulates monthly closure) + snapshot = await billing_service.create_billing_period_snapshot( + orm_session, test_pro_org, period_start, period_end + ) + + # Verify snapshot + assert snapshot.period_start == period_start + assert snapshot.period_end == period_end + assert snapshot.seat_count == 2 # Owner + 1 paid member + assert snapshot.total_cost == 8140 # (2 * 4000) + 40 + 100 + assert snapshot.status == 'pending' + + async def test_member_invitation_auto_licensing_workflow( + self, mock_request, orm_session, test_pro_org, test_user, test_user3 + ): + """Test workflow of inviting a member and auto-licensing them.""" + # Use existing test_user3 instead of creating new user + # Simulate invitation acceptance and auto-licensing + new_member = UserOrgModel( + user_id=test_user3.id, + org_id=test_pro_org.id, + role=OrgRoles.developer, + user_email=test_user3.email, + is_paid=True, # Auto-licensed + ) + orm_session.add(new_member) + orm_session.commit() + + # Create audit log for auto-licensing + audit_log = BillingAuditLog( + org_id=test_pro_org.id, + user_id=test_user3.id, + action='member_auto_licensed_on_invite_accept', + details={ + 'member_id': str(test_user3.id), + 'member_email': test_user3.email, + 'invite_role': 'developer', + }, + ) + orm_session.add(audit_log) + orm_session.commit() + + # Verify workflow + assert new_member.is_paid is True + + # Verify audit log + audit_logs = ( + orm_session.query(BillingAuditLog) + .filter_by(org_id=test_pro_org.id, action='member_auto_licensed_on_invite_accept') + .all() + ) + assert len(audit_logs) == 1 + + async def test_legacy_to_new_billing_migration_workflow( + self, mock_request, orm_session, test_pro_org, test_billing_members + ): + """Test migration from legacy billing to new seat-based billing.""" + # Simulate legacy billing state + test_pro_org.subscription_id = "sub_legacy_migration" + + # Set all members as unpaid initially (legacy state) + for member in test_billing_members: + member.is_paid = False + + # Get owner + owner = orm_session.query(UserOrgModel).filter_by(org_id=test_pro_org.id, role=OrgRoles.owner).first() + owner.is_paid = False + + orm_session.commit() + + # Simulate migration: auto-license all existing members + all_members = orm_session.query(UserOrgModel).filter_by(org_id=test_pro_org.id).all() + + for member in all_members: + member.is_paid = True + + orm_session.commit() + + # Verify migration + paid_members = orm_session.query(UserOrgModel).filter_by(org_id=test_pro_org.id, is_paid=True).count() + assert paid_members == 3 # Owner + 2 members + + @patch('stripe.Subscription.retrieve') + async def test_subscription_cancellation_workflow( + self, mock_stripe_retrieve, mock_request, orm_session, test_pro_org, test_billing_members + ): + """Test workflow when subscription is cancelled.""" + setup_mock_request_auth(mock_request, get_org_owner_id(test_pro_org)) + # Mock cancelled subscription for member licensing check + cancelled_subscription = MagicMock() + cancelled_subscription.cancel_at_period_end = True + cancelled_subscription.current_period_end = int((datetime.now() + timedelta(days=7)).timestamp()) + + def mock_get(key, default=None): + if key == 'cancel_at_period_end': + return True + elif key == 'current_period_end': + return cancelled_subscription.current_period_end + elif key == 'items': + return {'data': [{'price': {'id': 'price_legacy_123'}}]} + return default + + cancelled_subscription.get = mock_get + mock_stripe_retrieve.return_value = cancelled_subscription + + # Test that member licensing is blocked for cancelled subscription + body = UpdateMemberLicensesBody(add=[], remove=[]) + + with pytest.raises(HTTPException) as excinfo: + await update_member_licenses( + request=mock_request, org_id=str(test_pro_org.id), body=body, orm=orm_session + ) + + assert excinfo.value.status_code == 400 + assert "subscription is scheduled to cancel" in excinfo.value.detail + + # This test primarily verifies that cancelled subscriptions prevent seat management, + # which is the core functionality we care about for the cancellation workflow + + +class TestBillingDataConsistency: + """Test data consistency across billing components.""" + + async def test_seat_count_consistency_across_components( + self, orm_session, test_pro_org, test_billing_members + ): + """Test seat counts are consistent between service, models, and Stripe.""" + # Count paid members in database + db_paid_count = ( + orm_session.query(UserOrgModel).filter_by(org_id=test_pro_org.id, is_paid=True).count() + ) + + # Should be consistent with owner + paid members + assert db_paid_count >= 1 # At least the owner + + async def test_usage_data_consistency_billing_dashboard( + self, orm_session, test_pro_org, test_billing_members + ): + """Test usage data consistency between service and dashboard view.""" + # Create project for usage + project = ProjectModel(name="Consistency Test", org_id=test_pro_org.id) + orm_session.add(project) + orm_session.flush() + + test_usage = {"tokens": 1500000, "spans": 750} + test_costs = {"tokens": 30, "spans": 75} + + with ( + patch.object(billing_service, 'get_usage_for_period', return_value=test_usage), + patch.object(billing_service, 'calculate_usage_costs', return_value=test_costs), + patch.object(billing_service, 'get_seat_price', return_value=4000), + ): + # Get data from service directly + period_start = datetime(2024, 1, 1) + period_end = datetime(2024, 1, 31) + + service_usage = await billing_service.get_usage_for_period( + orm_session, str(test_pro_org.id), period_start, period_end + ) + service_costs = await billing_service.calculate_usage_costs(service_usage) + + # Get data from dashboard view + dashboard_view = BillingDashboardView(MagicMock()) + dashboard_view.request.state.session.user_id = "00000000-0000-0000-0000-000000000000" + + dashboard_result = await dashboard_view(org_id=str(test_pro_org.id), orm=orm_session) + + # Extract response data if wrapped in JSONResponse + if hasattr(dashboard_result, 'body'): + import json + + dashboard_result = json.loads(dashboard_result.body.decode()) + + # Verify consistency + assert service_usage == test_usage + assert service_costs == test_costs + assert dashboard_result['current_period']['usage_quantities'] == test_usage + assert dashboard_result['current_period']['usage_costs'] == test_costs + + async def test_cost_calculation_consistency(self, orm_session, test_pro_org, test_billing_members): + """Test cost calculations are consistent across all billing components.""" + # Test data + usage_quantities = {"tokens": 2000000, "spans": 1000} + + # Calculate costs multiple times + with patch.object(billing_service, 'get_usage_pricing') as mock_pricing: + from decimal import Decimal + + mock_pricing.return_value = { + 'tokens': {'price_per_unit': Decimal('0.00002'), 'unit_size': 1000}, + 'spans': {'price_per_unit': Decimal('0.001'), 'unit_size': 1}, + } + + costs1 = await billing_service.calculate_usage_costs(usage_quantities) + costs2 = await billing_service.calculate_usage_costs(usage_quantities) + costs3 = await billing_service.calculate_usage_costs(usage_quantities) + + # All calculations should be identical + assert costs1 == costs2 == costs3 + + # Verify expected calculations + # Tokens: 2M / 1000 * 0.00002 = 0.04 = 4 cents + # Spans: 1000 * 0.001 = 1.00 = 100 cents + assert costs1.get('tokens', 0) == 4 + assert costs1.get('spans', 0) == 100 + + async def test_audit_log_completeness( + self, mock_request, orm_session, test_pro_org, test_billing_members, billing_period_factory + ): + """Test all billing actions generate appropriate audit log entries.""" + setup_mock_request_auth(mock_request, get_org_owner_id(test_pro_org)) + initial_log_count = orm_session.query(BillingAuditLog).filter_by(org_id=test_pro_org.id).count() + + # Perform several billing operations + + # 1. Create billing period + billing_period = billing_period_factory( + test_pro_org.id, + total_cost=5000, + ) + orm_session.add(billing_period) + orm_session.commit() + + # Add audit log for period creation + period_log = BillingAuditLog( + org_id=test_pro_org.id, + user_id=mock_request.state.session.user_id, + action='billing_period_created', + details={'period_id': str(billing_period.id)}, + ) + orm_session.add(period_log) + + # 2. Create member licensing log + member_log = BillingAuditLog( + org_id=test_pro_org.id, + user_id=mock_request.state.session.user_id, + action='member_licensed', + details={'member_id': str(test_billing_members[0].user_id)}, + ) + orm_session.add(member_log) + + orm_session.commit() + + # Verify audit logs were created + final_log_count = orm_session.query(BillingAuditLog).filter_by(org_id=test_pro_org.id).count() + assert final_log_count == initial_log_count + 2 + + # Verify log content + logs = orm_session.query(BillingAuditLog).filter_by(org_id=test_pro_org.id).all() + actions = [log.action for log in logs] + assert 'billing_period_created' in actions + assert 'member_licensed' in actions + + +class TestBillingPerformance: + """Test performance aspects of the billing system.""" + + async def test_billing_dashboard_query_performance(self, orm_session, test_pro_org, test_billing_members): + """Test billing dashboard queries perform efficiently with large datasets.""" + # Create multiple billing periods + periods = [] + import time + + base_day = int(time.time() % 20) + 1 + + for i in range(20): # Simulate 20 months of data + unique_day = base_day + (i % 5) # Vary days to avoid conflicts + period = BillingPeriod( + org_id=test_pro_org.id, + period_start=datetime(2024, 1, unique_day, tzinfo=timezone.utc) + timedelta(days=30 * i), + period_end=datetime(2024, 1, unique_day + 1, tzinfo=timezone.utc) + timedelta(days=30 * i), + seat_cost=4000, + total_cost=4200, + status='paid', + ) + periods.append(period) + + orm_session.add_all(periods) + orm_session.commit() + + # Test dashboard performance + dashboard_view = BillingDashboardView(MagicMock()) + dashboard_view.request.state.session.user_id = "00000000-0000-0000-0000-000000000000" + + with ( + patch.object(billing_service, 'get_usage_for_period', return_value={}), + patch.object(billing_service, 'calculate_usage_costs', return_value={}), + patch.object(billing_service, 'get_seat_price', return_value=4000), + ): + start_time = datetime.now() + result = await dashboard_view(org_id=str(test_pro_org.id), orm=orm_session) + end_time = datetime.now() + + # Verify reasonable performance (should be under 1 second for this dataset) + execution_time = (end_time - start_time).total_seconds() + assert execution_time < 1.0 + + # Extract response data if wrapped in JSONResponse + if hasattr(result, 'body'): + import json + + result = json.loads(result.body.decode()) + + # Verify correct data limiting (only 12 past periods returned) + assert len(result['past_periods']) <= 12 + + async def test_usage_calculation_performance(self, orm_session, test_pro_org, test_billing_members): + """Test usage calculation performance with large amounts of data.""" + # Create multiple projects + projects = [] + for i in range(10): + project = ProjectModel(name=f"Performance Test Project {i}", org_id=test_pro_org.id) + projects.append(project) + + orm_session.add_all(projects) + orm_session.flush() + + # Mock large dataset response + with patch('agentops.opsboard.services.billing_service.get_clickhouse') as mock_clickhouse: + mock_client = MagicMock() + mock_result = MagicMock() + # Simulate large usage numbers + mock_result.result_rows = [ + (100000, 8200000) + ] # span_count, total_tokens (5000000+2500000+500000+200000) + mock_client.query.return_value = mock_result + mock_clickhouse.return_value = mock_client + + start_time = datetime.now() + usage_data = await billing_service.get_usage_for_period( + orm_session, str(test_pro_org.id), datetime(2024, 1, 1), datetime(2024, 1, 31) + ) + end_time = datetime.now() + + # Verify performance + execution_time = (end_time - start_time).total_seconds() + assert execution_time < 0.5 # Should be very fast + + # Verify data + assert usage_data['tokens'] == 8200000 # Sum of all token types + assert usage_data['spans'] == 100000 + + async def test_billing_service_cache_performance(self, orm_session, test_pro_org, test_billing_members): + """Test billing service caching improves performance.""" + # Create project + project = ProjectModel(name="Cache Performance Test", org_id=test_pro_org.id) + orm_session.add(project) + orm_session.flush() + + period_start = datetime(2024, 1, 1) + period_end = datetime(2024, 1, 31) + + with patch('agentops.opsboard.services.billing_service.get_clickhouse') as mock_clickhouse: + mock_client = MagicMock() + mock_result = MagicMock() + mock_result.result_rows = [(1000, 82000)] # span_count, total_tokens (50000+25000+5000+2000) + mock_client.query.return_value = mock_result + mock_clickhouse.return_value = mock_client + + # First call - should hit database + start_time1 = datetime.now() + await billing_service.get_usage_for_period( + orm_session, str(test_pro_org.id), period_start, period_end + ) + end_time1 = datetime.now() + + # Second call - should use cache + start_time2 = datetime.now() + await billing_service.get_usage_for_period( + orm_session, str(test_pro_org.id), period_start, period_end + ) + end_time2 = datetime.now() + + # Cache should be faster + time1 = (end_time1 - start_time1).total_seconds() + time2 = (end_time2 - start_time2).total_seconds() + + # Second call should be significantly faster (cache hit) + assert time2 < time1 + assert mock_client.query.call_count == 1 # Only called once + + +class TestBillingEdgeCases: + """Test edge cases in the billing system.""" + + async def test_billing_with_zero_usage(self, orm_session, test_pro_org, test_billing_members): + """Test billing calculations work correctly with zero usage.""" + with ( + patch.object(billing_service, 'get_usage_for_period', return_value={}), + patch.object(billing_service, 'calculate_usage_costs', return_value={}), + patch.object(billing_service, 'get_seat_price', return_value=4000), + ): + billing_period = await billing_service.create_billing_period_snapshot( + orm_session, + test_pro_org, + datetime(2024, 1, 1, tzinfo=timezone.utc), + datetime(2024, 1, 31, tzinfo=timezone.utc), + ) + + # Verify zero usage is handled correctly + assert billing_period.usage_quantities == {} + assert billing_period.usage_costs == {} + assert billing_period.seat_cost == 8000 # 2 * 4000 (owner + 1 paid member) + assert billing_period.total_cost == 8000 # Only seat cost + + async def test_billing_with_single_member_org(self, orm_session, test_user3): + """Test billing works correctly for single-member organizations.""" + # Create single-member org + single_org = OrgModel( + name="Single Member Org", prem_status=PremStatus.pro, subscription_id="sub_single" + ) + orm_session.add(single_org) + orm_session.flush() + + owner = UserOrgModel( + user_id=test_user3.id, + org_id=single_org.id, + role=OrgRoles.owner, + user_email=test_user3.email, + is_paid=True, + ) + orm_session.add(owner) + orm_session.flush() + + with ( + patch.object(billing_service, 'get_usage_for_period', return_value={"tokens": 100000}), + patch.object(billing_service, 'calculate_usage_costs', return_value={"tokens": 2}), + patch.object(billing_service, 'get_seat_price', return_value=4000), + ): + billing_period = await billing_service.create_billing_period_snapshot( + orm_session, + single_org, + datetime(2024, 1, 1, tzinfo=timezone.utc), + datetime(2024, 1, 31, tzinfo=timezone.utc), + ) + + # Verify single member billing + assert billing_period.seat_count == 1 + assert billing_period.seat_cost == 4000 + assert billing_period.usage_costs == {"tokens": 2} + assert billing_period.total_cost == 4002 + + async def test_billing_during_org_deletion( + self, mock_request, orm_session, test_pro_org, test_billing_members, billing_period_factory + ): + """Test billing data handling when organization is deleted.""" + setup_mock_request_auth(mock_request, get_org_owner_id(test_pro_org)) + org_id = test_pro_org.id + + # Create billing data + billing_period = billing_period_factory( + org_id, + total_cost=5000, + ) + orm_session.add(billing_period) + + audit_log = BillingAuditLog( + org_id=org_id, user_id=mock_request.state.session.user_id, action='test_action', details={} + ) + orm_session.add(audit_log) + orm_session.commit() + + # Delete organization + orm_session.delete(test_pro_org) + + try: + orm_session.commit() + + # Check if billing data was cascade deleted or preserved + remaining_periods = orm_session.query(BillingPeriod).filter_by(org_id=org_id).all() + remaining_logs = orm_session.query(BillingAuditLog).filter_by(org_id=org_id).all() + + # Behavior depends on database foreign key constraints + # This test documents the expected behavior + + except Exception: + # If foreign key constraints prevent deletion, that's also valid + orm_session.rollback() + + async def test_billing_with_invalid_stripe_data( + self, mock_request, orm_session, test_pro_org, test_billing_members + ): + """Test billing system handles invalid or corrupted Stripe data.""" + setup_mock_request_auth(mock_request, get_org_owner_id(test_pro_org)) + dashboard_view = BillingDashboardView(mock_request) + + # Test with invalid subscription ID + test_pro_org.subscription_id = "sub_invalid_123" + orm_session.flush() + + with patch('stripe.Subscription.retrieve') as mock_retrieve: + mock_retrieve.side_effect = stripe.error.InvalidRequestError( + "No such subscription", "subscription" + ) + + with ( + patch.object(billing_service, 'get_usage_for_period', return_value={}), + patch.object(billing_service, 'calculate_usage_costs', return_value={}), + patch.object(billing_service, 'get_seat_price', return_value=4000), + ): + # Should handle error gracefully + result = await dashboard_view(org_id=str(test_pro_org.id), orm=orm_session) + + # Extract response data if wrapped in JSONResponse + if hasattr(result, 'body'): + import json + + result = json.loads(result.body.decode()) + + # Verify it still returns data (fallback behavior) + assert result['current_period'] is not None + assert result['is_legacy_billing'] is False # Default value + + async def test_billing_timezone_handling( + self, orm_session, test_pro_org, test_billing_members, billing_period_factory + ): + """Test billing system correctly handles different timezones.""" + # Test with different timezone periods + utc_start = datetime(2024, 1, 1, 0, 0, 0, tzinfo=timezone.utc) + utc_end = datetime(2024, 1, 31, 23, 59, 59, tzinfo=timezone.utc) + + # Create billing period with UTC times + billing_period = billing_period_factory( + test_pro_org.id, + seat_cost=4000, + total_cost=4000, + ) + orm_session.add(billing_period) + orm_session.commit() + + # Verify timezone-aware storage and retrieval + retrieved_period = orm_session.query(BillingPeriod).filter_by(id=billing_period.id).first() + + assert retrieved_period.period_start.tzinfo is not None + assert retrieved_period.period_end.tzinfo is not None diff --git a/app/api/tests/opsboard/views/__init__.py b/app/api/tests/opsboard/views/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/api/tests/opsboard/views/test_billing.py b/app/api/tests/opsboard/views/test_billing.py new file mode 100644 index 000000000..b684f765f --- /dev/null +++ b/app/api/tests/opsboard/views/test_billing.py @@ -0,0 +1,597 @@ +import pytest +from unittest.mock import patch, MagicMock +from fastapi import HTTPException +from fastapi.responses import JSONResponse +import uuid +import stripe + +from agentops.opsboard.views.billing import ( + BillingDashboardView, +) +from agentops.opsboard.models import OrgModel, UserOrgModel, OrgRoles, PremStatus +from agentops.opsboard.services.billing_service import billing_service + +# Import shared billing fixtures +pytest_plugins = ["tests._conftest.billing"] +from tests._conftest.billing_constants import ( + SEAT_PRICE_DEFAULT, + TOKEN_COST_SAMPLE, + SPAN_COST_SAMPLE, + TOKEN_QUANTITY_SAMPLE, + SPAN_QUANTITY_SAMPLE, +) + + +# Mock stripe at module level to prevent API key errors +stripe.api_key = 'sk_test_mock' + + +def extract_response_data(response): + """Helper function to extract data from JSONResponse wrapper.""" + if isinstance(response, JSONResponse): + # Get the content from the JSONResponse + import json + + return json.loads(response.body.decode()) + return response + + +@pytest.fixture +def billing_dashboard_view(mock_request): + """Create a BillingDashboardView instance for testing.""" + return BillingDashboardView(mock_request) + + +@pytest.fixture +def test_billing_period(orm_session, test_pro_org, billing_period_factory): + """Create a test billing period for testing.""" + billing_period = billing_period_factory( + test_pro_org.id, + seat_cost=8000, # $80 in cents (keeping for test consistency) + seat_count=2, + usage_costs={"tokens": TOKEN_COST_SAMPLE, "spans": SPAN_COST_SAMPLE}, + usage_quantities={"tokens": TOKEN_QUANTITY_SAMPLE, "spans": SPAN_QUANTITY_SAMPLE}, + total_cost=8200, + status='pending', + ) + orm_session.add(billing_period) + orm_session.flush() + return billing_period + + +class TestBillingDashboardView: + """Test cases for BillingDashboardView class.""" + + async def test_billing_dashboard_success( + self, billing_dashboard_view, orm_session, test_pro_org, test_user, test_billing_period + ): + """Test successful billing dashboard retrieval.""" + # Setup request + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user.id + + # Mock billing service + with ( + patch.object(billing_service, 'get_usage_for_period') as mock_get_usage, + patch.object(billing_service, 'calculate_usage_costs') as mock_calc_costs, + patch.object(billing_service, 'get_seat_price') as mock_seat_price, + ): + mock_get_usage.return_value = {"tokens": 500000, "spans": 100} + mock_calc_costs.return_value = {"tokens": 10, "spans": 5} + mock_seat_price.return_value = SEAT_PRICE_DEFAULT + + response = await billing_dashboard_view(org_id=str(test_pro_org.id), period=None, orm=orm_session) + + result = extract_response_data(response) + assert isinstance(response, JSONResponse) + assert result['current_period'] is not None + # Past periods are no longer returned since we moved away from stored periods + assert result['past_periods'] == [] + + async def test_billing_dashboard_org_not_found(self, billing_dashboard_view, orm_session, test_user): + """Test billing dashboard when organization doesn't exist.""" + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user.id + + fake_org_id = str(uuid.uuid4()) + + with pytest.raises(HTTPException) as exc_info: + await billing_dashboard_view(org_id=fake_org_id, period=None, orm=orm_session) + + assert exc_info.value.status_code == 403 + assert "Access denied" in str(exc_info.value.detail) + + async def test_billing_dashboard_access_denied_not_member( + self, billing_dashboard_view, orm_session, test_pro_org, test_user2 + ): + """Test billing dashboard access denied when user is not a member.""" + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user2.id + + with pytest.raises(HTTPException) as exc_info: + await billing_dashboard_view(org_id=str(test_pro_org.id), period=None, orm=orm_session) + + assert exc_info.value.status_code == 403 + assert "Access denied" in str(exc_info.value.detail) + + async def test_billing_dashboard_with_specific_period( + self, billing_dashboard_view, orm_session, test_pro_org, test_user, test_billing_period + ): + """Test billing dashboard with specific period requested.""" + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user.id + + response = await billing_dashboard_view( + org_id=str(test_pro_org.id), period=str(test_billing_period.id), orm=orm_session + ) + + result = extract_response_data(response) + assert result['current_period']['id'] == str(test_billing_period.id) + assert result['current_period']['seat_cost'] == 8000 + assert result['current_period']['total_cost'] == 8200 + + async def test_billing_dashboard_period_not_found( + self, billing_dashboard_view, orm_session, test_pro_org, test_user + ): + """Test billing dashboard when specific period doesn't exist.""" + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user.id + + fake_period_id = str(uuid.uuid4()) + + with pytest.raises(HTTPException) as exc_info: + await billing_dashboard_view(org_id=str(test_pro_org.id), period=fake_period_id, orm=orm_session) + + assert exc_info.value.status_code == 404 + assert "Billing period not found" in str(exc_info.value.detail) + + async def test_billing_dashboard_with_current_usage( + self, billing_dashboard_view, orm_session, test_pro_org, test_user + ): + """Test billing dashboard includes current period usage.""" + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user.id + + with ( + patch.object(billing_service, 'get_usage_for_period') as mock_get_usage, + patch.object(billing_service, 'calculate_usage_costs') as mock_calc_costs, + patch.object(billing_service, 'get_seat_price') as mock_seat_price, + ): + mock_get_usage.return_value = {"tokens": 1000000, "spans": 200} + mock_calc_costs.return_value = {"tokens": 20, "spans": 20} + mock_seat_price.return_value = 4000 + + response = await billing_dashboard_view(org_id=str(test_pro_org.id), period=None, orm=orm_session) + + result = extract_response_data(response) + assert result['current_period'] is not None + assert result['current_period']['usage_quantities']['tokens'] == 1000000 + assert result['current_period']['usage_quantities']['spans'] == 200 + + async def test_billing_dashboard_with_no_usage( + self, billing_dashboard_view, orm_session, test_pro_org, test_user + ): + """Test billing dashboard with no usage data.""" + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user.id + + with ( + patch.object(billing_service, 'get_usage_for_period') as mock_get_usage, + patch.object(billing_service, 'calculate_usage_costs') as mock_calc_costs, + patch.object(billing_service, 'get_seat_price') as mock_seat_price, + ): + mock_get_usage.return_value = {} + mock_calc_costs.return_value = {} + mock_seat_price.return_value = 4000 + + response = await billing_dashboard_view(org_id=str(test_pro_org.id), period=None, orm=orm_session) + + result = extract_response_data(response) + # With no usage and paid members, there should still be a current period + assert result['current_period'] is not None + assert result['current_period']['usage_quantities'] == {} + + async def test_billing_dashboard_with_past_periods( + self, billing_dashboard_view, orm_session, test_pro_org, test_user, billing_period_factory + ): + """Test billing dashboard includes historical billing periods.""" + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user.id + + # Create multiple billing periods + period1 = billing_period_factory( + test_pro_org.id, + total_cost=5000, + status='paid', + ) + + period2 = billing_period_factory( + test_pro_org.id, + total_cost=7500, + status='paid', + ) + + orm_session.add_all([period1, period2]) + orm_session.flush() + + with ( + patch.object(billing_service, 'get_usage_for_period') as mock_get_usage, + patch.object(billing_service, 'calculate_usage_costs') as mock_calc_costs, + patch.object(billing_service, 'get_seat_price') as mock_seat_price, + ): + mock_get_usage.return_value = {} + mock_calc_costs.return_value = {} + mock_seat_price.return_value = 4000 + + response = await billing_dashboard_view(org_id=str(test_pro_org.id), period=None, orm=orm_session) + + result = extract_response_data(response) + # Past periods are no longer returned since we moved away from stored periods + assert result['past_periods'] == [] + + async def test_billing_dashboard_usage_breakdown_tokens( + self, billing_dashboard_view, orm_session, test_pro_org, test_user, test_billing_period + ): + """Test billing dashboard shows token usage breakdown.""" + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user.id + + response = await billing_dashboard_view( + org_id=str(test_pro_org.id), period=str(test_billing_period.id), orm=orm_session + ) + + result = extract_response_data(response) + assert result['current_period']['usage_quantities']['tokens'] == 750000 + assert result['current_period']['usage_costs']['tokens'] == 150 + + async def test_billing_dashboard_usage_breakdown_spans( + self, billing_dashboard_view, orm_session, test_pro_org, test_user, test_billing_period + ): + """Test billing dashboard shows span usage breakdown.""" + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user.id + + response = await billing_dashboard_view( + org_id=str(test_pro_org.id), period=str(test_billing_period.id), orm=orm_session + ) + + result = extract_response_data(response) + assert result['current_period']['usage_quantities']['spans'] == 50 + assert result['current_period']['usage_costs']['spans'] == 50 + + async def test_billing_dashboard_seat_cost_calculation( + self, billing_dashboard_view, orm_session, test_pro_org, test_user, test_user2, test_user3 + ): + """Test billing dashboard calculates seat costs correctly.""" + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user.id + + # Add additional paid members + user_org2 = UserOrgModel( + user_id=test_user2.id, + org_id=test_pro_org.id, + role=OrgRoles.developer, + user_email=test_user2.email, + is_paid=True, + ) + + user_org3 = UserOrgModel( + user_id=test_user3.id, + org_id=test_pro_org.id, + role=OrgRoles.developer, + user_email=test_user3.email, + is_paid=True, + ) + + orm_session.add_all([user_org2, user_org3]) + orm_session.flush() + + with ( + patch.object(billing_service, 'get_usage_for_period') as mock_get_usage, + patch.object(billing_service, 'calculate_usage_costs') as mock_calc_costs, + patch.object(billing_service, 'get_seat_price') as mock_seat_price, + ): + mock_get_usage.return_value = {} + mock_calc_costs.return_value = {} + mock_seat_price.return_value = 4000 # $40 per seat + + response = await billing_dashboard_view(org_id=str(test_pro_org.id), period=None, orm=orm_session) + + result = extract_response_data(response) + # Should have 3 paid members (owner + 2 developers) + assert result['current_period']['seat_count'] == 3 + + async def test_billing_dashboard_total_cost_calculation( + self, billing_dashboard_view, orm_session, test_pro_org, test_user, test_billing_period + ): + """Test billing dashboard calculates total costs correctly.""" + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user.id + + response = await billing_dashboard_view( + org_id=str(test_pro_org.id), period=str(test_billing_period.id), orm=orm_session + ) + + result = extract_response_data(response) + # seat_cost (8000) + usage_costs (150 + 50) = 8200 + assert result['current_period']['total_cost'] == 8200 + + @patch('stripe.Subscription.retrieve') + async def test_billing_dashboard_with_stripe_subscription( + self, + mock_stripe_retrieve, + billing_dashboard_view, + orm_session, + test_pro_org, + test_user, + mock_stripe_subscription, + ): + """Test billing dashboard integrates with Stripe subscription data.""" + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user.id + + mock_stripe_retrieve.return_value = mock_stripe_subscription + + with ( + patch.object(billing_service, 'get_usage_for_period') as mock_get_usage, + patch.object(billing_service, 'calculate_usage_costs') as mock_calc_costs, + patch.object(billing_service, 'get_seat_price') as mock_seat_price, + ): + mock_get_usage.return_value = {} + mock_calc_costs.return_value = {} + mock_seat_price.return_value = 4000 + + response = await billing_dashboard_view(org_id=str(test_pro_org.id), period=None, orm=orm_session) + + # Should work without errors when Stripe integration is successful + assert isinstance(response, JSONResponse) + + @patch('stripe.Subscription.retrieve') + async def test_billing_dashboard_stripe_error_handling( + self, mock_stripe_retrieve, billing_dashboard_view, orm_session, test_pro_org, test_user + ): + """Test billing dashboard handles Stripe API errors gracefully.""" + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user.id + + mock_stripe_retrieve.side_effect = stripe.error.StripeError("API Error") + + with ( + patch.object(billing_service, 'get_usage_for_period') as mock_get_usage, + patch.object(billing_service, 'calculate_usage_costs') as mock_calc_costs, + patch.object(billing_service, 'get_seat_price') as mock_seat_price, + ): + mock_get_usage.return_value = {} + mock_calc_costs.return_value = {} + mock_seat_price.return_value = 4000 + + response = await billing_dashboard_view(org_id=str(test_pro_org.id), period=None, orm=orm_session) + + # Should still work but without Stripe data + assert isinstance(response, JSONResponse) + + async def test_billing_dashboard_legacy_billing_detection( + self, billing_dashboard_view, orm_session, test_user + ): + """Test billing dashboard detects legacy billing plans.""" + # Create org without subscription (legacy) + legacy_org = OrgModel(name="Legacy Org", prem_status=PremStatus.pro) + orm_session.add(legacy_org) + orm_session.flush() + + user_org = UserOrgModel( + user_id=test_user.id, + org_id=legacy_org.id, + role=OrgRoles.owner, + user_email=test_user.email, + is_paid=True, + ) + orm_session.add(user_org) + orm_session.flush() + + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user.id + + with ( + patch.object(billing_service, 'get_usage_for_period') as mock_get_usage, + patch.object(billing_service, 'calculate_usage_costs') as mock_calc_costs, + patch.object(billing_service, 'get_seat_price') as mock_seat_price, + ): + mock_get_usage.return_value = {} + mock_calc_costs.return_value = {} + mock_seat_price.return_value = 4000 + + response = await billing_dashboard_view(org_id=str(legacy_org.id), period=None, orm=orm_session) + + result = extract_response_data(response) + assert result['is_legacy_billing'] is False # No subscription means not legacy + + async def test_billing_dashboard_total_spent_calculation( + self, billing_dashboard_view, orm_session, test_pro_org, test_user, billing_period_factory + ): + """Test billing dashboard calculates total spent across all periods.""" + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user.id + + # Create multiple paid billing periods + period1 = billing_period_factory( + test_pro_org.id, + total_cost=5000, + status='paid', + ) + + period2 = billing_period_factory( + test_pro_org.id, + total_cost=7500, + status='paid', + ) + + orm_session.add_all([period1, period2]) + orm_session.flush() + + with ( + patch.object(billing_service, 'get_usage_for_period') as mock_get_usage, + patch.object(billing_service, 'calculate_usage_costs') as mock_calc_costs, + patch.object(billing_service, 'get_seat_price') as mock_seat_price, + ): + mock_get_usage.return_value = {} + mock_calc_costs.return_value = {} + mock_seat_price.return_value = 4000 + + response = await billing_dashboard_view(org_id=str(test_pro_org.id), period=None, orm=orm_session) + + result = extract_response_data(response) + # Since we moved away from stored periods, total_spent_all_time now only includes current period + # Current period: seat cost (4000) + usage costs (0) = 4000 + assert result['total_spent_all_time'] == 4000 + + async def test_billing_dashboard_period_status_values( + self, billing_dashboard_view, orm_session, test_pro_org, test_user, billing_period_factory + ): + """Test billing dashboard shows correct period status values.""" + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user.id + + period = billing_period_factory( + test_pro_org.id, + total_cost=4000, + status='invoiced', + ) + orm_session.add(period) + orm_session.flush() + + response = await billing_dashboard_view( + org_id=str(test_pro_org.id), period=str(period.id), orm=orm_session + ) + + result = extract_response_data(response) + assert result['current_period']['status'] == 'invoiced' + + async def test_billing_dashboard_datetime_formatting( + self, billing_dashboard_view, orm_session, test_pro_org, test_user, test_billing_period + ): + """Test billing dashboard formats datetime fields correctly.""" + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user.id + + response = await billing_dashboard_view( + org_id=str(test_pro_org.id), period=str(test_billing_period.id), orm=orm_session + ) + + result = extract_response_data(response) + assert result['current_period']['period_start'] is not None + assert result['current_period']['period_end'] is not None + # Should be ISO string format due to field_validator + assert isinstance(result['current_period']['period_start'], str) + assert isinstance(result['current_period']['period_end'], str) + + async def test_billing_dashboard_empty_usage_costs( + self, billing_dashboard_view, orm_session, test_pro_org, test_user, billing_period_factory + ): + """Test billing dashboard handles empty usage costs correctly.""" + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user.id + + period = billing_period_factory( + test_pro_org.id, + seat_cost=4000, + usage_costs={}, + usage_quantities={}, + total_cost=4000, + ) + orm_session.add(period) + orm_session.flush() + + response = await billing_dashboard_view( + org_id=str(test_pro_org.id), period=str(period.id), orm=orm_session + ) + + result = extract_response_data(response) + assert result['current_period']['usage_costs'] == {} + assert result['current_period']['usage_quantities'] == {} + assert result['current_period']['total_cost'] == 4000 + + async def test_billing_dashboard_exception_handling( + self, billing_dashboard_view, orm_session, test_pro_org, test_user + ): + """Test billing dashboard handles service exceptions gracefully.""" + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user.id + + with ( + patch.object(billing_service, 'get_usage_for_period') as mock_get_usage, + patch.object(billing_service, 'calculate_usage_costs') as mock_calc_costs, + patch.object(billing_service, 'get_seat_price') as mock_seat_price, + ): + # Mock service to raise exception + mock_get_usage.side_effect = Exception("Service error") + mock_calc_costs.return_value = {} + mock_seat_price.return_value = 4000 + + # The actual implementation doesn't catch this exception properly, + # so it will propagate up. Let's test that it raises the exception. + with pytest.raises(Exception) as exc_info: + await billing_dashboard_view(org_id=str(test_pro_org.id), period=None, orm=orm_session) + + assert "Service error" in str(exc_info.value) + + @patch('agentops.opsboard.services.billing_service.billing_service.get_usage_for_period') + async def test_billing_dashboard_usage_service_integration( + self, mock_get_usage, billing_dashboard_view, orm_session, test_pro_org, test_user + ): + """Test billing dashboard integrates with usage service correctly.""" + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user.id + + mock_get_usage.return_value = {"tokens": 2000000, "spans": 150} + + with ( + patch.object(billing_service, 'calculate_usage_costs') as mock_calc_costs, + patch.object(billing_service, 'get_seat_price') as mock_seat_price, + ): + mock_calc_costs.return_value = {"tokens": 40, "spans": 15} + mock_seat_price.return_value = 4000 + + response = await billing_dashboard_view(org_id=str(test_pro_org.id), period=None, orm=orm_session) + + result = extract_response_data(response) + # Verify service was called + mock_get_usage.assert_called() + assert result['current_period']['usage_quantities']['tokens'] == 2000000 + assert result['current_period']['usage_quantities']['spans'] == 150 + + @patch('agentops.opsboard.services.billing_service.billing_service.calculate_usage_costs') + async def test_billing_dashboard_cost_calculation_integration( + self, mock_calculate_costs, billing_dashboard_view, orm_session, test_pro_org, test_user + ): + """Test billing dashboard integrates with cost calculation service.""" + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = test_user.id + + mock_calculate_costs.return_value = {"tokens": 25, "spans": 30} + + with ( + patch.object(billing_service, 'get_usage_for_period') as mock_get_usage, + patch.object(billing_service, 'get_seat_price') as mock_seat_price, + ): + mock_get_usage.return_value = {"tokens": 1250000, "spans": 300} + mock_seat_price.return_value = 4000 + + response = await billing_dashboard_view(org_id=str(test_pro_org.id), period=None, orm=orm_session) + + # Verify service was called + mock_calculate_costs.assert_called() + assert isinstance(response, JSONResponse) + + async def test_billing_dashboard_user_not_authenticated( + self, billing_dashboard_view, orm_session, test_pro_org + ): + """Test billing dashboard when user is not authenticated.""" + billing_dashboard_view.request.state.session = MagicMock() + billing_dashboard_view.request.state.session.user_id = None + + with pytest.raises(HTTPException) as exc_info: + await billing_dashboard_view(org_id=str(test_pro_org.id), period=None, orm=orm_session) + + assert exc_info.value.status_code == 403 + assert "Access denied" in str(exc_info.value.detail) diff --git a/app/api/tests/opsboard/views/test_billing_member_licenses.py b/app/api/tests/opsboard/views/test_billing_member_licenses.py new file mode 100644 index 000000000..645965658 --- /dev/null +++ b/app/api/tests/opsboard/views/test_billing_member_licenses.py @@ -0,0 +1,1179 @@ +import pytest +from fastapi import HTTPException +from unittest.mock import patch, MagicMock +from datetime import datetime, timezone +import uuid +import stripe +import os + +from agentops.opsboard.models import OrgModel, UserOrgModel, OrgRoles, BillingAuditLog, PremStatus +from agentops.opsboard.views.orgs import ( + update_member_licenses, + preview_member_add_cost, + UpdateMemberLicensesBody, +) + +# Import shared billing fixtures +pytest_plugins = ["tests._conftest.billing"] + +# Mock stripe at module level to prevent API key errors +stripe.api_key = 'sk_test_mock' + + +@pytest.fixture +def test_licensed_members(orm_session, test_pro_org, test_user, test_user2, test_user3): + """Create test members with licensing status.""" + members = [] + + # Use existing test users from fixtures + test_users = [test_user, test_user2, test_user3] + + # Add existing test users to org with different paid states + for i, user in enumerate(test_users): + # Skip if user is already in org (e.g., test_user is the owner) + existing = orm_session.query(UserOrgModel).filter_by(user_id=user.id, org_id=test_pro_org.id).first() + + if not existing: + user_org = UserOrgModel( + user_id=user.id, + org_id=test_pro_org.id, + role=OrgRoles.developer, + user_email=user.email, + is_paid=(i == 1), # Second user (test_user2) is paid initially to match mock quantity=2 + ) + orm_session.add(user_org) + orm_session.flush() + members.append((user, user_org)) + else: + members.append((user, existing)) + + return members + + +@pytest.fixture(autouse=True) +def mock_stripe_config(): + """Automatically mock Stripe configuration for all tests.""" + # Patch the imported constants where they are used + with ( + patch('agentops.opsboard.views.orgs.STRIPE_SECRET_KEY', 'sk_test_123'), + patch('agentops.opsboard.views.orgs.STRIPE_SUBSCRIPTION_PRICE_ID', 'price_test123'), + patch('agentops.api.environment.STRIPE_SECRET_KEY', 'sk_test_123'), + patch('agentops.api.environment.STRIPE_SUBSCRIPTION_PRICE_ID', 'price_test123'), + patch.dict( + os.environ, {'STRIPE_SECRET_KEY': 'sk_test_123', 'STRIPE_SUBSCRIPTION_PRICE_ID': 'price_test123'} + ), + ): + yield + + +class TestUpdateMemberLicenses: + """Test cases for update_member_licenses function.""" + + async def test_update_member_licenses_success_add_members( + self, + mock_request, + orm_session, + test_pro_org, + test_licensed_members, + test_user, + mock_stripe_subscription, + ): + """Test successfully adding members to paid licenses.""" + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user.id + + # Get member IDs to add (test_user2 is already paid, test_user3 is not) + members_to_add = [str(member[0].id) for member in test_licensed_members[1:]] + + # Mock Stripe + with ( + patch('stripe.Subscription.retrieve') as mock_retrieve, + patch('stripe.Subscription.modify') as mock_modify, + ): + mock_retrieve.return_value = mock_stripe_subscription + mock_modify.return_value = mock_stripe_subscription + + # Call the function + result = await update_member_licenses( + org_id=str(test_pro_org.id), + request=mock_request, + body=UpdateMemberLicensesBody(add=members_to_add, remove=[]), + orm=orm_session, + ) + + # Verify response + assert result.message == "Successfully updated member licenses" + assert result.paid_members_count == 3 # Owner + 2 newly licensed members + + # The function already committed its changes, but we need to refresh our session + # to see the updates made by the function + orm_session.expunge_all() # Clear all objects from session + + # Verify database updates + # Check all members are now paid + paid_count = ( + orm_session.query(UserOrgModel) + .filter(UserOrgModel.org_id == test_pro_org.id, UserOrgModel.is_paid == True) + .count() + ) + assert paid_count == 3 # Owner + test_user2 + test_user3 + + # Specifically verify test_user3 was updated + test_user3 = test_licensed_members[2][0] + updated_user_org = ( + orm_session.query(UserOrgModel) + .filter_by(user_id=test_user3.id, org_id=test_pro_org.id) + .first() + ) + assert updated_user_org is not None + assert updated_user_org.is_paid is True + + # Verify Stripe was called to update quantity + mock_modify.assert_called_once() + + async def test_update_member_licenses_success_remove_members( + self, + mock_request, + orm_session, + test_pro_org, + test_licensed_members, + test_user, + mock_stripe_subscription, + ): + """Test successfully removing members from paid licenses.""" + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user.id + + # Get member ID to remove (test_user2 is paid) + member_to_remove = [str(test_licensed_members[1][0].id)] + + # Mock Stripe + with ( + patch('stripe.Subscription.retrieve') as mock_retrieve, + patch('stripe.Subscription.modify') as mock_modify, + ): + mock_retrieve.return_value = mock_stripe_subscription + mock_modify.return_value = mock_stripe_subscription + + # Call the function + result = await update_member_licenses( + org_id=str(test_pro_org.id), + request=mock_request, + body=UpdateMemberLicensesBody(add=[], remove=member_to_remove), + orm=orm_session, + ) + + # Verify response + assert result.message == "Successfully updated member licenses" + assert result.paid_members_count == 1 # Only owner remains + + # Refresh session to see updates + orm_session.expunge_all() + + # Verify database updates + updated_user_org = ( + orm_session.query(UserOrgModel) + .filter_by(user_id=test_licensed_members[1][0].id, org_id=test_pro_org.id) + .first() + ) + assert updated_user_org.is_paid is False + + async def test_update_member_licenses_mixed_add_remove( + self, + mock_request, + orm_session, + test_pro_org, + test_licensed_members, + test_user, + mock_stripe_subscription, + ): + """Test adding and removing members in the same request.""" + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user.id + + # Remove second member (paid test_user2), add third member (unpaid test_user3) + remove_ids = [str(test_licensed_members[1][0].id)] + add_ids = [str(test_licensed_members[2][0].id)] + + # Mock Stripe + with ( + patch('stripe.Subscription.retrieve') as mock_retrieve, + patch('stripe.Subscription.modify') as mock_modify, + ): + mock_retrieve.return_value = mock_stripe_subscription + mock_modify.return_value = mock_stripe_subscription + + # Call the function + result = await update_member_licenses( + org_id=str(test_pro_org.id), + request=mock_request, + body=UpdateMemberLicensesBody(add=add_ids, remove=remove_ids), + orm=orm_session, + ) + + # Verify response + assert result.message == "Successfully updated member licenses" + assert result.paid_members_count == 2 # Owner + 1 member + + async def test_update_member_licenses_user_not_authenticated( + self, mock_request, orm_session, test_pro_org, test_user + ): + """Test update_member_licenses when user is not found.""" + # Setup request with no current user + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = None + + # Call the function and expect HTTPException + with pytest.raises(HTTPException) as exc_info: + await update_member_licenses( + org_id=str(test_pro_org.id), + request=mock_request, + body=UpdateMemberLicensesBody(add=[], remove=[]), + orm=orm_session, + ) + + # Verify error response + assert exc_info.value.status_code == 401 + assert "User not authenticated" in str(exc_info.value.detail) + + async def test_update_member_licenses_org_not_found(self, mock_request, orm_session, test_user): + """Test update_member_licenses when organization doesn't exist.""" + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user.id + + fake_org_id = str(uuid.uuid4()) + + # Call the function and expect HTTPException + with pytest.raises(HTTPException) as exc_info: + await update_member_licenses( + org_id=fake_org_id, + request=mock_request, + body=UpdateMemberLicensesBody(add=[], remove=[]), + orm=orm_session, + ) + + # Verify error response - user gets permission denied if org doesn't exist + assert exc_info.value.status_code == 403 + assert 'Permission denied' in str(exc_info.value.detail) + + async def test_update_member_licenses_permission_denied_not_admin( + self, mock_request, orm_session, test_pro_org, test_user, test_user2 + ): + """Test update_member_licenses when user is not admin/owner.""" + # Use test_user2 as a non-admin user + # Add test_user2 as developer (not admin) + user_org = UserOrgModel( + user_id=test_user2.id, + org_id=test_pro_org.id, + role=OrgRoles.developer, + user_email=test_user2.email, + is_paid=False, + ) + orm_session.add(user_org) + orm_session.flush() + + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user2.id + + # Call the function and expect HTTPException + with pytest.raises(HTTPException) as exc_info: + await update_member_licenses( + org_id=str(test_pro_org.id), + request=mock_request, + body=UpdateMemberLicensesBody(add=[], remove=[]), + orm=orm_session, + ) + + # Verify error response + assert exc_info.value.status_code == 403 + assert "Permission denied" in str(exc_info.value.detail) + + async def test_update_member_licenses_no_subscription(self, mock_request, orm_session, test_user): + """Test update_member_licenses when org has no subscription.""" + # Create org without subscription + org = OrgModel(name="Free Org", prem_status=PremStatus.free) + orm_session.add(org) + orm_session.flush() + + # Add user as owner + user_org = UserOrgModel( + user_id=test_user.id, org_id=org.id, role=OrgRoles.owner, user_email=test_user.email, is_paid=True + ) + orm_session.add(user_org) + orm_session.flush() + + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user.id + + # Call the function and expect HTTPException + with pytest.raises(HTTPException) as exc_info: + await update_member_licenses( + org_id=str(org.id), + request=mock_request, + body=UpdateMemberLicensesBody(add=[], remove=[]), + orm=orm_session, + ) + + # Verify error response + assert exc_info.value.status_code == 400 + assert "subscription" in str(exc_info.value.detail).lower() + + async def test_update_member_licenses_cannot_remove_owner( + self, mock_request, orm_session, test_pro_org, test_user + ): + """Test update_member_licenses prevents removing license from owner.""" + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user.id + + # Try to remove owner + owner_id = [str(test_user.id)] + + # Call the function and expect HTTPException + with pytest.raises(HTTPException) as exc_info: + await update_member_licenses( + org_id=str(test_pro_org.id), + request=mock_request, + body=UpdateMemberLicensesBody(add=[], remove=owner_id), + orm=orm_session, + ) + + # Verify error response + assert exc_info.value.status_code == 400 + assert "Cannot remove license from organization owner" in str(exc_info.value.detail) + + @patch('stripe.Subscription.retrieve') + async def test_update_member_licenses_subscription_cancelled( + self, mock_stripe_retrieve, mock_request, orm_session, test_pro_org, test_user + ): + """Test update_member_licenses when subscription is cancelled.""" + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user.id + + # Mock cancelled subscription + mock_sub = MagicMock() + mock_sub.id = "sub_test123" + mock_sub.status = "active" # Status is active but scheduled to cancel + mock_sub.cancel_at_period_end = True + + def mock_get(key, default=None): + if key == 'cancel_at_period_end': + return True + elif key == 'items': + return {'data': []} + return default + + mock_sub.get = mock_get + mock_stripe_retrieve.return_value = mock_sub + + # Call the function and expect HTTPException + with pytest.raises(HTTPException) as exc_info: + await update_member_licenses( + org_id=str(test_pro_org.id), + request=mock_request, + body=UpdateMemberLicensesBody(add=[], remove=[]), + orm=orm_session, + ) + + # Verify error response + assert exc_info.value.status_code == 400 + assert "scheduled to cancel" in str(exc_info.value.detail).lower() + + @patch('stripe.Subscription.retrieve') + async def test_update_member_licenses_legacy_billing_plan( + self, mock_stripe_retrieve, mock_request, orm_session, test_pro_org, test_user + ): + """Test update_member_licenses when org is on legacy billing plan.""" + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user.id + + # Mock subscription without seat-based item + mock_sub = MagicMock() + mock_sub.id = "sub_test123" + mock_sub.status = "active" + mock_sub.cancel_at_period_end = False + mock_sub.items = MagicMock() + mock_sub.items.data = [] + + # Add non-seat-based item + mock_item = MagicMock() + mock_item.price = MagicMock() + mock_item.price.id = "price_different123" # Different from STRIPE_SUBSCRIPTION_PRICE_ID + mock_item.price.recurring = MagicMock() + mock_item.price.recurring.usage_type = "metered" # Not "licensed" + mock_sub.items.data.append(mock_item) + + def mock_get(key, default=None): + if key == 'cancel_at_period_end': + return False + elif key == 'items': + return {'data': mock_sub.items.data} + return default + + mock_sub.get = mock_get + mock_stripe_retrieve.return_value = mock_sub + + # Call the function and expect HTTPException + with pytest.raises(HTTPException) as exc_info: + await update_member_licenses( + org_id=str(test_pro_org.id), + request=mock_request, + body=UpdateMemberLicensesBody(add=[], remove=[]), + orm=orm_session, + ) + + # Verify error response - check for legacy billing message + assert exc_info.value.status_code == 400 + assert "legacy billing plan" in str(exc_info.value.detail).lower() + + @patch('stripe.Subscription.modify') + @patch('stripe.Subscription.retrieve') + async def test_update_member_licenses_stripe_subscription_update( + self, + mock_stripe_retrieve, + mock_stripe_modify, + mock_request, + orm_session, + test_pro_org, + test_licensed_members, + test_user, + mock_stripe_subscription, + ): + """Test update_member_licenses correctly updates Stripe subscription.""" + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user.id + + # Get member IDs to add + members_to_add = [str(member[0].id) for member in test_licensed_members[1:]] + + # Mock Stripe + mock_stripe_retrieve.return_value = mock_stripe_subscription + mock_stripe_modify.return_value = mock_stripe_subscription + + # Call the function + result = await update_member_licenses( + org_id=str(test_pro_org.id), + request=mock_request, + body=UpdateMemberLicensesBody(add=members_to_add, remove=[]), + orm=orm_session, + ) + + # Verify Stripe modify was called with correct parameters + mock_stripe_modify.assert_called_once_with( + "sub_test123", + items=[ + { + "id": "si_test123", + "quantity": 3, # Owner + 2 newly licensed members + } + ], + proration_behavior='create_prorations', + ) + + assert result.message == "Successfully updated member licenses" + + @patch('stripe.Subscription.modify') + @patch('stripe.Subscription.retrieve') + async def test_update_member_licenses_stripe_error_handling( + self, + mock_stripe_retrieve, + mock_stripe_modify, + mock_request, + orm_session, + test_pro_org, + test_licensed_members, + test_user, + mock_stripe_subscription, + ): + """Test update_member_licenses handles Stripe API errors.""" + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user.id + + # Get member IDs to add + members_to_add = [str(member[0].id) for member in test_licensed_members[1:2]] + + # Mock Stripe + mock_stripe_retrieve.return_value = mock_stripe_subscription + mock_stripe_modify.side_effect = stripe.error.StripeError("API Error") + + # Call the function and expect HTTPException + with pytest.raises(HTTPException) as exc_info: + await update_member_licenses( + org_id=str(test_pro_org.id), + request=mock_request, + body=UpdateMemberLicensesBody(add=members_to_add, remove=[]), + orm=orm_session, + ) + + # Verify error response + assert exc_info.value.status_code == 500 + assert "Failed to update subscription" in str(exc_info.value.detail) + + async def test_update_member_licenses_creates_audit_logs( + self, + mock_request, + orm_session, + test_pro_org, + test_licensed_members, + test_user, + mock_stripe_subscription, + ): + """Test update_member_licenses creates proper audit log entries.""" + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user.id + + # Get member to add + member_to_add = test_licensed_members[1][0] + + # Mock Stripe + with ( + patch('stripe.Subscription.retrieve') as mock_retrieve, + patch('stripe.Subscription.modify') as mock_modify, + ): + mock_retrieve.return_value = mock_stripe_subscription + mock_modify.return_value = mock_stripe_subscription + + # Call the function + result = await update_member_licenses( + org_id=str(test_pro_org.id), + request=mock_request, + body=UpdateMemberLicensesBody(add=[str(member_to_add.id)], remove=[]), + orm=orm_session, + ) + + # Verify audit logs were created + audit_logs = orm_session.query(BillingAuditLog).filter_by(org_id=test_pro_org.id).all() + + assert len(audit_logs) > 0 + + # Find the member_licensed log + licensed_log = next((log for log in audit_logs if log.action == 'member_licensed'), None) + assert licensed_log is not None + assert licensed_log.details['member_id'] == str(member_to_add.id) + assert licensed_log.details['member_email'] == member_to_add.email + + async def test_update_member_licenses_transaction_rollback_on_stripe_error( + self, + mock_request, + orm_session, + test_pro_org, + test_licensed_members, + test_user, + mock_stripe_subscription, + ): + """Test update_member_licenses rolls back database changes when Stripe fails.""" + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user.id + + # Get member to add (test_user3 is unpaid) + member_to_add = test_licensed_members[2][0] + + # Check initial state + initial_user_org = ( + orm_session.query(UserOrgModel) + .filter_by(user_id=member_to_add.id, org_id=test_pro_org.id) + .first() + ) + assert initial_user_org.is_paid is False + + # Mock Stripe to fail + with ( + patch('stripe.Subscription.retrieve') as mock_retrieve, + patch('stripe.Subscription.modify') as mock_modify, + ): + mock_retrieve.return_value = mock_stripe_subscription + mock_modify.side_effect = stripe.error.StripeError("API Error") + + # Call the function and expect HTTPException + with pytest.raises(HTTPException) as exc_info: + await update_member_licenses( + org_id=str(test_pro_org.id), + request=mock_request, + body=UpdateMemberLicensesBody(add=[str(member_to_add.id)], remove=[]), + orm=orm_session, + ) + + # Verify error + assert exc_info.value.status_code == 500 + + # Verify database wasn't changed + final_user_org = ( + orm_session.query(UserOrgModel) + .filter_by(user_id=member_to_add.id, org_id=test_pro_org.id) + .first() + ) + assert final_user_org.is_paid is False # Should remain unchanged + + async def test_update_member_licenses_final_paid_count_calculation( + self, + mock_request, + orm_session, + test_pro_org, + test_licensed_members, + test_user, + mock_stripe_subscription, + ): + """Test update_member_licenses correctly calculates final paid member count.""" + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user.id + + # Initial state: owner (paid) + test_user2 (paid) + test_user3 (unpaid) + # Add test_user3 (unpaid), remove test_user2 (paid) + add_ids = [str(test_licensed_members[2][0].id)] # test_user3 (unpaid) + remove_ids = [str(test_licensed_members[1][0].id)] # test_user2 (paid) + + # Mock Stripe + with ( + patch('stripe.Subscription.retrieve') as mock_retrieve, + patch('stripe.Subscription.modify') as mock_modify, + ): + mock_retrieve.return_value = mock_stripe_subscription + mock_modify.return_value = mock_stripe_subscription + + # Call the function + result = await update_member_licenses( + org_id=str(test_pro_org.id), + request=mock_request, + body=UpdateMemberLicensesBody(add=add_ids, remove=remove_ids), + orm=orm_session, + ) + + # Verify final count + # Should be: owner (always paid) + newly added member = 2 + assert result.paid_members_count == 2 + + # Verify Stripe was called with correct quantity + mock_modify.assert_called_once() + call_args = mock_modify.call_args[1] + assert call_args["items"][0]["quantity"] == 2 + + async def test_update_member_licenses_ignores_non_members( + self, + mock_request, + orm_session, + test_pro_org, + test_licensed_members, + test_user, + mock_stripe_subscription, + ): + """Test update_member_licenses ignores user IDs that aren't org members.""" + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user.id + + # Try to add a non-existent user ID (which should be ignored) + # This simulates trying to add a user that doesn't exist or isn't a member + non_member_id = str(uuid.uuid4()) + add_ids = [non_member_id] + + # Mock Stripe + with ( + patch('stripe.Subscription.retrieve') as mock_retrieve, + patch('stripe.Subscription.modify') as mock_modify, + ): + mock_retrieve.return_value = mock_stripe_subscription + mock_modify.return_value = mock_stripe_subscription + + # Call the function + result = await update_member_licenses( + org_id=str(test_pro_org.id), + request=mock_request, + body=UpdateMemberLicensesBody(add=add_ids, remove=[]), + orm=orm_session, + ) + + # Verify no changes were made + assert result.paid_members_count == 2 # Only owner + already paid member + + async def test_update_member_licenses_race_condition_protection( + self, + mock_request, + orm_session, + test_pro_org, + test_licensed_members, + test_user, + mock_stripe_subscription, + ): + """Test update_member_licenses uses row locking to prevent race conditions.""" + # This test would require testing the actual SQL queries used + # In practice, we'd verify that SELECT ... FOR UPDATE is used + # For now, we'll just ensure the function completes successfully + + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user.id + + # Mock Stripe + with ( + patch('stripe.Subscription.retrieve') as mock_retrieve, + patch('stripe.Subscription.modify') as mock_modify, + ): + mock_retrieve.return_value = mock_stripe_subscription + mock_modify.return_value = mock_stripe_subscription + + # Call the function + result = await update_member_licenses( + org_id=str(test_pro_org.id), + request=mock_request, + body=UpdateMemberLicensesBody(add=[], remove=[]), + orm=orm_session, + ) + + assert result.message == "Successfully updated member licenses" + + async def test_update_member_licenses_empty_add_remove_lists( + self, mock_request, orm_session, test_pro_org, test_user, mock_stripe_subscription + ): + """Test update_member_licenses with empty add and remove lists.""" + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user.id + + # Mock Stripe + with ( + patch('stripe.Subscription.retrieve') as mock_retrieve, + patch('stripe.Subscription.modify') as mock_modify, + ): + mock_retrieve.return_value = mock_stripe_subscription + mock_modify.return_value = mock_stripe_subscription + + # Call the function with empty lists + result = await update_member_licenses( + org_id=str(test_pro_org.id), + request=mock_request, + body=UpdateMemberLicensesBody(add=[], remove=[]), + orm=orm_session, + ) + + # Should succeed but make no changes + assert result.message == "Successfully updated member licenses" + + +class TestPreviewMemberAddCost: + """Test cases for preview_member_add_cost function.""" + + async def test_preview_member_add_cost_success(self, mock_request, orm_session, test_pro_org, test_user): + """Test successfully previewing member addition cost.""" + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user.id + + # Mock Stripe subscription and invoice + with ( + patch('stripe.Subscription.retrieve') as mock_retrieve, + patch('stripe.Invoice.create_preview') as mock_create_preview, + ): + # Mock subscription + mock_sub = MagicMock() + mock_sub.id = "sub_test123" + mock_sub.customer = "cus_test123" + mock_sub.items = MagicMock() + mock_sub.items.data = [] + + # Mock subscription item + mock_item = { + 'id': 'si_test123', + 'quantity': 2, + 'price': { + 'id': 'price_test123', + 'unit_amount': 4000, + 'currency': 'usd', + 'recurring': {'interval': 'month', 'interval_count': 1}, + }, + } + + def mock_sub_get(key, default=None): + if key == 'items': + return {'data': [mock_item]} + elif key == 'current_period_end': + return 1735689600 + return default + + mock_sub.get = mock_sub_get + mock_retrieve.return_value = mock_sub + + # Mock invoices + mock_upcoming_invoice = MagicMock() + mock_upcoming_invoice.amount_due = 8000 # Not used anymore + + # Mock line items with proration + mock_proration_line_item = { + 'amount': 1333, # $13.33 proration for partial month (1/3 of $40) + 'parent': { + 'type': 'subscription_item_details', + 'subscription_item_details': {'proration': True}, + }, + } + + mock_subscription_line_item = { + 'amount': 4000, # Regular subscription charge + 'parent': { + 'type': 'subscription_item_details', + 'subscription_item_details': {'proration': False}, + }, + } + + mock_upcoming_invoice.lines = MagicMock() + mock_upcoming_invoice.lines.data = [mock_proration_line_item, mock_subscription_line_item] + + # Return only the upcoming invoice (no more current invoice call) + mock_create_preview.return_value = mock_upcoming_invoice + + # Call the function + result = await preview_member_add_cost( + org_id=str(test_pro_org.id), request=mock_request, orm=orm_session + ) + + # Verify response + assert result.immediate_charge == 13.33 # Proration amount from line item + assert result.next_period_charge == 40.00 # Regular price per seat + assert result.billing_interval == "month" + assert result.currency == "usd" + + # Verify Stripe API calls + assert mock_retrieve.call_count == 1 + assert mock_create_preview.call_count == 1 # Only one preview call now + + # Verify the preview call parameters + mock_create_preview.assert_called_with( + customer="cus_test123", + subscription="sub_test123", + subscription_details={ + 'items': [ + { + 'id': 'si_test123', + 'quantity': 3, # Current 2 + preview 1 + } + ], + 'proration_behavior': 'create_prorations', + }, + ) + + async def test_preview_member_add_cost_user_not_authenticated( + self, mock_request, orm_session, test_pro_org, test_user + ): + """Test preview_member_add_cost when user is not found.""" + # Setup request with no current user + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = None + + # Call the function and expect HTTPException + with pytest.raises(HTTPException) as exc_info: + await preview_member_add_cost(org_id=str(test_pro_org.id), request=mock_request, orm=orm_session) + + # Verify error response + assert exc_info.value.status_code == 401 + assert "User not authenticated" in str(exc_info.value.detail) + + async def test_preview_member_add_cost_org_not_found(self, mock_request, orm_session, test_user): + """Test preview_member_add_cost when organization doesn't exist.""" + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user.id + + fake_org_id = str(uuid.uuid4()) + + # Call the function and expect HTTPException + with pytest.raises(HTTPException) as exc_info: + await preview_member_add_cost(org_id=fake_org_id, request=mock_request, orm=orm_session) + + # Verify error response + assert exc_info.value.status_code == 404 + assert 'Organization not found' in str(exc_info.value.detail) + + async def test_preview_member_add_cost_permission_denied( + self, mock_request, orm_session, test_pro_org, test_user, test_user3 + ): + """Test preview_member_add_cost when user is not a member.""" + # Use test_user3 who is not a member of test_pro_org + # Ensure test_user3 is not in the org + existing = ( + orm_session.query(UserOrgModel).filter_by(user_id=test_user3.id, org_id=test_pro_org.id).first() + ) + if existing: + orm_session.delete(existing) + orm_session.flush() + + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user3.id + + # Call the function and expect HTTPException + with pytest.raises(HTTPException) as exc_info: + await preview_member_add_cost(org_id=str(test_pro_org.id), request=mock_request, orm=orm_session) + + # Verify error response + assert exc_info.value.status_code == 403 + assert "permission" in str(exc_info.value.detail).lower() + + async def test_preview_member_add_cost_no_subscription(self, mock_request, orm_session, test_user): + """Test preview_member_add_cost when org has no subscription.""" + # Create org without subscription + org = OrgModel(name="Free Org", prem_status=PremStatus.free) + orm_session.add(org) + orm_session.flush() + + # Add user as owner + user_org = UserOrgModel( + user_id=test_user.id, org_id=org.id, role=OrgRoles.owner, user_email=test_user.email, is_paid=True + ) + orm_session.add(user_org) + orm_session.flush() + + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user.id + + # Call the function and expect HTTPException + with pytest.raises(HTTPException) as exc_info: + await preview_member_add_cost(org_id=str(org.id), request=mock_request, orm=orm_session) + + # Verify error response + assert exc_info.value.status_code == 400 + assert "subscription" in str(exc_info.value.detail).lower() + + @patch('stripe.Invoice.create_preview') + @patch('stripe.Subscription.retrieve') + async def test_preview_member_add_cost_stripe_integration( + self, + mock_stripe_retrieve, + mock_stripe_create_preview, + mock_request, + orm_session, + test_pro_org, + test_user, + mock_stripe_subscription, + ): + """Test preview_member_add_cost integrates with Stripe upcoming invoice API.""" + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user.id + + # Mock Stripe subscription + mock_stripe_retrieve.return_value = mock_stripe_subscription + + # Mock Stripe invoices + mock_upcoming_invoice = MagicMock() + mock_upcoming_invoice.amount_due = 8000 # Not used anymore + + # Mock line items with proration + mock_proration_line_item = { + 'amount': 1333, # $13.33 proration for partial month (1/3 of $40) + 'parent': {'type': 'subscription_item_details', 'subscription_item_details': {'proration': True}}, + } + + mock_subscription_line_item = { + 'amount': 4000, # Regular subscription charge + 'parent': { + 'type': 'subscription_item_details', + 'subscription_item_details': {'proration': False}, + }, + } + + mock_upcoming_invoice.lines = MagicMock() + mock_upcoming_invoice.lines.data = [mock_proration_line_item, mock_subscription_line_item] + + # Return only the upcoming invoice (no more current invoice call) + mock_stripe_create_preview.return_value = mock_upcoming_invoice + + # Call the function + result = await preview_member_add_cost( + org_id=str(test_pro_org.id), request=mock_request, orm=orm_session + ) + + # Verify Stripe subscription was retrieved + mock_stripe_retrieve.assert_called_once_with("sub_test123", expand=["items.data.price.product"]) + + # Verify invoice preview was called correctly + assert mock_stripe_create_preview.call_count == 1 # Only one call now + mock_stripe_create_preview.assert_called_with( + customer="cus_test123", + subscription="sub_test123", + subscription_details={ + 'items': [ + { + "id": "si_test123", + "quantity": 3, # Current 2 + preview 1 + } + ], + 'proration_behavior': 'create_prorations', + }, + ) + + # Verify response + assert result.immediate_charge == 13.33 # Proration amount from line item + + @patch('stripe.Invoice.create_preview') + async def test_preview_member_add_cost_stripe_error_handling( + self, mock_stripe_create_preview, mock_request, orm_session, test_pro_org, test_user + ): + """Test preview_member_add_cost handles Stripe API errors gracefully.""" + # Setup request + mock_request.state.session = MagicMock() + mock_request.state.session.user_id = test_user.id + + # Mock Stripe to raise error + mock_stripe_create_preview.side_effect = stripe.error.StripeError("API Error") + + with patch('stripe.Subscription.retrieve') as mock_retrieve: + # Mock subscription with proper structure + mock_sub = MagicMock() + mock_sub.id = "sub_test123" + mock_sub.customer = "cus_test123" + + # Mock subscription item with seat pricing + mock_item = { + 'id': 'si_test123', + 'quantity': 2, + 'price': { + 'id': 'price_test123', + 'unit_amount': 4000, + 'currency': 'usd', + 'recurring': {'interval': 'month', 'interval_count': 1}, + }, + } + + def mock_get(key, default=None): + if key == 'items': + return {'data': [mock_item]} + elif key == 'current_period_end': + return 1735689600 + return default + + mock_sub.get = mock_get + mock_retrieve.return_value = mock_sub + + # Call the function - should return fallback values + result = await preview_member_add_cost( + org_id=str(test_pro_org.id), request=mock_request, orm=orm_session + ) + + # Should return fallback values + assert result.immediate_charge == 0 + assert result.next_period_charge == 40 + assert result.billing_interval == "month" + + +class TestBillingAuditLogging: + """Test cases for billing audit log functionality.""" + + def test_billing_audit_log_creation_member_licensed(self, orm_session, test_pro_org, test_user): + """Test creating audit log for member licensing action.""" + # Create audit log + audit_log = BillingAuditLog( + org_id=test_pro_org.id, + user_id=test_user.id, + action='member_licensed', + details={ + 'member_id': str(test_user.id), + 'member_email': test_user.email, + 'before_seat_count': 1, + 'after_seat_count': 2, + }, + ) + orm_session.add(audit_log) + orm_session.commit() + + # Verify it was created + assert audit_log.id is not None + assert audit_log.action == 'member_licensed' + assert audit_log.details['member_id'] == str(test_user.id) + + def test_billing_audit_log_creation_member_unlicensed(self, orm_session, test_pro_org, test_user): + """Test creating audit log for member unlicensing action.""" + # Create audit log + audit_log = BillingAuditLog( + org_id=test_pro_org.id, + user_id=test_user.id, + action='member_unlicensed', + details={ + 'member_id': str(test_user.id), + 'member_email': test_user.email, + 'before_seat_count': 2, + 'after_seat_count': 1, + }, + ) + orm_session.add(audit_log) + orm_session.commit() + + # Verify it was created + assert audit_log.id is not None + assert audit_log.action == 'member_unlicensed' + assert audit_log.details['after_seat_count'] == 1 + + def test_billing_audit_log_details_format(self, orm_session, test_pro_org, test_user): + """Test audit log details contain proper information.""" + # Create comprehensive audit log + details = { + 'member_id': str(test_user.id), + 'member_email': test_user.email, + 'member_name': test_user.full_name, + 'before_seat_count': 3, + 'after_seat_count': 4, + 'updated_by': 'admin@example.com', + 'timestamp': datetime.now(timezone.utc).isoformat(), + 'subscription_id': 'sub_test123', + } + + audit_log = BillingAuditLog( + org_id=test_pro_org.id, user_id=test_user.id, action='member_licensed', details=details + ) + orm_session.add(audit_log) + orm_session.commit() + + # Verify all details are stored + retrieved_log = orm_session.query(BillingAuditLog).filter_by(id=audit_log.id).first() + assert retrieved_log.details == details + + +class TestBillingErrorCodes: + """Test cases for billing error code handling.""" + + def test_billing_error_code_stripe_api_error(self): + """Test STRIPE_API_ERROR error code is properly set.""" + error_response = {"error": "Failed to update subscription", "error_code": "STRIPE_API_ERROR"} + assert error_response["error_code"] == "STRIPE_API_ERROR" + + def test_billing_error_code_no_subscription(self): + """Test NO_SUBSCRIPTION error code is properly set.""" + error_response = {"error": "No active subscription found", "error_code": "NO_SUBSCRIPTION"} + assert error_response["error_code"] == "NO_SUBSCRIPTION" + + def test_billing_error_code_owner_required(self): + """Test OWNER_REQUIRED error code is properly set.""" + error_response = { + "error": "Cannot remove license from organization owner", + "error_code": "OWNER_REQUIRED", + } + assert error_response["error_code"] == "OWNER_REQUIRED" + + def test_billing_error_code_permission_denied(self): + """Test PERMISSION_DENIED error code is properly set.""" + error_response = {"error": "Permission denied", "error_code": "PERMISSION_DENIED"} + assert error_response["error_code"] == "PERMISSION_DENIED" + + def test_billing_error_code_subscription_cancelled(self): + """Test SUBSCRIPTION_CANCELLED error code is properly set.""" + error_response = {"error": "Subscription is not active", "error_code": "SUBSCRIPTION_CANCELLED"} + assert error_response["error_code"] == "SUBSCRIPTION_CANCELLED" + + def test_billing_error_code_legacy_billing_plan(self): + """Test LEGACY_BILLING_PLAN error code is properly set.""" + error_response = { + "error": "Organization is on legacy billing plan", + "error_code": "LEGACY_BILLING_PLAN", + } + assert error_response["error_code"] == "LEGACY_BILLING_PLAN" diff --git a/app/api/tests/opsboard/views/test_orgs.py b/app/api/tests/opsboard/views/test_orgs.py new file mode 100644 index 000000000..003fa0cc0 --- /dev/null +++ b/app/api/tests/opsboard/views/test_orgs.py @@ -0,0 +1,1226 @@ +import pytest +import uuid +import os +from unittest.mock import patch +from fastapi import HTTPException +from sqlalchemy import orm +import stripe + +from agentops.opsboard.models import ( + OrgModel, + UserOrgModel, + UserModel, + OrgInviteModel, + OrgRoles, + PremStatus, +) +from agentops.opsboard.views.orgs import ( + get_user_orgs, + get_org, + create_org, + update_org, + invite_to_org, + get_org_invites, + accept_org_invite, + remove_from_org, + change_member_role, + create_checkout_session, + CreateCheckoutSessionBody, +) +from agentops.opsboard.schemas import ( + OrgCreateSchema, + OrgUpdateSchema, + OrgInviteSchema, + OrgMemberRemoveSchema, + OrgMemberRoleSchema, +) + + +# Mock Stripe environment variables for testing to avoid warnings +@pytest.fixture(autouse=True) +def mock_stripe_env_vars(): + with ( + patch.dict( + os.environ, + { + 'STRIPE_SECRET_KEY': 'sk_test_mock_key', + 'STRIPE_SUBSCRIPTION_PRICE_ID': 'price_test_subscription', + 'STRIPE_TOKEN_PRICE_ID': 'price_test_token', + 'STRIPE_SPAN_PRICE_ID': 'price_test_span', + }, + ), + patch('stripe.Account.retrieve'), + ): + yield + + +@pytest.mark.asyncio +async def test_get_user_orgs(mock_request, orm_session, test_user_org_owner): + """Test getting all organizations for a user.""" + # Call the endpoint function + result = get_user_orgs(request=mock_request, orm=orm_session) + + # Verify that it returns a list and contains our test org + assert isinstance(result, list) + assert len(result) > 0 + + # Check that our test org is in the results + org_ids = [o.id for o in result] + assert str(test_user_org_owner.id) in org_ids + + +@pytest.mark.asyncio +async def test_get_org(mock_request, orm_session, test_user_org_member): + """Test getting a specific organization by ID.""" + # Call the endpoint function + result = get_org(request=mock_request, org_id=str(test_user_org_member.id), orm=orm_session) + + # Verify the org data matches + assert result.id == str(test_user_org_member.id) + assert result.name == test_user_org_member.name + assert len(result.users) == 1 + assert result.users[0].user_id == "00000000-0000-0000-0000-000000000000" + assert result.users[0].role == OrgRoles.developer.value + + +@pytest.mark.asyncio +async def test_get_org_not_found(mock_request, orm_session): + """Test getting an organization that doesn't exist.""" + non_existent_id = str(uuid.uuid4()) + + # Expect an HTTP 404 exception + with pytest.raises(HTTPException) as excinfo: + get_org(request=mock_request, org_id=non_existent_id, orm=orm_session) + + assert excinfo.value.status_code == 404 + assert excinfo.value.detail == "Organization not found" + + +@pytest.mark.asyncio +async def test_create_org(mock_request, orm_session, test_user): + """Test creating a new organization.""" + # Create the request body + body = OrgCreateSchema(name="New Test Organization") + + # Call the endpoint function + result = create_org(request=mock_request, orm=orm_session, body=body) + + # Verify the organization was created with the right data + assert result.name == body.name + assert result.id is not None + + # Verify we can find it in the database + created_org = orm_session.query(OrgModel).filter_by(id=uuid.UUID(result.id)).one() + assert created_org.name == body.name + + # Verify that the user is an owner + user_org = orm_session.query(UserOrgModel).filter_by(user_id=test_user.id, org_id=created_org.id).one() + assert user_org.role == OrgRoles.owner + + +@pytest.mark.asyncio +async def test_update_org(mock_request, orm_session, test_user): + """Test updating an organization's name.""" + # Create a fresh organization for this test + org = OrgModel( + name="Original Org Name", + prem_status=PremStatus.free, + ) + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + orm_session.commit() # Commit to ensure it's persisted + + # Create the update body + body = OrgUpdateSchema(name="Updated Organization Name") + + # Fetch org again with relationships to ensure we have the latest + org = orm_session.query(OrgModel).options(orm.selectinload(OrgModel.users)).filter_by(id=org.id).one() + + # Verify the user is an owner of this org + membership = org.get_user_membership(user_id) + assert membership is not None, "User membership not found" + assert membership.role == OrgRoles.owner, "User is not an owner" + + # Now call the update endpoint + result = update_org(request=mock_request, org_id=str(org.id), orm=orm_session, body=body) + + # Verify the updates were applied + assert result.name == body.name + + # Refresh the session to get the latest data + orm_session.expire_all() # Clear cached objects + + # Verify the database was updated + updated_org = orm_session.query(OrgModel).filter_by(id=org.id).one() + assert updated_org.name == body.name + + +@pytest.mark.asyncio +async def test_update_org_not_admin(mock_request, orm_session, test_user_org_member): + """Test updating an organization without admin permissions.""" + # Change the role to developer (not admin or owner) + user_org = test_user_org_member.get_user_membership(mock_request.state.session.user_id) + user_org.role = OrgRoles.developer + orm_session.flush() + + # Create the update body + body = OrgUpdateSchema(name="Updated Organization Name") + + # Expect an HTTP 404 exception (since we use security by obscurity) + with pytest.raises(HTTPException) as excinfo: + update_org(request=mock_request, org_id=str(test_user_org_member.id), orm=orm_session, body=body) + + assert excinfo.value.status_code == 404 + assert excinfo.value.detail == "Organization not found" + + # Restore the role + user_org.role = OrgRoles.owner + orm_session.flush() + + +@pytest.mark.asyncio +@patch('agentops.opsboard.views.orgs._send_invitation_email') +async def test_invite_to_org(mock_send_email, mock_request, orm_session, test_user): + """Test inviting a user to an organization.""" + # Mock the email function to not raise any exceptions + mock_send_email.return_value = None + + # Create a fresh organization for this test + org = OrgModel( + name="Test Org for Invites", + prem_status=PremStatus.enterprise, # Use enterprise to avoid the member limit + ) + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + orm_session.commit() # Commit to ensure it's persisted + + # Create the invite body + body = OrgInviteSchema(email="newuser@example.com", role=OrgRoles.developer.value) + + # Fetch org again with relationships to ensure we have the latest + org = ( + orm_session.query(OrgModel) + .options(orm.selectinload(OrgModel.users), orm.selectinload(OrgModel.invites)) + .filter_by(id=org.id) + .one() + ) + + # Verify the user is an owner of this org + membership = org.get_user_membership(user_id) + assert membership is not None, "User membership not found" + assert membership.role == OrgRoles.owner, "User is not an owner" + + # Now call the invite endpoint + result = invite_to_org(request=mock_request, org_id=str(org.id), orm=orm_session, body=body) + + # Verify the status response + assert result.success is True + assert result.message == "Invitation sent successfully" + + # Verify the invite exists in the database + invite = orm_session.query(OrgInviteModel).filter_by(org_id=org.id, invitee_email=body.email).one() + assert invite.role == OrgRoles.developer + assert invite.org_name == org.name + + +@pytest.mark.asyncio +async def test_invite_to_org_already_member(mock_request, orm_session, test_user_org_owner): + """Test inviting a user who is already a member.""" + # Create the invite body with the same email as the existing member + body = OrgInviteSchema(email="test@example.com", role=OrgRoles.developer.value) + + # Expect an HTTP 400 exception + with pytest.raises(HTTPException) as excinfo: + invite_to_org(request=mock_request, org_id=str(test_user_org_owner.id), orm=orm_session, body=body) + + assert excinfo.value.status_code == 400 + assert excinfo.value.detail == "User is already a member of this organization" + + +@pytest.mark.asyncio +async def test_invite_to_org_not_admin(mock_request, orm_session, test_user_org_member): + """Test inviting a user without admin permissions.""" + # Change the role to developer (not admin or owner) + user_org = test_user_org_member.get_user_membership(mock_request.state.session.user_id) + user_org.role = OrgRoles.developer + orm_session.flush() + + # Create the invite body + body = OrgInviteSchema(email="newuser@example.com", role=OrgRoles.developer.value) + + # Expect an HTTP 404 exception (since we use security by obscurity) + with pytest.raises(HTTPException) as excinfo: + invite_to_org(request=mock_request, org_id=str(test_user_org_member.id), orm=orm_session, body=body) + + assert excinfo.value.status_code == 404 + assert excinfo.value.detail == "Organization not found" + + # Restore the role + user_org.role = OrgRoles.owner + orm_session.flush() + + +@pytest.mark.asyncio +@patch('agentops.opsboard.views.orgs._send_invitation_email') +async def test_invite_to_org_case_insensitive(mock_send_email, mock_request, orm_session, test_user): + """Test that email invitations are case-insensitive.""" + mock_send_email.return_value = None + + org = OrgModel( + name="Test Org for Case Sensitivity", + prem_status=PremStatus.enterprise, + ) + orm_session.add(org) + orm_session.flush() + + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + orm_session.commit() + + body = OrgInviteSchema(email="newuser@example.com", role=OrgRoles.developer.value) + result = invite_to_org(request=mock_request, org_id=str(org.id), orm=orm_session, body=body) + assert result.success is True + + body_upper = OrgInviteSchema(email="NEWUSER@example.com", role=OrgRoles.developer.value) + with pytest.raises(HTTPException) as excinfo: + invite_to_org(request=mock_request, org_id=str(org.id), orm=orm_session, body=body_upper) + assert excinfo.value.status_code == 400 + assert excinfo.value.detail == "User already has a pending invitation" + + body_mixed = OrgInviteSchema(email="NewUser@Example.COM", role=OrgRoles.developer.value) + with pytest.raises(HTTPException) as excinfo: + invite_to_org(request=mock_request, org_id=str(org.id), orm=orm_session, body=body_mixed) + assert excinfo.value.status_code == 400 + assert excinfo.value.detail == "User already has a pending invitation" + + invite = orm_session.query(OrgInviteModel).filter_by(org_id=org.id).one() + assert invite.invitee_email == "newuser@example.com" # Should be lowercase + + +@pytest.mark.asyncio +async def test_invite_to_org_member_limit(mock_request, orm_session, test_user): + """Test inviting a user when the organization has reached its member limit.""" + # Create a fresh organization with free plan (which has a member limit of 1) + org = OrgModel( + name="Test Org with Member Limit", + prem_status=PremStatus.free, # Free plan has a member limit of 1 + ) + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship (this is the first and only allowed member) + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + orm_session.commit() # Commit to ensure it's persisted + + # Create the invite body for a second user (which should exceed the limit) + body = OrgInviteSchema(email="newuser@example.com", role=OrgRoles.developer.value) + + # Expect an HTTP 400 exception due to member limit + with pytest.raises(HTTPException) as excinfo: + invite_to_org(request=mock_request, org_id=str(org.id), orm=orm_session, body=body) + + assert excinfo.value.status_code == 400 + assert excinfo.value.detail == "Organization has reached its member limit" + + # Verify no invite was created + invites = orm_session.query(OrgInviteModel).filter_by(org_id=org.id).all() + assert len(invites) == 0 + + +@pytest.mark.asyncio +@patch('agentops.opsboard.views.orgs._send_invitation_email') +async def test_invite_to_org_after_upgrade(mock_send_email, mock_request, orm_session, test_user): + """Test inviting users after upgrading from free to enterprise plan.""" + # Mock the email function to not raise any exceptions + mock_send_email.return_value = None + + # Create a fresh organization with free plan (which has a member limit of 1) + org = OrgModel( + name="Test Org for Plan Upgrade", + prem_status=PremStatus.free, # Free plan has a member limit of 1 + ) + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship (this is the first and only allowed member) + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + orm_session.commit() # Commit to ensure it's persisted + + # Upgrade the organization plan to enterprise (which has no member limit) + org.prem_status = PremStatus.enterprise + orm_session.commit() + + # Reload the org with all relationships + org = OrgModel.get_by_id(orm_session, org.id) + + # Create the invite body for a second user (which should now work) + body = OrgInviteSchema(email="newuser@example.com", role=OrgRoles.developer.value) + + # This should now succeed with the enterprise plan + result = invite_to_org(request=mock_request, org_id=str(org.id), orm=orm_session, body=body) + + # Verify the invite success response + assert result.success is True + assert result.message == "Invitation sent successfully" + + # Verify the invite was created in the database + invites = orm_session.query(OrgInviteModel).filter_by(org_id=org.id).all() + assert len(invites) == 1 + assert invites[0].invitee_email == "newuser@example.com" + assert invites[0].role == OrgRoles.developer + + +@pytest.mark.asyncio +async def test_get_org_invites(mock_request, orm_session, test_user): + """Test getting all invitations for the authenticated user (as invitee).""" + # Create a fresh org for this test + org = OrgModel(name="Test Org for Invites") + orm_session.add(org) + orm_session.flush() + + invite = OrgInviteModel( + inviter_id=test_user.id, + invitee_email="test@example.com", + org_id=org.id, + role=OrgRoles.developer, + org_name=org.name, + ) + orm_session.add(invite) + orm_session.commit() # Commit to ensure it's persisted + + # Call the endpoint function + result = get_org_invites(request=mock_request, orm=orm_session) + + # Verify the result contains our invite + assert isinstance(result, list) + assert len(result) > 0 + + # Find our invite in the results (might be other test artifacts) + our_invite = None + for invite_response in result: + if invite_response.org_id == str(org.id) and invite_response.invitee_email == "test@example.com": + our_invite = invite_response + break + + assert our_invite is not None + assert our_invite.inviter_id == str(test_user.id) + assert our_invite.org_id == str(org.id) + assert our_invite.role == OrgRoles.developer.value + assert our_invite.invitee_email == "test@example.com" + + +@pytest.mark.asyncio +async def test_accept_org_invite(mock_request, orm_session, test_user): + """Test accepting an invitation to join an organization.""" + # Create a fresh organization for this test + org = OrgModel( + name="Test Org for Invite", + prem_status=PremStatus.free, + ) + orm_session.add(org) + orm_session.flush() + + # The current user ID from the mock request + user_id = mock_request.state.session.user_id + + invite = OrgInviteModel( + inviter_id=test_user.id, + invitee_email="test@example.com", + org_id=org.id, + role=OrgRoles.developer, + org_name=org.name, + ) + orm_session.add(invite) + orm_session.commit() # Ensure it's persisted + + # Now we should be able to find the invitation when accept_org_invite runs + invitation = ( + orm_session.query(OrgInviteModel).filter_by(invitee_email="test@example.com", org_id=org.id).first() + ) + assert invitation is not None, "Invitation not found in database" + + # Call the endpoint function + result = accept_org_invite(request=mock_request, org_id=str(org.id), orm=orm_session) + + # Verify the status response + assert result.success is True + assert result.message == "Organization invitation accepted" + + # Verify the invite was removed and user-org relationship was created + invites = ( + orm_session.query(OrgInviteModel).filter_by(invitee_email="test@example.com", org_id=org.id).all() + ) + assert len(invites) == 0 + + # Verify the user-org relationship was created + user_orgs = orm_session.query(UserOrgModel).filter_by(user_id=user_id, org_id=org.id).all() + assert len(user_orgs) > 0 + + +@pytest.mark.asyncio +async def test_accept_org_invite_case_insensitive(mock_request, orm_session, test_user): + """Test accepting an invitation with different email casing.""" + org = OrgModel( + name="Test Org for Case Sensitive Accept", + prem_status=PremStatus.free, + ) + orm_session.add(org) + orm_session.flush() + + invite = OrgInviteModel( + inviter_id=test_user.id, + invitee_email="test@example.com", + org_id=org.id, + role=OrgRoles.developer, + org_name=org.name, + ) + orm_session.add(invite) + orm_session.commit() + + # Get the test user from the session to ensure auth_user relationship is loaded + user_from_session = orm_session.get(UserModel, test_user.id) + if not user_from_session: + pytest.skip("Test user not found in session") + + # Check if auth_user exists, if not skip this test + if not user_from_session.auth_user: + pytest.skip("Test user does not have auth_user relationship set up") + + # Save the original email + original_email = user_from_session.auth_user.email + + # Temporarily modify the auth user's email in memory only (not persisted) + # This simulates a user whose auth email has different casing + object.__setattr__(user_from_session.auth_user, 'email', 'TEST@EXAMPLE.COM') + + try: + # Accept with the uppercase email (should still find the lowercase invite) + result = accept_org_invite(request=mock_request, org_id=str(org.id), orm=orm_session) + + # Verify the result + assert result.success is True + assert result.message == "Organization invitation accepted" + + # Verify invite was removed + invites = orm_session.query(OrgInviteModel).filter_by(org_id=org.id).all() + assert len(invites) == 0 + + # Verify user was added to org + user_id = mock_request.state.session.user_id + user_orgs = orm_session.query(UserOrgModel).filter_by(user_id=user_id, org_id=org.id).all() + assert len(user_orgs) > 0 + + finally: + # Restore the original email + object.__setattr__(user_from_session.auth_user, 'email', original_email) + + +@pytest.mark.asyncio +async def test_accept_org_invite_not_found(mock_request, orm_session): + """Test accepting an invitation that doesn't exist.""" + non_existent_id = str(uuid.uuid4()) + + # Expect an HTTP 404 exception + with pytest.raises(HTTPException) as excinfo: + accept_org_invite(request=mock_request, org_id=non_existent_id, orm=orm_session) + + assert excinfo.value.status_code == 404 + assert excinfo.value.detail == "Invitation not found" + + +@pytest.mark.asyncio +async def test_remove_from_org(mock_request, orm_session, test_user2): + """Test removing a user from an organization.""" + # Create a fresh organization for this test + org = OrgModel( + name="Test Org for Remove", + prem_status=PremStatus.free, + ) + orm_session.add(org) + orm_session.flush() + + # Add the primary test user as an owner + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + + # Add the second test user as a developer + user2_org = UserOrgModel( + user_id=test_user2.id, + org_id=org.id, + role=OrgRoles.developer, + user_email=test_user2.email, + ) + orm_session.add(user2_org) + orm_session.commit() # Commit to ensure both relationships are persisted + + # Create the remove body using the second user's ID + body = OrgMemberRemoveSchema(user_id=str(test_user2.id)) + + # Fetch org again with relationships + org = orm_session.query(OrgModel).options(orm.selectinload(OrgModel.users)).filter_by(id=org.id).one() + + # Verify both users are in the org + assert len(org.users) == 2, "Expected both users to be in the org" + + # Call the endpoint function + result = remove_from_org(request=mock_request, org_id=str(org.id), orm=orm_session, body=body) + + # Verify the status response + assert result.success is True + assert result.message == "User removed from organization" + + # Verify the user was removed + user_orgs = orm_session.query(UserOrgModel).filter_by(user_id=test_user2.id, org_id=org.id).all() + assert len(user_orgs) == 0, "Expected the second user to be removed from the org" + + +@pytest.mark.asyncio +async def test_remove_from_org_owner(mock_request, orm_session, test_user, test_user2): + """Test removing an owner from an organization (which should fail).""" + # First create a fresh org + org = OrgModel(name="Test Org for Remove Owner") + orm_session.add(org) + orm_session.flush() + + # Add the primary test user as owner + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + orm_session.flush() + + # Add test_user2 as an owner + # We're using the existing test_user2 fixture which already exists in auth.users + second_user_org = UserOrgModel( + user_id=test_user2.id, + org_id=org.id, + role=OrgRoles.owner, + user_email=test_user2.email, + ) + orm_session.add(second_user_org) + orm_session.commit() # Need to commit to ensure relationships are persisted + + # Create the remove body - try to remove the second owner + body = OrgMemberRemoveSchema(user_id=str(test_user2.id)) + + # Expect an HTTP 400 exception + with pytest.raises(HTTPException) as excinfo: + remove_from_org(request=mock_request, org_id=str(org.id), orm=orm_session, body=body) + + assert excinfo.value.status_code == 400 + assert excinfo.value.detail == "User cannot be removed" + + +@pytest.mark.asyncio +async def test_remove_from_org_self(mock_request, orm_session, test_user_org_owner): + """Test removing yourself from an organization (which should fail).""" + # Create the remove body with the authenticated user's ID + body = OrgMemberRemoveSchema(user_id=str(mock_request.state.session.user_id)) + + # Expect an HTTP 400 exception + with pytest.raises(HTTPException) as excinfo: + remove_from_org(request=mock_request, org_id=str(test_user_org_owner.id), orm=orm_session, body=body) + + assert excinfo.value.status_code == 400 + assert excinfo.value.detail == "User cannot be removed" + + +@pytest.mark.asyncio +async def test_change_member_role(mock_request, orm_session, test_user2): + """Test changing a user's role in an organization.""" + # Create a fresh organization for this test + org = OrgModel( + name="Test Org for Role Change", + prem_status=PremStatus.free, + ) + orm_session.add(org) + orm_session.flush() + + # Add the primary test user as an owner + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + + # Add the second test user as a developer + user2_org = UserOrgModel( + user_id=test_user2.id, + org_id=org.id, + role=OrgRoles.developer, + user_email=test_user2.email, + ) + orm_session.add(user2_org) + orm_session.commit() # Commit to ensure both relationships are persisted + + # Create the role change body using the second user's ID + body = OrgMemberRoleSchema(user_id=str(test_user2.id), role=OrgRoles.admin.value) + + # Call the endpoint function + result = change_member_role(request=mock_request, org_id=str(org.id), orm=orm_session, body=body) + + # Verify the status response + assert result.success is True + assert result.message == "User role updated" + + # Refresh the session to get the latest data from the database + orm_session.expire_all() # Clear cached objects + + # Verify the role was updated + user_org = orm_session.query(UserOrgModel).filter_by(user_id=test_user2.id, org_id=org.id).one() + assert user_org.role == OrgRoles.admin, "Expected the user role to be updated to admin" + + +@pytest.mark.asyncio +async def test_change_member_role_to_owner(mock_request, orm_session, test_user2): + """Test changing a user's role to owner.""" + # Create a fresh organization for this test to avoid session issues + org = OrgModel( + name="Test Org for Owner Role Change", + prem_status=PremStatus.free, + ) + orm_session.add(org) + orm_session.flush() + + # Add the primary test user as an owner + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + + # Add test_user2 as a developer + user2_org = UserOrgModel( + user_id=test_user2.id, + org_id=org.id, + role=OrgRoles.developer, + user_email=test_user2.email, + ) + orm_session.add(user2_org) + orm_session.commit() # Commit to ensure both relationships are persisted + + # Create the role change body + body = OrgMemberRoleSchema(user_id=str(test_user2.id), role=OrgRoles.owner.value) + + # Call the endpoint function + result = change_member_role(request=mock_request, org_id=str(org.id), orm=orm_session, body=body) + + # Verify the status response + assert result.success is True + assert result.message == "User role updated" + + # Refresh the session to get the latest data from the database + orm_session.expire_all() # Clear cached objects + + # Verify the role was updated + user_org = orm_session.query(UserOrgModel).filter_by(user_id=test_user2.id, org_id=org.id).one() + assert user_org.role == OrgRoles.owner + + +@pytest.mark.asyncio +async def test_change_member_role_from_owner_to_developer( + mock_request, orm_session, test_user_org_owner, test_user2 +): + """Test changing a user's role from owner to developer (when there are multiple owners).""" + # Create a fresh organization for this test to avoid session issues + org = OrgModel( + name="Test Org for Role Change", + prem_status=PremStatus.free, + ) + orm_session.add(org) + orm_session.flush() + + # Add the primary test user as an owner + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + + # Add test_user2 as another owner + user2_org = UserOrgModel( + user_id=test_user2.id, + org_id=org.id, + role=OrgRoles.owner, + user_email=test_user2.email, + ) + orm_session.add(user2_org) + orm_session.commit() # Commit to ensure both relationships are persisted + + # Create the role change body + body = OrgMemberRoleSchema(user_id=str(test_user2.id), role=OrgRoles.developer.value) + + # Call the endpoint function + result = change_member_role(request=mock_request, org_id=str(org.id), orm=orm_session, body=body) + + # Verify the status response + assert result.success is True + assert result.message == "User role updated" + + # Refresh the session to get the latest data from the database + orm_session.expire_all() # Clear cached objects + + # Verify the role was updated + user_org = orm_session.query(UserOrgModel).filter_by(user_id=test_user2.id, org_id=org.id).one() + assert user_org.role == OrgRoles.developer + + +@pytest.mark.asyncio +async def test_change_last_owner_role(mock_request, orm_session): + """Test changing the role of the last owner (which should fail).""" + # Create a fresh organization for this test to avoid session issues + org = OrgModel( + name="Test Org for Last Owner Role", + prem_status=PremStatus.free, + ) + orm_session.add(org) + orm_session.flush() + + # Add the primary test user as the only owner + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + orm_session.commit() # Commit to ensure the relationship is persisted + + # Create the role change body to change the only owner to a developer + body = OrgMemberRoleSchema(user_id=str(mock_request.state.session.user_id), role=OrgRoles.developer.value) + + # Expect an HTTP 400 exception when trying to change the only owner's role + with pytest.raises(HTTPException) as excinfo: + change_member_role(request=mock_request, org_id=str(org.id), orm=orm_session, body=body) + + # Verify the error message + assert excinfo.value.status_code == 400 + assert excinfo.value.detail == "Cannot remove the last owner" + + # Verify the role wasn't changed + orm_session.expire_all() # Clear cached objects + user_org = orm_session.query(UserOrgModel).filter_by(user_id=user_id, org_id=org.id).one() + assert user_org.role == OrgRoles.owner, "The user role should not have been changed" + + +@pytest.mark.asyncio +async def test_change_member_role_as_admin(mock_request, orm_session, test_user, test_user2, test_user3): + """Test changing a user's role as an admin (not owner).""" + # Create a fresh organization for this test + org = OrgModel( + name="Test Org for Admin Role Change", + prem_status=PremStatus.free, + ) + orm_session.add(org) + orm_session.flush() + + # Add test_user2 as the owner + owner_org = UserOrgModel( + user_id=test_user2.id, + org_id=org.id, + role=OrgRoles.owner, + user_email=test_user2.email, + ) + orm_session.add(owner_org) + + # Add the primary test user as an admin (not owner) + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.admin, user_email="test@example.com" + ) + orm_session.add(user_org) + + # Add test_user3 as a developer + dev_org = UserOrgModel( + user_id=test_user3.id, org_id=org.id, role=OrgRoles.developer, user_email=test_user3.email + ) + orm_session.add(dev_org) + orm_session.commit() # Commit to ensure all relationships are persisted + + # Create the role change body to promote developer to admin + body = OrgMemberRoleSchema(user_id=str(test_user3.id), role=OrgRoles.admin.value) + + # Call the endpoint function with the admin user (mock_request contains test_user's ID) + result = change_member_role(request=mock_request, org_id=str(org.id), orm=orm_session, body=body) + + # Verify the status response + assert result.success is True + assert result.message == "User role updated" + + # Refresh the session to get the latest data from the database + orm_session.expire_all() # Clear cached objects + + # Verify the role was updated + user_org = orm_session.query(UserOrgModel).filter_by(user_id=test_user3.id, org_id=org.id).one() + assert user_org.role == OrgRoles.admin + + # Verify admin cannot promote someone to owner + body = OrgMemberRoleSchema(user_id=str(test_user3.id), role=OrgRoles.owner.value) + + # Expect an HTTP 400 exception + with pytest.raises(HTTPException) as excinfo: + change_member_role(request=mock_request, org_id=str(org.id), orm=orm_session, body=body) + + assert excinfo.value.status_code == 400 + assert excinfo.value.detail == "Only owners can assign the owner role" + + +@pytest.mark.asyncio +@patch('stripe.checkout.Session.create') +@patch('stripe.Price.retrieve') +@patch('stripe.PromotionCode.list') +@patch('agentops.opsboard.views.orgs.STRIPE_SECRET_KEY', 'test_stripe_key') +async def test_create_checkout_session_with_valid_promotion_code( + mock_promo_list, mock_price_retrieve, mock_stripe_session, mock_request, orm_session, test_user +): + """Test successful checkout with a promotion code.""" + # Create a fresh organization for this test + org = OrgModel( + name="Test Org for Promotion Code", + prem_status=PremStatus.free, + ) + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + orm_session.commit() + + # Ensure the auth_user relationship is loaded (the test user should already have billing_email) + user_from_session = orm_session.get(UserModel, test_user.id) + if not user_from_session: + pytest.skip("Test user not found in session") + + # Verify the user has billing_email from auth.users + if not user_from_session.billing_email: + pytest.skip("Test user does not have billing_email set up properly") + + # Mock the promotion code lookup + mock_promo_code = type('obj', (object,), {'id': 'promo_123'}) + mock_promo_list.return_value.data = [mock_promo_code] + + # Mock the price retrieve call + mock_price = type('obj', (object,), {'recurring': type('obj', (object,), {'usage_type': 'licensed'})}) + mock_price_retrieve.return_value = mock_price + + # Mock the Stripe session creation + mock_stripe_session.return_value.client_secret = "test_client_secret_123" + + # Create the request body with promotion code + body = CreateCheckoutSessionBody(price_id="price_test123", discount_code="SAVE20") + + # Call the endpoint with the new signature + result = await create_checkout_session( + request=mock_request, org_id=str(org.id), body=body, orm=orm_session + ) + + # Verify the response + assert result.clientSecret == "test_client_secret_123" + + # Verify promotion code lookup was called + mock_promo_list.assert_called_once_with(code="SAVE20", active=True, limit=1) + + # Verify Stripe was called with the promotion code ID + mock_stripe_session.assert_called_once() + call_args = mock_stripe_session.call_args[1] + assert call_args['discounts'] == [{'promotion_code': 'promo_123'}] + assert call_args['customer_email'] == user_from_session.billing_email + assert call_args['line_items'][0]['price'] == "price_test123" + + +@pytest.mark.asyncio +@patch('stripe.checkout.Session.create') +@patch('stripe.Price.retrieve') +@patch('stripe.Coupon.retrieve') +@patch('stripe.PromotionCode.list') +@patch('agentops.opsboard.views.orgs.STRIPE_SECRET_KEY', 'test_stripe_key') +async def test_create_checkout_session_with_valid_coupon_id( + mock_promo_list, + mock_coupon_retrieve, + mock_price_retrieve, + mock_stripe_session, + mock_request, + orm_session, + test_user, +): + """Test successful checkout with a direct coupon ID.""" + # Create a fresh organization for this test + org = OrgModel( + name="Test Org for Coupon", + prem_status=PremStatus.free, + ) + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + orm_session.commit() + + # Ensure the auth_user relationship is loaded (the test user should already have billing_email) + user_from_session = orm_session.get(UserModel, test_user.id) + if not user_from_session: + pytest.skip("Test user not found in session") + + # Verify the user has billing_email from auth.users + if not user_from_session.billing_email: + pytest.skip("Test user does not have billing_email set up properly") + + # Mock promotion code lookup to return empty (not a promotion code) + mock_promo_list.return_value.data = [] + + # Mock coupon retrieval to return a valid coupon + mock_coupon = type('obj', (object,), {'valid': True}) + mock_coupon_retrieve.return_value = mock_coupon + + # Mock the price retrieve call + mock_price = type('obj', (object,), {'recurring': type('obj', (object,), {'usage_type': 'licensed'})}) + mock_price_retrieve.return_value = mock_price + + # Mock the Stripe session creation + mock_stripe_session.return_value.client_secret = "test_client_secret_456" + + # Create the request body with coupon ID + body = CreateCheckoutSessionBody(price_id="price_test456", discount_code="SUMMER_SALE") + + # Call the endpoint with the new signature + result = await create_checkout_session( + request=mock_request, org_id=str(org.id), body=body, orm=orm_session + ) + + # Verify the response + assert result.clientSecret == "test_client_secret_456" + + # Verify promotion code lookup was called first + mock_promo_list.assert_called_once_with(code="SUMMER_SALE", active=True, limit=1) + + # Verify coupon retrieval was called as fallback + mock_coupon_retrieve.assert_called_once_with("SUMMER_SALE") + + # Verify Stripe was called with the coupon + mock_stripe_session.assert_called_once() + call_args = mock_stripe_session.call_args[1] + assert call_args['discounts'] == [{'coupon': "SUMMER_SALE"}] + assert call_args['customer_email'] == user_from_session.billing_email + assert call_args['line_items'][0]['price'] == "price_test456" + + +@pytest.mark.asyncio +@patch('stripe.checkout.Session.create') +@patch('stripe.Price.retrieve') +@patch('stripe.Coupon.retrieve') +@patch('stripe.PromotionCode.list') +@patch('agentops.opsboard.views.orgs.STRIPE_SECRET_KEY', 'test_stripe_key') +async def test_create_checkout_session_with_invalid_discount_code( + mock_promo_list, + mock_coupon_retrieve, + mock_price_retrieve, + mock_stripe_session, + mock_request, + orm_session, + test_user, +): + """Test error handling for invalid discount codes.""" + # Create a fresh organization for this test + org = OrgModel( + name="Test Org for Invalid Code", + prem_status=PremStatus.free, + ) + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + orm_session.commit() + + # Ensure the auth_user relationship is loaded (the test user should already have billing_email) + user_from_session = orm_session.get(UserModel, test_user.id) + if not user_from_session: + pytest.skip("Test user not found in session") + + # Verify the user has billing_email from auth.users + if not user_from_session.billing_email: + pytest.skip("Test user does not have billing_email set up properly") + + # Mock promotion code lookup to return empty (not a promotion code) + mock_promo_list.return_value.data = [] + + # Mock coupon retrieval to raise an error (invalid coupon) + mock_coupon_retrieve.side_effect = stripe.error.InvalidRequestError( + message="No such coupon: 'INVALID'", param="coupon" + ) + + # Mock the price retrieve call + mock_price = type('obj', (object,), {'recurring': type('obj', (object,), {'usage_type': 'licensed'})}) + mock_price_retrieve.return_value = mock_price + + # Create the request body with invalid discount code + body = CreateCheckoutSessionBody(price_id="price_test789", discount_code="INVALID") + + from agentops.opsboard.views.orgs import create_checkout_session + + # Expect an HTTP 400 exception for invalid discount code + with pytest.raises(HTTPException) as excinfo: + await create_checkout_session( + request=mock_request, + org_id=str(org.id), + body=body, + orm=orm_session, + ) + + assert excinfo.value.status_code == 400 + assert excinfo.value.detail == "Invalid discount code" + + +@pytest.mark.asyncio +@patch('stripe.checkout.Session.create') +@patch('stripe.Price.retrieve') +@patch('agentops.opsboard.views.orgs.STRIPE_SECRET_KEY', 'test_stripe_key') +async def test_create_checkout_session_without_discount_code( + mock_price_retrieve, mock_stripe_session, mock_request, orm_session, test_user +): + """Test that checkout works without a discount code.""" + # Create a fresh organization for this test + org = OrgModel( + name="Test Org No Discount", + prem_status=PremStatus.free, + ) + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + orm_session.commit() + + # Ensure the auth_user relationship is loaded (the test user should already have billing_email) + user_from_session = orm_session.get(UserModel, test_user.id) + if not user_from_session: + pytest.skip("Test user not found in session") + + # Verify the user has billing_email from auth.users + if not user_from_session.billing_email: + pytest.skip("Test user does not have billing_email set up properly") + + # Mock the price retrieve call + mock_price = type('obj', (object,), {'recurring': type('obj', (object,), {'usage_type': 'licensed'})}) + mock_price_retrieve.return_value = mock_price + + # Mock the Stripe session creation + mock_stripe_session.return_value.client_secret = "test_client_secret_no_discount" + + # Create the request body without any discount + body = CreateCheckoutSessionBody(price_id="price_test999") + + from agentops.opsboard.views.orgs import create_checkout_session + + # Call the endpoint without discount parameters + result = await create_checkout_session( + request=mock_request, org_id=str(org.id), body=body, orm=orm_session + ) + + # Verify the response + assert result.clientSecret == "test_client_secret_no_discount" + + # Verify Stripe was called without discounts + mock_stripe_session.assert_called_once() + call_args = mock_stripe_session.call_args[1] + assert 'discounts' not in call_args # No discounts field when not using discount codes + assert call_args['customer_email'] == user_from_session.billing_email + assert call_args['line_items'][0]['price'] == "price_test999" + + +@pytest.mark.asyncio +@patch('agentops.opsboard.views.orgs.STRIPE_SECRET_KEY', 'test_stripe_key') +@patch('stripe.Subscription.retrieve') +async def test_get_user_orgs_with_discount(mock_stripe_subscription, mock_request, orm_session, test_user): + """Test that discount info is properly returned in organization list.""" + # Create a fresh organization with pro status and subscription + org = OrgModel( + name="Test Org with Discount", prem_status=PremStatus.pro, subscription_id="sub_test_with_discount" + ) + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + orm_session.commit() + + # Mock Stripe subscription with discount + mock_subscription = { + 'id': 'sub_test_with_discount', + 'status': 'active', + 'current_period_start': 1734000000, # Some start timestamp + 'current_period_end': 1735689600, # Some future timestamp + 'cancel_at_period_end': False, + 'discount': { + 'coupon': {'id': 'SUMMER_SALE', 'percent_off': 20, 'valid': True}, + 'promotion_code': 'SAVE20', + }, + } + mock_stripe_subscription.return_value = mock_subscription + + from agentops.opsboard.views.orgs import get_user_orgs + + # Call the endpoint + result = get_user_orgs(request=mock_request, orm=orm_session) + + # Find our test org in the results + test_org_response = None + for org_response in result: + if org_response.id == str(org.id): + test_org_response = org_response + break + + assert test_org_response is not None + assert test_org_response.subscription_end_date == 1735689600 + assert test_org_response.subscription_cancel_at_period_end is False + + # Note: The current implementation doesn't return discount info in the response + # This test verifies the subscription details are fetched correctly + # If discount info needs to be added to the response, the schema and view would need updates diff --git a/app/api/tests/opsboard/views/test_orgs_edgecases.py b/app/api/tests/opsboard/views/test_orgs_edgecases.py new file mode 100644 index 000000000..f243de14a --- /dev/null +++ b/app/api/tests/opsboard/views/test_orgs_edgecases.py @@ -0,0 +1,184 @@ +import pytest +import uuid +from fastapi import HTTPException +from sqlalchemy import orm + +from agentops.opsboard.models import ( + OrgModel, + UserOrgModel, + OrgInviteModel, + OrgRoles, + PremStatus, + UserModel, +) +from agentops.opsboard.views.orgs import ( + create_org, + invite_to_org, + remove_from_org, + change_member_role, +) +from agentops.opsboard.schemas import ( + OrgCreateSchema, + OrgInviteSchema, + OrgMemberRemoveSchema, + OrgMemberRoleSchema, +) + + +@pytest.mark.asyncio +async def test_create_org_user_not_found(mock_request, orm_session, monkeypatch): + """Test creating an organization when the user doesn't exist.""" + # Mock orm.get to return None for UserModel (user not found) + original_get_by_id = UserModel.get_by_id + + def mock_get_by_id(session, id): + return None + + # Apply the monkeypatch + monkeypatch.setattr(UserModel, "get_by_id", mock_get_by_id) + + # Create the request body + body = OrgCreateSchema(name="New Test Organization") + + # Expect an HTTP 500 exception + with pytest.raises(HTTPException) as excinfo: + create_org(request=mock_request, orm=orm_session, body=body) + + assert excinfo.value.status_code == 500 + assert excinfo.value.detail == "User not found" + + # Restore the original method + monkeypatch.setattr(UserModel, "get_by_id", original_get_by_id) + + +@pytest.mark.asyncio +async def test_invite_to_org_existing_invite(mock_request, orm_session, test_user): + """Test inviting a user when there's an existing invite for the same email.""" + # Create a fresh organization for this test + org = OrgModel( + name="Test Org for Existing Invite", + prem_status=PremStatus.enterprise, # Use enterprise to avoid the member limit + ) + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + orm_session.commit() # Commit to ensure it's persisted + + # First create an invitation + invite_email = "newuser@example.com" + invite = OrgInviteModel( + inviter_id=user_id, + invitee_email=invite_email, + org_id=org.id, + role=OrgRoles.developer, + org_name=org.name, + ) + orm_session.add(invite) + orm_session.commit() + + # Fetch org again with relationships to ensure we have the latest + org = ( + orm_session.query(OrgModel) + .options(orm.selectinload(OrgModel.users), orm.selectinload(OrgModel.invites)) + .filter_by(id=org.id) + .one() + ) + + # Try to create another invite with the same email + body = OrgInviteSchema(email=invite_email, role=OrgRoles.admin.value) + + # Expect an HTTP 400 exception + with pytest.raises(HTTPException) as excinfo: + invite_to_org(request=mock_request, org_id=str(org.id), orm=orm_session, body=body) + + assert excinfo.value.status_code == 400 + assert excinfo.value.detail == "User already has a pending invitation" + + +@pytest.mark.asyncio +async def test_remove_from_org_user_not_found(mock_request, orm_session, test_user): + """Test removing a user who isn't part of the organization.""" + # Create a fresh organization for this test + org = OrgModel( + name="Test Org for Remove Non-Member", + prem_status=PremStatus.free, + ) + orm_session.add(org) + orm_session.flush() + + # Add the primary test user as an owner + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + orm_session.commit() # Commit to ensure both relationships are persisted + + # Create the remove body using a non-existent user ID + non_member_id = str(uuid.uuid4()) + body = OrgMemberRemoveSchema(user_id=non_member_id) + + # Expect an HTTP 400 exception + with pytest.raises(HTTPException) as excinfo: + remove_from_org(request=mock_request, org_id=str(org.id), orm=orm_session, body=body) + + assert excinfo.value.status_code == 400 + assert excinfo.value.detail == "User cannot be removed" + + +@pytest.mark.asyncio +async def test_change_member_role_non_owner_promotes_to_owner( + mock_request, orm_session, test_user, test_user2, test_user3 +): + """Test when a non-owner tries to promote someone to owner.""" + # Create a fresh organization for this test + org = OrgModel( + name="Test Org for Non-Owner Promotion", + prem_status=PremStatus.free, + ) + orm_session.add(org) + orm_session.flush() + + # Add test_user2 as the owner + owner_org = UserOrgModel( + user_id=test_user2.id, + org_id=org.id, + role=OrgRoles.owner, + user_email=test_user2.email, + ) + orm_session.add(owner_org) + + # Add the primary test user as an admin (not owner) + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.admin, user_email="test@example.com" + ) + orm_session.add(user_org) + + # Add test_user3 as a developer + dev_org = UserOrgModel( + user_id=test_user3.id, org_id=org.id, role=OrgRoles.developer, user_email=test_user3.email + ) + orm_session.add(dev_org) + orm_session.commit() # Commit to ensure all relationships are persisted + + # Attempt to promote the developer to owner by the admin (not owner) + body = OrgMemberRoleSchema(user_id=str(test_user3.id), role=OrgRoles.owner.value) + + # Expect an HTTP 400 exception + with pytest.raises(HTTPException) as excinfo: + change_member_role(request=mock_request, org_id=str(org.id), orm=orm_session, body=body) + + assert excinfo.value.status_code == 400 + assert excinfo.value.detail == "Only owners can assign the owner role" + + # Verify the role wasn't changed + orm_session.expire_all() # Clear cached objects + user_org = orm_session.query(UserOrgModel).filter_by(user_id=test_user3.id, org_id=org.id).one() + assert user_org.role == OrgRoles.developer, "The user role should not have been changed" diff --git a/app/api/tests/opsboard/views/test_orgs_missing.py b/app/api/tests/opsboard/views/test_orgs_missing.py new file mode 100644 index 000000000..502ac65a3 --- /dev/null +++ b/app/api/tests/opsboard/views/test_orgs_missing.py @@ -0,0 +1,155 @@ +import pytest +from fastapi import HTTPException + +from agentops.opsboard.models import ( + OrgModel, + UserOrgModel, + OrgInviteModel, + ProjectModel, + OrgRoles, + Environment, + PremStatus, +) +from agentops.opsboard.views.orgs import ( + delete_org, + accept_org_invite, +) + + +@pytest.mark.asyncio +async def test_delete_org(mock_request, orm_session, test_user): + """Test deleting an organization.""" + # Create a fresh organization for this test + org = OrgModel( + name="Test Org for Deletion", + prem_status=PremStatus.free, + ) + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + orm_session.commit() # Commit to ensure it's persisted + + # Call the endpoint function + result = delete_org(request=mock_request, org_id=str(org.id), orm=orm_session) + + # Verify the status response + assert result.success is True + assert result.message == "Organization deleted" + + # Verify the organization was deleted + deleted_org = orm_session.query(OrgModel).filter_by(id=org.id).first() + assert deleted_org is None + + +@pytest.mark.asyncio +async def test_delete_org_not_owner(mock_request, orm_session, test_user): + """Test deleting an organization without owner permissions.""" + # Create a fresh organization for this test + org = OrgModel( + name="Test Org for Non-Owner Deletion", + prem_status=PremStatus.free, + ) + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship with admin role (not owner) + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.admin, user_email="test@example.com" + ) + orm_session.add(user_org) + orm_session.commit() # Commit to ensure it's persisted + + # Expect a 403 exception + with pytest.raises(HTTPException) as excinfo: + delete_org(request=mock_request, org_id=str(org.id), orm=orm_session) + + assert excinfo.value.status_code == 403 + assert excinfo.value.detail == "Organization cannot be deleted" + + # Verify the organization still exists + org_still_exists = orm_session.query(OrgModel).filter_by(id=org.id).first() + assert org_still_exists is not None + + +@pytest.mark.asyncio +async def test_delete_org_with_projects(mock_request, orm_session, test_user): + """Test deleting an organization that still has projects (should fail).""" + # Create a fresh organization for this test + org = OrgModel( + name="Test Org with Projects", + prem_status=PremStatus.free, + ) + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + orm_session.flush() + + # Create a project in the organization + project = ProjectModel(name="Test Project", org_id=org.id, environment=Environment.development) + orm_session.add(project) + orm_session.commit() # Commit to ensure it's persisted + + # Reload the org with all relationships + org = OrgModel.get_by_id(orm_session, org.id) + + # Expect a 400 exception + with pytest.raises(HTTPException) as excinfo: + delete_org(request=mock_request, org_id=str(org.id), orm=orm_session) + + assert excinfo.value.status_code == 400 + assert excinfo.value.detail == "Organization cannot be deleted while it still contains projects" + + # Verify the organization still exists + org_still_exists = orm_session.query(OrgModel).filter_by(id=org.id).first() + assert org_still_exists is not None + + +@pytest.mark.asyncio +async def test_accept_org_invite_user_not_found(mock_request, orm_session, test_user, monkeypatch): + """Test accepting an invitation when the user doesn't exist.""" + # Create a fresh organization for this test + org = OrgModel( + name="Test Org for Invite", + prem_status=PremStatus.free, + ) + orm_session.add(org) + orm_session.flush() + + invite = OrgInviteModel( + inviter_id=test_user.id, # Use existing test user as inviter + invitee_email="test@example.com", + org_id=org.id, + role=OrgRoles.developer, + org_name=org.name, + ) + orm_session.add(invite) + orm_session.commit() # Ensure it's persisted + + # Mock UserModel.get_by_id to return None + from agentops.opsboard.models import UserModel + + def mock_get_by_id(session, user_id): + return None + + monkeypatch.setattr(UserModel, "get_by_id", mock_get_by_id) + + # Since auth user exists in test data but UserModel.get_by_id returns None, + # the function will try to wait for user creation and then return 500 + with pytest.raises(HTTPException) as excinfo: + accept_org_invite(request=mock_request, org_id=str(org.id), orm=orm_session) + + assert excinfo.value.status_code == 500 + assert "User record not yet created" in excinfo.value.detail diff --git a/app/api/tests/opsboard/views/test_projects.py b/app/api/tests/opsboard/views/test_projects.py new file mode 100644 index 000000000..3e6f627d2 --- /dev/null +++ b/app/api/tests/opsboard/views/test_projects.py @@ -0,0 +1,442 @@ +import pytest +import uuid +from fastapi import HTTPException +from sqlalchemy import orm + +from agentops.opsboard.models import ( + OrgModel, + UserOrgModel, + ProjectModel, + OrgRoles, + Environment, + PremStatus, +) +from agentops.opsboard.views.projects import ( + get_projects, + get_project, + create_project, + update_project, + delete_project, + regenerate_api_key, +) +from agentops.opsboard.schemas import ( + ProjectCreateSchema, + ProjectUpdateSchema, +) + + +@pytest.mark.asyncio +async def test_get_projects(mock_request, orm_session, test_user): + """Test getting all projects for a user.""" + # Create an org first + org = OrgModel(name="Test Org for Projects") + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship with the test user fixture + user_org = UserOrgModel( + user_id=test_user.id, org_id=org.id, role=OrgRoles.owner, user_email=test_user.email + ) + orm_session.add(user_org) + + # Create a project + project = ProjectModel(name="Test Project", org_id=org.id, environment=Environment.development) + orm_session.add(project) + orm_session.flush() + + # Call the endpoint function + result = await get_projects(request=mock_request, orm=orm_session) + + # Verify that it returns a list and the test project is in the results + assert isinstance(result, list) + assert len(result) > 0 + + # Check that our test project is in the results + project_ids = [p.id for p in result] + assert str(project.id) in project_ids + + +@pytest.mark.asyncio +async def test_get_project(mock_request, orm_session, test_project): + """Test getting a specific project by ID.""" + # Call the endpoint function + result = get_project(request=mock_request, project_id=str(test_project.id), orm=orm_session) + + # Verify the project data matches + assert result.id == str(test_project.id) + assert result.name == test_project.name + assert result.environment == test_project.environment.value + assert result.api_key == str(test_project.api_key) + assert result.org_id == str(test_project.org_id) + assert result.org.id == str(test_project.org.id) + assert result.org.name == test_project.org.name + + +@pytest.mark.asyncio +async def test_get_project_not_found(mock_request, orm_session): + """Test getting a project that doesn't exist.""" + non_existent_id = str(uuid.uuid4()) + + # Expect an HTTP 404 exception + with pytest.raises(HTTPException) as excinfo: + get_project(request=mock_request, project_id=non_existent_id, orm=orm_session) + + assert excinfo.value.status_code == 404 + assert excinfo.value.detail == "Project not found" + + +@pytest.mark.asyncio +async def test_create_project(mock_request, orm_session, test_user): + """Test creating a new project.""" + # Create a fresh org and user-org relationship + org = OrgModel(name="Test Org for Create") + orm_session.add(org) + orm_session.flush() + + # Add the test user as an owner of the org + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + orm_session.flush() + + # Create the request body + body = ProjectCreateSchema( + name="New Test Project", org_id=str(org.id), environment=Environment.staging.value + ) + + # Call the endpoint function + result = create_project(request=mock_request, orm=orm_session, body=body) + + # Verify the project was created with the right data + assert result.name == body.name + assert result.org_id == body.org_id + assert result.environment == body.environment + assert result.api_key is not None + + # Verify we can find it in the database + created_project = orm_session.query(ProjectModel).filter_by(id=uuid.UUID(result.id)).one() + assert created_project.name == body.name + assert created_project.environment == Environment.staging + + +@pytest.mark.asyncio +async def test_create_project_not_admin(mock_request, orm_session, test_user): + """Test creating a project without admin permissions.""" + # Create an org directly in this test + org = OrgModel(name="Test Org for Non-Admin Test") + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship with developer role (not admin or owner) + user_org = UserOrgModel( + user_id=test_user.id, org_id=org.id, role=OrgRoles.developer, user_email=test_user.email + ) + orm_session.add(user_org) + orm_session.flush() + + # Create the request body + body = ProjectCreateSchema( + name="New Test Project", org_id=str(org.id), environment=Environment.staging.value + ) + + # Expect an HTTP 404 exception (security through obscurity - not found instead of forbidden) + with pytest.raises(HTTPException) as excinfo: + create_project(request=mock_request, orm=orm_session, body=body) + + assert excinfo.value.status_code == 404 + assert excinfo.value.detail == "Organization not found" + + +@pytest.mark.asyncio +async def test_update_project(mock_request, orm_session, test_project): + """Test updating a project's name and environment.""" + + # Create the update body + body = ProjectUpdateSchema(name="Updated Project Name", environment=Environment.production.value) + + # Execute the update + result = update_project(request=mock_request, project_id=str(test_project.id), orm=orm_session, body=body) + + # Verify the updates were applied + assert result.name == body.name + assert result.environment == body.environment + + # Refresh the session to get the latest data + orm_session.expire_all() + + # Verify the database was updated + updated_project = orm_session.query(ProjectModel).filter_by(id=test_project.id).one() + assert updated_project.name == body.name + assert updated_project.environment == Environment.production + + +@pytest.mark.asyncio +async def test_update_project_not_admin(mock_request, orm_session, test_project): + """Test updating a project without admin permissions.""" + # Get the current test project and its organization + project_id = test_project.id + org_id = test_project.org_id + + # Change the user's role to developer (not admin or owner) + user_id = mock_request.state.session.user_id + user_org = test_project.org.get_user_membership(str(user_id)) + + if user_org: + # Change the existing role to developer + user_org.role = OrgRoles.developer + else: + # Create a new membership with developer role + user_org = UserOrgModel( + user_id=user_id, org_id=org_id, role=OrgRoles.developer, user_email="test@example.com" + ) + orm_session.add(user_org) + + # Commit the changes + orm_session.commit() + + # Create the update body + body = ProjectUpdateSchema(name="Updated Project Name", environment=Environment.production.value) + + # Expect an HTTP 403 exception + with pytest.raises(HTTPException) as excinfo: + update_project(request=mock_request, project_id=str(project_id), orm=orm_session, body=body) + + assert excinfo.value.status_code == 403 + assert excinfo.value.detail == "You don't have permission to update this project" + + +@pytest.mark.asyncio +async def test_update_project_invalid_environment(mock_request, orm_session, test_project): + """Test updating a project with an invalid environment.""" + # Create the update body with an invalid environment + body = ProjectUpdateSchema(name="Updated Project Name", environment="invalid_environment") + + # Expect an HTTP 400 exception + with pytest.raises(HTTPException) as excinfo: + update_project(request=mock_request, project_id=str(test_project.id), orm=orm_session, body=body) + + assert excinfo.value.status_code == 400 + assert excinfo.value.detail == "Invalid environment" + + +@pytest.mark.asyncio +async def test_delete_project(mock_request, orm_session, test_user): + """Test deleting a project.""" + # Create all the test data in this test + org = OrgModel(name="Test Org for Delete") + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship with test_user fixture + user_org = UserOrgModel( + user_id=test_user.id, org_id=org.id, role=OrgRoles.owner, user_email=test_user.email + ) + orm_session.add(user_org) + orm_session.flush() + + # Create a project + project = ProjectModel(name="Project to Delete", org_id=org.id, environment=Environment.development) + orm_session.add(project) + orm_session.flush() + + # Load relationships to ensure they're available + project = ( + orm_session.query(ProjectModel) + .options(orm.joinedload(ProjectModel.org).joinedload(OrgModel.users)) + .filter_by(id=project.id) + .one() + ) + + # Call the endpoint function directly with the session + result = delete_project(request=mock_request, project_id=str(project.id), orm=orm_session) + + # Verify the status response + assert result.success is True + assert result.message == "Project deleted successfully" + + projects = orm_session.query(ProjectModel).filter_by(id=project.id).all() + assert len(projects) == 0 + + +@pytest.mark.asyncio +async def test_delete_project_not_owner(mock_request, orm_session, test_user): + """Test deleting a project without owner permissions.""" + # Create all the test data in this test + org = OrgModel(name="Test Org for Non-Owner Delete") + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship with admin role (not owner) using test_user + user_org = UserOrgModel( + user_id=test_user.id, + org_id=org.id, + role=OrgRoles.admin, # Admin role, not owner + user_email=test_user.email, + ) + orm_session.add(user_org) + orm_session.flush() + + # Create a project + project = ProjectModel( + name="Project for Non-Owner Delete Test", org_id=org.id, environment=Environment.development + ) + orm_session.add(project) + orm_session.flush() + + # Load relationships to ensure they're available + project = ( + orm_session.query(ProjectModel) + .options(orm.joinedload(ProjectModel.org).joinedload(OrgModel.users)) + .filter_by(id=project.id) + .one() + ) + + # Expect an HTTP 403 exception + with pytest.raises(HTTPException) as excinfo: + delete_project(request=mock_request, project_id=str(project.id), orm=orm_session) + + assert excinfo.value.status_code == 403 + assert excinfo.value.detail == "Only organization owners can delete projects" + + +@pytest.mark.asyncio +async def test_create_project_limit(mock_request, orm_session, test_user): + """Test creating a project when the organization has reached its project limit.""" + # Create a fresh organization with free plan (which has a project limit of 1) + org = OrgModel( + name="Test Org with Project Limit", + prem_status=PremStatus.free, # Free plan has a project limit of 1 + ) + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + orm_session.flush() + + # Create a project (which takes up the only allowed project slot) + project = ProjectModel(name="First Project", org_id=org.id, environment=Environment.development) + orm_session.add(project) + orm_session.commit() # Commit to ensure it's persisted + + # Reload the org with all relationships + org = OrgModel.get_by_id(orm_session, org.id) + + # Create the request body for a second project (which should exceed the limit) + body = ProjectCreateSchema( + name="Second Project", org_id=str(org.id), environment=Environment.development.value + ) + + # Expect an HTTP 403 exception due to project limit + with pytest.raises(HTTPException) as excinfo: + create_project(request=mock_request, orm=orm_session, body=body) + + assert excinfo.value.status_code == 403 + assert excinfo.value.detail == "Organization has reached it's project limit" + + # Verify no second project was created + projects = orm_session.query(ProjectModel).filter_by(org_id=org.id).all() + assert len(projects) == 1 + + +@pytest.mark.asyncio +async def test_create_project_after_upgrade(mock_request, orm_session, test_user): + """Test creating projects after upgrading from free to enterprise plan.""" + # Create a fresh organization with free plan (which has a project limit of 1) + org = OrgModel( + name="Test Org for Plan Upgrade", + prem_status=PremStatus.free, # Free plan has a project limit of 1 + ) + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + orm_session.flush() + + # Create a project (using up the only allowed slot in the free plan) + project = ProjectModel(name="First Project", org_id=org.id, environment=Environment.development) + orm_session.add(project) + orm_session.commit() + + # Upgrade the organization plan to enterprise (which has no project limit) + org.prem_status = PremStatus.enterprise + orm_session.commit() + + # Reload the org with all relationships + org = OrgModel.get_by_id(orm_session, org.id) + + # Create the request body for a second project (which should now work) + body = ProjectCreateSchema( + name="Second Project", org_id=str(org.id), environment=Environment.development.value + ) + + # This should now succeed with the enterprise plan + result = create_project(request=mock_request, orm=orm_session, body=body) + + # Verify the project was created with the right data + assert result.name == body.name + assert result.org_id == body.org_id + assert result.api_key is not None + + # Verify we now have two projects in the database + projects = orm_session.query(ProjectModel).filter_by(org_id=org.id).all() + assert len(projects) == 2 + + +@pytest.mark.asyncio +async def test_regenerate_api_key(mock_request, orm_session, test_user): + """Test regenerating a project's API key.""" + # Create all the test data in this test + org = OrgModel(name="Test Org for Regenerate Key") + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship with owner role using test_user + user_org = UserOrgModel( + user_id=test_user.id, org_id=org.id, role=OrgRoles.owner, user_email=test_user.email + ) + orm_session.add(user_org) + orm_session.flush() + + # Create a project with a specific API key + initial_api_key = uuid.uuid4() + project = ProjectModel( + name="Project for Key Regeneration", + org_id=org.id, + environment=Environment.development, + api_key=initial_api_key, + ) + orm_session.add(project) + orm_session.flush() + + # Load relationships to ensure they're available + project = ( + orm_session.query(ProjectModel) + .options(orm.joinedload(ProjectModel.org).joinedload(OrgModel.users)) + .filter_by(id=project.id) + .one() + ) + + # Save the original API key + original_api_key = project.api_key + + # Call the endpoint function + result = regenerate_api_key(request=mock_request, project_id=str(project.id), orm=orm_session) + + # Verify the response contains a new API key + assert result.api_key != str(original_api_key) + + # Verify the database was updated + updated_project = orm_session.query(ProjectModel).filter_by(id=project.id).one() + assert str(updated_project.api_key) != str(original_api_key) diff --git a/app/api/tests/opsboard/views/test_projects_edgecases.py b/app/api/tests/opsboard/views/test_projects_edgecases.py new file mode 100644 index 000000000..02e4cdf2b --- /dev/null +++ b/app/api/tests/opsboard/views/test_projects_edgecases.py @@ -0,0 +1,181 @@ +import pytest +import uuid +from fastapi import HTTPException +from unittest.mock import patch + +from agentops.opsboard.models import ( + OrgModel, + UserOrgModel, + ProjectModel, + OrgRoles, + Environment, +) +from agentops.opsboard.views.projects import ( + get_projects, + get_project, + create_project, + update_project, +) +from agentops.opsboard.schemas import ( + ProjectCreateSchema, + ProjectUpdateSchema, +) + + +@pytest.mark.asyncio +async def test_get_projects_with_missing_count(mock_request, orm_session, test_user): + """Test getting projects when a project has no trace/span count data.""" + # Create an org first + org = OrgModel(name="Test Org for Missing Counts") + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship with the test user fixture + user_org = UserOrgModel( + user_id=test_user.id, org_id=org.id, role=OrgRoles.owner, user_email=test_user.email + ) + orm_session.add(user_org) + + # Create a project + project = ProjectModel( + name="Test Project Without Counts", org_id=org.id, environment=Environment.development + ) + orm_session.add(project) + orm_session.flush() + + # Mock TraceCountsModel.select to return empty counts + empty_counts = [] + with patch('agentops.api.models.metrics.TraceCountsModel.select', return_value=empty_counts): + # Call the endpoint function + result = await get_projects(request=mock_request, orm=orm_session) + + # Verify that it returns a list and the test project is in the results + assert isinstance(result, list) + assert len(result) > 0 + + # Find our project in the results + project_response = None + for p in result: + if p.id == str(project.id): + project_response = p + break + + assert project_response is not None + assert project_response.name == project.name + # Verify that the counts are not set (they should be None or default) + assert project_response.span_count == 0 + assert project_response.trace_count == 0 + + +@pytest.mark.asyncio +async def test_get_project_user_not_member(mock_request, orm_session, test_user, test_user2): + """Test getting a project when the user is not a member of the organization.""" + # Create an org that the test user is NOT a member of + org = OrgModel(name="Test Org Not Member") + orm_session.add(org) + orm_session.flush() + + # Add test_user2 as the owner (not the main test user) + user_org = UserOrgModel( + user_id=test_user2.id, org_id=org.id, role=OrgRoles.owner, user_email=test_user2.email + ) + orm_session.add(user_org) + + # Create a project in that org + project = ProjectModel(name="Test Project Non-Member", org_id=org.id, environment=Environment.development) + orm_session.add(project) + orm_session.commit() + + # Expect an HTTP 404 exception when the main test user tries to access it + with pytest.raises(HTTPException) as excinfo: + get_project(request=mock_request, project_id=str(project.id), orm=orm_session) + + assert excinfo.value.status_code == 404 + assert excinfo.value.detail == "Project not found" + + +@pytest.mark.asyncio +async def test_create_project_default_environment(mock_request, orm_session, test_user): + """Test creating a project without specifying an environment (should use development).""" + # Create a fresh org and user-org relationship + org = OrgModel(name="Test Org for Default Environment") + orm_session.add(org) + orm_session.flush() + + # Add the test user as an owner of the org + user_id = mock_request.state.session.user_id + user_org = UserOrgModel( + user_id=user_id, org_id=org.id, role=OrgRoles.owner, user_email="test@example.com" + ) + orm_session.add(user_org) + orm_session.flush() + + # Create the request body WITHOUT environment field + body = ProjectCreateSchema( + name="Project With Default Environment", + org_id=str(org.id), + # environment is intentionally omitted + ) + + # Call the endpoint function + result = create_project(request=mock_request, orm=orm_session, body=body) + + # Verify the project was created with the default environment + assert result.name == body.name + assert result.org_id == body.org_id + assert result.environment == Environment.development.value + assert result.api_key is not None + + # Verify in the database + created_project = orm_session.query(ProjectModel).filter_by(id=uuid.UUID(result.id)).one() + assert created_project.name == body.name + assert created_project.environment == Environment.development + + +@pytest.mark.asyncio +async def test_update_project_name_only(mock_request, orm_session, test_project): + """Test updating only a project's name, not environment.""" + # Create the update body with only name + new_name = "Updated Project Name Only" + body = ProjectUpdateSchema(name=new_name) + + # Execute the update + result = update_project(request=mock_request, project_id=str(test_project.id), orm=orm_session, body=body) + + # Verify only the name was updated + assert result.name == new_name + assert result.environment == test_project.environment.value # should remain unchanged + + # Refresh the session to get the latest data + orm_session.expire_all() + + # Verify the database was updated correctly + updated_project = orm_session.query(ProjectModel).filter_by(id=test_project.id).one() + assert updated_project.name == new_name + assert updated_project.environment == test_project.environment # should remain unchanged + + +@pytest.mark.asyncio +async def test_update_project_environment_only(mock_request, orm_session, test_project): + """Test updating only a project's environment, not name.""" + # Get the original name for verification later + original_name = test_project.name + + # Create the update body with only environment + new_environment = Environment.production.value + body = ProjectUpdateSchema(environment=new_environment) + + # Execute the update + result = update_project(request=mock_request, project_id=str(test_project.id), orm=orm_session, body=body) + + # Verify only the environment was updated + assert result.name == original_name # should remain unchanged + assert result.environment == new_environment + + # Refresh the session to get the latest data + orm_session.expire_all() + + # Verify the database was updated correctly + updated_project = orm_session.query(ProjectModel).filter_by(id=test_project.id).one() + assert updated_project.name == original_name # should remain unchanged + assert updated_project.environment == Environment.production diff --git a/app/api/tests/opsboard/views/test_projects_missing.py b/app/api/tests/opsboard/views/test_projects_missing.py new file mode 100644 index 000000000..b875a2637 --- /dev/null +++ b/app/api/tests/opsboard/views/test_projects_missing.py @@ -0,0 +1,77 @@ +import pytest +import uuid +from fastapi import HTTPException +from sqlalchemy import orm + +from agentops.opsboard.models import ( + OrgModel, + UserOrgModel, + ProjectModel, + OrgRoles, + Environment, +) +from agentops.opsboard.views.projects import ( + regenerate_api_key, +) + + +@pytest.mark.asyncio +async def test_regenerate_api_key_not_admin(mock_request, orm_session, test_user): + """Test regenerating a project's API key without admin permissions.""" + # Create all the test data in this test + org = OrgModel(name="Test Org for Non-Admin Regenerate Key") + orm_session.add(org) + orm_session.flush() + + # Create a user-org relationship with developer role (not admin or owner) + user_org = UserOrgModel( + user_id=test_user.id, + org_id=org.id, + role=OrgRoles.developer, # Developer role, not admin or owner + user_email=test_user.email + ) + orm_session.add(user_org) + orm_session.flush() + + # Create a project with a specific API key + initial_api_key = uuid.uuid4() + project = ProjectModel( + name="Project for Non-Admin Key Regeneration", + org_id=org.id, + environment=Environment.development, + api_key=initial_api_key, + ) + orm_session.add(project) + orm_session.flush() + + # Load relationships to ensure they're available + project = ( + orm_session.query(ProjectModel) + .options(orm.joinedload(ProjectModel.org).joinedload(OrgModel.users)) + .filter_by(id=project.id) + .one() + ) + + # Expect an HTTP 404 exception (security through obscurity) + with pytest.raises(HTTPException) as excinfo: + regenerate_api_key(request=mock_request, project_id=str(project.id), orm=orm_session) + + assert excinfo.value.status_code == 404 + assert excinfo.value.detail == "Project not found" + + # Verify the API key wasn't changed + unchanged_project = orm_session.query(ProjectModel).filter_by(id=project.id).one() + assert unchanged_project.api_key == initial_api_key + + +@pytest.mark.asyncio +async def test_regenerate_api_key_project_not_found(mock_request, orm_session): + """Test regenerating an API key for a project that doesn't exist.""" + non_existent_id = str(uuid.uuid4()) + + # Expect an HTTP 404 exception + with pytest.raises(HTTPException) as excinfo: + regenerate_api_key(request=mock_request, project_id=non_existent_id, orm=orm_session) + + assert excinfo.value.status_code == 404 + assert excinfo.value.detail == "Project not found" \ No newline at end of file diff --git a/app/api/tests/opsboard/views/test_users.py b/app/api/tests/opsboard/views/test_users.py new file mode 100644 index 000000000..97553618a --- /dev/null +++ b/app/api/tests/opsboard/views/test_users.py @@ -0,0 +1,90 @@ +import pytest + +from agentops.opsboard.views.users import get_user, update_user, update_user_survey_complete +from agentops.opsboard.schemas import UserUpdateSchema, UserResponse, StatusResponse + + +async def test_get_user(mock_request, orm_session, test_user): + """Test getting user details.""" + # Call the view function + response = get_user(request=mock_request, orm=orm_session) + + # Verify response + assert isinstance(response, UserResponse) + assert response.full_name == "Test User" + assert response.email == "test@example.com" + assert response.survey_is_complete is False + + +async def test_update_user(mock_request, orm_session, test_user): + """Test updating user details.""" + # Create update data + update_data = UserUpdateSchema(full_name="Updated Name", survey_is_complete=True) + + # Call the view function + response = update_user(request=mock_request, orm=orm_session, body=update_data) + + # Verify response + assert isinstance(response, UserResponse) + assert response.full_name == "Updated Name" + assert response.survey_is_complete is True + + # Verify database was updated + updated_user = orm_session.get_one(type(test_user), test_user.id) + assert updated_user.full_name == "Updated Name" + assert updated_user.survey_is_complete is True + + +async def test_update_user_survey_complete(mock_request, orm_session, test_user): + """Test marking the user survey as complete.""" + # Reset survey_is_complete to False for this test + test_user.survey_is_complete = False + orm_session.commit() + + # Call the view function + response = update_user_survey_complete(request=mock_request, orm=orm_session) + + # Verify response + assert isinstance(response, StatusResponse) + assert response.success is True + assert "complete" in response.message.lower() + + # Verify database was updated + updated_user = orm_session.get_one(type(test_user), test_user.id) + assert updated_user.survey_is_complete is True + + +async def test_get_user_not_found(mock_request, orm_session, monkeypatch): + """Test getting a user that doesn't exist.""" + # Mock UserModel.get_by_id to return None + from agentops.opsboard.models import UserModel + + monkeypatch.setattr(UserModel, 'get_by_id', lambda *args, **kwargs: None) + + # Call the view function and expect an exception + with pytest.raises(Exception): + get_user(request=mock_request, orm=orm_session) + + +async def test_update_user_not_found(mock_request, orm_session, monkeypatch): + """Test updating a user that doesn't exist.""" + # Mock UserModel.get_by_id to return None + from agentops.opsboard.models import UserModel + + monkeypatch.setattr(UserModel, 'get_by_id', lambda *args, **kwargs: None) + + # Call the view function and expect an exception + with pytest.raises(Exception): + update_user(request=mock_request, orm=orm_session, body=UserUpdateSchema(full_name="Test")) + + +async def test_update_user_survey_complete_not_found(mock_request, orm_session, monkeypatch): + """Test marking survey complete for a user that doesn't exist.""" + # Mock UserModel.get_by_id to return None + from agentops.opsboard.models import UserModel + + monkeypatch.setattr(UserModel, 'get_by_id', lambda *args, **kwargs: None) + + # Call the view function and expect an exception + with pytest.raises(Exception): + update_user_survey_complete(request=mock_request, orm=orm_session) diff --git a/app/api/tests/public/test_public_api.py b/app/api/tests/public/test_public_api.py new file mode 100644 index 000000000..19e2d04ed --- /dev/null +++ b/app/api/tests/public/test_public_api.py @@ -0,0 +1,408 @@ +import pytest +import jwt +import uuid +from datetime import datetime, timezone +from agentops.api.auth import generate_jwt, JWT_ALGO +from agentops.api.environment import JWT_SECRET_KEY +from agentops.opsboard.models import ProjectModel + + +@pytest.fixture +def test_api_key(): + """Generate a UUID for premium test project API key.""" + return str(uuid.uuid4()) + + +@pytest.fixture +def test_free_api_key(): + """Generate a UUID for free plan test project API key.""" + return str(uuid.uuid4()) + + +@pytest.fixture +def test_trace_id(): + """Generate a unique trace ID for testing.""" + import random + + return str(random.randint(10**37, 10**38 - 1)) + + +@pytest.fixture +def test_span_id(): + """Generate a unique span ID for testing.""" + import random + + return str(random.randint(10**19, 10**20 - 1)) + + +@pytest.fixture +def test_project_with_api_key(orm_session, test_user_org_owner_prem, test_api_key): + """Create a test project with the specific API key for testing.""" + org = test_user_org_owner_prem + + project = ProjectModel( + name="Test Public API Project", + org_id=org.id, + environment="development", + api_key=test_api_key, + ) + orm_session.add(project) + orm_session.commit() + + project_obj = ProjectModel.get_by_id(orm_session, project.id) + + yield project_obj + + # Cleanup: delete the project after the test + orm_session.delete(project_obj) + orm_session.commit() + + +@pytest.fixture +def test_free_project_with_api_key(orm_session, test_user_org_owner, test_free_api_key): + """Create a free plan test project for testing restrictions.""" + org = test_user_org_owner + + project = ProjectModel( + name="Test Free Project", + org_id=org.id, + environment="development", + api_key=test_free_api_key, + # TODO the project org will dictate the plan + ) + orm_session.add(project) + orm_session.commit() + + project_obj = ProjectModel.get_by_id(orm_session, project.id) + + yield project_obj + + # Cleanup: delete the project after the test + orm_session.delete(project_obj) + orm_session.commit() + + +@pytest.fixture +async def test_trace_data(async_clickhouse_client, test_project_with_api_key, test_trace_id): + """Create test trace data in ClickHouse.""" + import random + + project = test_project_with_api_key + project_id_str = str(project.id) + + # Insert test trace + trace_data = { + "Timestamp": datetime.now(timezone.utc), + "TraceId": test_trace_id, + "SpanId": str(random.randint(10**19, 10**20 - 1)), # Unique span ID for the root span + "ParentSpanId": "", + "TraceState": "", + "SpanName": "test_trace", + "SpanKind": "SPAN_KIND_INTERNAL", + "ServiceName": "test_service", + "ResourceAttributes": {"agentops.project.id": project_id_str}, + "ScopeName": "", + "ScopeVersion": "", + "SpanAttributes": {"tags": "test,public-api"}, + "Duration": 1000000, + "StatusCode": "STATUS_CODE_OK", + "StatusMessage": "", + "Events.Timestamp": [], + "Events.Name": [], + "Events.Attributes": [], + "Links.TraceId": [], + "Links.SpanId": [], + "Links.TraceState": [], + "Links.Attributes": [], + } + + await async_clickhouse_client.insert( + table="otel_traces", data=[list(trace_data.values())], column_names=list(trace_data.keys()) + ) + + yield trace_data + + # Cleanup: delete the trace data after the test + await async_clickhouse_client.command(f"DELETE FROM otel_traces WHERE TraceId = '{test_trace_id}'") + + +@pytest.fixture +async def test_span_data(async_clickhouse_client, test_trace_data, test_span_id, test_trace_id): + """Create test span data in ClickHouse.""" + # Use the same project ID as the trace data + project_id_str = test_trace_data["ResourceAttributes"]["agentops.project.id"] + + # Insert test span + span_data = { + "Timestamp": datetime.now(timezone.utc), + "TraceId": test_trace_id, + "SpanId": test_span_id, + "ParentSpanId": "", + "TraceState": "", + "SpanName": "test_span", + "SpanKind": "SPAN_KIND_INTERNAL", + "ServiceName": "test_service", + "ResourceAttributes": {"agentops.project.id": project_id_str, "service.name": "test_service"}, + "ScopeName": "", + "ScopeVersion": "", + "SpanAttributes": {"operation": "test", "test": "value"}, + "Duration": 1000000, # 1ms in nanoseconds + "StatusCode": "STATUS_CODE_OK", + "StatusMessage": "", + "Events.Timestamp": [], + "Events.Name": [], + "Events.Attributes": [], + "Links.TraceId": [], + "Links.SpanId": [], + "Links.TraceState": [], + "Links.Attributes": [], + } + + await async_clickhouse_client.insert( + table="otel_traces", data=[list(span_data.values())], column_names=list(span_data.keys()) + ) + + yield span_data + + # Cleanup: delete the span data after the test + await async_clickhouse_client.command(f"DELETE FROM otel_traces WHERE SpanId = '{test_span_id}'") + + +@pytest.fixture +def valid_bearer_token(test_project_with_api_key): + """Generate a valid JWT bearer token for testing.""" + project = test_project_with_api_key + return generate_jwt(project) + + +class TestAuthenticationEndpoint: + """Tests for POST /public/v1/auth/access_token""" + + @pytest.mark.asyncio + async def test_get_access_token_success(self, async_app_client, test_project_with_api_key, test_api_key): + """Test successful API key to bearer token conversion.""" + response = await async_app_client.post("/public/v1/auth/access_token", json={"api_key": test_api_key}) + + assert response.status_code == 200 + data = response.json() + assert "bearer" in data + + @pytest.mark.asyncio + async def test_get_access_token_invalid_api_key(self, async_app_client): + """Test with invalid API key.""" + response = await async_app_client.post( + "/public/v1/auth/access_token", json={"api_key": "invalid-key-123"} + ) + + assert response.status_code == 400 + + @pytest.mark.asyncio + async def test_get_access_token_missing_api_key(self, async_app_client): + """Test with missing API key.""" + response = await async_app_client.post("/public/v1/auth/access_token", json={}) + + assert response.status_code == 422 + # this is an internal fastapi thing + + @pytest.mark.skip( + reason="Free plan blocking temporarily disabled - see BasePublicAPIView._verify_project_has_access" + ) + @pytest.mark.asyncio + async def test_get_access_token_free_plan_blocked( + self, async_app_client, test_free_project_with_api_key, test_free_api_key + ): + """Test that free plan projects are blocked from accessing the API.""" + response = await async_app_client.post( + "/public/v1/auth/access_token", json={"api_key": test_free_api_key} + ) + + assert response.status_code == 403 + assert "not available for free plan projects" in response.json()["detail"] + + +class TestProjectEndpoint: + """Tests for GET /public/v1/project""" + + @pytest.mark.asyncio + async def test_get_project_success(self, async_app_client, test_project_with_api_key, valid_bearer_token): + """Test successful project details retrieval.""" + project = test_project_with_api_key + token = valid_bearer_token + + response = await async_app_client.get( + "/public/v1/project", headers={"Authorization": f"Bearer {token}"} + ) + + assert response.status_code == 200 + data = response.json() + + assert data["id"] == str(project.id) + assert data["name"] == project.name + assert data["environment"] == project.environment + + @pytest.mark.asyncio + async def test_get_project_missing_auth_header(self, async_app_client): + """Test with missing Authorization header.""" + response = await async_app_client.get("/public/v1/project") + + assert response.status_code == 400 + assert "Missing or invalid Authorization header" in response.json()["detail"] + + @pytest.mark.asyncio + async def test_get_project_invalid_bearer_token(self, async_app_client): + """Test with invalid bearer token.""" + response = await async_app_client.get( + "/public/v1/project", headers={"Authorization": "Bearer invalid-token-123"} + ) + + assert response.status_code == 400 + + +class TestTraceEndpoints: + """Tests for trace-related endpoints""" + + @pytest.mark.asyncio + async def test_get_trace_success( + self, + async_app_client, + test_trace_data, + test_span_data, + valid_bearer_token, + test_trace_id, + async_clickhouse_client, + test_project_with_api_key, + ): + """Test successful trace retrieval.""" + token = valid_bearer_token + + response = await async_app_client.get( + f"/public/v1/traces/{test_trace_id}", headers={"Authorization": f"Bearer {token}"} + ) + + assert response.status_code == 200 + data = response.json() + + assert data["trace_id"] == test_trace_id + assert "spans" in data + assert "tags" in data + + @pytest.mark.asyncio + async def test_get_trace_metrics_success( + self, async_app_client, test_trace_data, valid_bearer_token, test_trace_id + ): + """Test successful trace metrics retrieval.""" + token = valid_bearer_token + + response = await async_app_client.get( + f"/public/v1/traces/{test_trace_id}/metrics", headers={"Authorization": f"Bearer {token}"} + ) + + assert response.status_code == 200 + data = response.json() + # Metrics response structure will depend on TraceMetricsResponse model + assert isinstance(data, dict) + + @pytest.mark.asyncio + async def test_get_trace_not_found(self, async_app_client, valid_bearer_token): + """Test trace not found.""" + token = valid_bearer_token + + response = await async_app_client.get( + "/public/v1/traces/nonexistent-trace-id", headers={"Authorization": f"Bearer {token}"} + ) + + assert response.status_code == 404 + assert "Trace not found" in response.json()["detail"] + + @pytest.mark.asyncio + async def test_get_trace_missing_trace_id(self, async_app_client, valid_bearer_token): + """Test with missing trace_id parameter.""" + token = valid_bearer_token + + response = await async_app_client.get( + "/public/v1/traces/", headers={"Authorization": f"Bearer {token}"} + ) + + assert response.status_code == 404 # Route not found + + +class TestSpanEndpoints: + """Tests for span-related endpoints""" + + @pytest.mark.asyncio + async def test_get_span_success(self, async_app_client, test_span_data, valid_bearer_token, test_span_id): + """Test successful span retrieval.""" + token = valid_bearer_token + + response = await async_app_client.get( + f"/public/v1/spans/{test_span_id}", headers={"Authorization": f"Bearer {token}"} + ) + + assert response.status_code == 200 + data = response.json() + + assert data["span_id"] == test_span_id + assert data["span_name"] == "test_span" + assert data["span_kind"] == "SPAN_KIND_INTERNAL" + assert "attributes" in data + + @pytest.mark.asyncio + async def test_get_span_metrics_success( + self, async_app_client, test_span_data, valid_bearer_token, test_span_id + ): + """Test successful span metrics retrieval.""" + token = valid_bearer_token + + response = await async_app_client.get( + f"/public/v1/spans/{test_span_id}/metrics", headers={"Authorization": f"Bearer {token}"} + ) + + assert response.status_code == 200 + data = response.json() + # Metrics response structure will depend on SpanMetricsResponse model + assert isinstance(data, dict) + + @pytest.mark.asyncio + async def test_get_span_not_found(self, async_app_client, valid_bearer_token): + """Test span not found.""" + token = valid_bearer_token + + response = await async_app_client.get( + "/public/v1/spans/nonexistent-span-id", headers={"Authorization": f"Bearer {token}"} + ) + + assert response.status_code == 404 + assert "Span not found" in response.json()["detail"] + + +class TestErrorCases: + """Tests for various error scenarios""" + + @pytest.mark.asyncio + async def test_malformed_bearer_token(self, async_app_client): + """Test with malformed Authorization header.""" + response = await async_app_client.get( + "/public/v1/project", headers={"Authorization": "NotBearer token123"} + ) + + assert response.status_code == 400 + assert "Missing or invalid Authorization header" in response.json()["detail"] + + @pytest.mark.asyncio + async def test_expired_bearer_token(self, async_app_client): + """Test with expired JWT token.""" + # Create an expired token (with past exp claim) + import time + + expired_payload = { + "project_id": "test-project-id", + "is_premium": True, + "exp": int(time.time()) - 3600, # Expired 1 hour ago + } + expired_token = jwt.encode(expired_payload, JWT_SECRET_KEY, algorithm=JWT_ALGO) + + response = await async_app_client.get( + "/public/v1/project", headers={"Authorization": f"Bearer {expired_token}"} + ) + + assert response.status_code == 400 diff --git a/app/api/tests/smoke.py b/app/api/tests/smoke.py new file mode 100644 index 000000000..694862c90 --- /dev/null +++ b/app/api/tests/smoke.py @@ -0,0 +1,80 @@ +import agentops +import pytest +from agentops import Session +from datetime import datetime +import requests + + +@pytest.fixture +def agentops_init(): + agentops.init() + + +@pytest.fixture +def agentops_session(agentops_init): + """Create an agentops session""" + session = agentops.start_session() + + assert session, "Failed agentops.start_session() returned None." + yield session + agentops.end_all_sessions() + + +def test_logs_read_write_to_session(agentops_session: Session): + """ + Subsequently tests `/v3/logs/{session_id}` endpoint for PUT -> GET. + """ + session_id = str(agentops_session.session_id) + api_base = "http://localhost:8000" # Or get from environment variable + + # Test writing to session + test_data = { + "stdout_line_count": 5, + "stderr_line_count": 1, + "log_level_counts": {"INFO": 3, "WARNING": 2}, + "start_time": datetime.now().isoformat(), + "end_time": datetime.now().isoformat(), + "is_capturing": False, + "logs": [ + {"level": "INFO", "message": "Test write log 1"}, + {"level": "WARNING", "message": "Test warning 1"}, + {"level": "INFO", "message": "Test write log 2"}, + ], + } + + # Write logs using real HTTP request + response = requests.put( + f"{api_base}/v3/logs/{session_id}", + json=test_data, + headers={"Authorization": f"Bearer {agentops_session.jwt}"}, + ) + + assert response.status_code == 200 + write_response = response.json() + assert write_response["status"] == "success" + assert write_response["session_id"] == session_id + assert "url" in write_response + assert "filename" in write_response + + # Read logs back using real HTTP request + response = requests.get( + f"{api_base}/v3/logs/{session_id}", + headers={"Authorization": f"Bearer {agentops_session.jwt}"}, + ) + + assert response.status_code == 200 + read_response = response.json() + assert read_response["session_id"] == session_id + assert "logs" in read_response + assert len(read_response["logs"]) > 0 + + # Verify the log file we just wrote is in the response + found_file = False + for log_file in read_response["logs"]: + if log_file["name"] == write_response["filename"]: + found_file = True + assert "url" in log_file + assert "created_at" in log_file + break + + assert found_file, "Could not find the written log file in the GET response" diff --git a/app/api/tests/test_duration_calculation.py b/app/api/tests/test_duration_calculation.py new file mode 100644 index 000000000..3fe31f9fc --- /dev/null +++ b/app/api/tests/test_duration_calculation.py @@ -0,0 +1,59 @@ +from agentops.api.models.traces import nanosecond_timedelta +import datetime +import os +import sys + +# Ensure the repo root (which contains the `agentops` package) is on the path +REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir)) +if REPO_ROOT not in sys.path: + sys.path.insert(0, REPO_ROOT) + + +def _wall_clock_ns(start: datetime.datetime, duration_ns: int) -> datetime.datetime: + """Helper to convert a start time + duration nanoseconds into an end datetime.""" + return start + nanosecond_timedelta(duration_ns) + + +def test_overlapping_spans_wall_clock_less_than_sum(): + """Two overlapping spans should yield wall-clock duration < sum(duration).""" + + root_start = datetime.datetime(2025, 7, 7, 1, 19, 4, 69444, tzinfo=datetime.timezone.utc) + child_start = root_start + datetime.timedelta(seconds=1) + + root_duration_ns = 30_000_000_000 # 30 s + child_duration_ns = 15_000_000_000 # 15 s (overlaps root) + + root_end = _wall_clock_ns(root_start, root_duration_ns) + child_end = _wall_clock_ns(child_start, child_duration_ns) + + expected_wall_clock_ns = int((max(root_end, child_end) - min(root_start, child_start)).total_seconds() * 1e9) + + # Ensure overlap made wall-clock less than naive sum + assert expected_wall_clock_ns == 30_000_000_000 # 30 s elapsed (root span duration) + assert expected_wall_clock_ns < (root_duration_ns + child_duration_ns) + + +def test_non_overlapping_spans_wall_clock_equals_sum(): + """If spans do not overlap the wall-clock duration equals the sum.""" + + first_start = datetime.datetime(2025, 7, 7, 10, 0, 0, tzinfo=datetime.timezone.utc) + first_dur_ns = 10_000_000_000 # 10 s + first_end = _wall_clock_ns(first_start, first_dur_ns) + + second_start = first_end # starts immediately after first ends + second_dur_ns = 5_000_000_000 # 5 s + second_end = _wall_clock_ns(second_start, second_dur_ns) + + wall_clock_ns = int((second_end - first_start).total_seconds() * 1e9) + assert wall_clock_ns == first_dur_ns + second_dur_ns == 15_000_000_000 + + +def test_single_span_wall_clock_equals_itself(): + """Single span should report its own duration.""" + + start = datetime.datetime(2025, 7, 7, 12, 0, 0, tzinfo=datetime.timezone.utc) + dur_ns = 8_500_000_000 # 8.5 s + end = _wall_clock_ns(start, dur_ns) + + wall_clock_ns = int((end - start).total_seconds() * 1e9) + assert wall_clock_ns == dur_ns diff --git a/app/api/tests/test_sentry_sanitizer.py b/app/api/tests/test_sentry_sanitizer.py new file mode 100644 index 000000000..0eb0a2330 --- /dev/null +++ b/app/api/tests/test_sentry_sanitizer.py @@ -0,0 +1,95 @@ +""" +Tests for the Sentry event sanitizer +""" + +from agentops.common.sentry import sanitize_event, SENSITIVE_DATA_PLACEHOLDER + + +def test_sanitize_event_without_exception(): + """Test that events without exceptions are returned unchanged""" + mock_event = {"message": "Test event without exception"} + result = sanitize_event(mock_event, {}) + + assert result == mock_event + assert result is mock_event + + +def test_sanitize_event_empty_vars(): + """Test that events with empty vars are handled correctly""" + mock_event = {"exception": {"values": [{"stacktrace": {"frames": [{"vars": {}}]}}]}} + + result = sanitize_event(mock_event, {}) + assert result["exception"]["values"][0]["stacktrace"]["frames"][0]["vars"] == {} + + +def test_comprehensive_sanitization(): + """Comprehensive test for sanitizing passwords in various locations""" + mock_event = { + "exception": { + "values": [ + { + "stacktrace": { + "frames": [ + { + "vars": { + # Root level password + "password": "super_secret", + # Non-sensitive data that should be preserved + "normal_var": "keep this", + # Nested dictionary with password + "user_config": { + "username": "testuser", + "password": "123password456", + "settings": {"password": "nested_deeper_pw"}, + }, + # Array of primitives (should be untouched) + "simple_array": [1, 2, 3, "string", True, None], + # Array with dictionary containing password + "users": [{"name": "user1", "password": "user1_password"}], + # Complex nested structure + "complex_data": [ + { + "name": "keep_this", + "items": [ + {"id": 1, "password": "level3_pw_1"}, + {"id": 2, "password": "level3_pw_2"}, + ], + } + ], + } + } + ] + } + } + ] + } + } + + result = sanitize_event(mock_event, {}) + + # Get the variables dict for easier access + frame_vars = result["exception"]["values"][0]["stacktrace"]["frames"][0]["vars"] + + # Test root level password sanitization + assert frame_vars["password"] == SENSITIVE_DATA_PLACEHOLDER + assert frame_vars["normal_var"] == "keep this" + + # Test nested dictionary sanitization + assert frame_vars["user_config"]["username"] == "testuser" + assert frame_vars["user_config"]["password"] == SENSITIVE_DATA_PLACEHOLDER + assert frame_vars["user_config"]["settings"]["password"] == SENSITIVE_DATA_PLACEHOLDER + + # Test array of primitives (should be untouched) + assert frame_vars["simple_array"] == [1, 2, 3, "string", True, None] + + # Test array with dictionary containing password + assert frame_vars["users"][0]["name"] == "user1" + assert frame_vars["users"][0]["password"] == SENSITIVE_DATA_PLACEHOLDER + + # Test complex nested structure + complex_data = frame_vars["complex_data"][0] + assert complex_data["name"] == "keep_this" + assert complex_data["items"][0]["id"] == 1 + assert complex_data["items"][0]["password"] == SENSITIVE_DATA_PLACEHOLDER + assert complex_data["items"][1]["id"] == 2 + assert complex_data["items"][1]["password"] == SENSITIVE_DATA_PLACEHOLDER diff --git a/app/api/tests/v3/test_jwt_auth.py b/app/api/tests/v3/test_jwt_auth.py new file mode 100644 index 000000000..e450107b3 --- /dev/null +++ b/app/api/tests/v3/test_jwt_auth.py @@ -0,0 +1,130 @@ +from datetime import datetime, timedelta +from unittest.mock import patch, MagicMock + +import jwt +import pytest +from fastapi.testclient import TestClient + +from agentops.api.app import app +from agentops.api.auth import JWTPayload, JWT_ALGO +from agentops.api.environment import JWT_SECRET_KEY + + +@pytest.fixture +def test_client(): + """Test API [FastAPI] Client""" + return TestClient(app) + + +@pytest.fixture +def jwt_secret(): + """Get the JWT secret from environment variables""" + return JWT_SECRET_KEY + + +@pytest.fixture +def valid_jwt_payload(): + """Create a valid JWT payload for testing""" + return JWTPayload( + exp=(datetime.now() + timedelta(hours=1)).timestamp(), + aud="authenticated", + project_id="test-project-id", + project_prem_status="premium", + api_key="test-api-key", + ) + + +@pytest.fixture +def expired_jwt_payload(): + """Create an expired JWT payload for testing""" + return JWTPayload( + exp=(datetime.now() - timedelta(hours=1)).timestamp(), + aud="authenticated", + project_id="test-project-id", + project_prem_status="premium", + api_key="test-api-key", + ) + + +@pytest.fixture +def valid_jwt(valid_jwt_payload, jwt_secret): + """Create a valid JWT token for testing""" + return jwt.encode(valid_jwt_payload.asdict(), jwt_secret, algorithm=JWT_ALGO) + + +@pytest.fixture +def expired_jwt(expired_jwt_payload, jwt_secret): + """Create an expired JWT token for testing""" + return jwt.encode(expired_jwt_payload.asdict(), jwt_secret, algorithm=JWT_ALGO) + + +def test_jwt_info_endpoint_with_valid_token(test_client, valid_jwt, valid_jwt_payload): + """Test that the JWT info endpoint works with a valid token""" + headers = {"Authorization": f"Bearer {valid_jwt}"} + + # Mock the verify_jwt function to avoid database lookup + with patch('agentops.api.auth.verify_jwt', return_value=valid_jwt_payload): + # Also mock the ProjectModel.get_by_id to avoid database lookup + with patch('agentops.opsboard.models.ProjectModel.get_by_id') as mock_get: + # Create a mock project that matches the JWT payload + mock_project = MagicMock() + mock_project.org.prem_status.value = valid_jwt_payload.project_prem_status + mock_get.return_value = mock_project + + response = test_client.get("/v3/auth/token", headers=headers) + + assert response.status_code == 200 + assert response.json()["message"] == "JWT token is valid" + assert "payload" in response.json() + assert "expires_at" in response.json() + + # Check that the payload contains the expected fields + payload = response.json()["payload"] + assert payload["project_id"] == "test-project-id" + assert payload["project_prem_status"] == "premium" + assert payload["aud"] == "authenticated" + assert "exp" in payload + assert "api_key" in payload + + +def test_jwt_info_endpoint_with_expired_token(test_client, expired_jwt): + """Test that the JWT info endpoint returns 401 with an expired token""" + headers = {"Authorization": f"Bearer {expired_jwt}"} + + # We want the real verify_jwt function to be called to test expiration + response = test_client.get("/v3/auth/token", headers=headers) + assert response.status_code == 401 + assert "Token has expired" in response.json()["detail"] + + +def test_jwt_info_endpoint_without_token(test_client): + """Test that the JWT info endpoint returns 401 without a token""" + response = test_client.get("/v3/auth/token") + assert response.status_code == 401 + assert "Authorization header missing" in response.json()["detail"] + + +def test_jwt_info_endpoint_with_invalid_token(test_client): + """Test that the JWT info endpoint returns 401 with an invalid token""" + headers = {"Authorization": "Bearer invalid.token.here"} + response = test_client.get("/v3/auth/token", headers=headers) + assert response.status_code == 401 + assert "Invalid token" in response.json()["detail"] + + +def test_jwt_info_endpoint_plan_changed(test_client, valid_jwt, valid_jwt_payload): + """Test when project plan has changed since token was issued""" + headers = {"Authorization": f"Bearer {valid_jwt}"} + + # Mock the verify_jwt function to return our payload + with patch('agentops.api.auth.verify_jwt', return_value=valid_jwt_payload): + # Mock ProjectModel.get_by_id to return a project with a different plan + with patch('agentops.opsboard.models.ProjectModel.get_by_id') as mock_get: + mock_project = MagicMock() + mock_project.org.prem_status.value = "free" # Different from token's "premium" + mock_get.return_value = mock_project + + response = test_client.get("/v3/auth/token", headers=headers) + + assert response.status_code == 401 + assert "Reauthorized to use new plan" in response.json()["detail"] diff --git a/app/api/tests/v3/test_jwt_generation.py b/app/api/tests/v3/test_jwt_generation.py new file mode 100644 index 000000000..c61dcc1bf --- /dev/null +++ b/app/api/tests/v3/test_jwt_generation.py @@ -0,0 +1,72 @@ +from unittest.mock import patch, MagicMock +from uuid import UUID + +import pytest + +from agentops.opsboard.models import ProjectModel + + +@pytest.mark.asyncio +async def test_get_token_valid_api_key(async_app_client): + """Test getting a JWT token with a valid API key""" + # Mock a project for the test + mock_project = MagicMock() + mock_project.id = "test-project-id" + mock_project.api_key = UUID("11111111-1111-1111-1111-111111111111") + mock_project.org.prem_status.value = "premium" + + # Mock the ProjectModel.get_by_api_key method + with patch.object(ProjectModel, 'get_by_api_key', return_value=mock_project): + # Mock the generate_jwt function to return a predictable token + with patch('agentops.api.routes.v3.generate_jwt', return_value="test.jwt.token"): + response = await async_app_client.post( + "/v3/auth/token", + json={"api_key": "11111111-1111-1111-1111-111111111111"} + ) + + assert response.status_code == 200 + data = response.json() + assert "token" in data + assert data["token"] == "test.jwt.token" + assert data["project_id"] == "test-project-id" + assert data["project_prem_status"] == "premium" + + +@pytest.mark.asyncio +async def test_get_token_invalid_api_key_format(async_app_client): + """Test getting a JWT token with an invalid API key format""" + response = await async_app_client.post( + "/v3/auth/token", + json={"api_key": "not-a-uuid"} + ) + + assert response.status_code == 400 + assert "Invalid API key format" in response.json()["error"] + + +@pytest.mark.asyncio +async def test_get_token_nonexistent_api_key(async_app_client): + """Test getting a JWT token with a nonexistent API key""" + # Mock the ProjectModel.get_by_api_key method to return None + with patch.object(ProjectModel, 'get_by_api_key', return_value=None): + response = await async_app_client.post( + "/v3/auth/token", + json={"api_key": "11111111-1111-1111-1111-111111111111"} + ) + + assert response.status_code == 403 + assert "Invalid API key" in response.json()["error"] + + +@pytest.mark.asyncio +async def test_get_token_server_error(async_app_client): + """Test handling of server errors in token generation""" + # Mock the ProjectModel.get_by_api_key method to raise an exception + with patch.object(ProjectModel, 'get_by_api_key', side_effect=Exception("Database error")): + response = await async_app_client.post( + "/v3/auth/token", + json={"api_key": "11111111-1111-1111-1111-111111111111"} + ) + + assert response.status_code == 500 + assert "Authentication failed" in response.json()["error"] \ No newline at end of file diff --git a/app/api/tests/v3/test_jwt_payload.py b/app/api/tests/v3/test_jwt_payload.py new file mode 100644 index 000000000..4bba6da52 --- /dev/null +++ b/app/api/tests/v3/test_jwt_payload.py @@ -0,0 +1,44 @@ +import pytest + + +@pytest.mark.asyncio +async def test_get_jwt_and_verify(async_app_client, test_project): + """Test the complete end-to-end flow: get token, use token, verify payload""" + + api_key, project_id = str(test_project.api_key), str(test_project.id) + + auth_response = await async_app_client.post("/v3/auth/token", json={"api_key": api_key}) + assert auth_response.status_code == 200 + token = auth_response.json()["token"] + + headers = {"Authorization": f"Bearer {token}"} + info_response = await async_app_client.get("/v3/auth/token", headers=headers) + + assert info_response.status_code == 200 + payload = info_response.json()["payload"] + assert "project_id" in payload + assert "api_key" in payload + assert payload["project_id"] == project_id + assert payload["api_key"] == api_key + + +async def test_get_jwt_placeholder_api_key(async_app_client): + """Test the get token endpoint with a placeholder API key""" + + auth_response = await async_app_client.post( + "/v3/auth/token", json={"api_key": "INSERT-YOUR-API-KEY-HERE"} + ) + + assert auth_response.status_code == 400 + assert 'error' in auth_response.json() + + +async def test_get_jwt_non_existent_api_key(async_app_client): + """Test the get token endpoint with a non-existent API key""" + + auth_response = await async_app_client.post( + "/v3/auth/token", json={"api_key": "ffffffff-0000-0000-0000-000000000000"} + ) + + assert auth_response.status_code == 403 + assert 'error' in auth_response.json() diff --git a/app/api/tests/v4/test_logs.py b/app/api/tests/v4/test_logs.py new file mode 100644 index 000000000..4b9ecc335 --- /dev/null +++ b/app/api/tests/v4/test_logs.py @@ -0,0 +1,341 @@ +""" +Tests for v4 logs API endpoints including LogsUploadView and get_trace_logs. +""" + +import pytest +from io import BytesIO +from unittest.mock import patch, MagicMock, AsyncMock +from fastapi import HTTPException, status, Request + +from agentops.api.routes.v4.logs import LogsUploadView, get_trace_logs, convert_trace_id +from agentops.api.storage import ObjectUploadResponse +from agentops.api.environment import SUPABASE_URL, SUPABASE_S3_LOGS_BUCKET + + +@pytest.fixture +def mock_jwt_payload(): + """Mock JWT payload for testing""" + return { + 'project_id': 'test-project-123', + 'project_prem_status': 'premium', + 'api_key': 'test-api-key', + 'aud': 'authenticated', + 'exp': 1234567890, + } + + +@pytest.fixture +def mock_s3_client(): + """Mock S3 client for testing""" + client = MagicMock() + client.upload_fileobj = MagicMock() + client.get_object = MagicMock() + client.exceptions.NoSuchKey = Exception + return client + + +@pytest.fixture +def mock_request(): + """Mock FastAPI Request for testing""" + request = MagicMock(spec=Request) + + # Create a proper async iterator for the stream method + async def async_stream_generator(chunks): + for chunk in chunks: + yield chunk + + # Default stream that will be overridden in individual tests + request.stream = AsyncMock(return_value=async_stream_generator([])) + + # Add required headers for public route validation + request.headers = { + "x-forwarded-for": "192.168.0.1", + "x-forwarded-host": "api.agentops.ai", + "origin": "https://app.agentops.ai", + "referer": "https://app.agentops.ai/signin", + "user-agent": "Mozilla/5.0 Chrome/91.0.4472.124", + } + return request + + +class TestLogsUploadView: + """Tests for the LogsUploadView class""" + + def test_bucket_name_configuration(self, mock_request): + """Test that LogsUploadView has correct bucket configuration""" + view = LogsUploadView(mock_request) + assert view.bucket_name == SUPABASE_S3_LOGS_BUCKET + + @pytest.mark.asyncio + async def test_successful_log_upload(self, mock_jwt_payload, mock_s3_client, mock_request): + """Test successful log file upload with trace ID""" + view = LogsUploadView(mock_request) + + # Set trace ID header (merge with existing headers) + trace_id = "test-trace-12345" + mock_request.headers.update({"Trace-Id": trace_id}) + + # Mock request stream + test_content = b'[INFO] Test log content\n[ERROR] Test error message' + + async def async_stream_generator(): + for chunk in [test_content]: + yield chunk + + mock_request.stream = lambda: async_stream_generator() + + with ( + patch('agentops.api.storage.get_s3_client', return_value=mock_s3_client), + patch('agentops.auth.views.API_URL', 'http://localhost:8000'), + ): # Bypass validation + response = await view(token=mock_jwt_payload) + + assert isinstance(response, ObjectUploadResponse) + assert response.size == len(test_content) + expected_url = f"{SUPABASE_URL}/storage/v1/object/public/{SUPABASE_S3_LOGS_BUCKET}/{trace_id}.log" + assert response.url == expected_url + + # Verify S3 upload was called with correct parameters + mock_s3_client.upload_fileobj.assert_called_once() + args = mock_s3_client.upload_fileobj.call_args[0] + assert isinstance(args[0], BytesIO) + assert args[1] == SUPABASE_S3_LOGS_BUCKET + assert args[2] == f"{trace_id}.log" + + def test_missing_trace_id(self, mock_jwt_payload, mock_request): + """Test that missing trace ID raises appropriate error""" + view = LogsUploadView(mock_request) + view.token = mock_jwt_payload + + # Remove Trace-Id header while keeping others + mock_request.headers = {k: v for k, v in mock_request.headers.items() if k != "Trace-Id"} + + with pytest.raises(HTTPException) as exc_info: + _ = view.filename + + assert exc_info.value.status_code == status.HTTP_400_BAD_REQUEST + assert "No trace ID provided" in exc_info.value.detail + + def test_invalid_trace_id_characters(self, mock_jwt_payload, mock_request): + """Test that invalid characters in trace ID are rejected""" + view = LogsUploadView(mock_request) + view.token = mock_jwt_payload + + # Trace ID with invalid characters + invalid_trace_ids = ["trace@123", "trace#456", "trace 789", "trace/abc", "trace\\def"] + + for invalid_id in invalid_trace_ids: + mock_request.headers.update({"Trace-Id": invalid_id}) + + with pytest.raises(HTTPException) as exc_info: + _ = view.filename + + assert exc_info.value.status_code == status.HTTP_400_BAD_REQUEST + assert "Trace ID contains invalid characters" in exc_info.value.detail + + def test_valid_trace_id_characters(self, mock_jwt_payload, mock_request): + """Test that valid trace IDs are accepted""" + view = LogsUploadView(mock_request) + view.token = mock_jwt_payload + + valid_trace_ids = [ + "trace123", + "trace-456", + "trace_789", + "trace.abc", + "trace-123_456.def", + "TRACE-UPPER-123", + ] + + for valid_id in valid_trace_ids: + mock_request.headers.update({"Trace-Id": valid_id}) + assert view.filename == f"{valid_id}.log" + + @pytest.mark.asyncio + async def test_file_size_limit_enforcement(self, mock_jwt_payload, mock_request): + """Test that file size limits are enforced for log uploads""" + view = LogsUploadView(mock_request) + view.max_size = 100 # Set small limit for testing + + mock_request.headers.update({"Trace-Id": "test-trace"}) + + # Mock request stream with oversized content + large_content = b'x' * 150 # Exceeds 100 byte limit + + async def async_stream_generator(): + for chunk in [large_content]: + yield chunk + + mock_request.stream = lambda: async_stream_generator() + + with patch('agentops.auth.views.API_URL', 'http://localhost:8000'): # Bypass validation + with pytest.raises(HTTPException) as exc_info: + await view(token=mock_jwt_payload) + + assert exc_info.value.status_code == status.HTTP_413_REQUEST_ENTITY_TOO_LARGE + assert "File size exceeds the maximum limit" in exc_info.value.detail + + +class TestGetTraceLogs: + """Tests for the get_trace_logs endpoint""" + + def test_convert_trace_id_hex_to_int(self): + """Test conversion of hex trace IDs to integers""" + # Hex strings should be converted + assert convert_trace_id("1a2b3c") == str(int("1a2b3c", 16)) + assert convert_trace_id("ABCDEF") == str(int("ABCDEF", 16)) + assert convert_trace_id("123abc") == str(int("123abc", 16)) + + # Pure numeric strings should remain unchanged + assert convert_trace_id("123456") == "123456" + + # Invalid hex should remain unchanged + assert convert_trace_id("invalid") == "invalid" + assert convert_trace_id("123xyz") == "123xyz" + + def test_convert_trace_id_edge_cases(self): + """Test edge cases for trace ID conversion""" + # Empty string + assert convert_trace_id("") == "" + + # Mixed case hex + assert convert_trace_id("1A2b3C") == str(int("1A2b3C", 16)) + + # Long hex string + long_hex = "abcdef1234567890" + assert convert_trace_id(long_hex) == str(int(long_hex, 16)) + + @pytest.mark.asyncio + async def test_get_trace_logs_successful_retrieval(self, mock_s3_client): + """Test successful log retrieval for valid trace""" + trace_id = "test-trace-123" + log_content = "INFO: Test log entry\nERROR: Test error" + + # Mock S3 response + mock_response = {'Body': MagicMock()} + mock_response['Body'].read.return_value = log_content.encode('utf-8') + mock_s3_client.get_object.return_value = mock_response + + # Mock request with session + mock_request = MagicMock() + mock_request.state.session.user_id = "user-123" + + # Mock ORM session + mock_orm = MagicMock() + + # Mock trace model + with ( + patch('agentops.api.routes.v4.logs.TraceModel') as mock_trace_model, + patch('agentops.api.routes.v4.logs.ProjectModel') as mock_project_model, + patch('agentops.api.routes.v4.logs.get_s3_client', return_value=mock_s3_client), + ): + # Setup trace mock with AsyncMock + mock_trace = MagicMock() + mock_trace.spans = ["span1", "span2"] # Non-empty spans + mock_trace.project_id = "project-123" + mock_trace_model.select = AsyncMock(return_value=mock_trace) + + # Setup project mock + mock_project = MagicMock() + mock_project.is_freeplan = False + mock_project.org.is_user_member.return_value = True + mock_project_model.get_by_id.return_value = mock_project + + response = await get_trace_logs(request=mock_request, orm=mock_orm, trace_id=trace_id) + + # Function is decorated with @add_cors_headers which wraps it in JSONResponse + assert hasattr(response, 'body') + # Extract the JSON data from the response + import json + response_data = json.loads(response.body.decode()) + assert response_data['content'] == log_content + assert response_data['trace_id'] == trace_id + assert not response_data['freeplan_truncated'] + + # Verify S3 was called with converted trace ID + mock_s3_client.get_object.assert_called_once_with( + Bucket=SUPABASE_S3_LOGS_BUCKET, Key=f"{trace_id}.log" + ) + + @pytest.mark.asyncio + async def test_get_trace_logs_nonexistent_trace(self): + """Test error when trace doesn't exist""" + trace_id = "nonexistent-trace" + + mock_request = MagicMock() + mock_orm = MagicMock() + + with patch('agentops.api.routes.v4.logs.TraceModel') as mock_trace_model: + # Mock empty trace (no spans) + mock_trace = MagicMock() + mock_trace.spans = [] # Empty spans indicate no trace + mock_trace_model.select = AsyncMock(return_value=mock_trace) + + with pytest.raises(HTTPException) as exc_info: + await get_trace_logs(request=mock_request, orm=mock_orm, trace_id=trace_id) + + assert exc_info.value.status_code == status.HTTP_403_FORBIDDEN + assert "You do not have access to this trace" in exc_info.value.detail + + @pytest.mark.asyncio + async def test_get_trace_logs_no_permission(self): + """Test error when user doesn't have access to trace""" + trace_id = "restricted-trace" + + mock_request = MagicMock() + mock_request.state.session.user_id = "user-123" + mock_orm = MagicMock() + + with ( + patch('agentops.api.routes.v4.logs.TraceModel') as mock_trace_model, + patch('agentops.api.routes.v4.logs.ProjectModel') as mock_project_model, + ): + # Setup trace mock + mock_trace = MagicMock() + mock_trace.spans = ["span1"] # Non-empty spans + mock_trace.project_id = "project-123" + mock_trace_model.select = AsyncMock(return_value=mock_trace) + + # Setup project mock - user is not a member + mock_project = MagicMock() + mock_project.org.is_user_member.return_value = False + mock_project_model.get_by_id.return_value = mock_project + + with pytest.raises(HTTPException) as exc_info: + await get_trace_logs(request=mock_request, orm=mock_orm, trace_id=trace_id) + + assert exc_info.value.status_code == status.HTTP_403_FORBIDDEN + assert "You do not have access to this trace" in exc_info.value.detail + + @pytest.mark.asyncio + async def test_get_trace_logs_s3_file_not_found(self, mock_s3_client): + """Test error when log file doesn't exist in S3""" + trace_id = "trace-without-logs" + + # Mock S3 to raise NoSuchKey exception + mock_s3_client.get_object.side_effect = mock_s3_client.exceptions.NoSuchKey() + + mock_request = MagicMock() + mock_request.state.session.user_id = "user-123" + mock_orm = MagicMock() + + with ( + patch('agentops.api.routes.v4.logs.TraceModel') as mock_trace_model, + patch('agentops.api.routes.v4.logs.ProjectModel') as mock_project_model, + patch('agentops.api.routes.v4.logs.get_s3_client', return_value=mock_s3_client), + ): + # Setup valid trace and project + mock_trace = MagicMock() + mock_trace.spans = ["span1"] + mock_trace.project_id = "project-123" + mock_trace_model.select = AsyncMock(return_value=mock_trace) + + mock_project = MagicMock() + mock_project.org.is_user_member.return_value = True + mock_project_model.get_by_id.return_value = mock_project + + with pytest.raises(HTTPException) as exc_info: + await get_trace_logs(request=mock_request, orm=mock_orm, trace_id=trace_id) + + assert exc_info.value.status_code == status.HTTP_404_NOT_FOUND + assert f"No logs found for trace ID: {trace_id}" in exc_info.value.detail \ No newline at end of file diff --git a/app/api/tests/v4/test_meterics_duoroute.py b/app/api/tests/v4/test_meterics_duoroute.py new file mode 100644 index 000000000..9c0c1532f --- /dev/null +++ b/app/api/tests/v4/test_meterics_duoroute.py @@ -0,0 +1,137 @@ +from datetime import datetime +from unittest.mock import MagicMock, patch, AsyncMock + +import pytest + + +""" +"this is a feature not a bug" LMAO +""" + + +# FIXME: Remove test skip after https://github.com/AgentOps-AI/AgentOps.Next/issues/820 +pytestmark = [pytest.mark.skip] + + +@pytest.mark.asyncio +async def test_metrics_dual_endpoints(async_test_client, valid_jwt): + """ + Test that both /metrics and /meterics endpoints return the same response. + This verifies our dual endpoint feature works correctly. + + Note: This test just verifies that both endpoints exist and return the same response. + It's not testing the actual metrics functionality, just the routing. + """ + # Mock token verification + with patch('agentops.api.auth.get_jwt_token', return_value={'project_id': 'test-project'}): + # Test the /metrics endpoint + metrics_response = await async_test_client.get( + "/v4/metrics/test", headers={"Authorization": f"Bearer {valid_jwt}"} + ) + + # Test the /meterics endpoint + meterics_response = await async_test_client.get( + "/v4/meterics/test", headers={"Authorization": f"Bearer {valid_jwt}"} + ) + + # Verify both endpoints return the same status code + assert metrics_response.status_code == meterics_response.status_code + + # Verify both endpoints return the same response + assert metrics_response.json() == meterics_response.json() + + # Verify the response content + assert metrics_response.json() == {"message": "Test endpoint working"} + + +@pytest.mark.asyncio +async def test_metrics_other_endpoints_dual_behavior(async_test_client, valid_jwt): + """ + Test that other metrics endpoints like /trace/{trace_id} are also + accessible via both /metrics and /meterics paths. + + This test mocks the database calls to isolate the routing functionality. + """ + # Mock data + trace_id = "1234567890abcdef" + # Create proper datetime objects for the timestamps + start_time = datetime(2023, 1, 1, 0, 0, 0) + end_time = datetime(2023, 1, 1, 0, 0, 1) + + mock_data = [ + { + "SpanId": "span1", + "TraceId": trace_id, + "SpanName": "test-span", + "ServiceName": "test-service", + "Duration": 100000000, # duration in nanoseconds + "SpanAttributes": { + "gen_ai.usage.prompt_tokens": 10, + "gen_ai.usage.completion_tokens": 20, + "gen_ai.usage.total_tokens": 30, + "gen_ai.request.model": "test-model", + "gen_ai.system": "test-system", + }, + "ResourceAttributes": {"agentops.project.id": "test-project"}, + "StartTime": start_time, # Use datetime object instead of string + "EndTime": end_time, # Use datetime object instead of string + } + ] + + # Create a completely mocked response for the async clickhouse client + mock_result = MagicMock() + mock_result.named_results.return_value = mock_data + + # Set up AsyncMock for query method + mock_query = AsyncMock(return_value=mock_result) + + # Create patches for token and query building + token_patch = patch('agentops.api.auth.get_jwt_token', return_value={'project_id': 'test-project'}) + query_patch = patch( + 'agentops.api.routes.v4.metrics.queries.build_span_metrics_query', + return_value=("SELECT mock_query", {"trace_id": trace_id}), + ) + + # Patch the token_metrics and duration_metrics calculation functions + token_metrics_patch = patch( + 'agentops.api.routes.v4.metrics.utils.calculate_token_metrics', + return_value={"token_usage": 100, "model_usage": {}, "system_usage": {}}, + ) + duration_metrics_patch = patch( + 'agentops.api.routes.v4.metrics.utils.calculate_duration_metrics', + return_value={ + "start_time": start_time.isoformat(), + "end_time": end_time.isoformat(), + "total_duration_ns": 100000000, + }, + ) + + # This is the critical part - directly patch the clickhouse query method in the route + query_method_patch = patch('clickhouse_connect.driver.asyncclient.AsyncClient.query', mock_query) + + with token_patch, query_patch, query_method_patch, token_metrics_patch, duration_metrics_patch: + # Test the /metrics/trace/{trace_id} endpoint + metrics_response = await async_test_client.get( + f"/v4/metrics/trace/{trace_id}", headers={"Authorization": f"Bearer {valid_jwt}"} + ) + + # Test the /meterics/trace/{trace_id} endpoint + meterics_response = await async_test_client.get( + f"/v4/meterics/trace/{trace_id}", headers={"Authorization": f"Bearer {valid_jwt}"} + ) + + # Verify both endpoints return the same status code + assert metrics_response.status_code == meterics_response.status_code + + # Both endpoints should return the same response + assert metrics_response.json() == meterics_response.json() + + # Verify the mock was called + assert ( + mock_query.call_count >= 2 + ), "The ClickHouse query method should be called at least twice (once for each endpoint)" + + # If the status is 404, ensure that both endpoints return the same error message + if metrics_response.status_code == 404: + assert "not_found" in metrics_response.json()["detail"]["error"] + assert trace_id in metrics_response.json()["detail"]["message"] diff --git a/app/api/tests/v4/test_objects.py b/app/api/tests/v4/test_objects.py new file mode 100644 index 000000000..a4a57d123 --- /dev/null +++ b/app/api/tests/v4/test_objects.py @@ -0,0 +1,153 @@ +""" +Tests for v4 objects API endpoints including ObjectUploadView. +""" + +import pytest +from io import BytesIO +from unittest.mock import patch, MagicMock, AsyncMock +from fastapi import Request + +from agentops.api.routes.v4.objects import ObjectUploadView +from agentops.api.storage import ObjectUploadResponse +from agentops.api.environment import SUPABASE_S3_BUCKET + + +@pytest.fixture +def mock_jwt_payload(): + """Mock JWT payload for testing""" + return { + 'project_id': 'test-project-123', + 'project_prem_status': 'premium', + 'api_key': 'test-api-key', + 'aud': 'authenticated', + 'exp': 1234567890, + } + + +@pytest.fixture +def mock_s3_client(): + """Mock S3 client for testing""" + client = MagicMock() + client.upload_fileobj = MagicMock() + return client + + +@pytest.fixture +def mock_request(): + """Mock FastAPI Request for testing""" + request = MagicMock(spec=Request) + + # Create a proper async iterator for the stream method + async def async_stream_generator(chunks): + for chunk in chunks: + yield chunk + + # Default stream that will be overridden in individual tests + request.stream = AsyncMock(return_value=async_stream_generator([])) + + # Add required headers for public route validation + request.headers = { + "x-forwarded-for": "192.168.0.1", + "x-forwarded-host": "api.agentops.ai", + "origin": "https://app.agentops.ai", + "referer": "https://app.agentops.ai/signin", + "user-agent": "Mozilla/5.0 Chrome/91.0.4472.124", + } + return request + + +class TestObjectUploadView: + """Tests for the ObjectUploadView class""" + + def test_bucket_name_configuration(self, mock_request): + """Test that ObjectUploadView has correct bucket configuration""" + view = ObjectUploadView(mock_request) + assert view.bucket_name == SUPABASE_S3_BUCKET + + @pytest.mark.asyncio + async def test_successful_object_upload(self, mock_jwt_payload, mock_s3_client, mock_request): + """Test successful object upload with generated filename""" + view = ObjectUploadView(mock_request) + + # Mock request stream + test_content = b'{"key": "value", "data": [1, 2, 3]}' + + async def async_stream_generator(): + for chunk in [test_content]: + yield chunk + + mock_request.stream = lambda: async_stream_generator() + + with ( + patch('agentops.api.storage.get_s3_client', return_value=mock_s3_client), + patch('agentops.auth.views.API_URL', 'http://localhost:8000'), + ): # Bypass validation + response = await view(token=mock_jwt_payload) + + assert isinstance(response, ObjectUploadResponse) + assert response.size == len(test_content) + + # Verify the URL contains the project ID and UUID format + assert f"/{SUPABASE_S3_BUCKET}/test-project-123/" in response.url + + # Verify S3 upload was called + mock_s3_client.upload_fileobj.assert_called_once() + args = mock_s3_client.upload_fileobj.call_args[0] + assert isinstance(args[0], BytesIO) + assert args[1] == SUPABASE_S3_BUCKET + + def test_filename_generation_uniqueness(self, mock_jwt_payload, mock_request): + """Test that filename generation includes project ID and UUID""" + view = ObjectUploadView(mock_request) + view.token = mock_jwt_payload + + filename = view.filename + + # Should start with project ID + assert filename.startswith("test-project-123/") + + # Should have UUID format after the slash + uuid_part = filename.split('/', 1)[1] + # UUID4 hex is 32 characters + assert len(uuid_part) == 32 + # Should be valid hex + assert all(c in '0123456789abcdef' for c in uuid_part) + + def test_filename_caching(self, mock_jwt_payload, mock_request): + """Test that filename is cached and doesn't change between calls""" + view = ObjectUploadView(mock_request) + view.token = mock_jwt_payload + + # First call + filename1 = view.filename + # Second call should return the same value + filename2 = view.filename + + assert filename1 == filename2 + + @pytest.mark.asyncio + async def test_chunked_object_upload(self, mock_jwt_payload, mock_s3_client, mock_request): + """Test that chunked uploads work correctly for objects""" + view = ObjectUploadView(mock_request) + + # Mock request stream with multiple chunks + chunks = [b'{"part1":', b'"data",', b'"part2":123}'] + + async def async_stream_generator(): + for chunk in chunks: + yield chunk + + mock_request.stream = lambda: async_stream_generator() + + with ( + patch('agentops.api.storage.get_s3_client', return_value=mock_s3_client), + patch('agentops.auth.views.API_URL', 'http://localhost:8000'), + ): # Bypass validation + response = await view(token=mock_jwt_payload) + + assert response.size == sum(len(chunk) for chunk in chunks) + + # Verify the complete content was uploaded + uploaded_content = mock_s3_client.upload_fileobj.call_args[0][0] + uploaded_content.seek(0) + assert uploaded_content.read() == b''.join(chunks) \ No newline at end of file diff --git a/app/api/tests/v4/test_schema.py b/app/api/tests/v4/test_schema.py new file mode 100644 index 000000000..459592835 --- /dev/null +++ b/app/api/tests/v4/test_schema.py @@ -0,0 +1,63 @@ +import pytest + + +EXPECTED_TABLES = [ + "otel_logs", + "otel_metrics", + "otel_metrics_exponential_histogram", + "otel_metrics_gauge", + "otel_metrics_histogram", + "otel_metrics_sum", + "otel_metrics_summary", + "otel_raw_traces", + "otel_raw_traces_trace_id_ts", + "otel_traces", + "otel_traces_0403251619", + "otel_traces_legacy", + "otel_traces_trace_id_ts", + "otel_traces_with_project", + "otel_traces_with_supabase_project_id", + "otel_raw_traces_trace_id_ts_mv", + "otel_traces_project_idx", + "otel_traces_trace_id_ts_mv", +] + + +@pytest.mark.asyncio +async def test_list_all_tables(clickhouse_client): + """Test that lists all available tables in the ClickHouse database.""" + query = f""" + SELECT + name + FROM + system.tables + WHERE + database = '{clickhouse_client.database}' AND NOT startsWith(name, '.inner_id') + ORDER BY + name + """ + + result = clickhouse_client.query(query) + tables = [row[0] for row in result.result_rows] + + assert sorted(tables) == sorted(EXPECTED_TABLES), "ClickHouse tables do not match expected list" + + +@pytest.mark.asyncio +async def test_list_all_tables_async(async_clickhouse_client): + """Test that lists all available tables in the ClickHouse database using async client.""" + query = f""" + SELECT + name + FROM + system.tables + WHERE + database = '{async_clickhouse_client.client.database}' AND NOT startsWith(name, '.inner_id') + ORDER BY + name + """ + + result = await async_clickhouse_client.query(query) + tables = [row[0] for row in result.result_rows] + + assert sorted(tables) == sorted(EXPECTED_TABLES), "ClickHouse tables do not match expected list" diff --git a/app/api/uv.lock b/app/api/uv.lock new file mode 100644 index 000000000..14fa09832 --- /dev/null +++ b/app/api/uv.lock @@ -0,0 +1,1920 @@ +version = 1 +requires-python = "==3.12.*" +resolution-markers = [ + "platform_python_implementation != 'PyPy'", + "platform_python_implementation == 'PyPy'", +] + +[[package]] +name = "agentops-api" +version = "1.0.0" +source = { editable = "." } +dependencies = [ + { name = "boto3" }, + { name = "clickhouse-connect" }, + { name = "clickhouse-driver" }, + { name = "dotenv" }, + { name = "fastapi" }, + { name = "greenlet" }, + { name = "httpcore" }, + { name = "httpx" }, + { name = "jinja2" }, + { name = "jockey" }, + { name = "jsonschema" }, + { name = "opentelemetry-api" }, + { name = "opentelemetry-sdk" }, + { name = "opentelemetry-semantic-conventions" }, + { name = "opentelemetry-semantic-conventions-ai" }, + { name = "psycopg", extra = ["binary"] }, + { name = "psycopg-pool" }, + { name = "pydantic" }, + { name = "pyjwt" }, + { name = "python-dotenv" }, + { name = "redis" }, + { name = "sentry-sdk" }, + { name = "sqlalchemy" }, + { name = "stripe" }, + { name = "supabase" }, + { name = "termcolor" }, + { name = "tokencost" }, + { name = "uvicorn", extra = ["standard"] }, + { name = "uvloop" }, + { name = "werkzeug" }, +] + +[package.dev-dependencies] +dev = [ + { name = "pdbpp" }, + { name = "pyfakefs" }, + { name = "pyinstrument" }, + { name = "pytest" }, + { name = "pytest-asyncio" }, + { name = "pytest-depends" }, + { name = "pytest-env" }, + { name = "pytest-mock" }, + { name = "pytest-recording" }, + { name = "pytest-sugar" }, + { name = "python-dotenv" }, + { name = "vcrpy" }, +] + +[package.metadata] +requires-dist = [ + { name = "boto3", specifier = ">=1.37.22" }, + { name = "clickhouse-connect", specifier = ">=0.8.15" }, + { name = "clickhouse-driver", specifier = ">=0.2.9" }, + { name = "dotenv", specifier = ">=0.9.9" }, + { name = "fastapi", specifier = ">=0.110.0" }, + { name = "greenlet", specifier = ">=3.1.1" }, + { name = "httpcore", specifier = ">=1.0.5" }, + { name = "httpx", specifier = ">=0.27.0" }, + { name = "jinja2", specifier = ">=3.1.6" }, + { name = "jockey", editable = "jockey" }, + { name = "jsonschema" }, + { name = "opentelemetry-api", specifier = ">=1.30.0" }, + { name = "opentelemetry-sdk", specifier = ">=1.30.0" }, + { name = "opentelemetry-semantic-conventions", specifier = ">=0.43b0" }, + { name = "opentelemetry-semantic-conventions-ai", specifier = ">=0.4.2" }, + { name = "psycopg", extras = ["binary"], specifier = ">=3.2.5" }, + { name = "psycopg-pool", specifier = ">=3.2.6" }, + { name = "pydantic", specifier = ">=2.10.6" }, + { name = "pyjwt", specifier = ">=2.8.0" }, + { name = "python-dotenv", specifier = ">=1.0.0" }, + { name = "redis", specifier = ">=5.2.1" }, + { name = "sentry-sdk", specifier = ">=1.39.1" }, + { name = "sqlalchemy", specifier = ">=2.0.40" }, + { name = "stripe" }, + { name = "supabase", specifier = ">=2.12.0" }, + { name = "termcolor", specifier = ">=2.0.0" }, + { name = "tokencost", specifier = ">=0.1.17" }, + { name = "uvicorn", extras = ["standard"], specifier = ">=0.27.0" }, + { name = "uvloop", specifier = ">=0.19.0" }, + { name = "werkzeug", specifier = ">=3.0.3" }, +] + +[package.metadata.requires-dev] +dev = [ + { name = "pdbpp", specifier = ">=0.10.3" }, + { name = "pyfakefs" }, + { name = "pyinstrument", specifier = ">=5.0.1" }, + { name = "pytest", specifier = ">=8.0.0" }, + { name = "pytest-asyncio" }, + { name = "pytest-depends" }, + { name = "pytest-env", specifier = ">=1.1.5" }, + { name = "pytest-mock" }, + { name = "pytest-recording" }, + { name = "pytest-sugar", specifier = ">=1.0.0" }, + { name = "python-dotenv" }, + { name = "vcrpy", git = "https://github.com/kevin1024/vcrpy.git?rev=5f1b20c4ca4a18c1fc8cfe049d7df12ca0659c9b" }, +] + +[[package]] +name = "aiohappyeyeballs" +version = "2.6.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558", size = 22760 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8", size = 15265 }, +] + +[[package]] +name = "aiohttp" +version = "3.11.14" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohappyeyeballs" }, + { name = "aiosignal" }, + { name = "attrs" }, + { name = "frozenlist" }, + { name = "multidict" }, + { name = "propcache" }, + { name = "yarl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6c/96/91e93ae5fd04d428c101cdbabce6c820d284d61d2614d00518f4fa52ea24/aiohttp-3.11.14.tar.gz", hash = "sha256:d6edc538c7480fa0a3b2bdd705f8010062d74700198da55d16498e1b49549b9c", size = 7676994 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9c/ca/e4acb3b41f9e176f50960f7162d656e79bed151b1f911173b2c4a6c0a9d2/aiohttp-3.11.14-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:70ab0f61c1a73d3e0342cedd9a7321425c27a7067bebeeacd509f96695b875fc", size = 705489 }, + { url = "https://files.pythonhosted.org/packages/84/d5/dcf870e0b11f0c1e3065b7f17673485afa1ddb3d630ccd8f328bccfb459f/aiohttp-3.11.14-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:602d4db80daf4497de93cb1ce00b8fc79969c0a7cf5b67bec96fa939268d806a", size = 464807 }, + { url = "https://files.pythonhosted.org/packages/7c/f0/dc417d819ae26be6abcd72c28af99d285887fddbf76d4bbe46346f201870/aiohttp-3.11.14-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3a8a0d127c10b8d89e69bbd3430da0f73946d839e65fec00ae48ca7916a31948", size = 456819 }, + { url = "https://files.pythonhosted.org/packages/28/db/f7deb0862ebb821aa3829db20081a122ba67ffd149303f2d5202e30f20cd/aiohttp-3.11.14-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca9f835cdfedcb3f5947304e85b8ca3ace31eef6346d8027a97f4de5fb687534", size = 1683536 }, + { url = "https://files.pythonhosted.org/packages/5e/0d/8bf0619e21c6714902c44ab53e275deb543d4d2e68ab2b7b8fe5ba267506/aiohttp-3.11.14-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8aa5c68e1e68fff7cd3142288101deb4316b51f03d50c92de6ea5ce646e6c71f", size = 1738111 }, + { url = "https://files.pythonhosted.org/packages/f5/10/204b3700bb57b30b9e759d453fcfb3ad79a3eb18ece4e298aaf7917757dd/aiohttp-3.11.14-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b512f1de1c688f88dbe1b8bb1283f7fbeb7a2b2b26e743bb2193cbadfa6f307", size = 1794508 }, + { url = "https://files.pythonhosted.org/packages/cc/39/3f65072614c62a315a951fda737e4d9e6e2703f1da0cd2f2d8f629e6092e/aiohttp-3.11.14-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc9253069158d57e27d47a8453d8a2c5a370dc461374111b5184cf2f147a3cc3", size = 1692006 }, + { url = "https://files.pythonhosted.org/packages/73/77/cc06ecea173f9bee2f20c8e32e2cf4c8e03909a707183cdf95434db4993e/aiohttp-3.11.14-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0b2501f1b981e70932b4a552fc9b3c942991c7ae429ea117e8fba57718cdeed0", size = 1620369 }, + { url = "https://files.pythonhosted.org/packages/87/75/5bd424bcd90c7eb2f50fd752d013db4cefb447deeecfc5bc4e8e0b1c74dd/aiohttp-3.11.14-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:28a3d083819741592685762d51d789e6155411277050d08066537c5edc4066e6", size = 1642508 }, + { url = "https://files.pythonhosted.org/packages/81/f0/ce936ec575e0569f91e5c8374086a6f7760926f16c3b95428fb55d6bfe91/aiohttp-3.11.14-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:0df3788187559c262922846087e36228b75987f3ae31dd0a1e5ee1034090d42f", size = 1685771 }, + { url = "https://files.pythonhosted.org/packages/68/b7/5216590b99b5b1f18989221c25ac9d9a14a7b0c3c4ae1ff728e906c36430/aiohttp-3.11.14-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:9e73fa341d8b308bb799cf0ab6f55fc0461d27a9fa3e4582755a3d81a6af8c09", size = 1648318 }, + { url = "https://files.pythonhosted.org/packages/a5/c2/c27061c4ab93fa25f925c7ebddc10c20d992dbbc329e89d493811299dc93/aiohttp-3.11.14-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:51ba80d473eb780a329d73ac8afa44aa71dfb521693ccea1dea8b9b5c4df45ce", size = 1704545 }, + { url = "https://files.pythonhosted.org/packages/09/f5/11b2da82f2c52365a5b760a4e944ae50a89cf5fb207024b7853615254584/aiohttp-3.11.14-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:8d1dd75aa4d855c7debaf1ef830ff2dfcc33f893c7db0af2423ee761ebffd22b", size = 1737839 }, + { url = "https://files.pythonhosted.org/packages/03/7f/145e23fe0a4c45b256f14c3268ada5497d487786334721ae8a0c818ee516/aiohttp-3.11.14-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41cf0cefd9e7b5c646c2ef529c8335e7eafd326f444cc1cdb0c47b6bc836f9be", size = 1695833 }, + { url = "https://files.pythonhosted.org/packages/1c/78/627dba6ee9fb9439e2e29b521adb1135877a9c7b54811fec5c46e59f2fc8/aiohttp-3.11.14-cp312-cp312-win32.whl", hash = "sha256:948abc8952aff63de7b2c83bfe3f211c727da3a33c3a5866a0e2cf1ee1aa950f", size = 412185 }, + { url = "https://files.pythonhosted.org/packages/3f/5f/1737cf6fcf0524693a4aeff8746530b65422236761e7bfdd79c6d2ce2e1c/aiohttp-3.11.14-cp312-cp312-win_amd64.whl", hash = "sha256:3b420d076a46f41ea48e5fcccb996f517af0d406267e31e6716f480a3d50d65c", size = 438526 }, +] + +[[package]] +name = "aiosignal" +version = "1.3.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "frozenlist" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ba/b5/6d55e80f6d8a08ce22b982eafa278d823b541c925f11ee774b0b9c43473d/aiosignal-1.3.2.tar.gz", hash = "sha256:a8c255c66fafb1e499c9351d0bf32ff2d8a0321595ebac3b93713656d2436f54", size = 19424 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/6a/bc7e17a3e87a2985d3e8f4da4cd0f481060eb78fb08596c42be62c90a4d9/aiosignal-1.3.2-py2.py3-none-any.whl", hash = "sha256:45cde58e409a301715980c2b01d0c28bdde3770d8290b5eb2173759d9acb31a5", size = 7597 }, +] + +[[package]] +name = "annotated-types" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643 }, +] + +[[package]] +name = "anthropic" +version = "0.49.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "distro" }, + { name = "httpx" }, + { name = "jiter" }, + { name = "pydantic" }, + { name = "sniffio" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/86/e3/a88c8494ce4d1a88252b9e053607e885f9b14d0a32273d47b727cbee4228/anthropic-0.49.0.tar.gz", hash = "sha256:c09e885b0f674b9119b4f296d8508907f6cff0009bc20d5cf6b35936c40b4398", size = 210016 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/74/5d90ad14d55fbe3f9c474fdcb6e34b4bed99e3be8efac98734a5ddce88c1/anthropic-0.49.0-py3-none-any.whl", hash = "sha256:bbc17ad4e7094988d2fa86b87753ded8dce12498f4b85fe5810f208f454a8375", size = 243368 }, +] + +[[package]] +name = "anyio" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "sniffio" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/95/7d/4c1bd541d4dffa1b52bd83fb8527089e097a106fc90b467a7313b105f840/anyio-4.9.0.tar.gz", hash = "sha256:673c0c244e15788651a4ff38710fea9675823028a6f08a5eda409e0c9840a028", size = 190949 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a1/ee/48ca1a7c89ffec8b6a0c5d02b89c305671d5ffd8d3c94acf8b8c408575bb/anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c", size = 100916 }, +] + +[[package]] +name = "attrs" +version = "25.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/b0/1367933a8532ee6ff8d63537de4f1177af4bff9f3e829baf7331f595bb24/attrs-25.3.0.tar.gz", hash = "sha256:75d7cefc7fb576747b2c81b4442d4d4a1ce0900973527c011d1030fd3bf4af1b", size = 812032 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/06/bb80f5f86020c4551da315d78b3ab75e8228f89f0162f2c3a819e407941a/attrs-25.3.0-py3-none-any.whl", hash = "sha256:427318ce031701fea540783410126f03899a97ffc6f61596ad581ac2e40e3bc3", size = 63815 }, +] + +[[package]] +name = "boto3" +version = "1.37.22" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "botocore" }, + { name = "jmespath" }, + { name = "s3transfer" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0b/e0/3b57442eae0c13236f6e966efb2a982e6ca245b8d58e01a1e0d1e8c262f2/boto3-1.37.22.tar.gz", hash = "sha256:78a0ec0aafbf6044104c98ad80b69e6d1c83d8233fda2c2d241029e6c705c510", size = 111377 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/17/a6ff3259271cbf4a9b0db67c1f9ad77d4442c75498218efb6a06ca125764/boto3-1.37.22-py3-none-any.whl", hash = "sha256:a14324d5fa5f4fea00c0e3c69754cbd28100f7fe194693eeecf2dc07446cf4ef", size = 139561 }, +] + +[[package]] +name = "botocore" +version = "1.37.22" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jmespath" }, + { name = "python-dateutil" }, + { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation == 'PyPy'" }, + { name = "urllib3", version = "2.3.0", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/55/8093a88e2ee26fd2028655a7ebc7f2cf04ec589e1c651fd0fb47edda2af4/botocore-1.37.22.tar.gz", hash = "sha256:b3b26f1a90236bcd17d4092f8c85a256b44e9955a16b633319a2f5678d605e9f", size = 13679309 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/b9/f412880f4837fb98d0c06bdbcbe07430f50c49db375d26fa0a2ddce26562/botocore-1.37.22-py3-none-any.whl", hash = "sha256:184db7c9314d13002bc827f511a5140574b5da1acda342d51e093dad6317de98", size = 13441302 }, +] + +[[package]] +name = "cachetools" +version = "5.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/81/3747dad6b14fa2cf53fcf10548cf5aea6913e96fab41a3c198676f8948a5/cachetools-5.5.2.tar.gz", hash = "sha256:1a661caa9175d26759571b2e19580f9d6393969e5dfca11fdb1f947a23e640d4", size = 28380 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/72/76/20fa66124dbe6be5cafeb312ece67de6b61dd91a0247d1ea13db4ebb33c2/cachetools-5.5.2-py3-none-any.whl", hash = "sha256:d26a22bcc62eb95c3beabd9f1ee5e820d3d2704fe2967cbe350e20c8ffcd3f0a", size = 10080 }, +] + +[[package]] +name = "certifi" +version = "2025.1.31" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1c/ab/c9f1e32b7b1bf505bf26f0ef697775960db7932abeb7b516de930ba2705f/certifi-2025.1.31.tar.gz", hash = "sha256:3d5da6925056f6f18f119200434a4780a94263f10d1c21d032a6f6b2baa20651", size = 167577 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/fc/bce832fd4fd99766c04d1ee0eead6b0ec6486fb100ae5e74c1d91292b982/certifi-2025.1.31-py3-none-any.whl", hash = "sha256:ca78db4565a652026a4db2bcdf68f2fb589ea80d0be70e03929ed730746b84fe", size = 166393 }, +] + +[[package]] +name = "cffi" +version = "1.17.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "platform_python_implementation == 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/84/e94227139ee5fb4d600a7a4927f322e1d4aea6fdc50bd3fca8493caba23f/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4", size = 183178 }, + { url = "https://files.pythonhosted.org/packages/da/ee/fb72c2b48656111c4ef27f0f91da355e130a923473bf5ee75c5643d00cca/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c", size = 178840 }, + { url = "https://files.pythonhosted.org/packages/cc/b6/db007700f67d151abadf508cbfd6a1884f57eab90b1bb985c4c8c02b0f28/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36", size = 454803 }, + { url = "https://files.pythonhosted.org/packages/1a/df/f8d151540d8c200eb1c6fba8cd0dfd40904f1b0682ea705c36e6c2e97ab3/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5", size = 478850 }, + { url = "https://files.pythonhosted.org/packages/28/c0/b31116332a547fd2677ae5b78a2ef662dfc8023d67f41b2a83f7c2aa78b1/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff", size = 485729 }, + { url = "https://files.pythonhosted.org/packages/91/2b/9a1ddfa5c7f13cab007a2c9cc295b70fbbda7cb10a286aa6810338e60ea1/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99", size = 471256 }, + { url = "https://files.pythonhosted.org/packages/b2/d5/da47df7004cb17e4955df6a43d14b3b4ae77737dff8bf7f8f333196717bf/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93", size = 479424 }, + { url = "https://files.pythonhosted.org/packages/0b/ac/2a28bcf513e93a219c8a4e8e125534f4f6db03e3179ba1c45e949b76212c/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3", size = 484568 }, + { url = "https://files.pythonhosted.org/packages/d4/38/ca8a4f639065f14ae0f1d9751e70447a261f1a30fa7547a828ae08142465/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8", size = 488736 }, + { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448 }, + { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976 }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/16/b0/572805e227f01586461c80e0fd25d65a2115599cc9dad142fee4b747c357/charset_normalizer-3.4.1.tar.gz", hash = "sha256:44251f18cd68a75b56585dd00dae26183e102cd5e0f9f1466e6df5da2ed64ea3", size = 123188 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0a/9a/dd1e1cdceb841925b7798369a09279bd1cf183cef0f9ddf15a3a6502ee45/charset_normalizer-3.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:73d94b58ec7fecbc7366247d3b0b10a21681004153238750bb67bd9012414545", size = 196105 }, + { url = "https://files.pythonhosted.org/packages/d3/8c/90bfabf8c4809ecb648f39794cf2a84ff2e7d2a6cf159fe68d9a26160467/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dad3e487649f498dd991eeb901125411559b22e8d7ab25d3aeb1af367df5efd7", size = 140404 }, + { url = "https://files.pythonhosted.org/packages/ad/8f/e410d57c721945ea3b4f1a04b74f70ce8fa800d393d72899f0a40526401f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c30197aa96e8eed02200a83fba2657b4c3acd0f0aa4bdc9f6c1af8e8962e0757", size = 150423 }, + { url = "https://files.pythonhosted.org/packages/f0/b8/e6825e25deb691ff98cf5c9072ee0605dc2acfca98af70c2d1b1bc75190d/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2369eea1ee4a7610a860d88f268eb39b95cb588acd7235e02fd5a5601773d4fa", size = 143184 }, + { url = "https://files.pythonhosted.org/packages/3e/a2/513f6cbe752421f16d969e32f3583762bfd583848b763913ddab8d9bfd4f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc2722592d8998c870fa4e290c2eec2c1569b87fe58618e67d38b4665dfa680d", size = 145268 }, + { url = "https://files.pythonhosted.org/packages/74/94/8a5277664f27c3c438546f3eb53b33f5b19568eb7424736bdc440a88a31f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffc9202a29ab3920fa812879e95a9e78b2465fd10be7fcbd042899695d75e616", size = 147601 }, + { url = "https://files.pythonhosted.org/packages/7c/5f/6d352c51ee763623a98e31194823518e09bfa48be2a7e8383cf691bbb3d0/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:804a4d582ba6e5b747c625bf1255e6b1507465494a40a2130978bda7b932c90b", size = 141098 }, + { url = "https://files.pythonhosted.org/packages/78/d4/f5704cb629ba5ab16d1d3d741396aec6dc3ca2b67757c45b0599bb010478/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0f55e69f030f7163dffe9fd0752b32f070566451afe180f99dbeeb81f511ad8d", size = 149520 }, + { url = "https://files.pythonhosted.org/packages/c5/96/64120b1d02b81785f222b976c0fb79a35875457fa9bb40827678e54d1bc8/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c4c3e6da02df6fa1410a7680bd3f63d4f710232d3139089536310d027950696a", size = 152852 }, + { url = "https://files.pythonhosted.org/packages/84/c9/98e3732278a99f47d487fd3468bc60b882920cef29d1fa6ca460a1fdf4e6/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:5df196eb874dae23dcfb968c83d4f8fdccb333330fe1fc278ac5ceeb101003a9", size = 150488 }, + { url = "https://files.pythonhosted.org/packages/13/0e/9c8d4cb99c98c1007cc11eda969ebfe837bbbd0acdb4736d228ccaabcd22/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e358e64305fe12299a08e08978f51fc21fac060dcfcddd95453eabe5b93ed0e1", size = 146192 }, + { url = "https://files.pythonhosted.org/packages/b2/21/2b6b5b860781a0b49427309cb8670785aa543fb2178de875b87b9cc97746/charset_normalizer-3.4.1-cp312-cp312-win32.whl", hash = "sha256:9b23ca7ef998bc739bf6ffc077c2116917eabcc901f88da1b9856b210ef63f35", size = 95550 }, + { url = "https://files.pythonhosted.org/packages/21/5b/1b390b03b1d16c7e382b561c5329f83cc06623916aab983e8ab9239c7d5c/charset_normalizer-3.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:6ff8a4a60c227ad87030d76e99cd1698345d4491638dfa6673027c48b3cd395f", size = 102785 }, + { url = "https://files.pythonhosted.org/packages/0e/f6/65ecc6878a89bb1c23a086ea335ad4bf21a588990c3f535a227b9eea9108/charset_normalizer-3.4.1-py3-none-any.whl", hash = "sha256:d98b1668f06378c6dbefec3b92299716b931cd4e6061f3c875a71ced1780ab85", size = 49767 }, +] + +[[package]] +name = "click" +version = "8.1.8" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a", size = 226593 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2", size = 98188 }, +] + +[[package]] +name = "clickhouse-connect" +version = "0.8.15" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "lz4" }, + { name = "pytz" }, + { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation == 'PyPy'" }, + { name = "urllib3", version = "2.3.0", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation != 'PyPy'" }, + { name = "zstandard" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/18/ca/33eb6c5febdbedb1b42d2f8b3a26c4fae8af488b6a7579b6d8e7a76885b3/clickhouse_connect-0.8.15.tar.gz", hash = "sha256:bfcec8c3ce41fcef4c873cc50c7a8fc17d5f834352176b3e492b14faca2d9dab", size = 90631 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/55/c6e994af94ae636f74151290667b4f60c028014e33bf28c2b6c17ac8f8b4/clickhouse_connect-0.8.15-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a12e17d6fc187b5140c36bb236611b7ad8d579933ee01e02594ecad031ed87c5", size = 261198 }, + { url = "https://files.pythonhosted.org/packages/c4/e5/02f43ad85c5952cc3b62db468702356c1e212945583da31a1641d3cd3951/clickhouse_connect-0.8.15-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3e08bdc73da45512fc0a93279ba883f4bcda10e8a040bc6e6a960e7ae2a921d2", size = 252891 }, + { url = "https://files.pythonhosted.org/packages/bf/5b/8dbfaaa2733b975aa11c3344621b5b5f817b598abc30c96a0c8249b02dda/clickhouse_connect-0.8.15-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a993c3ee0c883d1461120b9e343bf5a8bddd3bbf65b68dacbd20697e3b660ebb", size = 1057129 }, + { url = "https://files.pythonhosted.org/packages/68/3d/4ab5b7e0fa4d1bf3c854fb6b64b604a17c7c8c3b7988a750bb81502c3d44/clickhouse_connect-0.8.15-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef3b6eb6823a5f710744e601b2512b0cefed5dab907a19989892a573e6f297f4", size = 1075498 }, + { url = "https://files.pythonhosted.org/packages/6d/be/023a2fd6b64acfec42c883977eb08ed9fd744383c96c43124b9af587701c/clickhouse_connect-0.8.15-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:979f2efa3adbe168af6cb7b728804294d4ecc93b9d29fbd2847e6bcf2fa62199", size = 1030754 }, + { url = "https://files.pythonhosted.org/packages/bb/58/d406d4b9f2f508f2916862cc7b37ec7b3c61c217bb728efd86609a114909/clickhouse_connect-0.8.15-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:fb7726200e1088c74c9b0555ccf27d68b1c8b726e931c99ff769f9fc1de48910", size = 1056404 }, + { url = "https://files.pythonhosted.org/packages/cc/36/374201e09f7200ff4a20e0dc731d4b0459decf8d46065a8a39907bed05a9/clickhouse_connect-0.8.15-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:8bf898f0c2367bcdb2b2f96c42fd200b0339b5e532a72ae679bfbfb43f4ce5f9", size = 1073086 }, + { url = "https://files.pythonhosted.org/packages/50/bb/fba7569cfad8b951b8a6497bf19ae5440ab0b305c40d680a1a2395831a1f/clickhouse_connect-0.8.15-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:84d8067294ba6e65994fa887db3acdb6fbf3cbd850d5637c029f29e318eba116", size = 1098405 }, + { url = "https://files.pythonhosted.org/packages/31/5c/b1ab4ddf40ce3c786011429e5a9171b662efbb8933bf8b9a7586d9eac24a/clickhouse_connect-0.8.15-cp312-cp312-win32.whl", hash = "sha256:83527c9bc48a096e63f91cc429bf3fad01fe5b78ea83fd7751f9702f97388381", size = 228612 }, + { url = "https://files.pythonhosted.org/packages/fe/d4/3060fe62a3e0e1c41303acb7a00240a5a867774f176ca9c485d03727d4f6/clickhouse_connect-0.8.15-cp312-cp312-win_amd64.whl", hash = "sha256:f63e5500d36e79deb91bfeb82548dd1737b57684405566bc9652d8fede8ce451", size = 246549 }, +] + +[[package]] +name = "clickhouse-driver" +version = "0.2.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pytz" }, + { name = "tzlocal" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bf/0b/3790274f7591fc55b1f91bcc8e576338859cc632b1b17288b5bab79b769d/clickhouse-driver-0.2.9.tar.gz", hash = "sha256:050ea4870ead993910b39e7fae965dc1c347b2e8191dcd977cd4b385f9e19f87", size = 357752 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/58/acc74be412330aa4d681df2d13e013e84e27cc767dea73a507cb71c74cff/clickhouse_driver-0.2.9-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:fcb2fd00e58650ae206a6d5dbc83117240e622471aa5124733fbf2805eb8bda0", size = 221487 }, + { url = "https://files.pythonhosted.org/packages/f5/bc/09b69a1be0155e02a0df9ecafb63c9a2f7d9e412c865dd3c711e07967e85/clickhouse_driver-0.2.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b7a3e6b0a1eb218e3d870a94c76daaf65da46dca8f6888ea6542f94905c24d88", size = 217362 }, + { url = "https://files.pythonhosted.org/packages/ed/58/79eadc238d6ee0d7920ae36f0ea3a6479a8310bffb6c97ea6aa060a98434/clickhouse_driver-0.2.9-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4a8d8e2888a857d8db3d98765a5ad23ab561241feaef68bbffc5a0bd9c142342", size = 1018173 }, + { url = "https://files.pythonhosted.org/packages/44/61/1647a0d8aae2c4a3d8c3093d1799f943ff38a0cb81d5e4050be18993f3fa/clickhouse_driver-0.2.9-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:85d50c011467f5ff6772c4059345968b854b72e07a0219030b7c3f68419eb7f7", size = 1046542 }, + { url = "https://files.pythonhosted.org/packages/77/23/32bab0efeec64d56313b90c73d067440829630f9a5980de73cb52350a4c9/clickhouse_driver-0.2.9-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:93b395c1370629ccce8fb3e14cd5be2646d227bd32018c21f753c543e9a7e96b", size = 1057508 }, + { url = "https://files.pythonhosted.org/packages/07/8e/9b79fd85d28a9e83b87a8722a8e736d69ef5edde8cee5d1dde6950aa512f/clickhouse_driver-0.2.9-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6dbcee870c60d9835e5dce1456ab6b9d807e6669246357f4b321ef747b90fa43", size = 1032860 }, + { url = "https://files.pythonhosted.org/packages/bd/ca/208358dd8d80a25633b5f19a9acadb1fb23b55be7f2123e5e70d132de204/clickhouse_driver-0.2.9-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fffa5a5f317b1ec92e406a30a008929054cf3164d2324a3c465d0a0330273bf8", size = 984133 }, + { url = "https://files.pythonhosted.org/packages/19/e1/9767cea5bfc9451b7a2680d5b0d4bd3261c56db92002f90ce716209f59c1/clickhouse_driver-0.2.9-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:476702740a279744badbd177ae1c4a2d089ec128bd676861219d1f92078e4530", size = 1020897 }, + { url = "https://files.pythonhosted.org/packages/f5/bc/62511b61fbee97c8ab1c64ab4bf33045bcc132d236e61a65831c0de32b82/clickhouse_driver-0.2.9-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:5cd6d95fab5ff80e9dc9baedc9a926f62f74072d42d5804388d63b63bec0bb63", size = 989911 }, + { url = "https://files.pythonhosted.org/packages/a0/a8/e3ff5cbc24dbc087acf0733c47fe7a6a6a2f3225e9c168af2414fb803f3c/clickhouse_driver-0.2.9-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:05027d32d7cf3e46cb8d04f8c984745ae01bd1bc7b3579f9dadf9b3cca735697", size = 1045389 }, + { url = "https://files.pythonhosted.org/packages/d6/58/29f56e340094cfec72080773e3d94c7963c2e69f70edff83f2a139965d38/clickhouse_driver-0.2.9-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:3d11831842250b4c1b26503a6e9c511fc03db096608b7c6af743818c421a3032", size = 1063242 }, + { url = "https://files.pythonhosted.org/packages/ff/0f/161626812ad2bd9480ff390a96489983709d94b33da68f028ace9d1367be/clickhouse_driver-0.2.9-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:81b4b671b785ebb0b8aeabf2432e47072413d81db959eb8cfd8b6ab58c5799c6", size = 1039703 }, + { url = "https://files.pythonhosted.org/packages/4a/29/e353c4e835d722b4f6b259d668c2ac47f35bf6a0053414a80522df649ff5/clickhouse_driver-0.2.9-cp312-cp312-win32.whl", hash = "sha256:e893bd4e014877174a59e032b0e99809c95ec61328a0e6bd9352c74a2f6111a8", size = 198390 }, + { url = "https://files.pythonhosted.org/packages/5b/09/ff81e99e9ecbb85f2ada57a690b1d0cfee6f2e1eff59ee08609a160d5644/clickhouse_driver-0.2.9-cp312-cp312-win_amd64.whl", hash = "sha256:de6624e28eeffd01668803d28ae89e3d4e359b1bff8b60e4933e1cb3c6f86f18", size = 213585 }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 }, +] + +[[package]] +name = "deprecated" +version = "1.2.18" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wrapt" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/98/97/06afe62762c9a8a86af0cfb7bfdab22a43ad17138b07af5b1a58442690a2/deprecated-1.2.18.tar.gz", hash = "sha256:422b6f6d859da6f2ef57857761bfb392480502a64c3028ca9bbe86085d72115d", size = 2928744 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6e/c6/ac0b6c1e2d138f1002bcf799d330bd6d85084fece321e662a14223794041/Deprecated-1.2.18-py2.py3-none-any.whl", hash = "sha256:bd5011788200372a32418f888e326a09ff80d0214bd961147cfed01b5c018eec", size = 9998 }, +] + +[[package]] +name = "deprecation" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5a/d3/8ae2869247df154b64c1884d7346d412fed0c49df84db635aab2d1c40e62/deprecation-2.1.0.tar.gz", hash = "sha256:72b3bde64e5d778694b0cf68178aed03d15e15477116add3fb773e581f9518ff", size = 173788 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/c3/253a89ee03fc9b9682f1541728eb66db7db22148cd94f89ab22528cd1e1b/deprecation-2.1.0-py2.py3-none-any.whl", hash = "sha256:a10811591210e1fb0e768a8c25517cabeabcba6f0bf96564f8ff45189f90b14a", size = 11178 }, +] + +[[package]] +name = "distro" +version = "1.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed", size = 60722 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277 }, +] + +[[package]] +name = "docker" +version = "7.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pywin32", marker = "sys_platform == 'win32'" }, + { name = "requests" }, + { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation == 'PyPy'" }, + { name = "urllib3", version = "2.3.0", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/91/9b/4a2ea29aeba62471211598dac5d96825bb49348fa07e906ea930394a83ce/docker-7.1.0.tar.gz", hash = "sha256:ad8c70e6e3f8926cb8a92619b832b4ea5299e2831c14284663184e200546fa6c", size = 117834 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e3/26/57c6fb270950d476074c087527a558ccb6f4436657314bfb6cdf484114c4/docker-7.1.0-py3-none-any.whl", hash = "sha256:c96b93b7f0a746f9e77d325bcfb87422a3d8bd4f03136ae8a85b37f1898d5fc0", size = 147774 }, +] + +[[package]] +name = "dotenv" +version = "0.9.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "python-dotenv" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/b7/545d2c10c1fc15e48653c91efde329a790f2eecfbbf2bd16003b5db2bab0/dotenv-0.9.9-py2.py3-none-any.whl", hash = "sha256:29cf74a087b31dafdb5a446b6d7e11cbce8ed2741540e2339c69fbef92c94ce9", size = 1892 }, +] + +[[package]] +name = "durationpy" +version = "0.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9d/a4/e44218c2b394e31a6dd0d6b095c4e1f32d0be54c2a4b250032d717647bab/durationpy-0.10.tar.gz", hash = "sha256:1fa6893409a6e739c9c72334fc65cca1f355dbdd93405d30f726deb5bde42fba", size = 3335 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b0/0d/9feae160378a3553fa9a339b0e9c1a048e147a4127210e286ef18b730f03/durationpy-0.10-py3-none-any.whl", hash = "sha256:3b41e1b601234296b4fb368338fdcd3e13e0b4fb5b67345948f4f2bf9868b286", size = 3922 }, +] + +[[package]] +name = "fancycompleter" +version = "0.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyreadline", marker = "sys_platform == 'win32'" }, + { name = "pyrepl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/649d135442d8ecf8af5c7e235550c628056423c96c4bc6787348bdae9248/fancycompleter-0.9.1.tar.gz", hash = "sha256:09e0feb8ae242abdfd7ef2ba55069a46f011814a80fe5476be48f51b00247272", size = 10866 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/ef/c08926112034d017633f693d3afc8343393a035134a29dfc12dcd71b0375/fancycompleter-0.9.1-py3-none-any.whl", hash = "sha256:dd076bca7d9d524cc7f25ec8f35ef95388ffef9ef46def4d3d25e9b044ad7080", size = 9681 }, +] + +[[package]] +name = "fastapi" +version = "0.115.11" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pydantic" }, + { name = "starlette" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b5/28/c5d26e5860df807241909a961a37d45e10533acef95fc368066c7dd186cd/fastapi-0.115.11.tar.gz", hash = "sha256:cc81f03f688678b92600a65a5e618b93592c65005db37157147204d8924bf94f", size = 294441 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/5d/4d8bbb94f0dbc22732350c06965e40740f4a92ca560e90bb566f4f73af41/fastapi-0.115.11-py3-none-any.whl", hash = "sha256:32e1541b7b74602e4ef4a0260ecaf3aadf9d4f19590bba3e1bf2ac4666aa2c64", size = 94926 }, +] + +[[package]] +name = "frozenlist" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8f/ed/0f4cec13a93c02c47ec32d81d11c0c1efbadf4a471e3f3ce7cad366cbbd3/frozenlist-1.5.0.tar.gz", hash = "sha256:81d5af29e61b9c8348e876d442253723928dce6433e0e76cd925cd83f1b4b817", size = 39930 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/79/73/fa6d1a96ab7fd6e6d1c3500700963eab46813847f01ef0ccbaa726181dd5/frozenlist-1.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:31115ba75889723431aa9a4e77d5f398f5cf976eea3bdf61749731f62d4a4a21", size = 94026 }, + { url = "https://files.pythonhosted.org/packages/ab/04/ea8bf62c8868b8eada363f20ff1b647cf2e93377a7b284d36062d21d81d1/frozenlist-1.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7437601c4d89d070eac8323f121fcf25f88674627505334654fd027b091db09d", size = 54150 }, + { url = "https://files.pythonhosted.org/packages/d0/9a/8e479b482a6f2070b26bda572c5e6889bb3ba48977e81beea35b5ae13ece/frozenlist-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7948140d9f8ece1745be806f2bfdf390127cf1a763b925c4a805c603df5e697e", size = 51927 }, + { url = "https://files.pythonhosted.org/packages/e3/12/2aad87deb08a4e7ccfb33600871bbe8f0e08cb6d8224371387f3303654d7/frozenlist-1.5.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:feeb64bc9bcc6b45c6311c9e9b99406660a9c05ca8a5b30d14a78555088b0b3a", size = 282647 }, + { url = "https://files.pythonhosted.org/packages/77/f2/07f06b05d8a427ea0060a9cef6e63405ea9e0d761846b95ef3fb3be57111/frozenlist-1.5.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:683173d371daad49cffb8309779e886e59c2f369430ad28fe715f66d08d4ab1a", size = 289052 }, + { url = "https://files.pythonhosted.org/packages/bd/9f/8bf45a2f1cd4aa401acd271b077989c9267ae8463e7c8b1eb0d3f561b65e/frozenlist-1.5.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7d57d8f702221405a9d9b40f9da8ac2e4a1a8b5285aac6100f3393675f0a85ee", size = 291719 }, + { url = "https://files.pythonhosted.org/packages/41/d1/1f20fd05a6c42d3868709b7604c9f15538a29e4f734c694c6bcfc3d3b935/frozenlist-1.5.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30c72000fbcc35b129cb09956836c7d7abf78ab5416595e4857d1cae8d6251a6", size = 267433 }, + { url = "https://files.pythonhosted.org/packages/af/f2/64b73a9bb86f5a89fb55450e97cd5c1f84a862d4ff90d9fd1a73ab0f64a5/frozenlist-1.5.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:000a77d6034fbad9b6bb880f7ec073027908f1b40254b5d6f26210d2dab1240e", size = 283591 }, + { url = "https://files.pythonhosted.org/packages/29/e2/ffbb1fae55a791fd6c2938dd9ea779509c977435ba3940b9f2e8dc9d5316/frozenlist-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5d7f5a50342475962eb18b740f3beecc685a15b52c91f7d975257e13e029eca9", size = 273249 }, + { url = "https://files.pythonhosted.org/packages/2e/6e/008136a30798bb63618a114b9321b5971172a5abddff44a100c7edc5ad4f/frozenlist-1.5.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:87f724d055eb4785d9be84e9ebf0f24e392ddfad00b3fe036e43f489fafc9039", size = 271075 }, + { url = "https://files.pythonhosted.org/packages/ae/f0/4e71e54a026b06724cec9b6c54f0b13a4e9e298cc8db0f82ec70e151f5ce/frozenlist-1.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:6e9080bb2fb195a046e5177f10d9d82b8a204c0736a97a153c2466127de87784", size = 285398 }, + { url = "https://files.pythonhosted.org/packages/4d/36/70ec246851478b1c0b59f11ef8ade9c482ff447c1363c2bd5fad45098b12/frozenlist-1.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:9b93d7aaa36c966fa42efcaf716e6b3900438632a626fb09c049f6a2f09fc631", size = 294445 }, + { url = "https://files.pythonhosted.org/packages/37/e0/47f87544055b3349b633a03c4d94b405956cf2437f4ab46d0928b74b7526/frozenlist-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:52ef692a4bc60a6dd57f507429636c2af8b6046db8b31b18dac02cbc8f507f7f", size = 280569 }, + { url = "https://files.pythonhosted.org/packages/f9/7c/490133c160fb6b84ed374c266f42800e33b50c3bbab1652764e6e1fc498a/frozenlist-1.5.0-cp312-cp312-win32.whl", hash = "sha256:29d94c256679247b33a3dc96cce0f93cbc69c23bf75ff715919332fdbb6a32b8", size = 44721 }, + { url = "https://files.pythonhosted.org/packages/b1/56/4e45136ffc6bdbfa68c29ca56ef53783ef4c2fd395f7cbf99a2624aa9aaa/frozenlist-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:8969190d709e7c48ea386db202d708eb94bdb29207a1f269bab1196ce0dcca1f", size = 51329 }, + { url = "https://files.pythonhosted.org/packages/c6/c8/a5be5b7550c10858fcf9b0ea054baccab474da77d37f1e828ce043a3a5d4/frozenlist-1.5.0-py3-none-any.whl", hash = "sha256:d994863bba198a4a518b467bb971c56e1db3f180a25c6cf7bb1949c267f748c3", size = 11901 }, +] + +[[package]] +name = "future-fstrings" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5d/e2/3874574cce18a2e3608abfe5b4b5b3c9765653c464f5da18df8971cf501d/future_fstrings-1.2.0.tar.gz", hash = "sha256:6cf41cbe97c398ab5a81168ce0dbb8ad95862d3caf23c21e4430627b90844089", size = 5786 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ab/6d/ea1d52e9038558dd37f5d30647eb9f07888c164960a5d4daa5f970c6da25/future_fstrings-1.2.0-py2.py3-none-any.whl", hash = "sha256:90e49598b553d8746c4dc7d9442e0359d038c3039d802c91c0a55505da318c63", size = 6138 }, +] + +[[package]] +name = "gitdb" +version = "4.0.12" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "smmap" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/94/63b0fc47eb32792c7ba1fe1b694daec9a63620db1e313033d18140c2320a/gitdb-4.0.12.tar.gz", hash = "sha256:5ef71f855d191a3326fcfbc0d5da835f26b13fbcba60c32c21091c349ffdb571", size = 394684 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/61/5c78b91c3143ed5c14207f463aecfc8f9dbb5092fb2869baf37c273b2705/gitdb-4.0.12-py3-none-any.whl", hash = "sha256:67073e15955400952c6565cc3e707c554a4eea2e428946f7a4c162fab9bd9bcf", size = 62794 }, +] + +[[package]] +name = "gitpython" +version = "3.1.44" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "gitdb" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/89/37df0b71473153574a5cdef8f242de422a0f5d26d7a9e231e6f169b4ad14/gitpython-3.1.44.tar.gz", hash = "sha256:c87e30b26253bf5418b01b0660f818967f3c503193838337fe5e573331249269", size = 214196 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1d/9a/4114a9057db2f1462d5c8f8390ab7383925fe1ac012eaa42402ad65c2963/GitPython-3.1.44-py3-none-any.whl", hash = "sha256:9e0e10cda9bed1ee64bc9a6de50e7e38a9c9943241cd7f585f6df3ed28011110", size = 207599 }, +] + +[[package]] +name = "google-auth" +version = "2.40.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cachetools" }, + { name = "pyasn1-modules" }, + { name = "rsa" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/9b/e92ef23b84fa10a64ce4831390b7a4c2e53c0132568d99d4ae61d04c8855/google_auth-2.40.3.tar.gz", hash = "sha256:500c3a29adedeb36ea9cf24b8d10858e152f2412e3ca37829b3fa18e33d63b77", size = 281029 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/17/63/b19553b658a1692443c62bd07e5868adaa0ad746a0751ba62c59568cd45b/google_auth-2.40.3-py2.py3-none-any.whl", hash = "sha256:1370d4593e86213563547f97a92752fc658456fe4514c809544f330fed45a7ca", size = 216137 }, +] + +[[package]] +name = "gotrue" +version = "2.11.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "httpx", extra = ["http2"] }, + { name = "pydantic" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/9c/62c3241731b59c1c403377abef17b5e3782f6385b0317f6d7083271db501/gotrue-2.11.4.tar.gz", hash = "sha256:a9ced242b16c6d6bedc43bca21bbefea1ba5fb35fcdaad7d529342099d3b1767", size = 35353 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/47/3a/1a7cac16438f4e5319a0c879416d5e5032c98c3db2874e6e5300b3b475e6/gotrue-2.11.4-py3-none-any.whl", hash = "sha256:712e5018acc00d93cfc6d7bfddc3114eb3c420ab03b945757a8ba38c5fc3caa8", size = 41106 }, +] + +[[package]] +name = "greenlet" +version = "3.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2f/ff/df5fede753cc10f6a5be0931204ea30c35fa2f2ea7a35b25bdaf4fe40e46/greenlet-3.1.1.tar.gz", hash = "sha256:4ce3ac6cdb6adf7946475d7ef31777c26d94bccc377e070a7986bd2d5c515467", size = 186022 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7d/ec/bad1ac26764d26aa1353216fcbfa4670050f66d445448aafa227f8b16e80/greenlet-3.1.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:4afe7ea89de619adc868e087b4d2359282058479d7cfb94970adf4b55284574d", size = 274260 }, + { url = "https://files.pythonhosted.org/packages/66/d4/c8c04958870f482459ab5956c2942c4ec35cac7fe245527f1039837c17a9/greenlet-3.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f406b22b7c9a9b4f8aa9d2ab13d6ae0ac3e85c9a809bd590ad53fed2bf70dc79", size = 649064 }, + { url = "https://files.pythonhosted.org/packages/51/41/467b12a8c7c1303d20abcca145db2be4e6cd50a951fa30af48b6ec607581/greenlet-3.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c3a701fe5a9695b238503ce5bbe8218e03c3bcccf7e204e455e7462d770268aa", size = 663420 }, + { url = "https://files.pythonhosted.org/packages/27/8f/2a93cd9b1e7107d5c7b3b7816eeadcac2ebcaf6d6513df9abaf0334777f6/greenlet-3.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2846930c65b47d70b9d178e89c7e1a69c95c1f68ea5aa0a58646b7a96df12441", size = 658035 }, + { url = "https://files.pythonhosted.org/packages/57/5c/7c6f50cb12be092e1dccb2599be5a942c3416dbcfb76efcf54b3f8be4d8d/greenlet-3.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99cfaa2110534e2cf3ba31a7abcac9d328d1d9f1b95beede58294a60348fba36", size = 660105 }, + { url = "https://files.pythonhosted.org/packages/f1/66/033e58a50fd9ec9df00a8671c74f1f3a320564c6415a4ed82a1c651654ba/greenlet-3.1.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1443279c19fca463fc33e65ef2a935a5b09bb90f978beab37729e1c3c6c25fe9", size = 613077 }, + { url = "https://files.pythonhosted.org/packages/19/c5/36384a06f748044d06bdd8776e231fadf92fc896bd12cb1c9f5a1bda9578/greenlet-3.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b7cede291382a78f7bb5f04a529cb18e068dd29e0fb27376074b6d0317bf4dd0", size = 1135975 }, + { url = "https://files.pythonhosted.org/packages/38/f9/c0a0eb61bdf808d23266ecf1d63309f0e1471f284300ce6dac0ae1231881/greenlet-3.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:23f20bb60ae298d7d8656c6ec6db134bca379ecefadb0b19ce6f19d1f232a942", size = 1163955 }, + { url = "https://files.pythonhosted.org/packages/43/21/a5d9df1d21514883333fc86584c07c2b49ba7c602e670b174bd73cfc9c7f/greenlet-3.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:7124e16b4c55d417577c2077be379514321916d5790fa287c9ed6f23bd2ffd01", size = 299655 }, +] + +[[package]] +name = "h11" +version = "0.14.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f5/38/3af3d3633a34a3316095b39c8e8fb4853a28a536e55d347bd8d8e9a14b03/h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d", size = 100418 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/04/ff642e65ad6b90db43e668d70ffb6736436c7ce41fcc549f4e9472234127/h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761", size = 58259 }, +] + +[[package]] +name = "h2" +version = "4.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "hpack" }, + { name = "hyperframe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1b/38/d7f80fd13e6582fb8e0df8c9a653dcc02b03ca34f4d72f34869298c5baf8/h2-4.2.0.tar.gz", hash = "sha256:c8a52129695e88b1a0578d8d2cc6842bbd79128ac685463b887ee278126ad01f", size = 2150682 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d0/9e/984486f2d0a0bd2b024bf4bc1c62688fcafa9e61991f041fb0e2def4a982/h2-4.2.0-py3-none-any.whl", hash = "sha256:479a53ad425bb29af087f3458a61d30780bc818e4ebcf01f0b536ba916462ed0", size = 60957 }, +] + +[[package]] +name = "hpack" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2c/48/71de9ed269fdae9c8057e5a4c0aa7402e8bb16f2c6e90b3aa53327b113f8/hpack-4.1.0.tar.gz", hash = "sha256:ec5eca154f7056aa06f196a557655c5b009b382873ac8d1e66e79e87535f1dca", size = 51276 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/c6/80c95b1b2b94682a72cbdbfb85b81ae2daffa4291fbfa1b1464502ede10d/hpack-4.1.0-py3-none-any.whl", hash = "sha256:157ac792668d995c657d93111f46b4535ed114f0c9c8d672271bbec7eae1b496", size = 34357 }, +] + +[[package]] +name = "httpcore" +version = "1.0.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6a/41/d7d0a89eb493922c37d343b607bc1b5da7f5be7e383740b4753ad8943e90/httpcore-1.0.7.tar.gz", hash = "sha256:8551cb62a169ec7162ac7be8d4817d561f60e08eaa485234898414bb5a8a0b4c", size = 85196 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/87/f5/72347bc88306acb359581ac4d52f23c0ef445b57157adedb9aee0cd689d2/httpcore-1.0.7-py3-none-any.whl", hash = "sha256:a3fff8f43dc260d5bd363d9f9cf1830fa3a458b332856f34282de498ed420edd", size = 78551 }, +] + +[[package]] +name = "httptools" +version = "0.6.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a7/9a/ce5e1f7e131522e6d3426e8e7a490b3a01f39a6696602e1c4f33f9e94277/httptools-0.6.4.tar.gz", hash = "sha256:4e93eee4add6493b59a5c514da98c939b244fce4a0d8879cd3f466562f4b7d5c", size = 240639 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bb/0e/d0b71465c66b9185f90a091ab36389a7352985fe857e352801c39d6127c8/httptools-0.6.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:df017d6c780287d5c80601dafa31f17bddb170232d85c066604d8558683711a2", size = 200683 }, + { url = "https://files.pythonhosted.org/packages/e2/b8/412a9bb28d0a8988de3296e01efa0bd62068b33856cdda47fe1b5e890954/httptools-0.6.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:85071a1e8c2d051b507161f6c3e26155b5c790e4e28d7f236422dbacc2a9cc44", size = 104337 }, + { url = "https://files.pythonhosted.org/packages/9b/01/6fb20be3196ffdc8eeec4e653bc2a275eca7f36634c86302242c4fbb2760/httptools-0.6.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:69422b7f458c5af875922cdb5bd586cc1f1033295aa9ff63ee196a87519ac8e1", size = 508796 }, + { url = "https://files.pythonhosted.org/packages/f7/d8/b644c44acc1368938317d76ac991c9bba1166311880bcc0ac297cb9d6bd7/httptools-0.6.4-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:16e603a3bff50db08cd578d54f07032ca1631450ceb972c2f834c2b860c28ea2", size = 510837 }, + { url = "https://files.pythonhosted.org/packages/52/d8/254d16a31d543073a0e57f1c329ca7378d8924e7e292eda72d0064987486/httptools-0.6.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ec4f178901fa1834d4a060320d2f3abc5c9e39766953d038f1458cb885f47e81", size = 485289 }, + { url = "https://files.pythonhosted.org/packages/5f/3c/4aee161b4b7a971660b8be71a92c24d6c64372c1ab3ae7f366b3680df20f/httptools-0.6.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f9eb89ecf8b290f2e293325c646a211ff1c2493222798bb80a530c5e7502494f", size = 489779 }, + { url = "https://files.pythonhosted.org/packages/12/b7/5cae71a8868e555f3f67a50ee7f673ce36eac970f029c0c5e9d584352961/httptools-0.6.4-cp312-cp312-win_amd64.whl", hash = "sha256:db78cb9ca56b59b016e64b6031eda5653be0589dba2b1b43453f6e8b405a0970", size = 88634 }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517 }, +] + +[package.optional-dependencies] +http2 = [ + { name = "h2" }, +] + +[[package]] +name = "hyperframe" +version = "6.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/02/e7/94f8232d4a74cc99514c13a9f995811485a6903d48e5d952771ef6322e30/hyperframe-6.1.0.tar.gz", hash = "sha256:f630908a00854a7adeabd6382b43923a4c4cd4b821fcb527e6ab9e15382a3b08", size = 26566 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/48/30/47d0bf6072f7252e6521f3447ccfa40b421b6824517f82854703d0f5a98b/hyperframe-6.1.0-py3-none-any.whl", hash = "sha256:b03380493a519fce58ea5af42e4a42317bf9bd425596f7a0835ffce80f1a42e5", size = 13007 }, +] + +[[package]] +name = "idna" +version = "3.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 }, +] + +[[package]] +name = "importlib-metadata" +version = "8.6.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "zipp" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/33/08/c1395a292bb23fd03bdf572a1357c5a733d3eecbab877641ceacab23db6e/importlib_metadata-8.6.1.tar.gz", hash = "sha256:310b41d755445d74569f993ccfc22838295d9fe005425094fad953d7f15c8580", size = 55767 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/79/9d/0fb148dc4d6fa4a7dd1d8378168d9b4cd8d4560a6fbf6f0121c5fc34eb68/importlib_metadata-8.6.1-py3-none-any.whl", hash = "sha256:02a89390c1e15fdfdc0d7c6b25cb3e62650d0494005c97d6f148bf5b9787525e", size = 26971 }, +] + +[[package]] +name = "iniconfig" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f2/97/ebf4da567aa6827c909642694d71c9fcf53e5b504f2d96afea02718862f3/iniconfig-2.1.0.tar.gz", hash = "sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7", size = 4793 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050 }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899 }, +] + +[[package]] +name = "jiter" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1e/c2/e4562507f52f0af7036da125bb699602ead37a2332af0788f8e0a3417f36/jiter-0.9.0.tar.gz", hash = "sha256:aadba0964deb424daa24492abc3d229c60c4a31bfee205aedbf1acc7639d7893", size = 162604 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/d7/c55086103d6f29b694ec79156242304adf521577530d9031317ce5338c59/jiter-0.9.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:7b46249cfd6c48da28f89eb0be3f52d6fdb40ab88e2c66804f546674e539ec11", size = 309203 }, + { url = "https://files.pythonhosted.org/packages/b0/01/f775dfee50beb420adfd6baf58d1c4d437de41c9b666ddf127c065e5a488/jiter-0.9.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:609cf3c78852f1189894383cf0b0b977665f54cb38788e3e6b941fa6d982c00e", size = 319678 }, + { url = "https://files.pythonhosted.org/packages/ab/b8/09b73a793714726893e5d46d5c534a63709261af3d24444ad07885ce87cb/jiter-0.9.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d726a3890a54561e55a9c5faea1f7655eda7f105bd165067575ace6e65f80bb2", size = 341816 }, + { url = "https://files.pythonhosted.org/packages/35/6f/b8f89ec5398b2b0d344257138182cc090302854ed63ed9c9051e9c673441/jiter-0.9.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2e89dc075c1fef8fa9be219e249f14040270dbc507df4215c324a1839522ea75", size = 364152 }, + { url = "https://files.pythonhosted.org/packages/9b/ca/978cc3183113b8e4484cc7e210a9ad3c6614396e7abd5407ea8aa1458eef/jiter-0.9.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:04e8ffa3c353b1bc4134f96f167a2082494351e42888dfcf06e944f2729cbe1d", size = 406991 }, + { url = "https://files.pythonhosted.org/packages/13/3a/72861883e11a36d6aa314b4922125f6ae90bdccc225cd96d24cc78a66385/jiter-0.9.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:203f28a72a05ae0e129b3ed1f75f56bc419d5f91dfacd057519a8bd137b00c42", size = 395824 }, + { url = "https://files.pythonhosted.org/packages/87/67/22728a86ef53589c3720225778f7c5fdb617080e3deaed58b04789418212/jiter-0.9.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fca1a02ad60ec30bb230f65bc01f611c8608b02d269f998bc29cca8619a919dc", size = 351318 }, + { url = "https://files.pythonhosted.org/packages/69/b9/f39728e2e2007276806d7a6609cda7fac44ffa28ca0d02c49a4f397cc0d9/jiter-0.9.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:237e5cee4d5d2659aaf91bbf8ec45052cc217d9446070699441a91b386ae27dc", size = 384591 }, + { url = "https://files.pythonhosted.org/packages/eb/8f/8a708bc7fd87b8a5d861f1c118a995eccbe6d672fe10c9753e67362d0dd0/jiter-0.9.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:528b6b71745e7326eed73c53d4aa57e2a522242320b6f7d65b9c5af83cf49b6e", size = 520746 }, + { url = "https://files.pythonhosted.org/packages/95/1e/65680c7488bd2365dbd2980adaf63c562d3d41d3faac192ebc7ef5b4ae25/jiter-0.9.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:9f48e86b57bc711eb5acdfd12b6cb580a59cc9a993f6e7dcb6d8b50522dcd50d", size = 512754 }, + { url = "https://files.pythonhosted.org/packages/78/f3/fdc43547a9ee6e93c837685da704fb6da7dba311fc022e2766d5277dfde5/jiter-0.9.0-cp312-cp312-win32.whl", hash = "sha256:699edfde481e191d81f9cf6d2211debbfe4bd92f06410e7637dffb8dd5dfde06", size = 207075 }, + { url = "https://files.pythonhosted.org/packages/cd/9d/742b289016d155f49028fe1bfbeb935c9bf0ffeefdf77daf4a63a42bb72b/jiter-0.9.0-cp312-cp312-win_amd64.whl", hash = "sha256:099500d07b43f61d8bd780466d429c45a7b25411b334c60ca875fa775f68ccb0", size = 207999 }, +] + +[[package]] +name = "jmespath" +version = "1.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/00/2a/e867e8531cf3e36b41201936b7fa7ba7b5702dbef42922193f05c8976cd6/jmespath-1.0.1.tar.gz", hash = "sha256:90261b206d6defd58fdd5e85f478bf633a2901798906be2ad389150c5c60edbe", size = 25843 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/31/b4/b9b800c45527aadd64d5b442f9b932b00648617eb5d63d2c7a6587b7cafc/jmespath-1.0.1-py3-none-any.whl", hash = "sha256:02e2e4cc71b5bcab88332eebf907519190dd9e6e82107fa7f83b1003a6252980", size = 20256 }, +] + +[[package]] +name = "jockey" +version = "0.1.0" +source = { editable = "jockey" } +dependencies = [ + { name = "click" }, + { name = "docker" }, + { name = "fastapi" }, + { name = "gitpython" }, + { name = "jinja2" }, + { name = "kubernetes" }, + { name = "python-dotenv" }, + { name = "pyyaml" }, + { name = "redis" }, + { name = "uvicorn" }, +] + +[package.metadata] +requires-dist = [ + { name = "black", marker = "extra == 'dev'", specifier = ">=23.0.0" }, + { name = "click", specifier = ">=8.0.0" }, + { name = "docker", specifier = ">=6.0.0" }, + { name = "docker", marker = "extra == 'dev'", specifier = ">=6.0.0" }, + { name = "fastapi", specifier = ">=0.100.0" }, + { name = "gitpython", specifier = ">=3.1.0" }, + { name = "httpx", marker = "extra == 'dev'", specifier = ">=0.24.0" }, + { name = "jinja2", specifier = ">=3.0.0" }, + { name = "kubernetes", specifier = ">=28.0.0" }, + { name = "pytest", marker = "extra == 'dev'", specifier = ">=7.0.0" }, + { name = "pytest-cov", marker = "extra == 'dev'", specifier = ">=4.0.0" }, + { name = "pytest-mock", marker = "extra == 'dev'", specifier = ">=3.10.0" }, + { name = "python-dotenv", specifier = ">=1.0.0" }, + { name = "pyyaml", specifier = ">=6.0" }, + { name = "redis", specifier = ">=5.0.0" }, + { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.1.0" }, + { name = "uvicorn", specifier = ">=0.23.0" }, +] + +[[package]] +name = "jsonschema" +version = "4.23.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/38/2e/03362ee4034a4c917f697890ccd4aec0800ccf9ded7f511971c75451deec/jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4", size = 325778 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/4a/4f9dbeb84e8850557c02365a0eee0649abe5eb1d84af92a25731c6c0f922/jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566", size = 88462 }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2024.10.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/10/db/58f950c996c793472e336ff3655b13fbcf1e3b359dcf52dcf3ed3b52c352/jsonschema_specifications-2024.10.1.tar.gz", hash = "sha256:0f38b83639958ce1152d02a7f062902c41c8fd20d558b0c34344292d417ae272", size = 15561 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/0f/8910b19ac0670a0f80ce1008e5e751c4a57e14d2c4c13a482aa6079fa9d6/jsonschema_specifications-2024.10.1-py3-none-any.whl", hash = "sha256:a09a0680616357d9a0ecf05c12ad234479f549239d0f5b55f3deea67475da9bf", size = 18459 }, +] + +[[package]] +name = "kubernetes" +version = "33.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "durationpy" }, + { name = "google-auth" }, + { name = "oauthlib" }, + { name = "python-dateutil" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "requests-oauthlib" }, + { name = "six" }, + { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation == 'PyPy'" }, + { name = "urllib3", version = "2.3.0", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation != 'PyPy'" }, + { name = "websocket-client" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ae/52/19ebe8004c243fdfa78268a96727c71e08f00ff6fe69a301d0b7fcbce3c2/kubernetes-33.1.0.tar.gz", hash = "sha256:f64d829843a54c251061a8e7a14523b521f2dc5c896cf6d65ccf348648a88993", size = 1036779 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/89/43/d9bebfc3db7dea6ec80df5cb2aad8d274dd18ec2edd6c4f21f32c237cbbb/kubernetes-33.1.0-py2.py3-none-any.whl", hash = "sha256:544de42b24b64287f7e0aa9513c93cb503f7f40eea39b20f66810011a86eabc5", size = 1941335 }, +] + +[[package]] +name = "lz4" +version = "4.4.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/bc/b2e79af05be82841706ddd7d78059e5f78e6ca5828f92034394b54e303b7/lz4-4.4.3.tar.gz", hash = "sha256:91ed5b71f9179bf3dbfe85d92b52d4b53de2e559aa4daa3b7de18e0dd24ad77d", size = 171848 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/40/9a6db39950ba872c3b75ccf4826288a46b109ded1d20508d6044cc36e33c/lz4-4.4.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:43461e439ef71d49bb0ee3a1719494cd952a58d205496698e0cde866f22006bc", size = 220484 }, + { url = "https://files.pythonhosted.org/packages/b7/25/edd77ac155e167f0d183f0a30be1665ab581f77108ca6e19d628cd381e42/lz4-4.4.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2ae50a175fb7b900f7aa42575f4fe99c32ca0ff57e5a8c1fd25e1243e67409db", size = 189473 }, + { url = "https://files.pythonhosted.org/packages/55/59/80673123358c0e0b2b773b74ac3d14717e35cfcceac5243b61f88e08b883/lz4-4.4.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:38df5929ffefa9dda120ba1790a2e94fda81916c5aaa1ee652f4b1e515ebb9ed", size = 1264959 }, + { url = "https://files.pythonhosted.org/packages/ea/69/24a3d8609f9a05d93b407d93842d35e953bebf625cb4d128a9105c983d59/lz4-4.4.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2b45914f25d916324531d0259072b402c5f99b67c6e9ac8cbc3d49935aeb1d97", size = 1184842 }, + { url = "https://files.pythonhosted.org/packages/88/6e/680d0fc3dbec31aaffcad23d2e429b2974253ffda4636ea8a7e2cce5461c/lz4-4.4.3-cp312-cp312-win32.whl", hash = "sha256:848c5b040d2cfe35097b1d65d1095d83a3f86374ce879e189533f61405d8763b", size = 88157 }, + { url = "https://files.pythonhosted.org/packages/d4/c9/8fcaf3445d3dc2973861b1a1a27090e23952807facabcf092a587ff77754/lz4-4.4.3-cp312-cp312-win_amd64.whl", hash = "sha256:b1d179bdefd9ddb8d11d7de7825e73fb957511b722a8cb484e417885c210e68c", size = 99833 }, +] + +[[package]] +name = "markupsafe" +version = "3.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/97/5d42485e71dfc078108a86d6de8fa46db44a1a9295e89c5d6d4a06e23a62/markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0", size = 20537 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/09/d1f21434c97fc42f09d290cbb6350d44eb12f09cc62c9476effdb33a18aa/MarkupSafe-3.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9778bd8ab0a994ebf6f84c2b949e65736d5575320a17ae8984a77fab08db94cf", size = 14274 }, + { url = "https://files.pythonhosted.org/packages/6b/b0/18f76bba336fa5aecf79d45dcd6c806c280ec44538b3c13671d49099fdd0/MarkupSafe-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:846ade7b71e3536c4e56b386c2a47adf5741d2d8b94ec9dc3e92e5e1ee1e2225", size = 12348 }, + { url = "https://files.pythonhosted.org/packages/e0/25/dd5c0f6ac1311e9b40f4af06c78efde0f3b5cbf02502f8ef9501294c425b/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c99d261bd2d5f6b59325c92c73df481e05e57f19837bdca8413b9eac4bd8028", size = 24149 }, + { url = "https://files.pythonhosted.org/packages/f3/f0/89e7aadfb3749d0f52234a0c8c7867877876e0a20b60e2188e9850794c17/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e17c96c14e19278594aa4841ec148115f9c7615a47382ecb6b82bd8fea3ab0c8", size = 23118 }, + { url = "https://files.pythonhosted.org/packages/d5/da/f2eeb64c723f5e3777bc081da884b414671982008c47dcc1873d81f625b6/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88416bd1e65dcea10bc7569faacb2c20ce071dd1f87539ca2ab364bf6231393c", size = 22993 }, + { url = "https://files.pythonhosted.org/packages/da/0e/1f32af846df486dce7c227fe0f2398dc7e2e51d4a370508281f3c1c5cddc/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2181e67807fc2fa785d0592dc2d6206c019b9502410671cc905d132a92866557", size = 24178 }, + { url = "https://files.pythonhosted.org/packages/c4/f6/bb3ca0532de8086cbff5f06d137064c8410d10779c4c127e0e47d17c0b71/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:52305740fe773d09cffb16f8ed0427942901f00adedac82ec8b67752f58a1b22", size = 23319 }, + { url = "https://files.pythonhosted.org/packages/a2/82/8be4c96ffee03c5b4a034e60a31294daf481e12c7c43ab8e34a1453ee48b/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad10d3ded218f1039f11a75f8091880239651b52e9bb592ca27de44eed242a48", size = 23352 }, + { url = "https://files.pythonhosted.org/packages/51/ae/97827349d3fcffee7e184bdf7f41cd6b88d9919c80f0263ba7acd1bbcb18/MarkupSafe-3.0.2-cp312-cp312-win32.whl", hash = "sha256:0f4ca02bea9a23221c0182836703cbf8930c5e9454bacce27e767509fa286a30", size = 15097 }, + { url = "https://files.pythonhosted.org/packages/c1/80/a61f99dc3a936413c3ee4e1eecac96c0da5ed07ad56fd975f1a9da5bc630/MarkupSafe-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:8e06879fc22a25ca47312fbe7c8264eb0b662f6db27cb2d3bbbc74b1df4b9b87", size = 15601 }, +] + +[[package]] +name = "multidict" +version = "6.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/82/4a/7874ca44a1c9b23796c767dd94159f6c17e31c0e7d090552a1c623247d82/multidict-6.2.0.tar.gz", hash = "sha256:0085b0afb2446e57050140240a8595846ed64d1cbd26cef936bfab3192c673b8", size = 71066 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a4/e2/0153a8db878aef9b2397be81e62cbc3b32ca9b94e0f700b103027db9d506/multidict-6.2.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:437c33561edb6eb504b5a30203daf81d4a9b727e167e78b0854d9a4e18e8950b", size = 49204 }, + { url = "https://files.pythonhosted.org/packages/bb/9d/5ccb3224a976d1286f360bb4e89e67b7cdfb87336257fc99be3c17f565d7/multidict-6.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9f49585f4abadd2283034fc605961f40c638635bc60f5162276fec075f2e37a4", size = 29807 }, + { url = "https://files.pythonhosted.org/packages/62/32/ef20037f51b84b074a89bab5af46d4565381c3f825fc7cbfc19c1ee156be/multidict-6.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5dd7106d064d05896ce28c97da3f46caa442fe5a43bc26dfb258e90853b39b44", size = 30000 }, + { url = "https://files.pythonhosted.org/packages/97/81/b0a7560bfc3ec72606232cd7e60159e09b9cf29e66014d770c1315868fa2/multidict-6.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e25b11a0417475f093d0f0809a149aff3943c2c56da50fdf2c3c88d57fe3dfbd", size = 131820 }, + { url = "https://files.pythonhosted.org/packages/49/3b/768bfc0e41179fbccd3a22925329a11755b7fdd53bec66dbf6b8772f0bce/multidict-6.2.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ac380cacdd3b183338ba63a144a34e9044520a6fb30c58aa14077157a033c13e", size = 136272 }, + { url = "https://files.pythonhosted.org/packages/71/ac/fd2be3fe98ff54e7739448f771ba730d42036de0870737db9ae34bb8efe9/multidict-6.2.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:61d5541f27533f803a941d3a3f8a3d10ed48c12cf918f557efcbf3cd04ef265c", size = 135233 }, + { url = "https://files.pythonhosted.org/packages/93/76/1657047da771315911a927b364a32dafce4135b79b64208ce4ac69525c56/multidict-6.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:facaf11f21f3a4c51b62931feb13310e6fe3475f85e20d9c9fdce0d2ea561b87", size = 132861 }, + { url = "https://files.pythonhosted.org/packages/19/a5/9f07ffb9bf68b8aaa406c2abee27ad87e8b62a60551587b8e59ee91aea84/multidict-6.2.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:095a2eabe8c43041d3e6c2cb8287a257b5f1801c2d6ebd1dd877424f1e89cf29", size = 122166 }, + { url = "https://files.pythonhosted.org/packages/95/23/b5ce3318d9d6c8f105c3679510f9d7202980545aad8eb4426313bd8da3ee/multidict-6.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a0cc398350ef31167e03f3ca7c19313d4e40a662adcb98a88755e4e861170bdd", size = 136052 }, + { url = "https://files.pythonhosted.org/packages/ce/5c/02cffec58ffe120873dce520af593415b91cc324be0345f534ad3637da4e/multidict-6.2.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:7c611345bbe7cb44aabb877cb94b63e86f2d0db03e382667dbd037866d44b4f8", size = 130094 }, + { url = "https://files.pythonhosted.org/packages/49/f3/3b19a83f4ebf53a3a2a0435f3e447aa227b242ba3fd96a92404b31fb3543/multidict-6.2.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8cd1a0644ccaf27e9d2f6d9c9474faabee21f0578fe85225cc5af9a61e1653df", size = 140962 }, + { url = "https://files.pythonhosted.org/packages/cc/1a/c916b54fb53168c24cb6a3a0795fd99d0a59a0ea93fa9f6edeff5565cb20/multidict-6.2.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:89b3857652183b8206a891168af47bac10b970d275bba1f6ee46565a758c078d", size = 138082 }, + { url = "https://files.pythonhosted.org/packages/ef/1a/dcb7fb18f64b3727c61f432c1e1a0d52b3924016124e4bbc8a7d2e4fa57b/multidict-6.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:125dd82b40f8c06d08d87b3510beaccb88afac94e9ed4a6f6c71362dc7dbb04b", size = 136019 }, + { url = "https://files.pythonhosted.org/packages/fb/02/7695485375106f5c542574f70e1968c391f86fa3efc9f1fd76aac0af7237/multidict-6.2.0-cp312-cp312-win32.whl", hash = "sha256:76b34c12b013d813e6cb325e6bd4f9c984db27758b16085926bbe7ceeaace626", size = 26676 }, + { url = "https://files.pythonhosted.org/packages/3c/f5/f147000fe1f4078160157b15b0790fff0513646b0f9b7404bf34007a9b44/multidict-6.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:0b183a959fb88ad1be201de2c4bdf52fa8e46e6c185d76201286a97b6f5ee65c", size = 28899 }, + { url = "https://files.pythonhosted.org/packages/9c/fd/b247aec6add5601956d440488b7f23151d8343747e82c038af37b28d6098/multidict-6.2.0-py3-none-any.whl", hash = "sha256:5d26547423e5e71dcc562c4acdc134b900640a39abd9066d7326a7cc2324c530", size = 10266 }, +] + +[[package]] +name = "networkx" +version = "3.4.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fd/1d/06475e1cd5264c0b870ea2cc6fdb3e37177c1e565c43f56ff17a10e3937f/networkx-3.4.2.tar.gz", hash = "sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1", size = 2151368 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/54/dd730b32ea14ea797530a4479b2ed46a6fb250f682a9cfb997e968bf0261/networkx-3.4.2-py3-none-any.whl", hash = "sha256:df5d4365b724cf81b8c6a7312509d0c22386097011ad1abe274afd5e9d3bbc5f", size = 1723263 }, +] + +[[package]] +name = "oauthlib" +version = "3.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0b/5f/19930f824ffeb0ad4372da4812c50edbd1434f678c90c2733e1188edfc63/oauthlib-3.3.1.tar.gz", hash = "sha256:0f0f8aa759826a193cf66c12ea1af1637f87b9b4622d46e866952bb022e538c9", size = 185918 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/be/9c/92789c596b8df838baa98fa71844d84283302f7604ed565dafe5a6b5041a/oauthlib-3.3.1-py3-none-any.whl", hash = "sha256:88119c938d2b8fb88561af5f6ee0eec8cc8d552b7bb1f712743136eb7523b7a1", size = 160065 }, +] + +[[package]] +name = "opentelemetry-api" +version = "1.31.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "deprecated" }, + { name = "importlib-metadata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8a/cf/db26ab9d748bf50d6edf524fb863aa4da616ba1ce46c57a7dff1112b73fb/opentelemetry_api-1.31.1.tar.gz", hash = "sha256:137ad4b64215f02b3000a0292e077641c8611aab636414632a9b9068593b7e91", size = 64059 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6c/c8/86557ff0da32f3817bc4face57ea35cfdc2f9d3bcefd42311ef860dcefb7/opentelemetry_api-1.31.1-py3-none-any.whl", hash = "sha256:1511a3f470c9c8a32eeea68d4ea37835880c0eed09dd1a0187acc8b1301da0a1", size = 65197 }, +] + +[[package]] +name = "opentelemetry-sdk" +version = "1.31.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "opentelemetry-api" }, + { name = "opentelemetry-semantic-conventions" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/63/d9/4fe159908a63661e9e635e66edc0d0d816ed20cebcce886132b19ae87761/opentelemetry_sdk-1.31.1.tar.gz", hash = "sha256:c95f61e74b60769f8ff01ec6ffd3d29684743404603df34b20aa16a49dc8d903", size = 159523 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/36/758e5d3746bc86a2af20aa5e2236a7c5aa4264b501dc0e9f40efd9078ef0/opentelemetry_sdk-1.31.1-py3-none-any.whl", hash = "sha256:882d021321f223e37afaca7b4e06c1d8bbc013f9e17ff48a7aa017460a8e7dae", size = 118866 }, +] + +[[package]] +name = "opentelemetry-semantic-conventions" +version = "0.52b1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "deprecated" }, + { name = "opentelemetry-api" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/8c/599f9f27cff097ec4d76fbe9fe6d1a74577ceec52efe1a999511e3c42ef5/opentelemetry_semantic_conventions-0.52b1.tar.gz", hash = "sha256:7b3d226ecf7523c27499758a58b542b48a0ac8d12be03c0488ff8ec60c5bae5d", size = 111275 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/98/be/d4ba300cfc1d4980886efbc9b48ee75242b9fcf940d9c4ccdc9ef413a7cf/opentelemetry_semantic_conventions-0.52b1-py3-none-any.whl", hash = "sha256:72b42db327e29ca8bb1b91e8082514ddf3bbf33f32ec088feb09526ade4bc77e", size = 183409 }, +] + +[[package]] +name = "opentelemetry-semantic-conventions-ai" +version = "0.4.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2b/8f/7fb173fd1928398b81d0952f7a9f30381ce3215817e3ac6e92f180434874/opentelemetry_semantic_conventions_ai-0.4.3.tar.gz", hash = "sha256:761a68a7e99436dfc53cfe1f99507316aa0114ac480f0c42743b9320b7c94831", size = 4540 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/56/b178de82b650526ff5d5e67037786008ea0acd043051d535c483dabd3cc4/opentelemetry_semantic_conventions_ai-0.4.3-py3-none-any.whl", hash = "sha256:9ff60bbf38c8a891c20a355b4ca1948380361e27412c3ead264de0d050fa2570", size = 5384 }, +] + +[[package]] +name = "packaging" +version = "24.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 }, +] + +[[package]] +name = "pdbpp" +version = "0.10.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fancycompleter" }, + { name = "pygments" }, + { name = "wmctrl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1f/a3/c4bd048256fd4b7d28767ca669c505e156f24d16355505c62e6fce3314df/pdbpp-0.10.3.tar.gz", hash = "sha256:d9e43f4fda388eeb365f2887f4e7b66ac09dce9b6236b76f63616530e2f669f5", size = 68116 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/93/ee/491e63a57fffa78b9de1c337b06c97d0cd0753e88c00571c7b011680332a/pdbpp-0.10.3-py2.py3-none-any.whl", hash = "sha256:79580568e33eb3d6f6b462b1187f53e10cd8e4538f7d31495c9181e2cf9665d1", size = 23961 }, +] + +[[package]] +name = "pluggy" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556 }, +] + +[[package]] +name = "postgrest" +version = "0.19.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "deprecation" }, + { name = "httpx", extra = ["http2"] }, + { name = "pydantic" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/63/80/b0306469da7ad89db165ce4c76de2f12eccc7fadb900cab9cbaff760a587/postgrest-0.19.3.tar.gz", hash = "sha256:28a70f03bf3a975aa865a10487b1ce09b7195f56453f7c318a70d3117a3d323c", size = 15095 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b0/82/f1825a85745912cdd8956aad8ebc4b797d2f891c380c2b8825b35914dbd1/postgrest-0.19.3-py3-none-any.whl", hash = "sha256:03a7e638962454d10bb712c35e63a8a4bc452917917a4e9eb7427bd5b3c6c485", size = 22198 }, +] + +[[package]] +name = "propcache" +version = "0.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/92/76/f941e63d55c0293ff7829dd21e7cf1147e90a526756869a9070f287a68c9/propcache-0.3.0.tar.gz", hash = "sha256:a8fd93de4e1d278046345f49e2238cdb298589325849b2645d4a94c53faeffc5", size = 42722 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8d/2c/921f15dc365796ec23975b322b0078eae72995c7b4d49eba554c6a308d70/propcache-0.3.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e53d19c2bf7d0d1e6998a7e693c7e87300dd971808e6618964621ccd0e01fe4e", size = 79867 }, + { url = "https://files.pythonhosted.org/packages/11/a5/4a6cc1a559d1f2fb57ea22edc4245158cdffae92f7f92afcee2913f84417/propcache-0.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a61a68d630e812b67b5bf097ab84e2cd79b48c792857dc10ba8a223f5b06a2af", size = 46109 }, + { url = "https://files.pythonhosted.org/packages/e1/6d/28bfd3af3a567ad7d667348e7f46a520bda958229c4d545ba138a044232f/propcache-0.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fb91d20fa2d3b13deea98a690534697742029f4fb83673a3501ae6e3746508b5", size = 45635 }, + { url = "https://files.pythonhosted.org/packages/73/20/d75b42eaffe5075eac2f4e168f6393d21c664c91225288811d85451b2578/propcache-0.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:67054e47c01b7b349b94ed0840ccae075449503cf1fdd0a1fdd98ab5ddc2667b", size = 242159 }, + { url = "https://files.pythonhosted.org/packages/a5/fb/4b537dd92f9fd4be68042ec51c9d23885ca5fafe51ec24c58d9401034e5f/propcache-0.3.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:997e7b8f173a391987df40f3b52c423e5850be6f6df0dcfb5376365440b56667", size = 248163 }, + { url = "https://files.pythonhosted.org/packages/e7/af/8a9db04ac596d531ca0ef7dde518feaadfcdabef7b17d6a5ec59ee3effc2/propcache-0.3.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8d663fd71491dde7dfdfc899d13a067a94198e90695b4321084c6e450743b8c7", size = 248794 }, + { url = "https://files.pythonhosted.org/packages/9d/c4/ecfc988879c0fd9db03228725b662d76cf484b6b46f7e92fee94e4b52490/propcache-0.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8884ba1a0fe7210b775106b25850f5e5a9dc3c840d1ae9924ee6ea2eb3acbfe7", size = 243912 }, + { url = "https://files.pythonhosted.org/packages/04/a2/298dd27184faa8b7d91cc43488b578db218b3cc85b54d912ed27b8c5597a/propcache-0.3.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aa806bbc13eac1ab6291ed21ecd2dd426063ca5417dd507e6be58de20e58dfcf", size = 229402 }, + { url = "https://files.pythonhosted.org/packages/be/0d/efe7fec316ca92dbf4bc4a9ba49ca889c43ca6d48ab1d6fa99fc94e5bb98/propcache-0.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6f4d7a7c0aff92e8354cceca6fe223973ddf08401047920df0fcb24be2bd5138", size = 226896 }, + { url = "https://files.pythonhosted.org/packages/60/63/72404380ae1d9c96d96e165aa02c66c2aae6072d067fc4713da5cde96762/propcache-0.3.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:9be90eebc9842a93ef8335291f57b3b7488ac24f70df96a6034a13cb58e6ff86", size = 221447 }, + { url = "https://files.pythonhosted.org/packages/9d/18/b8392cab6e0964b67a30a8f4dadeaff64dc7022b5a34bb1d004ea99646f4/propcache-0.3.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:bf15fc0b45914d9d1b706f7c9c4f66f2b7b053e9517e40123e137e8ca8958b3d", size = 222440 }, + { url = "https://files.pythonhosted.org/packages/6f/be/105d9ceda0f97eff8c06bac1673448b2db2a497444de3646464d3f5dc881/propcache-0.3.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5a16167118677d94bb48bfcd91e420088854eb0737b76ec374b91498fb77a70e", size = 234104 }, + { url = "https://files.pythonhosted.org/packages/cb/c9/f09a4ec394cfcce4053d8b2a04d622b5f22d21ba9bb70edd0cad061fa77b/propcache-0.3.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:41de3da5458edd5678b0f6ff66691507f9885f5fe6a0fb99a5d10d10c0fd2d64", size = 239086 }, + { url = "https://files.pythonhosted.org/packages/ea/aa/96f7f9ed6def82db67c972bdb7bd9f28b95d7d98f7e2abaf144c284bf609/propcache-0.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:728af36011bb5d344c4fe4af79cfe186729efb649d2f8b395d1572fb088a996c", size = 230991 }, + { url = "https://files.pythonhosted.org/packages/5a/11/bee5439de1307d06fad176f7143fec906e499c33d7aff863ea8428b8e98b/propcache-0.3.0-cp312-cp312-win32.whl", hash = "sha256:6b5b7fd6ee7b54e01759f2044f936dcf7dea6e7585f35490f7ca0420fe723c0d", size = 40337 }, + { url = "https://files.pythonhosted.org/packages/e4/17/e5789a54a0455a61cb9efc4ca6071829d992220c2998a27c59aeba749f6f/propcache-0.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:2d15bc27163cd4df433e75f546b9ac31c1ba7b0b128bfb1b90df19082466ff57", size = 44404 }, + { url = "https://files.pythonhosted.org/packages/b5/35/6c4c6fc8774a9e3629cd750dc24a7a4fb090a25ccd5c3246d127b70f9e22/propcache-0.3.0-py3-none-any.whl", hash = "sha256:67dda3c7325691c2081510e92c561f465ba61b975f481735aefdfc845d2cd043", size = 12101 }, +] + +[[package]] +name = "psycopg" +version = "3.2.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, + { name = "tzdata", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/67/97/eea08f74f1c6dd2a02ee81b4ebfe5b558beb468ebbd11031adbf58d31be0/psycopg-3.2.6.tar.gz", hash = "sha256:16fa094efa2698f260f2af74f3710f781e4a6f226efe9d1fd0c37f384639ed8a", size = 156322 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d7/7d/0ba52deff71f65df8ec8038adad86ba09368c945424a9bd8145d679a2c6a/psycopg-3.2.6-py3-none-any.whl", hash = "sha256:f3ff5488525890abb0566c429146add66b329e20d6d4835662b920cbbf90ac58", size = 199077 }, +] + +[package.optional-dependencies] +binary = [ + { name = "psycopg-binary", marker = "implementation_name != 'pypy'" }, +] + +[[package]] +name = "psycopg-binary" +version = "3.2.6" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/c7/220b1273f0befb2cd9fe83d379b3484ae029a88798a90bc0d36f10bea5df/psycopg_binary-3.2.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f27a46ff0497e882e8c0286e8833c785b4d1a80f23e1bf606f4c90e5f9f3ce75", size = 3857986 }, + { url = "https://files.pythonhosted.org/packages/8a/d8/30176532826cf87c608a6f79dd668bf9aff0cdf8eb80209eddf4c5aa7229/psycopg_binary-3.2.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b30ee4821ded7de48b8048b14952512588e7c5477b0a5965221e1798afba61a1", size = 3940060 }, + { url = "https://files.pythonhosted.org/packages/54/7c/fa7cd1f057f33f7ae483d6bc5a03ec6eff111f8aa5c678d9aaef92705247/psycopg_binary-3.2.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e57edf3b1f5427f39660225b01f8e7b97f5cfab132092f014bf1638bc85d81d2", size = 4499082 }, + { url = "https://files.pythonhosted.org/packages/b8/81/1606966f6146187c273993ea6f88f2151b26741df8f4e01349a625983be9/psycopg_binary-3.2.6-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6c5172ce3e4ae7a4fd450070210f801e2ce6bc0f11d1208d29268deb0cda34de", size = 4307509 }, + { url = "https://files.pythonhosted.org/packages/69/ad/01c87aab17a4b89128b8036800d11ab296c7c2c623940cc7e6f2668f375a/psycopg_binary-3.2.6-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bcfab3804c43571a6615e559cdc4c4115785d258a4dd71a721be033f5f5f378d", size = 4547813 }, + { url = "https://files.pythonhosted.org/packages/65/30/f93a193846ee738ffe5d2a4837e7ddeb7279707af81d088cee96cae853a0/psycopg_binary-3.2.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8fa1c920cce16f1205f37b20c685c58b9656b170b8b4c93629100d342d0d118e", size = 4259847 }, + { url = "https://files.pythonhosted.org/packages/8e/73/65c4ae71be86675a62154407c92af4b917146f9ff3baaf0e4166c0734aeb/psycopg_binary-3.2.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2e118d818101c1608c6b5ba52a6c977614d8f05aa89467501172ba4d10588e11", size = 3846550 }, + { url = "https://files.pythonhosted.org/packages/53/cc/a24626cac3f208c776bb22e15e9a5e483aa81145221e6427e50381f40811/psycopg_binary-3.2.6-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:763319a8bfeca77d31512da71f5a33459b9568a7621c481c3828c62f9c38f351", size = 3320269 }, + { url = "https://files.pythonhosted.org/packages/55/e6/68c76fb9d6c53d5e4170a0c9216c7aa6c2903808f626d84d002b47a16931/psycopg_binary-3.2.6-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:2fbc05819560389dbece046966bc88e0f2ea77673497e274c4293b8b4c1d0703", size = 3399365 }, + { url = "https://files.pythonhosted.org/packages/b4/2c/55b140f5a2c582dae42ef38502c45ef69c938274242a40bd04c143081029/psycopg_binary-3.2.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5a57f99bb953b4bd6f32d0a9844664e7f6ca5ead9ba40e96635be3cd30794813", size = 3438908 }, + { url = "https://files.pythonhosted.org/packages/ae/f6/589c95cceccee2ab408b6b2e16f1ed6db4536fb24f2f5c9ce568cf43270c/psycopg_binary-3.2.6-cp312-cp312-win_amd64.whl", hash = "sha256:5de6809e19a465dcb9c269675bded46a135f2d600cd99f0735afbb21ddad2af4", size = 2782886 }, +] + +[[package]] +name = "psycopg-pool" +version = "3.2.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cf/13/1e7850bb2c69a63267c3dbf37387d3f71a00fd0e2fa55c5db14d64ba1af4/psycopg_pool-3.2.6.tar.gz", hash = "sha256:0f92a7817719517212fbfe2fd58b8c35c1850cdd2a80d36b581ba2085d9148e5", size = 29770 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/47/fd/4feb52a55c1a4bd748f2acaed1903ab54a723c47f6d0242780f4d97104d4/psycopg_pool-3.2.6-py3-none-any.whl", hash = "sha256:5887318a9f6af906d041a0b1dc1c60f8f0dda8340c2572b74e10907b51ed5da7", size = 38252 }, +] + +[[package]] +name = "pyasn1" +version = "0.6.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/e9/01f1a64245b89f039897cb0130016d79f77d52669aae6ee7b159a6c4c018/pyasn1-0.6.1.tar.gz", hash = "sha256:6f580d2bdd84365380830acf45550f2511469f673cb4a5ae3857a3170128b034", size = 145322 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/f1/d6a797abb14f6283c0ddff96bbdd46937f64122b8c925cab503dd37f8214/pyasn1-0.6.1-py3-none-any.whl", hash = "sha256:0d632f46f2ba09143da3a8afe9e33fb6f92fa2320ab7e886e2d0f7672af84629", size = 83135 }, +] + +[[package]] +name = "pyasn1-modules" +version = "0.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyasn1" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e9/e6/78ebbb10a8c8e4b61a59249394a4a594c1a7af95593dc933a349c8d00964/pyasn1_modules-0.4.2.tar.gz", hash = "sha256:677091de870a80aae844b1ca6134f54652fa2c8c5a52aa396440ac3106e941e6", size = 307892 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/47/8d/d529b5d697919ba8c11ad626e835d4039be708a35b0d22de83a269a6682c/pyasn1_modules-0.4.2-py3-none-any.whl", hash = "sha256:29253a9207ce32b64c3ac6600edc75368f98473906e8fd1043bd6b5b1de2c14a", size = 181259 }, +] + +[[package]] +name = "pycparser" +version = "2.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552 }, +] + +[[package]] +name = "pydantic" +version = "2.10.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b7/ae/d5220c5c52b158b1de7ca89fc5edb72f304a70a4c540c84c8844bf4008de/pydantic-2.10.6.tar.gz", hash = "sha256:ca5daa827cce33de7a42be142548b0096bf05a7e7b365aebfa5f8eeec7128236", size = 761681 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/3c/8cc1cc84deffa6e25d2d0c688ebb80635dfdbf1dbea3e30c541c8cf4d860/pydantic-2.10.6-py3-none-any.whl", hash = "sha256:427d664bf0b8a2b34ff5dd0f5a18df00591adcee7198fbd71981054cef37b584", size = 431696 }, +] + +[[package]] +name = "pydantic-core" +version = "2.27.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/01/f3e5ac5e7c25833db5eb555f7b7ab24cd6f8c322d3a3ad2d67a952dc0abc/pydantic_core-2.27.2.tar.gz", hash = "sha256:eb026e5a4c1fee05726072337ff51d1efb6f59090b7da90d30ea58625b1ffb39", size = 413443 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d6/74/51c8a5482ca447871c93e142d9d4a92ead74de6c8dc5e66733e22c9bba89/pydantic_core-2.27.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:9e0c8cfefa0ef83b4da9588448b6d8d2a2bf1a53c3f1ae5fca39eb3061e2f0b0", size = 1893127 }, + { url = "https://files.pythonhosted.org/packages/d3/f3/c97e80721735868313c58b89d2de85fa80fe8dfeeed84dc51598b92a135e/pydantic_core-2.27.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:83097677b8e3bd7eaa6775720ec8e0405f1575015a463285a92bfdfe254529ef", size = 1811340 }, + { url = "https://files.pythonhosted.org/packages/9e/91/840ec1375e686dbae1bd80a9e46c26a1e0083e1186abc610efa3d9a36180/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:172fce187655fece0c90d90a678424b013f8fbb0ca8b036ac266749c09438cb7", size = 1822900 }, + { url = "https://files.pythonhosted.org/packages/f6/31/4240bc96025035500c18adc149aa6ffdf1a0062a4b525c932065ceb4d868/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:519f29f5213271eeeeb3093f662ba2fd512b91c5f188f3bb7b27bc5973816934", size = 1869177 }, + { url = "https://files.pythonhosted.org/packages/fa/20/02fbaadb7808be578317015c462655c317a77a7c8f0ef274bc016a784c54/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:05e3a55d124407fffba0dd6b0c0cd056d10e983ceb4e5dbd10dda135c31071d6", size = 2038046 }, + { url = "https://files.pythonhosted.org/packages/06/86/7f306b904e6c9eccf0668248b3f272090e49c275bc488a7b88b0823444a4/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9c3ed807c7b91de05e63930188f19e921d1fe90de6b4f5cd43ee7fcc3525cb8c", size = 2685386 }, + { url = "https://files.pythonhosted.org/packages/8d/f0/49129b27c43396581a635d8710dae54a791b17dfc50c70164866bbf865e3/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6fb4aadc0b9a0c063206846d603b92030eb6f03069151a625667f982887153e2", size = 1997060 }, + { url = "https://files.pythonhosted.org/packages/0d/0f/943b4af7cd416c477fd40b187036c4f89b416a33d3cc0ab7b82708a667aa/pydantic_core-2.27.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:28ccb213807e037460326424ceb8b5245acb88f32f3d2777427476e1b32c48c4", size = 2004870 }, + { url = "https://files.pythonhosted.org/packages/35/40/aea70b5b1a63911c53a4c8117c0a828d6790483f858041f47bab0b779f44/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:de3cd1899e2c279b140adde9357c4495ed9d47131b4a4eaff9052f23398076b3", size = 1999822 }, + { url = "https://files.pythonhosted.org/packages/f2/b3/807b94fd337d58effc5498fd1a7a4d9d59af4133e83e32ae39a96fddec9d/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:220f892729375e2d736b97d0e51466252ad84c51857d4d15f5e9692f9ef12be4", size = 2130364 }, + { url = "https://files.pythonhosted.org/packages/fc/df/791c827cd4ee6efd59248dca9369fb35e80a9484462c33c6649a8d02b565/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a0fcd29cd6b4e74fe8ddd2c90330fd8edf2e30cb52acda47f06dd615ae72da57", size = 2158303 }, + { url = "https://files.pythonhosted.org/packages/9b/67/4e197c300976af185b7cef4c02203e175fb127e414125916bf1128b639a9/pydantic_core-2.27.2-cp312-cp312-win32.whl", hash = "sha256:1e2cb691ed9834cd6a8be61228471d0a503731abfb42f82458ff27be7b2186fc", size = 1834064 }, + { url = "https://files.pythonhosted.org/packages/1f/ea/cd7209a889163b8dcca139fe32b9687dd05249161a3edda62860430457a5/pydantic_core-2.27.2-cp312-cp312-win_amd64.whl", hash = "sha256:cc3f1a99a4f4f9dd1de4fe0312c114e740b5ddead65bb4102884b384c15d8bc9", size = 1989046 }, + { url = "https://files.pythonhosted.org/packages/bc/49/c54baab2f4658c26ac633d798dab66b4c3a9bbf47cff5284e9c182f4137a/pydantic_core-2.27.2-cp312-cp312-win_arm64.whl", hash = "sha256:3911ac9284cd8a1792d3cb26a2da18f3ca26c6908cc434a18f730dc0db7bfa3b", size = 1885092 }, +] + +[[package]] +name = "pyfakefs" +version = "5.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a8/50/a839c8812899e8955223d95b27767480856f9723b3230ddee0472cf1dbe2/pyfakefs-5.8.0.tar.gz", hash = "sha256:7e5457ee3cc67069d3cef6e278227ecfc80bfb61e925bc0a4d3b0af32d1c99ce", size = 215072 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/ac/ae2cf01b18b7ac04d22e5faf7d5eafcc000269c4f4a9036e40da6c37aed9/pyfakefs-5.8.0-py3-none-any.whl", hash = "sha256:4bd0fc8def7d0582139922447758632ff34a327b460a7e83feb6edbd841061dd", size = 230606 }, +] + +[[package]] +name = "pygments" +version = "2.19.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7c/2d/c3338d48ea6cc0feb8446d8e6937e1408088a72a39937982cc6111d17f84/pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f", size = 4968581 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293 }, +] + +[[package]] +name = "pyinstrument" +version = "5.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/64/6e/85c2722e40cab4fd9df6bbe68a0d032e237cf8cfada71e5f067e4e433214/pyinstrument-5.0.1.tar.gz", hash = "sha256:f4fd0754d02959c113a4b1ebed02f4627b6e2c138719ddf43244fd95f201c8c9", size = 263162 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e1/09/696e29364503393c5bd0471f1c396d41820167b3f496bf8b128dc981f30d/pyinstrument-5.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:cfd7b7dc56501a1f30aa059cc2f1746ece6258a841d2e4609882581f9c17f824", size = 128903 }, + { url = "https://files.pythonhosted.org/packages/b5/dd/36d1641414eb0ab3fb50815de8d927b74924a9bfb1e409c53e9aad4a16de/pyinstrument-5.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fe1f33178a2b0ddb3c6d2321406228bdad41286774e65314d511dcf4a71b83e4", size = 121440 }, + { url = "https://files.pythonhosted.org/packages/9e/3f/05196fb514735aceef9a9439f56bcaa5ccb8b440685aa4f13fdb9e925182/pyinstrument-5.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0519d02dee55a87afcf6d787f8d8f5a16d2b89f7ba9533064a986a2d31f27340", size = 144783 }, + { url = "https://files.pythonhosted.org/packages/73/4b/1b041b974e7e465ca311e712beb8be0bc9cf769bcfc6660b1b2ba630c27c/pyinstrument-5.0.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2f59ed9ac9466ff9b30eb7285160fa794aa3f8ce2bcf58a94142f945882d28ab", size = 143717 }, + { url = "https://files.pythonhosted.org/packages/4a/dc/3fa73e2dde1588b6281e494a14c183a27e1a67db7401fddf9c528fb8e1a9/pyinstrument-5.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cbf3114d332e499ba35ca4aedc1ef95bc6fb15c8d819729b5c0aeb35c8b64dd2", size = 145082 }, + { url = "https://files.pythonhosted.org/packages/91/24/b86d4273cc524a4f334a610a1c4b157146c808d8935e85d44dff3a6b75ee/pyinstrument-5.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:20f8054e85dd710f5a8c4d6b738867366ceef89671db09c87690ba1b5c66bd67", size = 144737 }, + { url = "https://files.pythonhosted.org/packages/3c/39/6025a71082122bfbfee4eac6649635e4c688954bdf306bcd3629457c49b2/pyinstrument-5.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:63e8d75ffa50c3cf6d980844efce0334659e934dcc3832bad08c23c171c545ff", size = 144488 }, + { url = "https://files.pythonhosted.org/packages/da/ce/679b0e9a278004defc93c277c3f81b456389dd530f89e28a45bd9dae203e/pyinstrument-5.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a3ca9c8540051513dd633de9d7eac9fee2eda50b78b6eedeaa7e5a7be66026b5", size = 144895 }, + { url = "https://files.pythonhosted.org/packages/58/d8/cf80bb278e2a071325e4fb244127eb68dce9d0520d20c1fda75414f119ee/pyinstrument-5.0.1-cp312-cp312-win32.whl", hash = "sha256:b549d910b846757ffbf74d94528d1a694a3848a6cfc6a6cab2ce697ee71e4548", size = 123027 }, + { url = "https://files.pythonhosted.org/packages/39/49/9251fe641d242d4c0dc49178b064f22da1c542d80e4040561428a9f8dd1c/pyinstrument-5.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:86f20b680223697a8ac5c061fb40a63d3ee519c7dfb1097627bd4480711216d9", size = 123818 }, +] + +[[package]] +name = "pyjwt" +version = "2.10.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e7/46/bd74733ff231675599650d3e47f361794b22ef3e3770998dda30d3b63726/pyjwt-2.10.1.tar.gz", hash = "sha256:3cc5772eb20009233caf06e9d8a0577824723b44e6648ee0a2aedb6cf9381953", size = 87785 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/61/ad/689f02752eeec26aed679477e80e632ef1b682313be70793d798c1d5fc8f/PyJWT-2.10.1-py3-none-any.whl", hash = "sha256:dcdd193e30abefd5debf142f9adfcdd2b58004e644f25406ffaebd50bd98dacb", size = 22997 }, +] + +[[package]] +name = "pyreadline" +version = "2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bc/7c/d724ef1ec3ab2125f38a1d53285745445ec4a8f19b9bb0761b4064316679/pyreadline-2.1.zip", hash = "sha256:4530592fc2e85b25b1a9f79664433da09237c1a270e4d78ea5aa3a2c7229e2d1", size = 109189 } + +[[package]] +name = "pyrepl" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/1b/ea40363be0056080454cdbabe880773c3c5bd66d7b13f0c8b8b8c8da1e0c/pyrepl-0.9.0.tar.gz", hash = "sha256:292570f34b5502e871bbb966d639474f2b57fbfcd3373c2d6a2f3d56e681a775", size = 48744 } + +[[package]] +name = "pytest" +version = "8.3.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ae/3c/c9d525a414d506893f0cd8a8d0de7706446213181570cdbd766691164e40/pytest-8.3.5.tar.gz", hash = "sha256:f4efe70cc14e511565ac476b57c279e12a855b11f48f212af1080ef2263d3845", size = 1450891 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/30/3d/64ad57c803f1fa1e963a7946b6e0fea4a70df53c1a7fed304586539c2bac/pytest-8.3.5-py3-none-any.whl", hash = "sha256:c69214aa47deac29fad6c2a4f590b9c4a9fdb16a403176fe154b79c0b4d4d820", size = 343634 }, +] + +[[package]] +name = "pytest-asyncio" +version = "0.25.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f2/a8/ecbc8ede70921dd2f544ab1cadd3ff3bf842af27f87bbdea774c7baa1d38/pytest_asyncio-0.25.3.tar.gz", hash = "sha256:fc1da2cf9f125ada7e710b4ddad05518d4cee187ae9412e9ac9271003497f07a", size = 54239 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/67/17/3493c5624e48fd97156ebaec380dcaafee9506d7e2c46218ceebbb57d7de/pytest_asyncio-0.25.3-py3-none-any.whl", hash = "sha256:9e89518e0f9bd08928f97a3482fdc4e244df17529460bc038291ccaf8f85c7c3", size = 19467 }, +] + +[[package]] +name = "pytest-depends" +version = "1.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama" }, + { name = "future-fstrings" }, + { name = "networkx" }, + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/95/5b/929e7381c342ca5040136577916d0bb20f97bbadded59fdb9aad084461a2/pytest-depends-1.0.1.tar.gz", hash = "sha256:90a28e2b87b75b18abd128c94015248544acac20e4392e9921e5a86f93319dfe", size = 8763 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/8a/96cec5c431fd706c8b2435dcb544224db7e09f4e3cc192d4c08d8980705a/pytest_depends-1.0.1-py3-none-any.whl", hash = "sha256:a1df072bcc93d77aca3f0946903f5fed8af2d9b0056db1dfc9ed5ac164ab0642", size = 10022 }, +] + +[[package]] +name = "pytest-env" +version = "1.1.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1f/31/27f28431a16b83cab7a636dce59cf397517807d247caa38ee67d65e71ef8/pytest_env-1.1.5.tar.gz", hash = "sha256:91209840aa0e43385073ac464a554ad2947cc2fd663a9debf88d03b01e0cc1cf", size = 8911 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/b8/87cfb16045c9d4092cfcf526135d73b88101aac83bc1adcf82dfb5fd3833/pytest_env-1.1.5-py3-none-any.whl", hash = "sha256:ce90cf8772878515c24b31cd97c7fa1f4481cd68d588419fd45f10ecaee6bc30", size = 6141 }, +] + +[[package]] +name = "pytest-mock" +version = "3.14.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c6/90/a955c3ab35ccd41ad4de556596fa86685bf4fc5ffcc62d22d856cfd4e29a/pytest-mock-3.14.0.tar.gz", hash = "sha256:2719255a1efeceadbc056d6bf3df3d1c5015530fb40cf347c0f9afac88410bd0", size = 32814 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f2/3b/b26f90f74e2986a82df6e7ac7e319b8ea7ccece1caec9f8ab6104dc70603/pytest_mock-3.14.0-py3-none-any.whl", hash = "sha256:0b72c38033392a5f4621342fe11e9219ac11ec9d375f8e2a0c164539e0d70f6f", size = 9863 }, +] + +[[package]] +name = "pytest-recording" +version = "0.13.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pytest" }, + { name = "vcrpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fe/2a/ea6b8036ae01979eae02d8ad5a7da14dec90d9176b613e49fb8d134c78fc/pytest_recording-0.13.2.tar.gz", hash = "sha256:000c3babbb466681457fd65b723427c1779a0c6c17d9e381c3142a701e124877", size = 25270 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/72/52/8e67a969e9fad3fa5ec4eab9f2a7348ff04692065c7deda21d76e9112703/pytest_recording-0.13.2-py3-none-any.whl", hash = "sha256:3820fe5743d1ac46e807989e11d073cb776a60bdc544cf43ebca454051b22d13", size = 12783 }, +] + +[[package]] +name = "pytest-sugar" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, + { name = "pytest" }, + { name = "termcolor" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f5/ac/5754f5edd6d508bc6493bc37d74b928f102a5fff82d9a80347e180998f08/pytest-sugar-1.0.0.tar.gz", hash = "sha256:6422e83258f5b0c04ce7c632176c7732cab5fdb909cb39cca5c9139f81276c0a", size = 14992 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/fb/889f1b69da2f13691de09a111c16c4766a433382d44aa0ecf221deded44a/pytest_sugar-1.0.0-py3-none-any.whl", hash = "sha256:70ebcd8fc5795dc457ff8b69d266a4e2e8a74ae0c3edc749381c64b5246c8dfd", size = 10171 }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 }, +] + +[[package]] +name = "python-dotenv" +version = "1.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bc/57/e84d88dfe0aec03b7a2d4327012c1627ab5f03652216c63d49846d7a6c58/python-dotenv-1.0.1.tar.gz", hash = "sha256:e324ee90a023d808f1959c46bcbc04446a10ced277783dc6ee09987c37ec10ca", size = 39115 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/3e/b68c118422ec867fa7ab88444e1274aa40681c606d59ac27de5a5588f082/python_dotenv-1.0.1-py3-none-any.whl", hash = "sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a", size = 19863 }, +] + +[[package]] +name = "pytz" +version = "2025.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5f/57/df1c9157c8d5a05117e455d66fd7cf6dbc46974f832b1058ed4856785d8a/pytz-2025.1.tar.gz", hash = "sha256:c2db42be2a2518b28e65f9207c4d05e6ff547d1efa4086469ef855e4ab70178e", size = 319617 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/38/ac33370d784287baa1c3d538978b5e2ea064d4c1b93ffbd12826c190dd10/pytz-2025.1-py2.py3-none-any.whl", hash = "sha256:89dd22dca55b46eac6eda23b2d72721bf1bdfef212645d81513ef5d03038de57", size = 507930 }, +] + +[[package]] +name = "pywin32" +version = "310" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6b/ec/4fdbe47932f671d6e348474ea35ed94227fb5df56a7c30cbbb42cd396ed0/pywin32-310-cp312-cp312-win32.whl", hash = "sha256:8a75a5cc3893e83a108c05d82198880704c44bbaee4d06e442e471d3c9ea4f3d", size = 8796239 }, + { url = "https://files.pythonhosted.org/packages/e3/e5/b0627f8bb84e06991bea89ad8153a9e50ace40b2e1195d68e9dff6b03d0f/pywin32-310-cp312-cp312-win_amd64.whl", hash = "sha256:bf5c397c9a9a19a6f62f3fb821fbf36cac08f03770056711f765ec1503972060", size = 9503839 }, + { url = "https://files.pythonhosted.org/packages/1f/32/9ccf53748df72301a89713936645a664ec001abd35ecc8578beda593d37d/pywin32-310-cp312-cp312-win_arm64.whl", hash = "sha256:2349cc906eae872d0663d4d6290d13b90621eaf78964bb1578632ff20e152966", size = 8459470 }, +] + +[[package]] +name = "pyyaml" +version = "6.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/54/ed/79a089b6be93607fa5cdaedf301d7dfb23af5f25c398d5ead2525b063e17/pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e", size = 130631 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/86/0c/c581167fc46d6d6d7ddcfb8c843a4de25bdd27e4466938109ca68492292c/PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab", size = 183873 }, + { url = "https://files.pythonhosted.org/packages/a8/0c/38374f5bb272c051e2a69281d71cba6fdb983413e6758b84482905e29a5d/PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725", size = 173302 }, + { url = "https://files.pythonhosted.org/packages/c3/93/9916574aa8c00aa06bbac729972eb1071d002b8e158bd0e83a3b9a20a1f7/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5", size = 739154 }, + { url = "https://files.pythonhosted.org/packages/95/0f/b8938f1cbd09739c6da569d172531567dbcc9789e0029aa070856f123984/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425", size = 766223 }, + { url = "https://files.pythonhosted.org/packages/b9/2b/614b4752f2e127db5cc206abc23a8c19678e92b23c3db30fc86ab731d3bd/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476", size = 767542 }, + { url = "https://files.pythonhosted.org/packages/d4/00/dd137d5bcc7efea1836d6264f049359861cf548469d18da90cd8216cf05f/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48", size = 731164 }, + { url = "https://files.pythonhosted.org/packages/c9/1f/4f998c900485e5c0ef43838363ba4a9723ac0ad73a9dc42068b12aaba4e4/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b", size = 756611 }, + { url = "https://files.pythonhosted.org/packages/df/d1/f5a275fdb252768b7a11ec63585bc38d0e87c9e05668a139fea92b80634c/PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4", size = 140591 }, + { url = "https://files.pythonhosted.org/packages/0c/e8/4f648c598b17c3d06e8753d7d13d57542b30d56e6c2dedf9c331ae56312e/PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8", size = 156338 }, +] + +[[package]] +name = "realtime" +version = "2.4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohttp" }, + { name = "python-dateutil" }, + { name = "typing-extensions" }, + { name = "websockets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6b/42/5d8d303c4f30a5c09bd93c937ddd89cf1ae37785c36010aeeba15f20e9ab/realtime-2.4.1.tar.gz", hash = "sha256:8e77616d8c721f0f17ea0a256f6b5cd6d626b0eb66b305544d5f330c3a6d9a4c", size = 18774 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/95/10420e7524f3ff4458a12cdd30a146b972aef3b02785c04ee237d493dfc0/realtime-2.4.1-py3-none-any.whl", hash = "sha256:6aacfec1ca3519fbb87219ce250dee3b6797156f5a091eb48d0e19945bc6d103", size = 22019 }, +] + +[[package]] +name = "redis" +version = "5.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/47/da/d283a37303a995cd36f8b92db85135153dc4f7a8e4441aa827721b442cfb/redis-5.2.1.tar.gz", hash = "sha256:16f2e22dff21d5125e8481515e386711a34cbec50f0e44413dd7d9c060a54e0f", size = 4608355 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3c/5f/fa26b9b2672cbe30e07d9a5bdf39cf16e3b80b42916757c5f92bca88e4ba/redis-5.2.1-py3-none-any.whl", hash = "sha256:ee7e1056b9aea0f04c6c2ed59452947f34c4940ee025f5dd83e6a6418b6989e4", size = 261502 }, +] + +[[package]] +name = "referencing" +version = "0.36.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2f/db/98b5c277be99dd18bfd91dd04e1b759cad18d1a338188c936e92f921c7e2/referencing-0.36.2.tar.gz", hash = "sha256:df2e89862cd09deabbdba16944cc3f10feb6b3e6f18e902f7cc25609a34775aa", size = 74744 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/b1/3baf80dc6d2b7bc27a95a67752d0208e410351e3feb4eb78de5f77454d8d/referencing-0.36.2-py3-none-any.whl", hash = "sha256:e8699adbbf8b5c7de96d8ffa0eb5c158b3beafce084968e2ea8bb08c6794dcd0", size = 26775 }, +] + +[[package]] +name = "regex" +version = "2024.11.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8e/5f/bd69653fbfb76cf8604468d3b4ec4c403197144c7bfe0e6a5fc9e02a07cb/regex-2024.11.6.tar.gz", hash = "sha256:7ab159b063c52a0333c884e4679f8d7a85112ee3078fe3d9004b2dd875585519", size = 399494 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ba/30/9a87ce8336b172cc232a0db89a3af97929d06c11ceaa19d97d84fa90a8f8/regex-2024.11.6-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:52fb28f528778f184f870b7cf8f225f5eef0a8f6e3778529bdd40c7b3920796a", size = 483781 }, + { url = "https://files.pythonhosted.org/packages/01/e8/00008ad4ff4be8b1844786ba6636035f7ef926db5686e4c0f98093612add/regex-2024.11.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fdd6028445d2460f33136c55eeb1f601ab06d74cb3347132e1c24250187500d9", size = 288455 }, + { url = "https://files.pythonhosted.org/packages/60/85/cebcc0aff603ea0a201667b203f13ba75d9fc8668fab917ac5b2de3967bc/regex-2024.11.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:805e6b60c54bf766b251e94526ebad60b7de0c70f70a4e6210ee2891acb70bf2", size = 284759 }, + { url = "https://files.pythonhosted.org/packages/94/2b/701a4b0585cb05472a4da28ee28fdfe155f3638f5e1ec92306d924e5faf0/regex-2024.11.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b85c2530be953a890eaffde05485238f07029600e8f098cdf1848d414a8b45e4", size = 794976 }, + { url = "https://files.pythonhosted.org/packages/4b/bf/fa87e563bf5fee75db8915f7352e1887b1249126a1be4813837f5dbec965/regex-2024.11.6-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bb26437975da7dc36b7efad18aa9dd4ea569d2357ae6b783bf1118dabd9ea577", size = 833077 }, + { url = "https://files.pythonhosted.org/packages/a1/56/7295e6bad94b047f4d0834e4779491b81216583c00c288252ef625c01d23/regex-2024.11.6-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:abfa5080c374a76a251ba60683242bc17eeb2c9818d0d30117b4486be10c59d3", size = 823160 }, + { url = "https://files.pythonhosted.org/packages/fb/13/e3b075031a738c9598c51cfbc4c7879e26729c53aa9cca59211c44235314/regex-2024.11.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b7fa6606c2881c1db9479b0eaa11ed5dfa11c8d60a474ff0e095099f39d98e", size = 796896 }, + { url = "https://files.pythonhosted.org/packages/24/56/0b3f1b66d592be6efec23a795b37732682520b47c53da5a32c33ed7d84e3/regex-2024.11.6-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0c32f75920cf99fe6b6c539c399a4a128452eaf1af27f39bce8909c9a3fd8cbe", size = 783997 }, + { url = "https://files.pythonhosted.org/packages/f9/a1/eb378dada8b91c0e4c5f08ffb56f25fcae47bf52ad18f9b2f33b83e6d498/regex-2024.11.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:982e6d21414e78e1f51cf595d7f321dcd14de1f2881c5dc6a6e23bbbbd68435e", size = 781725 }, + { url = "https://files.pythonhosted.org/packages/83/f2/033e7dec0cfd6dda93390089864732a3409246ffe8b042e9554afa9bff4e/regex-2024.11.6-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a7c2155f790e2fb448faed6dd241386719802296ec588a8b9051c1f5c481bc29", size = 789481 }, + { url = "https://files.pythonhosted.org/packages/83/23/15d4552ea28990a74e7696780c438aadd73a20318c47e527b47a4a5a596d/regex-2024.11.6-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:149f5008d286636e48cd0b1dd65018548944e495b0265b45e1bffecce1ef7f39", size = 852896 }, + { url = "https://files.pythonhosted.org/packages/e3/39/ed4416bc90deedbfdada2568b2cb0bc1fdb98efe11f5378d9892b2a88f8f/regex-2024.11.6-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:e5364a4502efca094731680e80009632ad6624084aff9a23ce8c8c6820de3e51", size = 860138 }, + { url = "https://files.pythonhosted.org/packages/93/2d/dd56bb76bd8e95bbce684326302f287455b56242a4f9c61f1bc76e28360e/regex-2024.11.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0a86e7eeca091c09e021db8eb72d54751e527fa47b8d5787caf96d9831bd02ad", size = 787692 }, + { url = "https://files.pythonhosted.org/packages/0b/55/31877a249ab7a5156758246b9c59539abbeba22461b7d8adc9e8475ff73e/regex-2024.11.6-cp312-cp312-win32.whl", hash = "sha256:32f9a4c643baad4efa81d549c2aadefaeba12249b2adc5af541759237eee1c54", size = 262135 }, + { url = "https://files.pythonhosted.org/packages/38/ec/ad2d7de49a600cdb8dd78434a1aeffe28b9d6fc42eb36afab4a27ad23384/regex-2024.11.6-cp312-cp312-win_amd64.whl", hash = "sha256:a93c194e2df18f7d264092dc8539b8ffb86b45b899ab976aa15d48214138e81b", size = 273567 }, +] + +[[package]] +name = "requests" +version = "2.32.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation == 'PyPy'" }, + { name = "urllib3", version = "2.3.0", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928 }, +] + +[[package]] +name = "requests-oauthlib" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "oauthlib" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/f2/05f29bc3913aea15eb670be136045bf5c5bbf4b99ecb839da9b422bb2c85/requests-oauthlib-2.0.0.tar.gz", hash = "sha256:b3dffaebd884d8cd778494369603a9e7b58d29111bf6b41bdc2dcd87203af4e9", size = 55650 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3b/5d/63d4ae3b9daea098d5d6f5da83984853c1bbacd5dc826764b249fe119d24/requests_oauthlib-2.0.0-py2.py3-none-any.whl", hash = "sha256:7dd8a5c40426b779b0868c404bdef9768deccf22749cde15852df527e6269b36", size = 24179 }, +] + +[[package]] +name = "rpds-py" +version = "0.23.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0a/79/2ce611b18c4fd83d9e3aecb5cba93e1917c050f556db39842889fa69b79f/rpds_py-0.23.1.tar.gz", hash = "sha256:7f3240dcfa14d198dba24b8b9cb3b108c06b68d45b7babd9eefc1038fdf7e707", size = 26806 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/8c/d17efccb9f5b9137ddea706664aebae694384ae1d5997c0202093e37185a/rpds_py-0.23.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3902df19540e9af4cc0c3ae75974c65d2c156b9257e91f5101a51f99136d834c", size = 364369 }, + { url = "https://files.pythonhosted.org/packages/6e/c0/ab030f696b5c573107115a88d8d73d80f03309e60952b64c584c70c659af/rpds_py-0.23.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:66f8d2a17e5838dd6fb9be6baaba8e75ae2f5fa6b6b755d597184bfcd3cb0eba", size = 349965 }, + { url = "https://files.pythonhosted.org/packages/b3/55/b40170f5a079c4fb0b6a82b299689e66e744edca3c3375a8b160fb797660/rpds_py-0.23.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:112b8774b0b4ee22368fec42749b94366bd9b536f8f74c3d4175d4395f5cbd31", size = 389064 }, + { url = "https://files.pythonhosted.org/packages/ab/1c/b03a912c59ec7c1e16b26e587b9dfa8ddff3b07851e781e8c46e908a365a/rpds_py-0.23.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e0df046f2266e8586cf09d00588302a32923eb6386ced0ca5c9deade6af9a149", size = 397741 }, + { url = "https://files.pythonhosted.org/packages/52/6f/151b90792b62fb6f87099bcc9044c626881fdd54e31bf98541f830b15cea/rpds_py-0.23.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0f3288930b947cbebe767f84cf618d2cbe0b13be476e749da0e6a009f986248c", size = 448784 }, + { url = "https://files.pythonhosted.org/packages/71/2a/6de67c0c97ec7857e0e9e5cd7c52405af931b303eb1e5b9eff6c50fd9a2e/rpds_py-0.23.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ce473a2351c018b06dd8d30d5da8ab5a0831056cc53b2006e2a8028172c37ce5", size = 440203 }, + { url = "https://files.pythonhosted.org/packages/db/5e/e759cd1c276d98a4b1f464b17a9bf66c65d29f8f85754e27e1467feaa7c3/rpds_py-0.23.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d550d7e9e7d8676b183b37d65b5cd8de13676a738973d330b59dc8312df9c5dc", size = 391611 }, + { url = "https://files.pythonhosted.org/packages/1c/1e/2900358efcc0d9408c7289769cba4c0974d9db314aa884028ed7f7364f61/rpds_py-0.23.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e14f86b871ea74c3fddc9a40e947d6a5d09def5adc2076ee61fb910a9014fb35", size = 423306 }, + { url = "https://files.pythonhosted.org/packages/23/07/6c177e6d059f5d39689352d6c69a926ee4805ffdb6f06203570234d3d8f7/rpds_py-0.23.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1bf5be5ba34e19be579ae873da515a2836a2166d8d7ee43be6ff909eda42b72b", size = 562323 }, + { url = "https://files.pythonhosted.org/packages/70/e4/f9097fd1c02b516fff9850792161eb9fc20a2fd54762f3c69eae0bdb67cb/rpds_py-0.23.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:d7031d493c4465dbc8d40bd6cafefef4bd472b17db0ab94c53e7909ee781b9ef", size = 588351 }, + { url = "https://files.pythonhosted.org/packages/87/39/5db3c6f326bfbe4576ae2af6435bd7555867d20ae690c786ff33659f293b/rpds_py-0.23.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:55ff4151cfd4bc635e51cfb1c59ac9f7196b256b12e3a57deb9e5742e65941ad", size = 557252 }, + { url = "https://files.pythonhosted.org/packages/fd/14/2d5ad292f144fa79bafb78d2eb5b8a3a91c358b6065443cb9c49b5d1fedf/rpds_py-0.23.1-cp312-cp312-win32.whl", hash = "sha256:a9d3b728f5a5873d84cba997b9d617c6090ca5721caaa691f3b1a78c60adc057", size = 222181 }, + { url = "https://files.pythonhosted.org/packages/a3/4f/0fce63e0f5cdd658e71e21abd17ac1bc9312741ebb8b3f74eeed2ebdf771/rpds_py-0.23.1-cp312-cp312-win_amd64.whl", hash = "sha256:b03a8d50b137ee758e4c73638b10747b7c39988eb8e6cd11abb7084266455165", size = 237426 }, +] + +[[package]] +name = "rsa" +version = "4.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyasn1" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/da/8a/22b7beea3ee0d44b1916c0c1cb0ee3af23b700b6da9f04991899d0c555d4/rsa-4.9.1.tar.gz", hash = "sha256:e7bdbfdb5497da4c07dfd35530e1a902659db6ff241e39d9953cad06ebd0ae75", size = 29034 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/8d/0133e4eb4beed9e425d9a98ed6e081a55d195481b7632472be1af08d2f6b/rsa-4.9.1-py3-none-any.whl", hash = "sha256:68635866661c6836b8d39430f97a996acbd61bfa49406748ea243539fe239762", size = 34696 }, +] + +[[package]] +name = "s3transfer" +version = "0.11.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "botocore" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0f/ec/aa1a215e5c126fe5decbee2e107468f51d9ce190b9763cb649f76bb45938/s3transfer-0.11.4.tar.gz", hash = "sha256:559f161658e1cf0a911f45940552c696735f5c74e64362e515f333ebed87d679", size = 148419 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/86/62/8d3fc3ec6640161a5649b2cddbbf2b9fa39c92541225b33f117c37c5a2eb/s3transfer-0.11.4-py3-none-any.whl", hash = "sha256:ac265fa68318763a03bf2dc4f39d5cbd6a9e178d81cc9483ad27da33637e320d", size = 84412 }, +] + +[[package]] +name = "sentry-sdk" +version = "2.23.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation == 'PyPy'" }, + { name = "urllib3", version = "2.3.0", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/60/fd/2c5f7161dbea1fa03381f139c443b4524f3a15d58e50c96a65d19f454ba2/sentry_sdk-2.23.1.tar.gz", hash = "sha256:2288320465065f3f056630ce55936426204f96f63f1208edb79e033ed03774db", size = 316248 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/00/9a9a2ab9020ee824d787f7e82a539305bf926393fe139baedbcf34356770/sentry_sdk-2.23.1-py2.py3-none-any.whl", hash = "sha256:42ef3a6cc1db3d22cb2ab24163d75b23f291ad9892b1a8c44075ce809a32b191", size = 336327 }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 }, +] + +[[package]] +name = "smmap" +version = "5.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/44/cd/a040c4b3119bbe532e5b0732286f805445375489fceaec1f48306068ee3b/smmap-5.0.2.tar.gz", hash = "sha256:26ea65a03958fa0c8a1c7e8c7a58fdc77221b8910f6be2131affade476898ad5", size = 22329 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/be/d09147ad1ec7934636ad912901c5fd7667e1c858e19d355237db0d0cd5e4/smmap-5.0.2-py3-none-any.whl", hash = "sha256:b30115f0def7d7531d22a0fb6502488d879e75b260a9db4d0819cfb25403af5e", size = 24303 }, +] + +[[package]] +name = "sniffio" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235 }, +] + +[[package]] +name = "sqlalchemy" +version = "2.0.40" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64'" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/68/c3/3f2bfa5e4dcd9938405fe2fab5b6ab94a9248a4f9536ea2fd497da20525f/sqlalchemy-2.0.40.tar.gz", hash = "sha256:d827099289c64589418ebbcaead0145cd19f4e3e8a93919a0100247af245fa00", size = 9664299 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/06/552c1f92e880b57d8b92ce6619bd569b25cead492389b1d84904b55989d8/sqlalchemy-2.0.40-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9d3b31d0a1c44b74d3ae27a3de422dfccd2b8f0b75e51ecb2faa2bf65ab1ba0d", size = 2112620 }, + { url = "https://files.pythonhosted.org/packages/01/72/a5bc6e76c34cebc071f758161dbe1453de8815ae6e662393910d3be6d70d/sqlalchemy-2.0.40-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:37f7a0f506cf78c80450ed1e816978643d3969f99c4ac6b01104a6fe95c5490a", size = 2103004 }, + { url = "https://files.pythonhosted.org/packages/bf/fd/0e96c8e6767618ed1a06e4d7a167fe13734c2f8113c4cb704443e6783038/sqlalchemy-2.0.40-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0bb933a650323e476a2e4fbef8997a10d0003d4da996aad3fd7873e962fdde4d", size = 3252440 }, + { url = "https://files.pythonhosted.org/packages/cd/6a/eb82e45b15a64266a2917a6833b51a334ea3c1991728fd905bfccbf5cf63/sqlalchemy-2.0.40-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6959738971b4745eea16f818a2cd086fb35081383b078272c35ece2b07012716", size = 3263277 }, + { url = "https://files.pythonhosted.org/packages/45/97/ebe41ab4530f50af99e3995ebd4e0204bf1b0dc0930f32250dde19c389fe/sqlalchemy-2.0.40-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:110179728e442dae85dd39591beb74072ae4ad55a44eda2acc6ec98ead80d5f2", size = 3198591 }, + { url = "https://files.pythonhosted.org/packages/e6/1c/a569c1b2b2f5ac20ba6846a1321a2bf52e9a4061001f282bf1c5528dcd69/sqlalchemy-2.0.40-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e8040680eaacdce4d635f12c55c714f3d4c7f57da2bc47a01229d115bd319191", size = 3225199 }, + { url = "https://files.pythonhosted.org/packages/8f/91/87cc71a6b10065ca0209d19a4bb575378abda6085e72fa0b61ffb2201b84/sqlalchemy-2.0.40-cp312-cp312-win32.whl", hash = "sha256:650490653b110905c10adac69408380688cefc1f536a137d0d69aca1069dc1d1", size = 2082959 }, + { url = "https://files.pythonhosted.org/packages/2a/9f/14c511cda174aa1ad9b0e42b64ff5a71db35d08b0d80dc044dae958921e5/sqlalchemy-2.0.40-cp312-cp312-win_amd64.whl", hash = "sha256:2be94d75ee06548d2fc591a3513422b873490efb124048f50556369a834853b0", size = 2108526 }, + { url = "https://files.pythonhosted.org/packages/d1/7c/5fc8e802e7506fe8b55a03a2e1dab156eae205c91bee46305755e086d2e2/sqlalchemy-2.0.40-py3-none-any.whl", hash = "sha256:32587e2e1e359276957e6fe5dad089758bc042a971a8a09ae8ecf7a8fe23d07a", size = 1903894 }, +] + +[[package]] +name = "starlette" +version = "0.46.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/04/1b/52b27f2e13ceedc79a908e29eac426a63465a1a01248e5f24aa36a62aeb3/starlette-0.46.1.tar.gz", hash = "sha256:3c88d58ee4bd1bb807c0d1acb381838afc7752f9ddaec81bbe4383611d833230", size = 2580102 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/4b/528ccf7a982216885a1ff4908e886b8fb5f19862d1962f56a3fce2435a70/starlette-0.46.1-py3-none-any.whl", hash = "sha256:77c74ed9d2720138b25875133f3a2dae6d854af2ec37dceb56aef370c1d8a227", size = 71995 }, +] + +[[package]] +name = "storage3" +version = "0.11.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "httpx", extra = ["http2"] }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ac/25/83eb4e4612dc07a3bb3cab96253c9c83752d4816f2cf38aa832dfb8d8813/storage3-0.11.3.tar.gz", hash = "sha256:883637132aad36d9d92b7c497a8a56dff7c51f15faf2ff7acbccefbbd5e97347", size = 9930 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c9/8d/ff89f85c4b48285ac7cddf0fafe5e55bb3742d374672b2fbd2627c213fa6/storage3-0.11.3-py3-none-any.whl", hash = "sha256:090c42152217d5d39bd94af3ddeb60c8982f3a283dcd90b53d058f2db33e6007", size = 17831 }, +] + +[[package]] +name = "strenum" +version = "0.4.15" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/85/ad/430fb60d90e1d112a62ff57bdd1f286ec73a2a0331272febfddd21f330e1/StrEnum-0.4.15.tar.gz", hash = "sha256:878fb5ab705442070e4dd1929bb5e2249511c0bcf2b0eeacf3bcd80875c82eff", size = 23384 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/69/297302c5f5f59c862faa31e6cb9a4cd74721cd1e052b38e464c5b402df8b/StrEnum-0.4.15-py3-none-any.whl", hash = "sha256:a30cda4af7cc6b5bf52c8055bc4bf4b2b6b14a93b574626da33df53cf7740659", size = 8851 }, +] + +[[package]] +name = "stripe" +version = "12.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "requests" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/31/00/346d0baff3ade82faf1299262ae9c0e1a497593e9c294837abecac8c7822/stripe-12.2.0.tar.gz", hash = "sha256:1ac2a4abba371acb3f99ff1c4a8748929862ad42d0cdee488298982f1be8d56e", size = 1393146 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9b/d6/c97a38e2997c368e62443aa8f7d0f3e903a9cb686d2445a23f5d4b552894/stripe-12.2.0-py2.py3-none-any.whl", hash = "sha256:cc9086d162e65e32893e4a03c31194e36e07870653a5f30aacc62da61e548cb9", size = 1633772 }, +] + +[[package]] +name = "supabase" +version = "2.13.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "gotrue" }, + { name = "httpx" }, + { name = "postgrest" }, + { name = "realtime" }, + { name = "storage3" }, + { name = "supafunc" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/0e/3d2f01d465b4636deb78f102e6feff47568aae5873946184afb75ff5abe3/supabase-2.13.0.tar.gz", hash = "sha256:452574d34bd978c8d11b5f02b0182b48e8854e511c969483c83875ec01495f11", size = 14251 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/a7/2ffbd3bea564927e74966a1a3a512a68b491d602d77890daa67e3033bdf4/supabase-2.13.0-py3-none-any.whl", hash = "sha256:6cfccc055be21dab311afc5e9d5b37f3a4966f8394703763fbc8f8e86f36eaa6", size = 17171 }, +] + +[[package]] +name = "supafunc" +version = "0.9.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "httpx", extra = ["http2"] }, + { name = "strenum" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/03/2ca4dddd4a8d28f5dbe204ea0350fb3e4fbf16156ef446f12e0a73d9e718/supafunc-0.9.3.tar.gz", hash = "sha256:29a06d0dc9fe049ecc1249e53ccf3d2a80d72239200f69b510740217aca6497c", size = 4730 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/ec/56e3de38ee99f11c6d645ce8f2a1c29c4561adcb47e53e7781b9c073aa7e/supafunc-0.9.3-py3-none-any.whl", hash = "sha256:83e36ed5e94d2dd0484011aad0b09337d35a87992adbc97acc31c8201aca05d0", size = 7690 }, +] + +[[package]] +name = "termcolor" +version = "2.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/37/72/88311445fd44c455c7d553e61f95412cf89054308a1aa2434ab835075fc5/termcolor-2.5.0.tar.gz", hash = "sha256:998d8d27da6d48442e8e1f016119076b690d962507531df4890fcd2db2ef8a6f", size = 13057 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/be/df630c387a0a054815d60be6a97eb4e8f17385d5d6fe660e1c02750062b4/termcolor-2.5.0-py3-none-any.whl", hash = "sha256:37b17b5fc1e604945c2642c872a3764b5d547a48009871aea3edd3afa180afb8", size = 7755 }, +] + +[[package]] +name = "tiktoken" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "regex" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ea/cf/756fedf6981e82897f2d570dd25fa597eb3f4459068ae0572d7e888cfd6f/tiktoken-0.9.0.tar.gz", hash = "sha256:d02a5ca6a938e0490e1ff957bc48c8b078c88cb83977be1625b1fd8aac792c5d", size = 35991 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/e5/21ff33ecfa2101c1bb0f9b6df750553bd873b7fb532ce2cb276ff40b197f/tiktoken-0.9.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e88f121c1c22b726649ce67c089b90ddda8b9662545a8aeb03cfef15967ddd03", size = 1065073 }, + { url = "https://files.pythonhosted.org/packages/8e/03/a95e7b4863ee9ceec1c55983e4cc9558bcfd8f4f80e19c4f8a99642f697d/tiktoken-0.9.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a6600660f2f72369acb13a57fb3e212434ed38b045fd8cc6cdd74947b4b5d210", size = 1008075 }, + { url = "https://files.pythonhosted.org/packages/40/10/1305bb02a561595088235a513ec73e50b32e74364fef4de519da69bc8010/tiktoken-0.9.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:95e811743b5dfa74f4b227927ed86cbc57cad4df859cb3b643be797914e41794", size = 1140754 }, + { url = "https://files.pythonhosted.org/packages/1b/40/da42522018ca496432ffd02793c3a72a739ac04c3794a4914570c9bb2925/tiktoken-0.9.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99376e1370d59bcf6935c933cb9ba64adc29033b7e73f5f7569f3aad86552b22", size = 1196678 }, + { url = "https://files.pythonhosted.org/packages/5c/41/1e59dddaae270ba20187ceb8aa52c75b24ffc09f547233991d5fd822838b/tiktoken-0.9.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:badb947c32739fb6ddde173e14885fb3de4d32ab9d8c591cbd013c22b4c31dd2", size = 1259283 }, + { url = "https://files.pythonhosted.org/packages/5b/64/b16003419a1d7728d0d8c0d56a4c24325e7b10a21a9dd1fc0f7115c02f0a/tiktoken-0.9.0-cp312-cp312-win_amd64.whl", hash = "sha256:5a62d7a25225bafed786a524c1b9f0910a1128f4232615bf3f8257a73aaa3b16", size = 894897 }, +] + +[[package]] +name = "tokencost" +version = "0.1.18" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohttp" }, + { name = "anthropic" }, + { name = "tiktoken" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f2/a7/3e2f66ffedd4578f372568100290a42a7dc1019594fc6d02760c7666e3e2/tokencost-0.1.18.tar.gz", hash = "sha256:2e4d9107e43e8a8646b52fe215f9cf36742e4bf8947c4e9b2dbf01600326a89d", size = 62453 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/a9/9b203cf547d578260f7ff294417e543570effd471fc648cd9b96e9638e4f/tokencost-0.1.18-py3-none-any.whl", hash = "sha256:d2789ed14cafd2b841cc8206d7df71865ea452477966e7a8aeb7e102dce4f7c2", size = 37742 }, +] + +[[package]] +name = "typing-extensions" +version = "4.12.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 }, +] + +[[package]] +name = "tzdata" +version = "2025.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/0f/fa4723f22942480be4ca9527bbde8d43f6c3f2fe8412f00e7f5f6746bc8b/tzdata-2025.1.tar.gz", hash = "sha256:24894909e88cdb28bd1636c6887801df64cb485bd593f2fd83ef29075a81d694", size = 194950 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/dd/84f10e23edd882c6f968c21c2434fe67bd4a528967067515feca9e611e5e/tzdata-2025.1-py2.py3-none-any.whl", hash = "sha256:7e127113816800496f027041c570f50bcd464a020098a3b6b199517772303639", size = 346762 }, +] + +[[package]] +name = "tzlocal" +version = "5.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "tzdata", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8b/2e/c14812d3d4d9cd1773c6be938f89e5735a1f11a9f184ac3639b93cef35d5/tzlocal-5.3.1.tar.gz", hash = "sha256:cceffc7edecefea1f595541dbd6e990cb1ea3d19bf01b2809f362a03dd7921fd", size = 30761 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c2/14/e2a54fabd4f08cd7af1c07030603c3356b74da07f7cc056e600436edfa17/tzlocal-5.3.1-py3-none-any.whl", hash = "sha256:eb1a66c3ef5847adf7a834f1be0800581b683b5608e74f86ecbcef8ab91bb85d", size = 18026 }, +] + +[[package]] +name = "urllib3" +version = "1.26.20" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "platform_python_implementation == 'PyPy'", +] +sdist = { url = "https://files.pythonhosted.org/packages/e4/e8/6ff5e6bc22095cfc59b6ea711b687e2b7ed4bdb373f7eeec370a97d7392f/urllib3-1.26.20.tar.gz", hash = "sha256:40c2dc0c681e47eb8f90e7e27bf6ff7df2e677421fd46756da1161c39ca70d32", size = 307380 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/cf/8435d5a7159e2a9c83a95896ed596f68cf798005fe107cc655b5c5c14704/urllib3-1.26.20-py2.py3-none-any.whl", hash = "sha256:0ed14ccfbf1c30a9072c7ca157e4319b70d65f623e91e7b32fadb2853431016e", size = 144225 }, +] + +[[package]] +name = "urllib3" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "platform_python_implementation != 'PyPy'", +] +sdist = { url = "https://files.pythonhosted.org/packages/aa/63/e53da845320b757bf29ef6a9062f5c669fe997973f966045cb019c3f4b66/urllib3-2.3.0.tar.gz", hash = "sha256:f8c5449b3cf0861679ce7e0503c7b44b5ec981bec0d1d3795a07f1ba96f0204d", size = 307268 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/19/4ec628951a74043532ca2cf5d97b7b14863931476d117c471e8e2b1eb39f/urllib3-2.3.0-py3-none-any.whl", hash = "sha256:1cee9ad369867bfdbbb48b7dd50374c0967a0bb7710050facf0dd6911440e3df", size = 128369 }, +] + +[[package]] +name = "uvicorn" +version = "0.34.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4b/4d/938bd85e5bf2edeec766267a5015ad969730bb91e31b44021dfe8b22df6c/uvicorn-0.34.0.tar.gz", hash = "sha256:404051050cd7e905de2c9a7e61790943440b3416f49cb409f965d9dcd0fa73e9", size = 76568 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/61/14/33a3a1352cfa71812a3a21e8c9bfb83f60b0011f5e36f2b1399d51928209/uvicorn-0.34.0-py3-none-any.whl", hash = "sha256:023dc038422502fa28a09c7a30bf2b6991512da7dcdb8fd35fe57cfc154126f4", size = 62315 }, +] + +[package.optional-dependencies] +standard = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "httptools" }, + { name = "python-dotenv" }, + { name = "pyyaml" }, + { name = "uvloop", marker = "platform_python_implementation != 'PyPy' and sys_platform != 'cygwin' and sys_platform != 'win32'" }, + { name = "watchfiles" }, + { name = "websockets" }, +] + +[[package]] +name = "uvloop" +version = "0.21.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/af/c0/854216d09d33c543f12a44b393c402e89a920b1a0a7dc634c42de91b9cf6/uvloop-0.21.0.tar.gz", hash = "sha256:3bf12b0fda68447806a7ad847bfa591613177275d35b6724b1ee573faa3704e3", size = 2492741 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8c/4c/03f93178830dc7ce8b4cdee1d36770d2f5ebb6f3d37d354e061eefc73545/uvloop-0.21.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:359ec2c888397b9e592a889c4d72ba3d6befba8b2bb01743f72fffbde663b59c", size = 1471284 }, + { url = "https://files.pythonhosted.org/packages/43/3e/92c03f4d05e50f09251bd8b2b2b584a2a7f8fe600008bcc4523337abe676/uvloop-0.21.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f7089d2dc73179ce5ac255bdf37c236a9f914b264825fdaacaded6990a7fb4c2", size = 821349 }, + { url = "https://files.pythonhosted.org/packages/a6/ef/a02ec5da49909dbbfb1fd205a9a1ac4e88ea92dcae885e7c961847cd51e2/uvloop-0.21.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:baa4dcdbd9ae0a372f2167a207cd98c9f9a1ea1188a8a526431eef2f8116cc8d", size = 4580089 }, + { url = "https://files.pythonhosted.org/packages/06/a7/b4e6a19925c900be9f98bec0a75e6e8f79bb53bdeb891916609ab3958967/uvloop-0.21.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86975dca1c773a2c9864f4c52c5a55631038e387b47eaf56210f873887b6c8dc", size = 4693770 }, + { url = "https://files.pythonhosted.org/packages/ce/0c/f07435a18a4b94ce6bd0677d8319cd3de61f3a9eeb1e5f8ab4e8b5edfcb3/uvloop-0.21.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:461d9ae6660fbbafedd07559c6a2e57cd553b34b0065b6550685f6653a98c1cb", size = 4451321 }, + { url = "https://files.pythonhosted.org/packages/8f/eb/f7032be105877bcf924709c97b1bf3b90255b4ec251f9340cef912559f28/uvloop-0.21.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:183aef7c8730e54c9a3ee3227464daed66e37ba13040bb3f350bc2ddc040f22f", size = 4659022 }, +] + +[[package]] +name = "vcrpy" +version = "7.0.0" +source = { git = "https://github.com/kevin1024/vcrpy.git?rev=5f1b20c4ca4a18c1fc8cfe049d7df12ca0659c9b#5f1b20c4ca4a18c1fc8cfe049d7df12ca0659c9b" } +dependencies = [ + { name = "pyyaml" }, + { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation == 'PyPy'" }, + { name = "urllib3", version = "2.3.0", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation != 'PyPy'" }, + { name = "wrapt" }, + { name = "yarl" }, +] + +[[package]] +name = "watchfiles" +version = "1.0.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f5/26/c705fc77d0a9ecdb9b66f1e2976d95b81df3cae518967431e7dbf9b5e219/watchfiles-1.0.4.tar.gz", hash = "sha256:6ba473efd11062d73e4f00c2b730255f9c1bdd73cd5f9fe5b5da8dbd4a717205", size = 94625 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5b/1a/8f4d9a1461709756ace48c98f07772bc6d4519b1e48b5fa24a4061216256/watchfiles-1.0.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:229e6ec880eca20e0ba2f7e2249c85bae1999d330161f45c78d160832e026ee2", size = 391345 }, + { url = "https://files.pythonhosted.org/packages/bc/d2/6750b7b3527b1cdaa33731438432e7238a6c6c40a9924049e4cebfa40805/watchfiles-1.0.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5717021b199e8353782dce03bd8a8f64438832b84e2885c4a645f9723bf656d9", size = 381515 }, + { url = "https://files.pythonhosted.org/packages/4e/17/80500e42363deef1e4b4818729ed939aaddc56f82f4e72b2508729dd3c6b/watchfiles-1.0.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0799ae68dfa95136dde7c472525700bd48777875a4abb2ee454e3ab18e9fc712", size = 449767 }, + { url = "https://files.pythonhosted.org/packages/10/37/1427fa4cfa09adbe04b1e97bced19a29a3462cc64c78630787b613a23f18/watchfiles-1.0.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:43b168bba889886b62edb0397cab5b6490ffb656ee2fcb22dec8bfeb371a9e12", size = 455677 }, + { url = "https://files.pythonhosted.org/packages/c5/7a/39e9397f3a19cb549a7d380412fd9e507d4854eddc0700bfad10ef6d4dba/watchfiles-1.0.4-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fb2c46e275fbb9f0c92e7654b231543c7bbfa1df07cdc4b99fa73bedfde5c844", size = 482219 }, + { url = "https://files.pythonhosted.org/packages/45/2d/7113931a77e2ea4436cad0c1690c09a40a7f31d366f79c6f0a5bc7a4f6d5/watchfiles-1.0.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:857f5fc3aa027ff5e57047da93f96e908a35fe602d24f5e5d8ce64bf1f2fc733", size = 518830 }, + { url = "https://files.pythonhosted.org/packages/f9/1b/50733b1980fa81ef3c70388a546481ae5fa4c2080040100cd7bf3bf7b321/watchfiles-1.0.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:55ccfd27c497b228581e2838d4386301227fc0cb47f5a12923ec2fe4f97b95af", size = 497997 }, + { url = "https://files.pythonhosted.org/packages/2b/b4/9396cc61b948ef18943e7c85ecfa64cf940c88977d882da57147f62b34b1/watchfiles-1.0.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c11ea22304d17d4385067588123658e9f23159225a27b983f343fcffc3e796a", size = 452249 }, + { url = "https://files.pythonhosted.org/packages/fb/69/0c65a5a29e057ad0dc691c2fa6c23b2983c7dabaa190ba553b29ac84c3cc/watchfiles-1.0.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:74cb3ca19a740be4caa18f238298b9d472c850f7b2ed89f396c00a4c97e2d9ff", size = 614412 }, + { url = "https://files.pythonhosted.org/packages/7f/b9/319fcba6eba5fad34327d7ce16a6b163b39741016b1996f4a3c96b8dd0e1/watchfiles-1.0.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:c7cce76c138a91e720d1df54014a047e680b652336e1b73b8e3ff3158e05061e", size = 611982 }, + { url = "https://files.pythonhosted.org/packages/f1/47/143c92418e30cb9348a4387bfa149c8e0e404a7c5b0585d46d2f7031b4b9/watchfiles-1.0.4-cp312-cp312-win32.whl", hash = "sha256:b045c800d55bc7e2cadd47f45a97c7b29f70f08a7c2fa13241905010a5493f94", size = 271822 }, + { url = "https://files.pythonhosted.org/packages/ea/94/b0165481bff99a64b29e46e07ac2e0df9f7a957ef13bec4ceab8515f44e3/watchfiles-1.0.4-cp312-cp312-win_amd64.whl", hash = "sha256:c2acfa49dd0ad0bf2a9c0bb9a985af02e89345a7189be1efc6baa085e0f72d7c", size = 285441 }, + { url = "https://files.pythonhosted.org/packages/11/de/09fe56317d582742d7ca8c2ca7b52a85927ebb50678d9b0fa8194658f536/watchfiles-1.0.4-cp312-cp312-win_arm64.whl", hash = "sha256:22bb55a7c9e564e763ea06c7acea24fc5d2ee5dfc5dafc5cfbedfe58505e9f90", size = 277141 }, +] + +[[package]] +name = "websocket-client" +version = "1.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e6/30/fba0d96b4b5fbf5948ed3f4681f7da2f9f64512e1d303f94b4cc174c24a5/websocket_client-1.8.0.tar.gz", hash = "sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da", size = 54648 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/84/44687a29792a70e111c5c477230a72c4b957d88d16141199bf9acb7537a3/websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526", size = 58826 }, +] + +[[package]] +name = "websockets" +version = "14.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/54/8359678c726243d19fae38ca14a334e740782336c9f19700858c4eb64a1e/websockets-14.2.tar.gz", hash = "sha256:5059ed9c54945efb321f097084b4c7e52c246f2c869815876a69d1efc4ad6eb5", size = 164394 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/81/04f7a397653dc8bec94ddc071f34833e8b99b13ef1a3804c149d59f92c18/websockets-14.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1f20522e624d7ffbdbe259c6b6a65d73c895045f76a93719aa10cd93b3de100c", size = 163096 }, + { url = "https://files.pythonhosted.org/packages/ec/c5/de30e88557e4d70988ed4d2eabd73fd3e1e52456b9f3a4e9564d86353b6d/websockets-14.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:647b573f7d3ada919fd60e64d533409a79dcf1ea21daeb4542d1d996519ca967", size = 160758 }, + { url = "https://files.pythonhosted.org/packages/e5/8c/d130d668781f2c77d106c007b6c6c1d9db68239107c41ba109f09e6c218a/websockets-14.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6af99a38e49f66be5a64b1e890208ad026cda49355661549c507152113049990", size = 160995 }, + { url = "https://files.pythonhosted.org/packages/a6/bc/f6678a0ff17246df4f06765e22fc9d98d1b11a258cc50c5968b33d6742a1/websockets-14.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:091ab63dfc8cea748cc22c1db2814eadb77ccbf82829bac6b2fbe3401d548eda", size = 170815 }, + { url = "https://files.pythonhosted.org/packages/d8/b2/8070cb970c2e4122a6ef38bc5b203415fd46460e025652e1ee3f2f43a9a3/websockets-14.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b374e8953ad477d17e4851cdc66d83fdc2db88d9e73abf755c94510ebddceb95", size = 169759 }, + { url = "https://files.pythonhosted.org/packages/81/da/72f7caabd94652e6eb7e92ed2d3da818626e70b4f2b15a854ef60bf501ec/websockets-14.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a39d7eceeea35db85b85e1169011bb4321c32e673920ae9c1b6e0978590012a3", size = 170178 }, + { url = "https://files.pythonhosted.org/packages/31/e0/812725b6deca8afd3a08a2e81b3c4c120c17f68c9b84522a520b816cda58/websockets-14.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0a6f3efd47ffd0d12080594f434faf1cd2549b31e54870b8470b28cc1d3817d9", size = 170453 }, + { url = "https://files.pythonhosted.org/packages/66/d3/8275dbc231e5ba9bb0c4f93144394b4194402a7a0c8ffaca5307a58ab5e3/websockets-14.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:065ce275e7c4ffb42cb738dd6b20726ac26ac9ad0a2a48e33ca632351a737267", size = 169830 }, + { url = "https://files.pythonhosted.org/packages/a3/ae/e7d1a56755ae15ad5a94e80dd490ad09e345365199600b2629b18ee37bc7/websockets-14.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e9d0e53530ba7b8b5e389c02282f9d2aa47581514bd6049d3a7cffe1385cf5fe", size = 169824 }, + { url = "https://files.pythonhosted.org/packages/b6/32/88ccdd63cb261e77b882e706108d072e4f1c839ed723bf91a3e1f216bf60/websockets-14.2-cp312-cp312-win32.whl", hash = "sha256:20e6dd0984d7ca3037afcb4494e48c74ffb51e8013cac71cf607fffe11df7205", size = 163981 }, + { url = "https://files.pythonhosted.org/packages/b3/7d/32cdb77990b3bdc34a306e0a0f73a1275221e9a66d869f6ff833c95b56ef/websockets-14.2-cp312-cp312-win_amd64.whl", hash = "sha256:44bba1a956c2c9d268bdcdf234d5e5ff4c9b6dc3e300545cbe99af59dda9dcce", size = 164421 }, + { url = "https://files.pythonhosted.org/packages/7b/c8/d529f8a32ce40d98309f4470780631e971a5a842b60aec864833b3615786/websockets-14.2-py3-none-any.whl", hash = "sha256:7a6ceec4ea84469f15cf15807a747e9efe57e369c384fa86e022b3bea679b79b", size = 157416 }, +] + +[[package]] +name = "werkzeug" +version = "3.1.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9f/69/83029f1f6300c5fb2471d621ab06f6ec6b3324685a2ce0f9777fd4a8b71e/werkzeug-3.1.3.tar.gz", hash = "sha256:60723ce945c19328679790e3282cc758aa4a6040e4bb330f53d30fa546d44746", size = 806925 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/52/24/ab44c871b0f07f491e5d2ad12c9bd7358e527510618cb1b803a88e986db1/werkzeug-3.1.3-py3-none-any.whl", hash = "sha256:54b78bf3716d19a65be4fceccc0d1d7b89e608834989dfae50ea87564639213e", size = 224498 }, +] + +[[package]] +name = "wmctrl" +version = "0.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/60/d9/6625ead93412c5ce86db1f8b4f2a70b8043e0a7c1d30099ba3c6a81641ff/wmctrl-0.5.tar.gz", hash = "sha256:7839a36b6fe9e2d6fd22304e5dc372dbced2116ba41283ea938b2da57f53e962", size = 5202 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/13/ca/723e3f8185738d7947f14ee7dc663b59415c6dee43bd71575f8c7f5cd6be/wmctrl-0.5-py2.py3-none-any.whl", hash = "sha256:ae695c1863a314c899e7cf113f07c0da02a394b968c4772e1936219d9234ddd7", size = 4268 }, +] + +[[package]] +name = "wrapt" +version = "1.17.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c3/fc/e91cc220803d7bc4db93fb02facd8461c37364151b8494762cc88b0fbcef/wrapt-1.17.2.tar.gz", hash = "sha256:41388e9d4d1522446fe79d3213196bd9e3b301a336965b9e27ca2788ebd122f3", size = 55531 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a1/bd/ab55f849fd1f9a58ed7ea47f5559ff09741b25f00c191231f9f059c83949/wrapt-1.17.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d5e2439eecc762cd85e7bd37161d4714aa03a33c5ba884e26c81559817ca0925", size = 53799 }, + { url = "https://files.pythonhosted.org/packages/53/18/75ddc64c3f63988f5a1d7e10fb204ffe5762bc663f8023f18ecaf31a332e/wrapt-1.17.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fc7cb4c1c744f8c05cd5f9438a3caa6ab94ce8344e952d7c45a8ed59dd88392", size = 38821 }, + { url = "https://files.pythonhosted.org/packages/48/2a/97928387d6ed1c1ebbfd4efc4133a0633546bec8481a2dd5ec961313a1c7/wrapt-1.17.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8fdbdb757d5390f7c675e558fd3186d590973244fab0c5fe63d373ade3e99d40", size = 38919 }, + { url = "https://files.pythonhosted.org/packages/73/54/3bfe5a1febbbccb7a2f77de47b989c0b85ed3a6a41614b104204a788c20e/wrapt-1.17.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5bb1d0dbf99411f3d871deb6faa9aabb9d4e744d67dcaaa05399af89d847a91d", size = 88721 }, + { url = "https://files.pythonhosted.org/packages/25/cb/7262bc1b0300b4b64af50c2720ef958c2c1917525238d661c3e9a2b71b7b/wrapt-1.17.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d18a4865f46b8579d44e4fe1e2bcbc6472ad83d98e22a26c963d46e4c125ef0b", size = 80899 }, + { url = "https://files.pythonhosted.org/packages/2a/5a/04cde32b07a7431d4ed0553a76fdb7a61270e78c5fd5a603e190ac389f14/wrapt-1.17.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc570b5f14a79734437cb7b0500376b6b791153314986074486e0b0fa8d71d98", size = 89222 }, + { url = "https://files.pythonhosted.org/packages/09/28/2e45a4f4771fcfb109e244d5dbe54259e970362a311b67a965555ba65026/wrapt-1.17.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6d9187b01bebc3875bac9b087948a2bccefe464a7d8f627cf6e48b1bbae30f82", size = 86707 }, + { url = "https://files.pythonhosted.org/packages/c6/d2/dcb56bf5f32fcd4bd9aacc77b50a539abdd5b6536872413fd3f428b21bed/wrapt-1.17.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:9e8659775f1adf02eb1e6f109751268e493c73716ca5761f8acb695e52a756ae", size = 79685 }, + { url = "https://files.pythonhosted.org/packages/80/4e/eb8b353e36711347893f502ce91c770b0b0929f8f0bed2670a6856e667a9/wrapt-1.17.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e8b2816ebef96d83657b56306152a93909a83f23994f4b30ad4573b00bd11bb9", size = 87567 }, + { url = "https://files.pythonhosted.org/packages/17/27/4fe749a54e7fae6e7146f1c7d914d28ef599dacd4416566c055564080fe2/wrapt-1.17.2-cp312-cp312-win32.whl", hash = "sha256:468090021f391fe0056ad3e807e3d9034e0fd01adcd3bdfba977b6fdf4213ea9", size = 36672 }, + { url = "https://files.pythonhosted.org/packages/15/06/1dbf478ea45c03e78a6a8c4be4fdc3c3bddea5c8de8a93bc971415e47f0f/wrapt-1.17.2-cp312-cp312-win_amd64.whl", hash = "sha256:ec89ed91f2fa8e3f52ae53cd3cf640d6feff92ba90d62236a81e4e563ac0e991", size = 38865 }, + { url = "https://files.pythonhosted.org/packages/2d/82/f56956041adef78f849db6b289b282e72b55ab8045a75abad81898c28d19/wrapt-1.17.2-py3-none-any.whl", hash = "sha256:b18f2d1533a71f069c7f82d524a52599053d4c7166e9dd374ae2136b7f40f7c8", size = 23594 }, +] + +[[package]] +name = "yarl" +version = "1.18.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "multidict" }, + { name = "propcache" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b7/9d/4b94a8e6d2b51b599516a5cb88e5bc99b4d8d4583e468057eaa29d5f0918/yarl-1.18.3.tar.gz", hash = "sha256:ac1801c45cbf77b6c99242eeff4fffb5e4e73a800b5c4ad4fc0be5def634d2e1", size = 181062 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/85/bd2e2729752ff4c77338e0102914897512e92496375e079ce0150a6dc306/yarl-1.18.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1dd4bdd05407ced96fed3d7f25dbbf88d2ffb045a0db60dbc247f5b3c5c25d50", size = 142644 }, + { url = "https://files.pythonhosted.org/packages/ff/74/1178322cc0f10288d7eefa6e4a85d8d2e28187ccab13d5b844e8b5d7c88d/yarl-1.18.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7c33dd1931a95e5d9a772d0ac5e44cac8957eaf58e3c8da8c1414de7dd27c576", size = 94962 }, + { url = "https://files.pythonhosted.org/packages/be/75/79c6acc0261e2c2ae8a1c41cf12265e91628c8c58ae91f5ff59e29c0787f/yarl-1.18.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:25b411eddcfd56a2f0cd6a384e9f4f7aa3efee14b188de13048c25b5e91f1640", size = 92795 }, + { url = "https://files.pythonhosted.org/packages/6b/32/927b2d67a412c31199e83fefdce6e645247b4fb164aa1ecb35a0f9eb2058/yarl-1.18.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:436c4fc0a4d66b2badc6c5fc5ef4e47bb10e4fd9bf0c79524ac719a01f3607c2", size = 332368 }, + { url = "https://files.pythonhosted.org/packages/19/e5/859fca07169d6eceeaa4fde1997c91d8abde4e9a7c018e371640c2da2b71/yarl-1.18.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e35ef8683211db69ffe129a25d5634319a677570ab6b2eba4afa860f54eeaf75", size = 342314 }, + { url = "https://files.pythonhosted.org/packages/08/75/76b63ccd91c9e03ab213ef27ae6add2e3400e77e5cdddf8ed2dbc36e3f21/yarl-1.18.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:84b2deecba4a3f1a398df819151eb72d29bfeb3b69abb145a00ddc8d30094512", size = 341987 }, + { url = "https://files.pythonhosted.org/packages/1a/e1/a097d5755d3ea8479a42856f51d97eeff7a3a7160593332d98f2709b3580/yarl-1.18.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00e5a1fea0fd4f5bfa7440a47eff01d9822a65b4488f7cff83155a0f31a2ecba", size = 336914 }, + { url = "https://files.pythonhosted.org/packages/0b/42/e1b4d0e396b7987feceebe565286c27bc085bf07d61a59508cdaf2d45e63/yarl-1.18.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d0e883008013c0e4aef84dcfe2a0b172c4d23c2669412cf5b3371003941f72bb", size = 325765 }, + { url = "https://files.pythonhosted.org/packages/7e/18/03a5834ccc9177f97ca1bbb245b93c13e58e8225276f01eedc4cc98ab820/yarl-1.18.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5a3f356548e34a70b0172d8890006c37be92995f62d95a07b4a42e90fba54272", size = 344444 }, + { url = "https://files.pythonhosted.org/packages/c8/03/a713633bdde0640b0472aa197b5b86e90fbc4c5bc05b727b714cd8a40e6d/yarl-1.18.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ccd17349166b1bee6e529b4add61727d3f55edb7babbe4069b5764c9587a8cc6", size = 340760 }, + { url = "https://files.pythonhosted.org/packages/eb/99/f6567e3f3bbad8fd101886ea0276c68ecb86a2b58be0f64077396cd4b95e/yarl-1.18.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b958ddd075ddba5b09bb0be8a6d9906d2ce933aee81100db289badbeb966f54e", size = 346484 }, + { url = "https://files.pythonhosted.org/packages/8e/a9/84717c896b2fc6cb15bd4eecd64e34a2f0a9fd6669e69170c73a8b46795a/yarl-1.18.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c7d79f7d9aabd6011004e33b22bc13056a3e3fb54794d138af57f5ee9d9032cb", size = 359864 }, + { url = "https://files.pythonhosted.org/packages/1e/2e/d0f5f1bef7ee93ed17e739ec8dbcb47794af891f7d165fa6014517b48169/yarl-1.18.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4891ed92157e5430874dad17b15eb1fda57627710756c27422200c52d8a4e393", size = 364537 }, + { url = "https://files.pythonhosted.org/packages/97/8a/568d07c5d4964da5b02621a517532adb8ec5ba181ad1687191fffeda0ab6/yarl-1.18.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ce1af883b94304f493698b00d0f006d56aea98aeb49d75ec7d98cd4a777e9285", size = 357861 }, + { url = "https://files.pythonhosted.org/packages/7d/e3/924c3f64b6b3077889df9a1ece1ed8947e7b61b0a933f2ec93041990a677/yarl-1.18.3-cp312-cp312-win32.whl", hash = "sha256:f91c4803173928a25e1a55b943c81f55b8872f0018be83e3ad4938adffb77dd2", size = 84097 }, + { url = "https://files.pythonhosted.org/packages/34/45/0e055320daaabfc169b21ff6174567b2c910c45617b0d79c68d7ab349b02/yarl-1.18.3-cp312-cp312-win_amd64.whl", hash = "sha256:7e2ee16578af3b52ac2f334c3b1f92262f47e02cc6193c598502bd46f5cd1477", size = 90399 }, + { url = "https://files.pythonhosted.org/packages/f5/4b/a06e0ec3d155924f77835ed2d167ebd3b211a7b0853da1cf8d8414d784ef/yarl-1.18.3-py3-none-any.whl", hash = "sha256:b57f4f58099328dfb26c6a771d09fb20dbbae81d20cfb66141251ea063bd101b", size = 45109 }, +] + +[[package]] +name = "zipp" +version = "3.21.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3f/50/bad581df71744867e9468ebd0bcd6505de3b275e06f202c2cb016e3ff56f/zipp-3.21.0.tar.gz", hash = "sha256:2c9958f6430a2040341a52eb608ed6dd93ef4392e02ffe219417c1b28b5dd1f4", size = 24545 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/1a/7e4798e9339adc931158c9d69ecc34f5e6791489d469f5e50ec15e35f458/zipp-3.21.0-py3-none-any.whl", hash = "sha256:ac1bbe05fd2991f160ebce24ffbac5f6d11d83dc90891255885223d42b3cd931", size = 9630 }, +] + +[[package]] +name = "zstandard" +version = "0.23.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "platform_python_implementation == 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ed/f6/2ac0287b442160a89d726b17a9184a4c615bb5237db763791a7fd16d9df1/zstandard-0.23.0.tar.gz", hash = "sha256:b2d8c62d08e7255f68f7a740bae85b3c9b8e5466baa9cbf7f57f1cde0ac6bc09", size = 681701 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/83/f23338c963bd9de687d47bf32efe9fd30164e722ba27fb59df33e6b1719b/zstandard-0.23.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b4567955a6bc1b20e9c31612e615af6b53733491aeaa19a6b3b37f3b65477094", size = 788713 }, + { url = "https://files.pythonhosted.org/packages/5b/b3/1a028f6750fd9227ee0b937a278a434ab7f7fdc3066c3173f64366fe2466/zstandard-0.23.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1e172f57cd78c20f13a3415cc8dfe24bf388614324d25539146594c16d78fcc8", size = 633459 }, + { url = "https://files.pythonhosted.org/packages/26/af/36d89aae0c1f95a0a98e50711bc5d92c144939efc1f81a2fcd3e78d7f4c1/zstandard-0.23.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b0e166f698c5a3e914947388c162be2583e0c638a4703fc6a543e23a88dea3c1", size = 4945707 }, + { url = "https://files.pythonhosted.org/packages/cd/2e/2051f5c772f4dfc0aae3741d5fc72c3dcfe3aaeb461cc231668a4db1ce14/zstandard-0.23.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:12a289832e520c6bd4dcaad68e944b86da3bad0d339ef7989fb7e88f92e96072", size = 5306545 }, + { url = "https://files.pythonhosted.org/packages/0a/9e/a11c97b087f89cab030fa71206963090d2fecd8eb83e67bb8f3ffb84c024/zstandard-0.23.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d50d31bfedd53a928fed6707b15a8dbeef011bb6366297cc435accc888b27c20", size = 5337533 }, + { url = "https://files.pythonhosted.org/packages/fc/79/edeb217c57fe1bf16d890aa91a1c2c96b28c07b46afed54a5dcf310c3f6f/zstandard-0.23.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:72c68dda124a1a138340fb62fa21b9bf4848437d9ca60bd35db36f2d3345f373", size = 5436510 }, + { url = "https://files.pythonhosted.org/packages/81/4f/c21383d97cb7a422ddf1ae824b53ce4b51063d0eeb2afa757eb40804a8ef/zstandard-0.23.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:53dd9d5e3d29f95acd5de6802e909ada8d8d8cfa37a3ac64836f3bc4bc5512db", size = 4859973 }, + { url = "https://files.pythonhosted.org/packages/ab/15/08d22e87753304405ccac8be2493a495f529edd81d39a0870621462276ef/zstandard-0.23.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:6a41c120c3dbc0d81a8e8adc73312d668cd34acd7725f036992b1b72d22c1772", size = 4936968 }, + { url = "https://files.pythonhosted.org/packages/eb/fa/f3670a597949fe7dcf38119a39f7da49a8a84a6f0b1a2e46b2f71a0ab83f/zstandard-0.23.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:40b33d93c6eddf02d2c19f5773196068d875c41ca25730e8288e9b672897c105", size = 5467179 }, + { url = "https://files.pythonhosted.org/packages/4e/a9/dad2ab22020211e380adc477a1dbf9f109b1f8d94c614944843e20dc2a99/zstandard-0.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9206649ec587e6b02bd124fb7799b86cddec350f6f6c14bc82a2b70183e708ba", size = 4848577 }, + { url = "https://files.pythonhosted.org/packages/08/03/dd28b4484b0770f1e23478413e01bee476ae8227bbc81561f9c329e12564/zstandard-0.23.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:76e79bc28a65f467e0409098fa2c4376931fd3207fbeb6b956c7c476d53746dd", size = 4693899 }, + { url = "https://files.pythonhosted.org/packages/2b/64/3da7497eb635d025841e958bcd66a86117ae320c3b14b0ae86e9e8627518/zstandard-0.23.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:66b689c107857eceabf2cf3d3fc699c3c0fe8ccd18df2219d978c0283e4c508a", size = 5199964 }, + { url = "https://files.pythonhosted.org/packages/43/a4/d82decbab158a0e8a6ebb7fc98bc4d903266bce85b6e9aaedea1d288338c/zstandard-0.23.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:9c236e635582742fee16603042553d276cca506e824fa2e6489db04039521e90", size = 5655398 }, + { url = "https://files.pythonhosted.org/packages/f2/61/ac78a1263bc83a5cf29e7458b77a568eda5a8f81980691bbc6eb6a0d45cc/zstandard-0.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a8fffdbd9d1408006baaf02f1068d7dd1f016c6bcb7538682622c556e7b68e35", size = 5191313 }, + { url = "https://files.pythonhosted.org/packages/e7/54/967c478314e16af5baf849b6ee9d6ea724ae5b100eb506011f045d3d4e16/zstandard-0.23.0-cp312-cp312-win32.whl", hash = "sha256:dc1d33abb8a0d754ea4763bad944fd965d3d95b5baef6b121c0c9013eaf1907d", size = 430877 }, + { url = "https://files.pythonhosted.org/packages/75/37/872d74bd7739639c4553bf94c84af7d54d8211b626b352bc57f0fd8d1e3f/zstandard-0.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:64585e1dba664dc67c7cdabd56c1e5685233fbb1fc1966cfba2a340ec0dfff7b", size = 495595 }, +] diff --git a/app/bun.lock b/app/bun.lock new file mode 100644 index 000000000..ebd8e002d --- /dev/null +++ b/app/bun.lock @@ -0,0 +1,782 @@ +{ + "lockfileVersion": 1, + "workspaces": { + "": { + "name": "agentops-monorepo-root", + "devDependencies": { + "@typescript-eslint/eslint-plugin": "^7.0.0", + "@typescript-eslint/parser": "^7.0.0", + "eslint": "^8.50.0", + "eslint-config-next": "^14.0.0", + "eslint-config-prettier": "^9.0.0", + "eslint-plugin-import": "^2.29.0", + "eslint-plugin-react": "^7.33.0", + "eslint-plugin-react-hooks": "^4.6.0", + "husky": "^9.0.0", + "lint-staged": "^15.0.0", + "prettier": "^3.0.0", + "prettier-plugin-tailwindcss": "^0.5.0", + "typescript": "^5.3.0", + }, + }, + }, + "packages": { + "@eslint-community/eslint-utils": ["@eslint-community/eslint-utils@4.5.1", "", { "dependencies": { "eslint-visitor-keys": "^3.4.3" }, "peerDependencies": { "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" } }, "sha512-soEIOALTfTK6EjmKMMoLugwaP0rzkad90iIWd1hMO9ARkSAyjfMfkRRhLvD5qH7vvM0Cg72pieUfR6yh6XxC4w=="], + + "@eslint-community/regexpp": ["@eslint-community/regexpp@4.12.1", "", {}, "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ=="], + + "@eslint/eslintrc": ["@eslint/eslintrc@2.1.4", "", { "dependencies": { "ajv": "^6.12.4", "debug": "^4.3.2", "espree": "^9.6.0", "globals": "^13.19.0", "ignore": "^5.2.0", "import-fresh": "^3.2.1", "js-yaml": "^4.1.0", "minimatch": "^3.1.2", "strip-json-comments": "^3.1.1" } }, "sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ=="], + + "@eslint/js": ["@eslint/js@8.57.1", "", {}, "sha512-d9zaMRSTIKDLhctzH12MtXvJKSSUhaHcjV+2Z+GK+EEY7XKpP5yR4x+N3TAcHTcu963nIr+TMcCb4DBCYX1z6Q=="], + + "@humanwhocodes/config-array": ["@humanwhocodes/config-array@0.13.0", "", { "dependencies": { "@humanwhocodes/object-schema": "^2.0.3", "debug": "^4.3.1", "minimatch": "^3.0.5" } }, "sha512-DZLEEqFWQFiyK6h5YIeynKx7JlvCYWL0cImfSRXZ9l4Sg2efkFGTuFf6vzXjK1cq6IYkU+Eg/JizXw+TD2vRNw=="], + + "@humanwhocodes/module-importer": ["@humanwhocodes/module-importer@1.0.1", "", {}, "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA=="], + + "@humanwhocodes/object-schema": ["@humanwhocodes/object-schema@2.0.3", "", {}, "sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA=="], + + "@isaacs/cliui": ["@isaacs/cliui@8.0.2", "", { "dependencies": { "string-width": "^5.1.2", "string-width-cjs": "npm:string-width@^4.2.0", "strip-ansi": "^7.0.1", "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", "wrap-ansi": "^8.1.0", "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" } }, "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA=="], + + "@next/eslint-plugin-next": ["@next/eslint-plugin-next@14.2.26", "", { "dependencies": { "glob": "10.3.10" } }, "sha512-SPEj1O5DAVTPaWD9XPupelfT2APNIgcDYD2OzEm328BEmHaglhmYNUvxhzfJYDr12AgAfW4V3UHSV93qaeELJA=="], + + "@nodelib/fs.scandir": ["@nodelib/fs.scandir@2.1.5", "", { "dependencies": { "@nodelib/fs.stat": "2.0.5", "run-parallel": "^1.1.9" } }, "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g=="], + + "@nodelib/fs.stat": ["@nodelib/fs.stat@2.0.5", "", {}, "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A=="], + + "@nodelib/fs.walk": ["@nodelib/fs.walk@1.2.8", "", { "dependencies": { "@nodelib/fs.scandir": "2.1.5", "fastq": "^1.6.0" } }, "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg=="], + + "@nolyfill/is-core-module": ["@nolyfill/is-core-module@1.0.39", "", {}, "sha512-nn5ozdjYQpUCZlWGuxcJY/KpxkWQs4DcbMCmKojjyrYDEAGy4Ce19NN4v5MduafTwJlbKc99UA8YhSVqq9yPZA=="], + + "@pkgjs/parseargs": ["@pkgjs/parseargs@0.11.0", "", {}, "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg=="], + + "@rtsao/scc": ["@rtsao/scc@1.1.0", "", {}, "sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g=="], + + "@rushstack/eslint-patch": ["@rushstack/eslint-patch@1.11.0", "", {}, "sha512-zxnHvoMQVqewTJr/W4pKjF0bMGiKJv1WX7bSrkl46Hg0QjESbzBROWK0Wg4RphzSOS5Jiy7eFimmM3UgMrMZbQ=="], + + "@types/json5": ["@types/json5@0.0.29", "", {}, "sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ=="], + + "@typescript-eslint/eslint-plugin": ["@typescript-eslint/eslint-plugin@7.18.0", "", { "dependencies": { "@eslint-community/regexpp": "^4.10.0", "@typescript-eslint/scope-manager": "7.18.0", "@typescript-eslint/type-utils": "7.18.0", "@typescript-eslint/utils": "7.18.0", "@typescript-eslint/visitor-keys": "7.18.0", "graphemer": "^1.4.0", "ignore": "^5.3.1", "natural-compare": "^1.4.0", "ts-api-utils": "^1.3.0" }, "peerDependencies": { "@typescript-eslint/parser": "^7.0.0", "eslint": "^8.56.0" } }, "sha512-94EQTWZ40mzBc42ATNIBimBEDltSJ9RQHCC8vc/PDbxi4k8dVwUAv4o98dk50M1zB+JGFxp43FP7f8+FP8R6Sw=="], + + "@typescript-eslint/parser": ["@typescript-eslint/parser@7.18.0", "", { "dependencies": { "@typescript-eslint/scope-manager": "7.18.0", "@typescript-eslint/types": "7.18.0", "@typescript-eslint/typescript-estree": "7.18.0", "@typescript-eslint/visitor-keys": "7.18.0", "debug": "^4.3.4" }, "peerDependencies": { "eslint": "^8.56.0" } }, "sha512-4Z+L8I2OqhZV8qA132M4wNL30ypZGYOQVBfMgxDH/K5UX0PNqTu1c6za9ST5r9+tavvHiTWmBnKzpCJ/GlVFtg=="], + + "@typescript-eslint/scope-manager": ["@typescript-eslint/scope-manager@7.18.0", "", { "dependencies": { "@typescript-eslint/types": "7.18.0", "@typescript-eslint/visitor-keys": "7.18.0" } }, "sha512-jjhdIE/FPF2B7Z1uzc6i3oWKbGcHb87Qw7AWj6jmEqNOfDFbJWtjt/XfwCpvNkpGWlcJaog5vTR+VV8+w9JflA=="], + + "@typescript-eslint/type-utils": ["@typescript-eslint/type-utils@7.18.0", "", { "dependencies": { "@typescript-eslint/typescript-estree": "7.18.0", "@typescript-eslint/utils": "7.18.0", "debug": "^4.3.4", "ts-api-utils": "^1.3.0" }, "peerDependencies": { "eslint": "^8.56.0" } }, "sha512-XL0FJXuCLaDuX2sYqZUUSOJ2sG5/i1AAze+axqmLnSkNEVMVYLF+cbwlB2w8D1tinFuSikHmFta+P+HOofrLeA=="], + + "@typescript-eslint/types": ["@typescript-eslint/types@7.18.0", "", {}, "sha512-iZqi+Ds1y4EDYUtlOOC+aUmxnE9xS/yCigkjA7XpTKV6nCBd3Hp/PRGGmdwnfkV2ThMyYldP1wRpm/id99spTQ=="], + + "@typescript-eslint/typescript-estree": ["@typescript-eslint/typescript-estree@7.18.0", "", { "dependencies": { "@typescript-eslint/types": "7.18.0", "@typescript-eslint/visitor-keys": "7.18.0", "debug": "^4.3.4", "globby": "^11.1.0", "is-glob": "^4.0.3", "minimatch": "^9.0.4", "semver": "^7.6.0", "ts-api-utils": "^1.3.0" } }, "sha512-aP1v/BSPnnyhMHts8cf1qQ6Q1IFwwRvAQGRvBFkWlo3/lH29OXA3Pts+c10nxRxIBrDnoMqzhgdwVe5f2D6OzA=="], + + "@typescript-eslint/utils": ["@typescript-eslint/utils@7.18.0", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.4.0", "@typescript-eslint/scope-manager": "7.18.0", "@typescript-eslint/types": "7.18.0", "@typescript-eslint/typescript-estree": "7.18.0" }, "peerDependencies": { "eslint": "^8.56.0" } }, "sha512-kK0/rNa2j74XuHVcoCZxdFBMF+aq/vH83CXAOHieC+2Gis4mF8jJXT5eAfyD3K0sAxtPuwxaIOIOvhwzVDt/kw=="], + + "@typescript-eslint/visitor-keys": ["@typescript-eslint/visitor-keys@7.18.0", "", { "dependencies": { "@typescript-eslint/types": "7.18.0", "eslint-visitor-keys": "^3.4.3" } }, "sha512-cDF0/Gf81QpY3xYyJKDV14Zwdmid5+uuENhjH2EqFaF0ni+yAyq/LzMaIJdhNJXZI7uLzwIlA+V7oWoyn6Curg=="], + + "@ungap/structured-clone": ["@ungap/structured-clone@1.3.0", "", {}, "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g=="], + + "@unrs/resolver-binding-win32-x64-msvc": ["@unrs/resolver-binding-win32-x64-msvc@1.3.3", "", { "os": "win32", "cpu": "x64" }, "sha512-GraLbYqOJcmW1qY3osB+2YIiD62nVf2/bVLHZmrb4t/YSUwE03l7TwcDJl08T/Tm3SVhepX8RQkpzWbag/Sb4w=="], + + "acorn": ["acorn@8.14.1", "", { "bin": "bin/acorn" }, "sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg=="], + + "acorn-jsx": ["acorn-jsx@5.3.2", "", { "peerDependencies": { "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ=="], + + "ajv": ["ajv@6.12.6", "", { "dependencies": { "fast-deep-equal": "^3.1.1", "fast-json-stable-stringify": "^2.0.0", "json-schema-traverse": "^0.4.1", "uri-js": "^4.2.2" } }, "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g=="], + + "ansi-escapes": ["ansi-escapes@7.0.0", "", { "dependencies": { "environment": "^1.0.0" } }, "sha512-GdYO7a61mR0fOlAsvC9/rIHf7L96sBc6dEWzeOu+KAea5bZyQRPIpojrVoI4AXGJS/ycu/fBTdLrUkA4ODrvjw=="], + + "ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="], + + "ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="], + + "argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="], + + "aria-query": ["aria-query@5.3.2", "", {}, "sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw=="], + + "array-buffer-byte-length": ["array-buffer-byte-length@1.0.2", "", { "dependencies": { "call-bound": "^1.0.3", "is-array-buffer": "^3.0.5" } }, "sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw=="], + + "array-includes": ["array-includes@3.1.8", "", { "dependencies": { "call-bind": "^1.0.7", "define-properties": "^1.2.1", "es-abstract": "^1.23.2", "es-object-atoms": "^1.0.0", "get-intrinsic": "^1.2.4", "is-string": "^1.0.7" } }, "sha512-itaWrbYbqpGXkGhZPGUulwnhVf5Hpy1xiCFsGqyIGglbBxmG5vSjxQen3/WGOjPpNEv1RtBLKxbmVXm8HpJStQ=="], + + "array-union": ["array-union@2.1.0", "", {}, "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw=="], + + "array.prototype.findlast": ["array.prototype.findlast@1.2.5", "", { "dependencies": { "call-bind": "^1.0.7", "define-properties": "^1.2.1", "es-abstract": "^1.23.2", "es-errors": "^1.3.0", "es-object-atoms": "^1.0.0", "es-shim-unscopables": "^1.0.2" } }, "sha512-CVvd6FHg1Z3POpBLxO6E6zr+rSKEQ9L6rZHAaY7lLfhKsWYUBBOuMs0e9o24oopj6H+geRCX0YJ+TJLBK2eHyQ=="], + + "array.prototype.findlastindex": ["array.prototype.findlastindex@1.2.6", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.4", "define-properties": "^1.2.1", "es-abstract": "^1.23.9", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "es-shim-unscopables": "^1.1.0" } }, "sha512-F/TKATkzseUExPlfvmwQKGITM3DGTK+vkAsCZoDc5daVygbJBnjEUCbgkAvVFsgfXfX4YIqZ/27G3k3tdXrTxQ=="], + + "array.prototype.flat": ["array.prototype.flat@1.3.3", "", { "dependencies": { "call-bind": "^1.0.8", "define-properties": "^1.2.1", "es-abstract": "^1.23.5", "es-shim-unscopables": "^1.0.2" } }, "sha512-rwG/ja1neyLqCuGZ5YYrznA62D4mZXg0i1cIskIUKSiqF3Cje9/wXAls9B9s1Wa2fomMsIv8czB8jZcPmxCXFg=="], + + "array.prototype.flatmap": ["array.prototype.flatmap@1.3.3", "", { "dependencies": { "call-bind": "^1.0.8", "define-properties": "^1.2.1", "es-abstract": "^1.23.5", "es-shim-unscopables": "^1.0.2" } }, "sha512-Y7Wt51eKJSyi80hFrJCePGGNo5ktJCslFuboqJsbf57CCPcm5zztluPlc4/aD8sWsKvlwatezpV4U1efk8kpjg=="], + + "array.prototype.tosorted": ["array.prototype.tosorted@1.1.4", "", { "dependencies": { "call-bind": "^1.0.7", "define-properties": "^1.2.1", "es-abstract": "^1.23.3", "es-errors": "^1.3.0", "es-shim-unscopables": "^1.0.2" } }, "sha512-p6Fx8B7b7ZhL/gmUsAy0D15WhvDccw3mnGNbZpi3pmeJdxtWsj2jEaI4Y6oo3XiHfzuSgPwKc04MYt6KgvC/wA=="], + + "arraybuffer.prototype.slice": ["arraybuffer.prototype.slice@1.0.4", "", { "dependencies": { "array-buffer-byte-length": "^1.0.1", "call-bind": "^1.0.8", "define-properties": "^1.2.1", "es-abstract": "^1.23.5", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.6", "is-array-buffer": "^3.0.4" } }, "sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ=="], + + "ast-types-flow": ["ast-types-flow@0.0.8", "", {}, "sha512-OH/2E5Fg20h2aPrbe+QL8JZQFko0YZaF+j4mnQ7BGhfavO7OpSLa8a0y9sBwomHdSbkhTS8TQNayBfnW5DwbvQ=="], + + "async-function": ["async-function@1.0.0", "", {}, "sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA=="], + + "available-typed-arrays": ["available-typed-arrays@1.0.7", "", { "dependencies": { "possible-typed-array-names": "^1.0.0" } }, "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ=="], + + "axe-core": ["axe-core@4.10.3", "", {}, "sha512-Xm7bpRXnDSX2YE2YFfBk2FnF0ep6tmG7xPh8iHee8MIcrgq762Nkce856dYtJYLkuIoYZvGfTs/PbZhideTcEg=="], + + "axobject-query": ["axobject-query@4.1.0", "", {}, "sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ=="], + + "balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="], + + "brace-expansion": ["brace-expansion@1.1.11", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA=="], + + "braces": ["braces@3.0.3", "", { "dependencies": { "fill-range": "^7.1.1" } }, "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA=="], + + "call-bind": ["call-bind@1.0.8", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.0", "es-define-property": "^1.0.0", "get-intrinsic": "^1.2.4", "set-function-length": "^1.2.2" } }, "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww=="], + + "call-bind-apply-helpers": ["call-bind-apply-helpers@1.0.2", "", { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ=="], + + "call-bound": ["call-bound@1.0.4", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "get-intrinsic": "^1.3.0" } }, "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg=="], + + "callsites": ["callsites@3.1.0", "", {}, "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ=="], + + "chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="], + + "cli-cursor": ["cli-cursor@5.0.0", "", { "dependencies": { "restore-cursor": "^5.0.0" } }, "sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw=="], + + "cli-truncate": ["cli-truncate@4.0.0", "", { "dependencies": { "slice-ansi": "^5.0.0", "string-width": "^7.0.0" } }, "sha512-nPdaFdQ0h/GEigbPClz11D0v/ZJEwxmeVZGeMo3Z5StPtUTkA9o1lD6QwoirYiSDzbcwn2XcjwmCp68W1IS4TA=="], + + "color-convert": ["color-convert@2.0.1", "", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="], + + "color-name": ["color-name@1.1.4", "", {}, "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="], + + "colorette": ["colorette@2.0.20", "", {}, "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w=="], + + "commander": ["commander@13.1.0", "", {}, "sha512-/rFeCpNJQbhSZjGVwO9RFV3xPqbnERS8MmIQzCtD/zl6gpJuV/bMLuN92oG3F7d8oDEHHRrujSXNUr8fpjntKw=="], + + "concat-map": ["concat-map@0.0.1", "", {}, "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg=="], + + "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="], + + "damerau-levenshtein": ["damerau-levenshtein@1.0.8", "", {}, "sha512-sdQSFB7+llfUcQHUQO3+B8ERRj0Oa4w9POWMI/puGtuf7gFywGmkaLCElnudfTiKZV+NvHqL0ifzdrI8Ro7ESA=="], + + "data-view-buffer": ["data-view-buffer@1.0.2", "", { "dependencies": { "call-bound": "^1.0.3", "es-errors": "^1.3.0", "is-data-view": "^1.0.2" } }, "sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ=="], + + "data-view-byte-length": ["data-view-byte-length@1.0.2", "", { "dependencies": { "call-bound": "^1.0.3", "es-errors": "^1.3.0", "is-data-view": "^1.0.2" } }, "sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ=="], + + "data-view-byte-offset": ["data-view-byte-offset@1.0.1", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "is-data-view": "^1.0.1" } }, "sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ=="], + + "debug": ["debug@4.4.0", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA=="], + + "deep-is": ["deep-is@0.1.4", "", {}, "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ=="], + + "define-data-property": ["define-data-property@1.1.4", "", { "dependencies": { "es-define-property": "^1.0.0", "es-errors": "^1.3.0", "gopd": "^1.0.1" } }, "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A=="], + + "define-properties": ["define-properties@1.2.1", "", { "dependencies": { "define-data-property": "^1.0.1", "has-property-descriptors": "^1.0.0", "object-keys": "^1.1.1" } }, "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg=="], + + "dir-glob": ["dir-glob@3.0.1", "", { "dependencies": { "path-type": "^4.0.0" } }, "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA=="], + + "doctrine": ["doctrine@3.0.0", "", { "dependencies": { "esutils": "^2.0.2" } }, "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w=="], + + "dunder-proto": ["dunder-proto@1.0.1", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.1", "es-errors": "^1.3.0", "gopd": "^1.2.0" } }, "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A=="], + + "eastasianwidth": ["eastasianwidth@0.2.0", "", {}, "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA=="], + + "emoji-regex": ["emoji-regex@9.2.2", "", {}, "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="], + + "environment": ["environment@1.1.0", "", {}, "sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q=="], + + "es-abstract": ["es-abstract@1.23.9", "", { "dependencies": { "array-buffer-byte-length": "^1.0.2", "arraybuffer.prototype.slice": "^1.0.4", "available-typed-arrays": "^1.0.7", "call-bind": "^1.0.8", "call-bound": "^1.0.3", "data-view-buffer": "^1.0.2", "data-view-byte-length": "^1.0.2", "data-view-byte-offset": "^1.0.1", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.0.0", "es-set-tostringtag": "^2.1.0", "es-to-primitive": "^1.3.0", "function.prototype.name": "^1.1.8", "get-intrinsic": "^1.2.7", "get-proto": "^1.0.0", "get-symbol-description": "^1.1.0", "globalthis": "^1.0.4", "gopd": "^1.2.0", "has-property-descriptors": "^1.0.2", "has-proto": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "internal-slot": "^1.1.0", "is-array-buffer": "^3.0.5", "is-callable": "^1.2.7", "is-data-view": "^1.0.2", "is-regex": "^1.2.1", "is-shared-array-buffer": "^1.0.4", "is-string": "^1.1.1", "is-typed-array": "^1.1.15", "is-weakref": "^1.1.0", "math-intrinsics": "^1.1.0", "object-inspect": "^1.13.3", "object-keys": "^1.1.1", "object.assign": "^4.1.7", "own-keys": "^1.0.1", "regexp.prototype.flags": "^1.5.3", "safe-array-concat": "^1.1.3", "safe-push-apply": "^1.0.0", "safe-regex-test": "^1.1.0", "set-proto": "^1.0.0", "string.prototype.trim": "^1.2.10", "string.prototype.trimend": "^1.0.9", "string.prototype.trimstart": "^1.0.8", "typed-array-buffer": "^1.0.3", "typed-array-byte-length": "^1.0.3", "typed-array-byte-offset": "^1.0.4", "typed-array-length": "^1.0.7", "unbox-primitive": "^1.1.0", "which-typed-array": "^1.1.18" } }, "sha512-py07lI0wjxAC/DcfK1S6G7iANonniZwTISvdPzk9hzeH0IZIshbuuFxLIU96OyF89Yb9hiqWn8M/bY83KY5vzA=="], + + "es-define-property": ["es-define-property@1.0.1", "", {}, "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="], + + "es-errors": ["es-errors@1.3.0", "", {}, "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="], + + "es-iterator-helpers": ["es-iterator-helpers@1.2.1", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.3", "define-properties": "^1.2.1", "es-abstract": "^1.23.6", "es-errors": "^1.3.0", "es-set-tostringtag": "^2.0.3", "function-bind": "^1.1.2", "get-intrinsic": "^1.2.6", "globalthis": "^1.0.4", "gopd": "^1.2.0", "has-property-descriptors": "^1.0.2", "has-proto": "^1.2.0", "has-symbols": "^1.1.0", "internal-slot": "^1.1.0", "iterator.prototype": "^1.1.4", "safe-array-concat": "^1.1.3" } }, "sha512-uDn+FE1yrDzyC0pCo961B2IHbdM8y/ACZsKD4dG6WqrjV53BADjwa7D+1aom2rsNVfLyDgU/eigvlJGJ08OQ4w=="], + + "es-object-atoms": ["es-object-atoms@1.1.1", "", { "dependencies": { "es-errors": "^1.3.0" } }, "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA=="], + + "es-set-tostringtag": ["es-set-tostringtag@2.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "get-intrinsic": "^1.2.6", "has-tostringtag": "^1.0.2", "hasown": "^2.0.2" } }, "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA=="], + + "es-shim-unscopables": ["es-shim-unscopables@1.1.0", "", { "dependencies": { "hasown": "^2.0.2" } }, "sha512-d9T8ucsEhh8Bi1woXCf+TIKDIROLG5WCkxg8geBCbvk22kzwC5G2OnXVMO6FUsvQlgUUXQ2itephWDLqDzbeCw=="], + + "es-to-primitive": ["es-to-primitive@1.3.0", "", { "dependencies": { "is-callable": "^1.2.7", "is-date-object": "^1.0.5", "is-symbol": "^1.0.4" } }, "sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g=="], + + "escape-string-regexp": ["escape-string-regexp@4.0.0", "", {}, "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA=="], + + "eslint": ["eslint@8.57.1", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.2.0", "@eslint-community/regexpp": "^4.6.1", "@eslint/eslintrc": "^2.1.4", "@eslint/js": "8.57.1", "@humanwhocodes/config-array": "^0.13.0", "@humanwhocodes/module-importer": "^1.0.1", "@nodelib/fs.walk": "^1.2.8", "@ungap/structured-clone": "^1.2.0", "ajv": "^6.12.4", "chalk": "^4.0.0", "cross-spawn": "^7.0.2", "debug": "^4.3.2", "doctrine": "^3.0.0", "escape-string-regexp": "^4.0.0", "eslint-scope": "^7.2.2", "eslint-visitor-keys": "^3.4.3", "espree": "^9.6.1", "esquery": "^1.4.2", "esutils": "^2.0.2", "fast-deep-equal": "^3.1.3", "file-entry-cache": "^6.0.1", "find-up": "^5.0.0", "glob-parent": "^6.0.2", "globals": "^13.19.0", "graphemer": "^1.4.0", "ignore": "^5.2.0", "imurmurhash": "^0.1.4", "is-glob": "^4.0.0", "is-path-inside": "^3.0.3", "js-yaml": "^4.1.0", "json-stable-stringify-without-jsonify": "^1.0.1", "levn": "^0.4.1", "lodash.merge": "^4.6.2", "minimatch": "^3.1.2", "natural-compare": "^1.4.0", "optionator": "^0.9.3", "strip-ansi": "^6.0.1", "text-table": "^0.2.0" }, "bin": "bin/eslint.js" }, "sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA=="], + + "eslint-config-next": ["eslint-config-next@14.2.26", "", { "dependencies": { "@next/eslint-plugin-next": "14.2.26", "@rushstack/eslint-patch": "^1.3.3", "@typescript-eslint/eslint-plugin": "^5.4.2 || ^6.0.0 || ^7.0.0 || ^8.0.0", "@typescript-eslint/parser": "^5.4.2 || ^6.0.0 || ^7.0.0 || ^8.0.0", "eslint-import-resolver-node": "^0.3.6", "eslint-import-resolver-typescript": "^3.5.2", "eslint-plugin-import": "^2.28.1", "eslint-plugin-jsx-a11y": "^6.7.1", "eslint-plugin-react": "^7.33.2", "eslint-plugin-react-hooks": "^4.5.0 || 5.0.0-canary-7118f5dd7-20230705" }, "peerDependencies": { "eslint": "^7.23.0 || ^8.0.0", "typescript": ">=3.3.1" } }, "sha512-KZNh1xvWG1ZDFD2f2WkvvnMpp7Sjsl6xJXCsvfEe8GH1FLXn6GtXo7lY9S8xDcn6oBWmKA0hSrlrp1DNQ9QDnQ=="], + + "eslint-config-prettier": ["eslint-config-prettier@9.1.0", "", { "peerDependencies": { "eslint": ">=7.0.0" }, "bin": "bin/cli.js" }, "sha512-NSWl5BFQWEPi1j4TjVNItzYV7dZXZ+wP6I6ZhrBGpChQhZRUaElihE9uRRkcbRnNb76UMKDF3r+WTmNcGPKsqw=="], + + "eslint-import-resolver-node": ["eslint-import-resolver-node@0.3.9", "", { "dependencies": { "debug": "^3.2.7", "is-core-module": "^2.13.0", "resolve": "^1.22.4" } }, "sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g=="], + + "eslint-import-resolver-typescript": ["eslint-import-resolver-typescript@3.10.0", "", { "dependencies": { "@nolyfill/is-core-module": "1.0.39", "debug": "^4.4.0", "get-tsconfig": "^4.10.0", "is-bun-module": "^2.0.0", "stable-hash": "^0.0.5", "tinyglobby": "^0.2.12", "unrs-resolver": "^1.3.2" }, "peerDependencies": { "eslint": "*", "eslint-plugin-import": "*", "eslint-plugin-import-x": "*" }, "optionalPeers": ["eslint-plugin-import-x"] }, "sha512-aV3/dVsT0/H9BtpNwbaqvl+0xGMRGzncLyhm793NFGvbwGGvzyAykqWZ8oZlZuGwuHkwJjhWJkG1cM3ynvd2pQ=="], + + "eslint-module-utils": ["eslint-module-utils@2.12.0", "", { "dependencies": { "debug": "^3.2.7" } }, "sha512-wALZ0HFoytlyh/1+4wuZ9FJCD/leWHQzzrxJ8+rebyReSLk7LApMyd3WJaLVoN+D5+WIdJyDK1c6JnE65V4Zyg=="], + + "eslint-plugin-import": ["eslint-plugin-import@2.31.0", "", { "dependencies": { "@rtsao/scc": "^1.1.0", "array-includes": "^3.1.8", "array.prototype.findlastindex": "^1.2.5", "array.prototype.flat": "^1.3.2", "array.prototype.flatmap": "^1.3.2", "debug": "^3.2.7", "doctrine": "^2.1.0", "eslint-import-resolver-node": "^0.3.9", "eslint-module-utils": "^2.12.0", "hasown": "^2.0.2", "is-core-module": "^2.15.1", "is-glob": "^4.0.3", "minimatch": "^3.1.2", "object.fromentries": "^2.0.8", "object.groupby": "^1.0.3", "object.values": "^1.2.0", "semver": "^6.3.1", "string.prototype.trimend": "^1.0.8", "tsconfig-paths": "^3.15.0" }, "peerDependencies": { "eslint": "^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8 || ^9" } }, "sha512-ixmkI62Rbc2/w8Vfxyh1jQRTdRTF52VxwRVHl/ykPAmqG+Nb7/kNn+byLP0LxPgI7zWA16Jt82SybJInmMia3A=="], + + "eslint-plugin-jsx-a11y": ["eslint-plugin-jsx-a11y@6.10.2", "", { "dependencies": { "aria-query": "^5.3.2", "array-includes": "^3.1.8", "array.prototype.flatmap": "^1.3.2", "ast-types-flow": "^0.0.8", "axe-core": "^4.10.0", "axobject-query": "^4.1.0", "damerau-levenshtein": "^1.0.8", "emoji-regex": "^9.2.2", "hasown": "^2.0.2", "jsx-ast-utils": "^3.3.5", "language-tags": "^1.0.9", "minimatch": "^3.1.2", "object.fromentries": "^2.0.8", "safe-regex-test": "^1.0.3", "string.prototype.includes": "^2.0.1" }, "peerDependencies": { "eslint": "^3 || ^4 || ^5 || ^6 || ^7 || ^8 || ^9" } }, "sha512-scB3nz4WmG75pV8+3eRUQOHZlNSUhFNq37xnpgRkCCELU3XMvXAxLk1eqWWyE22Ki4Q01Fnsw9BA3cJHDPgn2Q=="], + + "eslint-plugin-react": ["eslint-plugin-react@7.37.4", "", { "dependencies": { "array-includes": "^3.1.8", "array.prototype.findlast": "^1.2.5", "array.prototype.flatmap": "^1.3.3", "array.prototype.tosorted": "^1.1.4", "doctrine": "^2.1.0", "es-iterator-helpers": "^1.2.1", "estraverse": "^5.3.0", "hasown": "^2.0.2", "jsx-ast-utils": "^2.4.1 || ^3.0.0", "minimatch": "^3.1.2", "object.entries": "^1.1.8", "object.fromentries": "^2.0.8", "object.values": "^1.2.1", "prop-types": "^15.8.1", "resolve": "^2.0.0-next.5", "semver": "^6.3.1", "string.prototype.matchall": "^4.0.12", "string.prototype.repeat": "^1.0.0" }, "peerDependencies": { "eslint": "^3 || ^4 || ^5 || ^6 || ^7 || ^8 || ^9.7" } }, "sha512-BGP0jRmfYyvOyvMoRX/uoUeW+GqNj9y16bPQzqAHf3AYII/tDs+jMN0dBVkl88/OZwNGwrVFxE7riHsXVfy/LQ=="], + + "eslint-plugin-react-hooks": ["eslint-plugin-react-hooks@4.6.2", "", { "peerDependencies": { "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0" } }, "sha512-QzliNJq4GinDBcD8gPB5v0wh6g8q3SUi6EFF0x8N/BL9PoVs0atuGc47ozMRyOWAKdwaZ5OnbOEa3WR+dSGKuQ=="], + + "eslint-scope": ["eslint-scope@7.2.2", "", { "dependencies": { "esrecurse": "^4.3.0", "estraverse": "^5.2.0" } }, "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg=="], + + "eslint-visitor-keys": ["eslint-visitor-keys@3.4.3", "", {}, "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag=="], + + "espree": ["espree@9.6.1", "", { "dependencies": { "acorn": "^8.9.0", "acorn-jsx": "^5.3.2", "eslint-visitor-keys": "^3.4.1" } }, "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ=="], + + "esquery": ["esquery@1.6.0", "", { "dependencies": { "estraverse": "^5.1.0" } }, "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg=="], + + "esrecurse": ["esrecurse@4.3.0", "", { "dependencies": { "estraverse": "^5.2.0" } }, "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag=="], + + "estraverse": ["estraverse@5.3.0", "", {}, "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA=="], + + "esutils": ["esutils@2.0.3", "", {}, "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g=="], + + "eventemitter3": ["eventemitter3@5.0.1", "", {}, "sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA=="], + + "execa": ["execa@8.0.1", "", { "dependencies": { "cross-spawn": "^7.0.3", "get-stream": "^8.0.1", "human-signals": "^5.0.0", "is-stream": "^3.0.0", "merge-stream": "^2.0.0", "npm-run-path": "^5.1.0", "onetime": "^6.0.0", "signal-exit": "^4.1.0", "strip-final-newline": "^3.0.0" } }, "sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg=="], + + "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="], + + "fast-glob": ["fast-glob@3.3.3", "", { "dependencies": { "@nodelib/fs.stat": "^2.0.2", "@nodelib/fs.walk": "^1.2.3", "glob-parent": "^5.1.2", "merge2": "^1.3.0", "micromatch": "^4.0.8" } }, "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg=="], + + "fast-json-stable-stringify": ["fast-json-stable-stringify@2.1.0", "", {}, "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw=="], + + "fast-levenshtein": ["fast-levenshtein@2.0.6", "", {}, "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw=="], + + "fastq": ["fastq@1.19.1", "", { "dependencies": { "reusify": "^1.0.4" } }, "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ=="], + + "fdir": ["fdir@6.4.3", "", { "peerDependencies": { "picomatch": "^3 || ^4" } }, "sha512-PMXmW2y1hDDfTSRc9gaXIuCCRpuoz3Kaz8cUelp3smouvfT632ozg2vrT6lJsHKKOF59YLbOGfAWGUcKEfRMQw=="], + + "file-entry-cache": ["file-entry-cache@6.0.1", "", { "dependencies": { "flat-cache": "^3.0.4" } }, "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg=="], + + "fill-range": ["fill-range@7.1.1", "", { "dependencies": { "to-regex-range": "^5.0.1" } }, "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg=="], + + "find-up": ["find-up@5.0.0", "", { "dependencies": { "locate-path": "^6.0.0", "path-exists": "^4.0.0" } }, "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng=="], + + "flat-cache": ["flat-cache@3.2.0", "", { "dependencies": { "flatted": "^3.2.9", "keyv": "^4.5.3", "rimraf": "^3.0.2" } }, "sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw=="], + + "flatted": ["flatted@3.3.3", "", {}, "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg=="], + + "for-each": ["for-each@0.3.5", "", { "dependencies": { "is-callable": "^1.2.7" } }, "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg=="], + + "foreground-child": ["foreground-child@3.3.1", "", { "dependencies": { "cross-spawn": "^7.0.6", "signal-exit": "^4.0.1" } }, "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw=="], + + "fs.realpath": ["fs.realpath@1.0.0", "", {}, "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw=="], + + "function-bind": ["function-bind@1.1.2", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="], + + "function.prototype.name": ["function.prototype.name@1.1.8", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.3", "define-properties": "^1.2.1", "functions-have-names": "^1.2.3", "hasown": "^2.0.2", "is-callable": "^1.2.7" } }, "sha512-e5iwyodOHhbMr/yNrc7fDYG4qlbIvI5gajyzPnb5TCwyhjApznQh1BMFou9b30SevY43gCJKXycoCBjMbsuW0Q=="], + + "functions-have-names": ["functions-have-names@1.2.3", "", {}, "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ=="], + + "get-east-asian-width": ["get-east-asian-width@1.3.0", "", {}, "sha512-vpeMIQKxczTD/0s2CdEWHcb0eeJe6TFjxb+J5xgX7hScxqrGuyjmv4c1D4A/gelKfyox0gJJwIHF+fLjeaM8kQ=="], + + "get-intrinsic": ["get-intrinsic@1.3.0", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "function-bind": "^1.1.2", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "math-intrinsics": "^1.1.0" } }, "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ=="], + + "get-proto": ["get-proto@1.0.1", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-object-atoms": "^1.0.0" } }, "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g=="], + + "get-stream": ["get-stream@8.0.1", "", {}, "sha512-VaUJspBffn/LMCJVoMvSAdmscJyS1auj5Zulnn5UoYcY531UWmdwhRWkcGKnGU93m5HSXP9LP2usOryrBtQowA=="], + + "get-symbol-description": ["get-symbol-description@1.1.0", "", { "dependencies": { "call-bound": "^1.0.3", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.6" } }, "sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg=="], + + "get-tsconfig": ["get-tsconfig@4.10.0", "", { "dependencies": { "resolve-pkg-maps": "^1.0.0" } }, "sha512-kGzZ3LWWQcGIAmg6iWvXn0ei6WDtV26wzHRMwDSzmAbcXrTEXxHy6IehI6/4eT6VRKyMP1eF1VqwrVUmE/LR7A=="], + + "glob": ["glob@10.3.10", "", { "dependencies": { "foreground-child": "^3.1.0", "jackspeak": "^2.3.5", "minimatch": "^9.0.1", "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0", "path-scurry": "^1.10.1" }, "bin": "dist/esm/bin.mjs" }, "sha512-fa46+tv1Ak0UPK1TOy/pZrIybNNt4HCv7SDzwyfiOZkvZLEbjsZkJBPtDHVshZjbecAoAGSC20MjLDG/qr679g=="], + + "glob-parent": ["glob-parent@6.0.2", "", { "dependencies": { "is-glob": "^4.0.3" } }, "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A=="], + + "globals": ["globals@13.24.0", "", { "dependencies": { "type-fest": "^0.20.2" } }, "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ=="], + + "globalthis": ["globalthis@1.0.4", "", { "dependencies": { "define-properties": "^1.2.1", "gopd": "^1.0.1" } }, "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ=="], + + "globby": ["globby@11.1.0", "", { "dependencies": { "array-union": "^2.1.0", "dir-glob": "^3.0.1", "fast-glob": "^3.2.9", "ignore": "^5.2.0", "merge2": "^1.4.1", "slash": "^3.0.0" } }, "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g=="], + + "gopd": ["gopd@1.2.0", "", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="], + + "graphemer": ["graphemer@1.4.0", "", {}, "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag=="], + + "has-bigints": ["has-bigints@1.1.0", "", {}, "sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg=="], + + "has-flag": ["has-flag@4.0.0", "", {}, "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="], + + "has-property-descriptors": ["has-property-descriptors@1.0.2", "", { "dependencies": { "es-define-property": "^1.0.0" } }, "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg=="], + + "has-proto": ["has-proto@1.2.0", "", { "dependencies": { "dunder-proto": "^1.0.0" } }, "sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ=="], + + "has-symbols": ["has-symbols@1.1.0", "", {}, "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="], + + "has-tostringtag": ["has-tostringtag@1.0.2", "", { "dependencies": { "has-symbols": "^1.0.3" } }, "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw=="], + + "hasown": ["hasown@2.0.2", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ=="], + + "human-signals": ["human-signals@5.0.0", "", {}, "sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ=="], + + "husky": ["husky@9.1.7", "", { "bin": "bin.js" }, "sha512-5gs5ytaNjBrh5Ow3zrvdUUY+0VxIuWVL4i9irt6friV+BqdCfmV11CQTWMiBYWHbXhco+J1kHfTOUkePhCDvMA=="], + + "ignore": ["ignore@5.3.2", "", {}, "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g=="], + + "import-fresh": ["import-fresh@3.3.1", "", { "dependencies": { "parent-module": "^1.0.0", "resolve-from": "^4.0.0" } }, "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ=="], + + "imurmurhash": ["imurmurhash@0.1.4", "", {}, "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA=="], + + "inflight": ["inflight@1.0.6", "", { "dependencies": { "once": "^1.3.0", "wrappy": "1" } }, "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA=="], + + "inherits": ["inherits@2.0.4", "", {}, "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="], + + "internal-slot": ["internal-slot@1.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "hasown": "^2.0.2", "side-channel": "^1.1.0" } }, "sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw=="], + + "is-array-buffer": ["is-array-buffer@3.0.5", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.3", "get-intrinsic": "^1.2.6" } }, "sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A=="], + + "is-async-function": ["is-async-function@2.1.1", "", { "dependencies": { "async-function": "^1.0.0", "call-bound": "^1.0.3", "get-proto": "^1.0.1", "has-tostringtag": "^1.0.2", "safe-regex-test": "^1.1.0" } }, "sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ=="], + + "is-bigint": ["is-bigint@1.1.0", "", { "dependencies": { "has-bigints": "^1.0.2" } }, "sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ=="], + + "is-boolean-object": ["is-boolean-object@1.2.2", "", { "dependencies": { "call-bound": "^1.0.3", "has-tostringtag": "^1.0.2" } }, "sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A=="], + + "is-bun-module": ["is-bun-module@2.0.0", "", { "dependencies": { "semver": "^7.7.1" } }, "sha512-gNCGbnnnnFAUGKeZ9PdbyeGYJqewpmc2aKHUEMO5nQPWU9lOmv7jcmQIv+qHD8fXW6W7qfuCwX4rY9LNRjXrkQ=="], + + "is-callable": ["is-callable@1.2.7", "", {}, "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA=="], + + "is-core-module": ["is-core-module@2.16.1", "", { "dependencies": { "hasown": "^2.0.2" } }, "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w=="], + + "is-data-view": ["is-data-view@1.0.2", "", { "dependencies": { "call-bound": "^1.0.2", "get-intrinsic": "^1.2.6", "is-typed-array": "^1.1.13" } }, "sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw=="], + + "is-date-object": ["is-date-object@1.1.0", "", { "dependencies": { "call-bound": "^1.0.2", "has-tostringtag": "^1.0.2" } }, "sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg=="], + + "is-extglob": ["is-extglob@2.1.1", "", {}, "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ=="], + + "is-finalizationregistry": ["is-finalizationregistry@1.1.1", "", { "dependencies": { "call-bound": "^1.0.3" } }, "sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg=="], + + "is-fullwidth-code-point": ["is-fullwidth-code-point@4.0.0", "", {}, "sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ=="], + + "is-generator-function": ["is-generator-function@1.1.0", "", { "dependencies": { "call-bound": "^1.0.3", "get-proto": "^1.0.0", "has-tostringtag": "^1.0.2", "safe-regex-test": "^1.1.0" } }, "sha512-nPUB5km40q9e8UfN/Zc24eLlzdSf9OfKByBw9CIdw4H1giPMeA0OIJvbchsCu4npfI2QcMVBsGEBHKZ7wLTWmQ=="], + + "is-glob": ["is-glob@4.0.3", "", { "dependencies": { "is-extglob": "^2.1.1" } }, "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg=="], + + "is-map": ["is-map@2.0.3", "", {}, "sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw=="], + + "is-number": ["is-number@7.0.0", "", {}, "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="], + + "is-number-object": ["is-number-object@1.1.1", "", { "dependencies": { "call-bound": "^1.0.3", "has-tostringtag": "^1.0.2" } }, "sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw=="], + + "is-path-inside": ["is-path-inside@3.0.3", "", {}, "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ=="], + + "is-regex": ["is-regex@1.2.1", "", { "dependencies": { "call-bound": "^1.0.2", "gopd": "^1.2.0", "has-tostringtag": "^1.0.2", "hasown": "^2.0.2" } }, "sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g=="], + + "is-set": ["is-set@2.0.3", "", {}, "sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg=="], + + "is-shared-array-buffer": ["is-shared-array-buffer@1.0.4", "", { "dependencies": { "call-bound": "^1.0.3" } }, "sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A=="], + + "is-stream": ["is-stream@3.0.0", "", {}, "sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA=="], + + "is-string": ["is-string@1.1.1", "", { "dependencies": { "call-bound": "^1.0.3", "has-tostringtag": "^1.0.2" } }, "sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA=="], + + "is-symbol": ["is-symbol@1.1.1", "", { "dependencies": { "call-bound": "^1.0.2", "has-symbols": "^1.1.0", "safe-regex-test": "^1.1.0" } }, "sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w=="], + + "is-typed-array": ["is-typed-array@1.1.15", "", { "dependencies": { "which-typed-array": "^1.1.16" } }, "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ=="], + + "is-weakmap": ["is-weakmap@2.0.2", "", {}, "sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w=="], + + "is-weakref": ["is-weakref@1.1.1", "", { "dependencies": { "call-bound": "^1.0.3" } }, "sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew=="], + + "is-weakset": ["is-weakset@2.0.4", "", { "dependencies": { "call-bound": "^1.0.3", "get-intrinsic": "^1.2.6" } }, "sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ=="], + + "isarray": ["isarray@2.0.5", "", {}, "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw=="], + + "isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="], + + "iterator.prototype": ["iterator.prototype@1.1.5", "", { "dependencies": { "define-data-property": "^1.1.4", "es-object-atoms": "^1.0.0", "get-intrinsic": "^1.2.6", "get-proto": "^1.0.0", "has-symbols": "^1.1.0", "set-function-name": "^2.0.2" } }, "sha512-H0dkQoCa3b2VEeKQBOxFph+JAbcrQdE7KC0UkqwpLmv2EC4P41QXP+rqo9wYodACiG5/WM5s9oDApTU8utwj9g=="], + + "jackspeak": ["jackspeak@2.3.6", "", { "dependencies": { "@isaacs/cliui": "^8.0.2" }, "optionalDependencies": { "@pkgjs/parseargs": "^0.11.0" } }, "sha512-N3yCS/NegsOBokc8GAdM8UcmfsKiSS8cipheD/nivzr700H+nsMOxJjQnvwOcRYVuFkdH0wGUvW2WbXGmrZGbQ=="], + + "js-tokens": ["js-tokens@4.0.0", "", {}, "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="], + + "js-yaml": ["js-yaml@4.1.0", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": "bin/js-yaml.js" }, "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA=="], + + "json-buffer": ["json-buffer@3.0.1", "", {}, "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ=="], + + "json-schema-traverse": ["json-schema-traverse@0.4.1", "", {}, "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="], + + "json-stable-stringify-without-jsonify": ["json-stable-stringify-without-jsonify@1.0.1", "", {}, "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw=="], + + "json5": ["json5@1.0.2", "", { "dependencies": { "minimist": "^1.2.0" }, "bin": "lib/cli.js" }, "sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA=="], + + "jsx-ast-utils": ["jsx-ast-utils@3.3.5", "", { "dependencies": { "array-includes": "^3.1.6", "array.prototype.flat": "^1.3.1", "object.assign": "^4.1.4", "object.values": "^1.1.6" } }, "sha512-ZZow9HBI5O6EPgSJLUb8n2NKgmVWTwCvHGwFuJlMjvLFqlGG6pjirPhtdsseaLZjSibD8eegzmYpUZwoIlj2cQ=="], + + "keyv": ["keyv@4.5.4", "", { "dependencies": { "json-buffer": "3.0.1" } }, "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw=="], + + "language-subtag-registry": ["language-subtag-registry@0.3.23", "", {}, "sha512-0K65Lea881pHotoGEa5gDlMxt3pctLi2RplBb7Ezh4rRdLEOtgi7n4EwK9lamnUCkKBqaeKRVebTq6BAxSkpXQ=="], + + "language-tags": ["language-tags@1.0.9", "", { "dependencies": { "language-subtag-registry": "^0.3.20" } }, "sha512-MbjN408fEndfiQXbFQ1vnd+1NoLDsnQW41410oQBXiyXDMYH5z505juWa4KUE1LqxRC7DgOgZDbKLxHIwm27hA=="], + + "levn": ["levn@0.4.1", "", { "dependencies": { "prelude-ls": "^1.2.1", "type-check": "~0.4.0" } }, "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ=="], + + "lilconfig": ["lilconfig@3.1.3", "", {}, "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw=="], + + "lint-staged": ["lint-staged@15.5.0", "", { "dependencies": { "chalk": "^5.4.1", "commander": "^13.1.0", "debug": "^4.4.0", "execa": "^8.0.1", "lilconfig": "^3.1.3", "listr2": "^8.2.5", "micromatch": "^4.0.8", "pidtree": "^0.6.0", "string-argv": "^0.3.2", "yaml": "^2.7.0" }, "bin": "bin/lint-staged.js" }, "sha512-WyCzSbfYGhK7cU+UuDDkzUiytbfbi0ZdPy2orwtM75P3WTtQBzmG40cCxIa8Ii2+XjfxzLH6Be46tUfWS85Xfg=="], + + "listr2": ["listr2@8.2.5", "", { "dependencies": { "cli-truncate": "^4.0.0", "colorette": "^2.0.20", "eventemitter3": "^5.0.1", "log-update": "^6.1.0", "rfdc": "^1.4.1", "wrap-ansi": "^9.0.0" } }, "sha512-iyAZCeyD+c1gPyE9qpFu8af0Y+MRtmKOncdGoA2S5EY8iFq99dmmvkNnHiWo+pj0s7yH7l3KPIgee77tKpXPWQ=="], + + "locate-path": ["locate-path@6.0.0", "", { "dependencies": { "p-locate": "^5.0.0" } }, "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw=="], + + "lodash.merge": ["lodash.merge@4.6.2", "", {}, "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ=="], + + "log-update": ["log-update@6.1.0", "", { "dependencies": { "ansi-escapes": "^7.0.0", "cli-cursor": "^5.0.0", "slice-ansi": "^7.1.0", "strip-ansi": "^7.1.0", "wrap-ansi": "^9.0.0" } }, "sha512-9ie8ItPR6tjY5uYJh8K/Zrv/RMZ5VOlOWvtZdEHYSTFKZfIBPQa9tOAEeAWhd+AnIneLJ22w5fjOYtoutpWq5w=="], + + "loose-envify": ["loose-envify@1.4.0", "", { "dependencies": { "js-tokens": "^3.0.0 || ^4.0.0" }, "bin": "cli.js" }, "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q=="], + + "lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="], + + "math-intrinsics": ["math-intrinsics@1.1.0", "", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="], + + "merge-stream": ["merge-stream@2.0.0", "", {}, "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w=="], + + "merge2": ["merge2@1.4.1", "", {}, "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg=="], + + "micromatch": ["micromatch@4.0.8", "", { "dependencies": { "braces": "^3.0.3", "picomatch": "^2.3.1" } }, "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA=="], + + "mimic-fn": ["mimic-fn@4.0.0", "", {}, "sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw=="], + + "mimic-function": ["mimic-function@5.0.1", "", {}, "sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA=="], + + "minimatch": ["minimatch@3.1.2", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw=="], + + "minimist": ["minimist@1.2.8", "", {}, "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA=="], + + "minipass": ["minipass@7.1.2", "", {}, "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw=="], + + "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="], + + "natural-compare": ["natural-compare@1.4.0", "", {}, "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw=="], + + "npm-run-path": ["npm-run-path@5.3.0", "", { "dependencies": { "path-key": "^4.0.0" } }, "sha512-ppwTtiJZq0O/ai0z7yfudtBpWIoxM8yE6nHi1X47eFR2EWORqfbu6CnPlNsjeN683eT0qG6H/Pyf9fCcvjnnnQ=="], + + "object-assign": ["object-assign@4.1.1", "", {}, "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg=="], + + "object-inspect": ["object-inspect@1.13.4", "", {}, "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew=="], + + "object-keys": ["object-keys@1.1.1", "", {}, "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA=="], + + "object.assign": ["object.assign@4.1.7", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.3", "define-properties": "^1.2.1", "es-object-atoms": "^1.0.0", "has-symbols": "^1.1.0", "object-keys": "^1.1.1" } }, "sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw=="], + + "object.entries": ["object.entries@1.1.9", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.4", "define-properties": "^1.2.1", "es-object-atoms": "^1.1.1" } }, "sha512-8u/hfXFRBD1O0hPUjioLhoWFHRmt6tKA4/vZPyckBr18l1KE9uHrFaFaUi8MDRTpi4uak2goyPTSNJLXX2k2Hw=="], + + "object.fromentries": ["object.fromentries@2.0.8", "", { "dependencies": { "call-bind": "^1.0.7", "define-properties": "^1.2.1", "es-abstract": "^1.23.2", "es-object-atoms": "^1.0.0" } }, "sha512-k6E21FzySsSK5a21KRADBd/NGneRegFO5pLHfdQLpRDETUNJueLXs3WCzyQ3tFRDYgbq3KHGXfTbi2bs8WQ6rQ=="], + + "object.groupby": ["object.groupby@1.0.3", "", { "dependencies": { "call-bind": "^1.0.7", "define-properties": "^1.2.1", "es-abstract": "^1.23.2" } }, "sha512-+Lhy3TQTuzXI5hevh8sBGqbmurHbbIjAi0Z4S63nthVLmLxfbj4T54a4CfZrXIrt9iP4mVAPYMo/v99taj3wjQ=="], + + "object.values": ["object.values@1.2.1", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.3", "define-properties": "^1.2.1", "es-object-atoms": "^1.0.0" } }, "sha512-gXah6aZrcUxjWg2zR2MwouP2eHlCBzdV4pygudehaKXSGW4v2AsRQUK+lwwXhii6KFZcunEnmSUoYp5CXibxtA=="], + + "once": ["once@1.4.0", "", { "dependencies": { "wrappy": "1" } }, "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w=="], + + "onetime": ["onetime@6.0.0", "", { "dependencies": { "mimic-fn": "^4.0.0" } }, "sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ=="], + + "optionator": ["optionator@0.9.4", "", { "dependencies": { "deep-is": "^0.1.3", "fast-levenshtein": "^2.0.6", "levn": "^0.4.1", "prelude-ls": "^1.2.1", "type-check": "^0.4.0", "word-wrap": "^1.2.5" } }, "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g=="], + + "own-keys": ["own-keys@1.0.1", "", { "dependencies": { "get-intrinsic": "^1.2.6", "object-keys": "^1.1.1", "safe-push-apply": "^1.0.0" } }, "sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg=="], + + "p-limit": ["p-limit@3.1.0", "", { "dependencies": { "yocto-queue": "^0.1.0" } }, "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ=="], + + "p-locate": ["p-locate@5.0.0", "", { "dependencies": { "p-limit": "^3.0.2" } }, "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw=="], + + "parent-module": ["parent-module@1.0.1", "", { "dependencies": { "callsites": "^3.0.0" } }, "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g=="], + + "path-exists": ["path-exists@4.0.0", "", {}, "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w=="], + + "path-is-absolute": ["path-is-absolute@1.0.1", "", {}, "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg=="], + + "path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="], + + "path-parse": ["path-parse@1.0.7", "", {}, "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw=="], + + "path-scurry": ["path-scurry@1.11.1", "", { "dependencies": { "lru-cache": "^10.2.0", "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" } }, "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA=="], + + "path-type": ["path-type@4.0.0", "", {}, "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw=="], + + "picomatch": ["picomatch@2.3.1", "", {}, "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA=="], + + "pidtree": ["pidtree@0.6.0", "", { "bin": "bin/pidtree.js" }, "sha512-eG2dWTVw5bzqGRztnHExczNxt5VGsE6OwTeCG3fdUf9KBsZzO3R5OIIIzWR+iZA0NtZ+RDVdaoE2dK1cn6jH4g=="], + + "possible-typed-array-names": ["possible-typed-array-names@1.1.0", "", {}, "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg=="], + + "prelude-ls": ["prelude-ls@1.2.1", "", {}, "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g=="], + + "prettier": ["prettier@3.5.3", "", { "bin": "bin/prettier.cjs" }, "sha512-QQtaxnoDJeAkDvDKWCLiwIXkTgRhwYDEQCghU9Z6q03iyek/rxRh/2lC3HB7P8sWT2xC/y5JDctPLBIGzHKbhw=="], + + "prettier-plugin-tailwindcss": ["prettier-plugin-tailwindcss@0.5.14", "", { "peerDependencies": { "@ianvs/prettier-plugin-sort-imports": "*", "@prettier/plugin-pug": "*", "@shopify/prettier-plugin-liquid": "*", "@trivago/prettier-plugin-sort-imports": "*", "@zackad/prettier-plugin-twig-melody": "*", "prettier": "^3.0", "prettier-plugin-astro": "*", "prettier-plugin-css-order": "*", "prettier-plugin-import-sort": "*", "prettier-plugin-jsdoc": "*", "prettier-plugin-marko": "*", "prettier-plugin-organize-attributes": "*", "prettier-plugin-organize-imports": "*", "prettier-plugin-sort-imports": "*", "prettier-plugin-style-order": "*", "prettier-plugin-svelte": "*" }, "optionalPeers": ["@ianvs/prettier-plugin-sort-imports", "@prettier/plugin-pug", "@shopify/prettier-plugin-liquid", "@trivago/prettier-plugin-sort-imports", "@zackad/prettier-plugin-twig-melody", "prettier-plugin-astro", "prettier-plugin-css-order", "prettier-plugin-import-sort", "prettier-plugin-jsdoc", "prettier-plugin-marko", "prettier-plugin-organize-attributes", "prettier-plugin-organize-imports", "prettier-plugin-sort-imports", "prettier-plugin-style-order", "prettier-plugin-svelte"] }, "sha512-Puaz+wPUAhFp8Lo9HuciYKM2Y2XExESjeT+9NQoVFXZsPPnc9VYss2SpxdQ6vbatmt8/4+SN0oe0I1cPDABg9Q=="], + + "prop-types": ["prop-types@15.8.1", "", { "dependencies": { "loose-envify": "^1.4.0", "object-assign": "^4.1.1", "react-is": "^16.13.1" } }, "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg=="], + + "punycode": ["punycode@2.3.1", "", {}, "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg=="], + + "queue-microtask": ["queue-microtask@1.2.3", "", {}, "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="], + + "react-is": ["react-is@16.13.1", "", {}, "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ=="], + + "reflect.getprototypeof": ["reflect.getprototypeof@1.0.10", "", { "dependencies": { "call-bind": "^1.0.8", "define-properties": "^1.2.1", "es-abstract": "^1.23.9", "es-errors": "^1.3.0", "es-object-atoms": "^1.0.0", "get-intrinsic": "^1.2.7", "get-proto": "^1.0.1", "which-builtin-type": "^1.2.1" } }, "sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw=="], + + "regexp.prototype.flags": ["regexp.prototype.flags@1.5.4", "", { "dependencies": { "call-bind": "^1.0.8", "define-properties": "^1.2.1", "es-errors": "^1.3.0", "get-proto": "^1.0.1", "gopd": "^1.2.0", "set-function-name": "^2.0.2" } }, "sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA=="], + + "resolve": ["resolve@2.0.0-next.5", "", { "dependencies": { "is-core-module": "^2.13.0", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, "bin": "bin/resolve" }, "sha512-U7WjGVG9sH8tvjW5SmGbQuui75FiyjAX72HX15DwBBwF9dNiQZRQAg9nnPhYy+TUnE0+VcrttuvNI8oSxZcocA=="], + + "resolve-from": ["resolve-from@4.0.0", "", {}, "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="], + + "resolve-pkg-maps": ["resolve-pkg-maps@1.0.0", "", {}, "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw=="], + + "restore-cursor": ["restore-cursor@5.1.0", "", { "dependencies": { "onetime": "^7.0.0", "signal-exit": "^4.1.0" } }, "sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA=="], + + "reusify": ["reusify@1.1.0", "", {}, "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw=="], + + "rfdc": ["rfdc@1.4.1", "", {}, "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA=="], + + "rimraf": ["rimraf@3.0.2", "", { "dependencies": { "glob": "^7.1.3" }, "bin": "bin.js" }, "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA=="], + + "run-parallel": ["run-parallel@1.2.0", "", { "dependencies": { "queue-microtask": "^1.2.2" } }, "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA=="], + + "safe-array-concat": ["safe-array-concat@1.1.3", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.2", "get-intrinsic": "^1.2.6", "has-symbols": "^1.1.0", "isarray": "^2.0.5" } }, "sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q=="], + + "safe-push-apply": ["safe-push-apply@1.0.0", "", { "dependencies": { "es-errors": "^1.3.0", "isarray": "^2.0.5" } }, "sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA=="], + + "safe-regex-test": ["safe-regex-test@1.1.0", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "is-regex": "^1.2.1" } }, "sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw=="], + + "semver": ["semver@6.3.1", "", { "bin": "bin/semver.js" }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="], + + "set-function-length": ["set-function-length@1.2.2", "", { "dependencies": { "define-data-property": "^1.1.4", "es-errors": "^1.3.0", "function-bind": "^1.1.2", "get-intrinsic": "^1.2.4", "gopd": "^1.0.1", "has-property-descriptors": "^1.0.2" } }, "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg=="], + + "set-function-name": ["set-function-name@2.0.2", "", { "dependencies": { "define-data-property": "^1.1.4", "es-errors": "^1.3.0", "functions-have-names": "^1.2.3", "has-property-descriptors": "^1.0.2" } }, "sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ=="], + + "set-proto": ["set-proto@1.0.0", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.0.0" } }, "sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw=="], + + "shebang-command": ["shebang-command@2.0.0", "", { "dependencies": { "shebang-regex": "^3.0.0" } }, "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA=="], + + "shebang-regex": ["shebang-regex@3.0.0", "", {}, "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="], + + "side-channel": ["side-channel@1.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.3", "side-channel-list": "^1.0.0", "side-channel-map": "^1.0.1", "side-channel-weakmap": "^1.0.2" } }, "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw=="], + + "side-channel-list": ["side-channel-list@1.0.0", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.3" } }, "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA=="], + + "side-channel-map": ["side-channel-map@1.0.1", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3" } }, "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA=="], + + "side-channel-weakmap": ["side-channel-weakmap@1.0.2", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3", "side-channel-map": "^1.0.1" } }, "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A=="], + + "signal-exit": ["signal-exit@4.1.0", "", {}, "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw=="], + + "slash": ["slash@3.0.0", "", {}, "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q=="], + + "slice-ansi": ["slice-ansi@5.0.0", "", { "dependencies": { "ansi-styles": "^6.0.0", "is-fullwidth-code-point": "^4.0.0" } }, "sha512-FC+lgizVPfie0kkhqUScwRu1O/lF6NOgJmlCgK+/LYxDCTk8sGelYaHDhFcDN+Sn3Cv+3VSa4Byeo+IMCzpMgQ=="], + + "stable-hash": ["stable-hash@0.0.5", "", {}, "sha512-+L3ccpzibovGXFK+Ap/f8LOS0ahMrHTf3xu7mMLSpEGU0EO9ucaysSylKo9eRDFNhWve/y275iPmIZ4z39a9iA=="], + + "string-argv": ["string-argv@0.3.2", "", {}, "sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q=="], + + "string-width": ["string-width@7.2.0", "", { "dependencies": { "emoji-regex": "^10.3.0", "get-east-asian-width": "^1.0.0", "strip-ansi": "^7.1.0" } }, "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ=="], + + "string-width-cjs": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="], + + "string.prototype.includes": ["string.prototype.includes@2.0.1", "", { "dependencies": { "call-bind": "^1.0.7", "define-properties": "^1.2.1", "es-abstract": "^1.23.3" } }, "sha512-o7+c9bW6zpAdJHTtujeePODAhkuicdAryFsfVKwA+wGw89wJ4GTY484WTucM9hLtDEOpOvI+aHnzqnC5lHp4Rg=="], + + "string.prototype.matchall": ["string.prototype.matchall@4.0.12", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.3", "define-properties": "^1.2.1", "es-abstract": "^1.23.6", "es-errors": "^1.3.0", "es-object-atoms": "^1.0.0", "get-intrinsic": "^1.2.6", "gopd": "^1.2.0", "has-symbols": "^1.1.0", "internal-slot": "^1.1.0", "regexp.prototype.flags": "^1.5.3", "set-function-name": "^2.0.2", "side-channel": "^1.1.0" } }, "sha512-6CC9uyBL+/48dYizRf7H7VAYCMCNTBeM78x/VTUe9bFEaxBepPJDa1Ow99LqI/1yF7kuy7Q3cQsYMrcjGUcskA=="], + + "string.prototype.repeat": ["string.prototype.repeat@1.0.0", "", { "dependencies": { "define-properties": "^1.1.3", "es-abstract": "^1.17.5" } }, "sha512-0u/TldDbKD8bFCQ/4f5+mNRrXwZ8hg2w7ZR8wa16e8z9XpePWl3eGEcUD0OXpEH/VJH/2G3gjUtR3ZOiBe2S/w=="], + + "string.prototype.trim": ["string.prototype.trim@1.2.10", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.2", "define-data-property": "^1.1.4", "define-properties": "^1.2.1", "es-abstract": "^1.23.5", "es-object-atoms": "^1.0.0", "has-property-descriptors": "^1.0.2" } }, "sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA=="], + + "string.prototype.trimend": ["string.prototype.trimend@1.0.9", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.2", "define-properties": "^1.2.1", "es-object-atoms": "^1.0.0" } }, "sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ=="], + + "string.prototype.trimstart": ["string.prototype.trimstart@1.0.8", "", { "dependencies": { "call-bind": "^1.0.7", "define-properties": "^1.2.1", "es-object-atoms": "^1.0.0" } }, "sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg=="], + + "strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="], + + "strip-ansi-cjs": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="], + + "strip-bom": ["strip-bom@3.0.0", "", {}, "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA=="], + + "strip-final-newline": ["strip-final-newline@3.0.0", "", {}, "sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw=="], + + "strip-json-comments": ["strip-json-comments@3.1.1", "", {}, "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig=="], + + "supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="], + + "supports-preserve-symlinks-flag": ["supports-preserve-symlinks-flag@1.0.0", "", {}, "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w=="], + + "text-table": ["text-table@0.2.0", "", {}, "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw=="], + + "tinyglobby": ["tinyglobby@0.2.12", "", { "dependencies": { "fdir": "^6.4.3", "picomatch": "^4.0.2" } }, "sha512-qkf4trmKSIiMTs/E63cxH+ojC2unam7rJ0WrauAzpT3ECNTxGRMlaXxVbfxMUC/w0LaYk6jQ4y/nGR9uBO3tww=="], + + "to-regex-range": ["to-regex-range@5.0.1", "", { "dependencies": { "is-number": "^7.0.0" } }, "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ=="], + + "ts-api-utils": ["ts-api-utils@1.4.3", "", { "peerDependencies": { "typescript": ">=4.2.0" } }, "sha512-i3eMG77UTMD0hZhgRS562pv83RC6ukSAC2GMNWc+9dieh/+jDM5u5YG+NHX6VNDRHQcHwmsTHctP9LhbC3WxVw=="], + + "tsconfig-paths": ["tsconfig-paths@3.15.0", "", { "dependencies": { "@types/json5": "^0.0.29", "json5": "^1.0.2", "minimist": "^1.2.6", "strip-bom": "^3.0.0" } }, "sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg=="], + + "type-check": ["type-check@0.4.0", "", { "dependencies": { "prelude-ls": "^1.2.1" } }, "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew=="], + + "type-fest": ["type-fest@0.20.2", "", {}, "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ=="], + + "typed-array-buffer": ["typed-array-buffer@1.0.3", "", { "dependencies": { "call-bound": "^1.0.3", "es-errors": "^1.3.0", "is-typed-array": "^1.1.14" } }, "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw=="], + + "typed-array-byte-length": ["typed-array-byte-length@1.0.3", "", { "dependencies": { "call-bind": "^1.0.8", "for-each": "^0.3.3", "gopd": "^1.2.0", "has-proto": "^1.2.0", "is-typed-array": "^1.1.14" } }, "sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg=="], + + "typed-array-byte-offset": ["typed-array-byte-offset@1.0.4", "", { "dependencies": { "available-typed-arrays": "^1.0.7", "call-bind": "^1.0.8", "for-each": "^0.3.3", "gopd": "^1.2.0", "has-proto": "^1.2.0", "is-typed-array": "^1.1.15", "reflect.getprototypeof": "^1.0.9" } }, "sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ=="], + + "typed-array-length": ["typed-array-length@1.0.7", "", { "dependencies": { "call-bind": "^1.0.7", "for-each": "^0.3.3", "gopd": "^1.0.1", "is-typed-array": "^1.1.13", "possible-typed-array-names": "^1.0.0", "reflect.getprototypeof": "^1.0.6" } }, "sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg=="], + + "typescript": ["typescript@5.8.2", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-aJn6wq13/afZp/jT9QZmwEjDqqvSGp1VT5GVg+f/t6/oVyrgXM6BY1h9BRh/O5p3PlUPAe+WuiEZOmb/49RqoQ=="], + + "unbox-primitive": ["unbox-primitive@1.1.0", "", { "dependencies": { "call-bound": "^1.0.3", "has-bigints": "^1.0.2", "has-symbols": "^1.1.0", "which-boxed-primitive": "^1.1.1" } }, "sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw=="], + + "unrs-resolver": ["unrs-resolver@1.3.3", "", { "optionalDependencies": { "@unrs/resolver-binding-win32-x64-msvc": "1.3.3" } }, "sha512-PFLAGQzYlyjniXdbmQ3dnGMZJXX5yrl2YS4DLRfR3BhgUsE1zpRIrccp9XMOGRfIHpdFvCn/nr5N1KMVda4x3A=="], + + "uri-js": ["uri-js@4.4.1", "", { "dependencies": { "punycode": "^2.1.0" } }, "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg=="], + + "which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="], + + "which-boxed-primitive": ["which-boxed-primitive@1.1.1", "", { "dependencies": { "is-bigint": "^1.1.0", "is-boolean-object": "^1.2.1", "is-number-object": "^1.1.1", "is-string": "^1.1.1", "is-symbol": "^1.1.1" } }, "sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA=="], + + "which-builtin-type": ["which-builtin-type@1.2.1", "", { "dependencies": { "call-bound": "^1.0.2", "function.prototype.name": "^1.1.6", "has-tostringtag": "^1.0.2", "is-async-function": "^2.0.0", "is-date-object": "^1.1.0", "is-finalizationregistry": "^1.1.0", "is-generator-function": "^1.0.10", "is-regex": "^1.2.1", "is-weakref": "^1.0.2", "isarray": "^2.0.5", "which-boxed-primitive": "^1.1.0", "which-collection": "^1.0.2", "which-typed-array": "^1.1.16" } }, "sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q=="], + + "which-collection": ["which-collection@1.0.2", "", { "dependencies": { "is-map": "^2.0.3", "is-set": "^2.0.3", "is-weakmap": "^2.0.2", "is-weakset": "^2.0.3" } }, "sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw=="], + + "which-typed-array": ["which-typed-array@1.1.19", "", { "dependencies": { "available-typed-arrays": "^1.0.7", "call-bind": "^1.0.8", "call-bound": "^1.0.4", "for-each": "^0.3.5", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-tostringtag": "^1.0.2" } }, "sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw=="], + + "word-wrap": ["word-wrap@1.2.5", "", {}, "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA=="], + + "wrap-ansi": ["wrap-ansi@9.0.0", "", { "dependencies": { "ansi-styles": "^6.2.1", "string-width": "^7.0.0", "strip-ansi": "^7.1.0" } }, "sha512-G8ura3S+3Z2G+mkgNRq8dqaFZAuxfsxpBB8OCTGRTCtp+l/v9nbFNmCUP1BZMts3G1142MsZfn6eeUKrr4PD1Q=="], + + "wrap-ansi-cjs": ["wrap-ansi@7.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="], + + "wrappy": ["wrappy@1.0.2", "", {}, "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="], + + "yaml": ["yaml@2.7.1", "", { "bin": "bin.mjs" }, "sha512-10ULxpnOCQXxJvBgxsn9ptjq6uviG/htZKk9veJGhlqn3w/DxQ631zFF+nlQXLwmImeS5amR2dl2U8sg6U9jsQ=="], + + "yocto-queue": ["yocto-queue@0.1.0", "", {}, "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q=="], + + "@eslint/eslintrc/minimatch": ["minimatch@3.1.2", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw=="], + + "@humanwhocodes/config-array/minimatch": ["minimatch@3.1.2", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw=="], + + "@isaacs/cliui/string-width": ["string-width@5.1.2", "", { "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", "strip-ansi": "^7.0.1" } }, "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA=="], + + "@isaacs/cliui/strip-ansi": ["strip-ansi@7.1.0", "", { "dependencies": { "ansi-regex": "^6.0.1" } }, "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ=="], + + "@isaacs/cliui/wrap-ansi": ["wrap-ansi@8.1.0", "", { "dependencies": { "ansi-styles": "^6.1.0", "string-width": "^5.0.1", "strip-ansi": "^7.0.1" } }, "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ=="], + + "@typescript-eslint/typescript-estree/minimatch": ["minimatch@9.0.5", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow=="], + + "@typescript-eslint/typescript-estree/semver": ["semver@7.7.1", "", { "bin": "bin/semver.js" }, "sha512-hlq8tAfn0m/61p4BVRcPzIGr6LKiMwo4VM6dGi6pt4qcRkmNzTcWq6eCEjEh+qXjkMDvPlOFFSGwQjoEa6gyMA=="], + + "eslint-import-resolver-node/debug": ["debug@3.2.7", "", { "dependencies": { "ms": "^2.1.1" } }, "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ=="], + + "eslint-import-resolver-node/resolve": ["resolve@1.22.10", "", { "dependencies": { "is-core-module": "^2.16.0", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, "bin": "bin/resolve" }, "sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w=="], + + "eslint-module-utils/debug": ["debug@3.2.7", "", { "dependencies": { "ms": "^2.1.1" } }, "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ=="], + + "eslint-plugin-import/debug": ["debug@3.2.7", "", { "dependencies": { "ms": "^2.1.1" } }, "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ=="], + + "eslint-plugin-import/doctrine": ["doctrine@2.1.0", "", { "dependencies": { "esutils": "^2.0.2" } }, "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw=="], + + "eslint-plugin-import/minimatch": ["minimatch@3.1.2", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw=="], + + "eslint-plugin-jsx-a11y/minimatch": ["minimatch@3.1.2", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw=="], + + "eslint-plugin-react/doctrine": ["doctrine@2.1.0", "", { "dependencies": { "esutils": "^2.0.2" } }, "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw=="], + + "eslint-plugin-react/minimatch": ["minimatch@3.1.2", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw=="], + + "eslint-plugin-react/semver": ["semver@6.3.1", "", { "bin": "bin/semver.js" }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="], + + "fast-glob/glob-parent": ["glob-parent@5.1.2", "", { "dependencies": { "is-glob": "^4.0.1" } }, "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow=="], + + "fdir/picomatch": ["picomatch@4.0.2", "", {}, "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg=="], + + "glob/minimatch": ["minimatch@9.0.5", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow=="], + + "is-bun-module/semver": ["semver@7.7.1", "", { "bin": "bin/semver.js" }, "sha512-hlq8tAfn0m/61p4BVRcPzIGr6LKiMwo4VM6dGi6pt4qcRkmNzTcWq6eCEjEh+qXjkMDvPlOFFSGwQjoEa6gyMA=="], + + "lint-staged/chalk": ["chalk@5.4.1", "", {}, "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w=="], + + "log-update/slice-ansi": ["slice-ansi@7.1.0", "", { "dependencies": { "ansi-styles": "^6.2.1", "is-fullwidth-code-point": "^5.0.0" } }, "sha512-bSiSngZ/jWeX93BqeIAbImyTbEihizcwNjFoRUIY/T1wWQsfsm2Vw1agPKylXvQTU7iASGdHhyqRlqQzfz+Htg=="], + + "log-update/strip-ansi": ["strip-ansi@7.1.0", "", { "dependencies": { "ansi-regex": "^6.0.1" } }, "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ=="], + + "log-update/wrap-ansi": ["wrap-ansi@9.0.0", "", { "dependencies": { "ansi-styles": "^6.2.1", "string-width": "^7.0.0", "strip-ansi": "^7.1.0" } }, "sha512-G8ura3S+3Z2G+mkgNRq8dqaFZAuxfsxpBB8OCTGRTCtp+l/v9nbFNmCUP1BZMts3G1142MsZfn6eeUKrr4PD1Q=="], + + "npm-run-path/path-key": ["path-key@4.0.0", "", {}, "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ=="], + + "restore-cursor/onetime": ["onetime@7.0.0", "", { "dependencies": { "mimic-function": "^5.0.0" } }, "sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ=="], + + "rimraf/glob": ["glob@7.2.3", "", { "dependencies": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", "inherits": "2", "minimatch": "^3.1.1", "once": "^1.3.0", "path-is-absolute": "^1.0.0" } }, "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q=="], + + "slice-ansi/ansi-styles": ["ansi-styles@6.2.1", "", {}, "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug=="], + + "string-width/emoji-regex": ["emoji-regex@10.4.0", "", {}, "sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw=="], + + "string-width/strip-ansi": ["strip-ansi@7.1.0", "", { "dependencies": { "ansi-regex": "^6.0.1" } }, "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ=="], + + "string-width-cjs/emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="], + + "string-width-cjs/is-fullwidth-code-point": ["is-fullwidth-code-point@3.0.0", "", {}, "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="], + + "tinyglobby/picomatch": ["picomatch@4.0.2", "", {}, "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg=="], + + "wrap-ansi/ansi-styles": ["ansi-styles@6.2.1", "", {}, "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug=="], + + "wrap-ansi/string-width": ["string-width@7.2.0", "", { "dependencies": { "emoji-regex": "^10.3.0", "get-east-asian-width": "^1.0.0", "strip-ansi": "^7.1.0" } }, "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ=="], + + "wrap-ansi/strip-ansi": ["strip-ansi@7.1.0", "", { "dependencies": { "ansi-regex": "^6.0.1" } }, "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ=="], + + "wrap-ansi-cjs/string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="], + + "@eslint/eslintrc/minimatch/brace-expansion": ["brace-expansion@1.1.11", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA=="], + + "@humanwhocodes/config-array/minimatch/brace-expansion": ["brace-expansion@1.1.11", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA=="], + + "@isaacs/cliui/string-width/strip-ansi": ["strip-ansi@7.1.0", "", { "dependencies": { "ansi-regex": "^6.0.1" } }, "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ=="], + + "@isaacs/cliui/strip-ansi/ansi-regex": ["ansi-regex@6.1.0", "", {}, "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA=="], + + "@isaacs/cliui/wrap-ansi/ansi-styles": ["ansi-styles@6.2.1", "", {}, "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug=="], + + "@isaacs/cliui/wrap-ansi/strip-ansi": ["strip-ansi@7.1.0", "", { "dependencies": { "ansi-regex": "^6.0.1" } }, "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ=="], + + "@typescript-eslint/typescript-estree/minimatch/brace-expansion": ["brace-expansion@2.0.1", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA=="], + + "eslint-plugin-import/minimatch/brace-expansion": ["brace-expansion@1.1.11", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA=="], + + "eslint-plugin-jsx-a11y/minimatch/brace-expansion": ["brace-expansion@1.1.11", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA=="], + + "eslint-plugin-react/minimatch/brace-expansion": ["brace-expansion@1.1.11", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA=="], + + "glob/minimatch/brace-expansion": ["brace-expansion@2.0.1", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA=="], + + "log-update/slice-ansi/ansi-styles": ["ansi-styles@6.2.1", "", {}, "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug=="], + + "log-update/slice-ansi/is-fullwidth-code-point": ["is-fullwidth-code-point@5.0.0", "", { "dependencies": { "get-east-asian-width": "^1.0.0" } }, "sha512-OVa3u9kkBbw7b8Xw5F9P+D/T9X+Z4+JruYVNapTjPYZYUznQ5YfWeFkOj606XYYW8yugTfC8Pj0hYqvi4ryAhA=="], + + "log-update/strip-ansi/ansi-regex": ["ansi-regex@6.1.0", "", {}, "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA=="], + + "log-update/wrap-ansi/ansi-styles": ["ansi-styles@6.2.1", "", {}, "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug=="], + + "log-update/wrap-ansi/string-width": ["string-width@7.2.0", "", { "dependencies": { "emoji-regex": "^10.3.0", "get-east-asian-width": "^1.0.0", "strip-ansi": "^7.1.0" } }, "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ=="], + + "rimraf/glob/minimatch": ["minimatch@3.1.2", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw=="], + + "string-width/strip-ansi/ansi-regex": ["ansi-regex@6.1.0", "", {}, "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA=="], + + "wrap-ansi-cjs/string-width/emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="], + + "wrap-ansi-cjs/string-width/is-fullwidth-code-point": ["is-fullwidth-code-point@3.0.0", "", {}, "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="], + + "wrap-ansi/string-width/emoji-regex": ["emoji-regex@10.4.0", "", {}, "sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw=="], + + "wrap-ansi/strip-ansi/ansi-regex": ["ansi-regex@6.1.0", "", {}, "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA=="], + + "@isaacs/cliui/string-width/strip-ansi/ansi-regex": ["ansi-regex@6.1.0", "", {}, "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA=="], + + "@isaacs/cliui/wrap-ansi/strip-ansi/ansi-regex": ["ansi-regex@6.1.0", "", {}, "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA=="], + + "log-update/wrap-ansi/string-width/emoji-regex": ["emoji-regex@10.4.0", "", {}, "sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw=="], + + "rimraf/glob/minimatch/brace-expansion": ["brace-expansion@1.1.11", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA=="], + } +} diff --git a/app/clickhouse/migrations/0000_init.sql b/app/clickhouse/migrations/0000_init.sql new file mode 100644 index 000000000..a1b2a9596 --- /dev/null +++ b/app/clickhouse/migrations/0000_init.sql @@ -0,0 +1,71 @@ +-- Table: otel_logs +CREATE TABLE otel_2.otel_logs (`Timestamp` DateTime64(9) CODEC(Delta(8), ZSTD(1)), `TraceId` String CODEC(ZSTD(1)), `SpanId` String CODEC(ZSTD(1)), `TraceFlags` UInt32 CODEC(ZSTD(1)), `SeverityText` LowCardinality(String) CODEC(ZSTD(1)), `SeverityNumber` Int32 CODEC(ZSTD(1)), `ServiceName` LowCardinality(String) CODEC(ZSTD(1)), `Body` String CODEC(ZSTD(1)), `ResourceSchemaUrl` String CODEC(ZSTD(1)), `ResourceAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `ScopeSchemaUrl` String CODEC(ZSTD(1)), `ScopeName` String CODEC(ZSTD(1)), `ScopeVersion` String CODEC(ZSTD(1)), `ScopeAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `LogAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), INDEX idx_trace_id TraceId TYPE bloom_filter(0.001) GRANULARITY 1, INDEX idx_res_attr_key mapKeys(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_res_attr_value mapValues(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_scope_attr_key mapKeys(ScopeAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_scope_attr_value mapValues(ScopeAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_log_attr_key mapKeys(LogAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_log_attr_value mapValues(LogAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_body Body TYPE tokenbf_v1(32768, 3, 0) GRANULARITY 1) ENGINE = MergeTree() PARTITION BY toDate(Timestamp) ORDER BY (ServiceName, SeverityText, toUnixTimestamp(Timestamp), TraceId) TTL toDateTime(Timestamp) + toIntervalDay(3) SETTINGS index_granularity = 8192, ttl_only_drop_parts = 1; + + +-- Table: otel_metrics +CREATE TABLE otel_2.otel_metrics (`Timestamp` DateTime64(9) CODEC(Delta(8), ZSTD(1)), `ResourceAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `ResourceSchemaUrl` String CODEC(ZSTD(1)), `ScopeName` String CODEC(ZSTD(1)), `ScopeVersion` String CODEC(ZSTD(1)), `ScopeAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `ScopeSchemaUrl` String CODEC(ZSTD(1)), `MetricName` String CODEC(ZSTD(1)), `MetricDescription` String CODEC(ZSTD(1)), `MetricUnit` String CODEC(ZSTD(1)), `Attributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `StartTimestamp` DateTime64(9) CODEC(Delta(8), ZSTD(1)), `TimeUnixNano` UInt64 CODEC(Delta(8), ZSTD(1)), `Value` Float64 CODEC(ZSTD(1)), `Exemplars.FilteredAttributes` Array(Map(LowCardinality(String), String)) CODEC(ZSTD(1)), `Exemplars.TimeUnixNano` Array(UInt64) CODEC(ZSTD(1)), `Exemplars.Value` Array(Float64) CODEC(ZSTD(1)), `Exemplars.SpanId` Array(String) CODEC(ZSTD(1)), `Exemplars.TraceId` Array(String) CODEC(ZSTD(1)), `Flags` UInt32 CODEC(ZSTD(1)), `MetricType` LowCardinality(String) CODEC(ZSTD(1))) ENGINE = MergeTree() PARTITION BY toDate(Timestamp) ORDER BY (MetricName, Attributes, ResourceAttributes, toUnixTimestamp64Nano(Timestamp)) TTL toDateTime(Timestamp) + toIntervalHour(12) SETTINGS index_granularity = 8192; + + +-- Table: otel_metrics_exponential_histogram +CREATE TABLE otel_2.otel_metrics_exponential_histogram (`ResourceAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `ResourceSchemaUrl` String CODEC(ZSTD(1)), `ScopeName` String CODEC(ZSTD(1)), `ScopeVersion` String CODEC(ZSTD(1)), `ScopeAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `ScopeDroppedAttrCount` UInt32 CODEC(ZSTD(1)), `ScopeSchemaUrl` String CODEC(ZSTD(1)), `ServiceName` LowCardinality(String) CODEC(ZSTD(1)), `MetricName` String CODEC(ZSTD(1)), `MetricDescription` String CODEC(ZSTD(1)), `MetricUnit` String CODEC(ZSTD(1)), `Attributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `StartTimeUnix` DateTime64(9) CODEC(Delta(8), ZSTD(1)), `TimeUnix` DateTime64(9) CODEC(Delta(8), ZSTD(1)), `Count` UInt64 CODEC(Delta(8), ZSTD(1)), `Sum` Float64 CODEC(ZSTD(1)), `Scale` Int32 CODEC(ZSTD(1)), `ZeroCount` UInt64 CODEC(ZSTD(1)), `PositiveOffset` Int32 CODEC(ZSTD(1)), `PositiveBucketCounts` Array(UInt64) CODEC(ZSTD(1)), `NegativeOffset` Int32 CODEC(ZSTD(1)), `NegativeBucketCounts` Array(UInt64) CODEC(ZSTD(1)), `Exemplars.FilteredAttributes` Array(Map(LowCardinality(String), String)) CODEC(ZSTD(1)), `Exemplars.TimeUnix` Array(DateTime64(9)) CODEC(ZSTD(1)), `Exemplars.Value` Array(Float64) CODEC(ZSTD(1)), `Exemplars.SpanId` Array(String) CODEC(ZSTD(1)), `Exemplars.TraceId` Array(String) CODEC(ZSTD(1)), `Flags` UInt32 CODEC(ZSTD(1)), `Min` Float64 CODEC(ZSTD(1)), `Max` Float64 CODEC(ZSTD(1)), `AggregationTemporality` Int32 CODEC(ZSTD(1)), INDEX idx_res_attr_key mapKeys(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_res_attr_value mapValues(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_scope_attr_key mapKeys(ScopeAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_scope_attr_value mapValues(ScopeAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_attr_key mapKeys(Attributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_attr_value mapValues(Attributes) TYPE bloom_filter(0.01) GRANULARITY 1) ENGINE = MergeTree() PARTITION BY toDate(TimeUnix) ORDER BY (ServiceName, MetricName, Attributes, toUnixTimestamp64Nano(TimeUnix)) TTL toDateTime(TimeUnix) + toIntervalDay(180) SETTINGS index_granularity = 8192, ttl_only_drop_parts = 1; + + +-- Table: otel_metrics_gauge +CREATE TABLE otel_2.otel_metrics_gauge (`ResourceAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `ResourceSchemaUrl` String CODEC(ZSTD(1)), `ScopeName` String CODEC(ZSTD(1)), `ScopeVersion` String CODEC(ZSTD(1)), `ScopeAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `ScopeDroppedAttrCount` UInt32 CODEC(ZSTD(1)), `ScopeSchemaUrl` String CODEC(ZSTD(1)), `ServiceName` LowCardinality(String) CODEC(ZSTD(1)), `MetricName` String CODEC(ZSTD(1)), `MetricDescription` String CODEC(ZSTD(1)), `MetricUnit` String CODEC(ZSTD(1)), `Attributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `StartTimeUnix` DateTime64(9) CODEC(Delta(8), ZSTD(1)), `TimeUnix` DateTime64(9) CODEC(Delta(8), ZSTD(1)), `Value` Float64 CODEC(ZSTD(1)), `Flags` UInt32 CODEC(ZSTD(1)), `Exemplars.FilteredAttributes` Array(Map(LowCardinality(String), String)) CODEC(ZSTD(1)), `Exemplars.TimeUnix` Array(DateTime64(9)) CODEC(ZSTD(1)), `Exemplars.Value` Array(Float64) CODEC(ZSTD(1)), `Exemplars.SpanId` Array(String) CODEC(ZSTD(1)), `Exemplars.TraceId` Array(String) CODEC(ZSTD(1)), INDEX idx_res_attr_key mapKeys(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_res_attr_value mapValues(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_scope_attr_key mapKeys(ScopeAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_scope_attr_value mapValues(ScopeAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_attr_key mapKeys(Attributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_attr_value mapValues(Attributes) TYPE bloom_filter(0.01) GRANULARITY 1) ENGINE = MergeTree() PARTITION BY toDate(TimeUnix) ORDER BY (ServiceName, MetricName, Attributes, toUnixTimestamp64Nano(TimeUnix)) TTL toDateTime(TimeUnix) + toIntervalDay(180) SETTINGS index_granularity = 8192, ttl_only_drop_parts = 1; + + +-- Table: otel_metrics_histogram +CREATE TABLE otel_2.otel_metrics_histogram (`ResourceAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `ResourceSchemaUrl` String CODEC(ZSTD(1)), `ScopeName` String CODEC(ZSTD(1)), `ScopeVersion` String CODEC(ZSTD(1)), `ScopeAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `ScopeDroppedAttrCount` UInt32 CODEC(ZSTD(1)), `ScopeSchemaUrl` String CODEC(ZSTD(1)), `ServiceName` LowCardinality(String) CODEC(ZSTD(1)), `MetricName` String CODEC(ZSTD(1)), `MetricDescription` String CODEC(ZSTD(1)), `MetricUnit` String CODEC(ZSTD(1)), `Attributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `StartTimeUnix` DateTime64(9) CODEC(Delta(8), ZSTD(1)), `TimeUnix` DateTime64(9) CODEC(Delta(8), ZSTD(1)), `Count` UInt64 CODEC(Delta(8), ZSTD(1)), `Sum` Float64 CODEC(ZSTD(1)), `BucketCounts` Array(UInt64) CODEC(ZSTD(1)), `ExplicitBounds` Array(Float64) CODEC(ZSTD(1)), `Exemplars.FilteredAttributes` Array(Map(LowCardinality(String), String)) CODEC(ZSTD(1)), `Exemplars.TimeUnix` Array(DateTime64(9)) CODEC(ZSTD(1)), `Exemplars.Value` Array(Float64) CODEC(ZSTD(1)), `Exemplars.SpanId` Array(String) CODEC(ZSTD(1)), `Exemplars.TraceId` Array(String) CODEC(ZSTD(1)), `Flags` UInt32 CODEC(ZSTD(1)), `Min` Float64 CODEC(ZSTD(1)), `Max` Float64 CODEC(ZSTD(1)), `AggregationTemporality` Int32 CODEC(ZSTD(1)), `ProjectId` String, INDEX idx_res_attr_key mapKeys(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_res_attr_value mapValues(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_scope_attr_key mapKeys(ScopeAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_scope_attr_value mapValues(ScopeAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_attr_key mapKeys(Attributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_attr_value mapValues(Attributes) TYPE bloom_filter(0.01) GRANULARITY 1) ENGINE = MergeTree() PARTITION BY toDate(TimeUnix) ORDER BY (ServiceName, MetricName, Attributes, toUnixTimestamp64Nano(TimeUnix)) TTL toDateTime(TimeUnix) + toIntervalDay(180) SETTINGS index_granularity = 8192, ttl_only_drop_parts = 1; + + +-- Table: otel_metrics_sum +CREATE TABLE otel_2.otel_metrics_sum (`ResourceAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `ResourceSchemaUrl` String CODEC(ZSTD(1)), `ScopeName` String CODEC(ZSTD(1)), `ScopeVersion` String CODEC(ZSTD(1)), `ScopeAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `ScopeDroppedAttrCount` UInt32 CODEC(ZSTD(1)), `ScopeSchemaUrl` String CODEC(ZSTD(1)), `ServiceName` LowCardinality(String) CODEC(ZSTD(1)), `MetricName` String CODEC(ZSTD(1)), `MetricDescription` String CODEC(ZSTD(1)), `MetricUnit` String CODEC(ZSTD(1)), `Attributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `StartTimeUnix` DateTime64(9) CODEC(Delta(8), ZSTD(1)), `TimeUnix` DateTime64(9) CODEC(Delta(8), ZSTD(1)), `Value` Float64 CODEC(ZSTD(1)), `Flags` UInt32 CODEC(ZSTD(1)), `Exemplars.FilteredAttributes` Array(Map(LowCardinality(String), String)) CODEC(ZSTD(1)), `Exemplars.TimeUnix` Array(DateTime64(9)) CODEC(ZSTD(1)), `Exemplars.Value` Array(Float64) CODEC(ZSTD(1)), `Exemplars.SpanId` Array(String) CODEC(ZSTD(1)), `Exemplars.TraceId` Array(String) CODEC(ZSTD(1)), `AggregationTemporality` Int32 CODEC(ZSTD(1)), `IsMonotonic` Bool CODEC(Delta(1), ZSTD(1)), INDEX idx_res_attr_key mapKeys(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_res_attr_value mapValues(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_scope_attr_key mapKeys(ScopeAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_scope_attr_value mapValues(ScopeAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_attr_key mapKeys(Attributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_attr_value mapValues(Attributes) TYPE bloom_filter(0.01) GRANULARITY 1) ENGINE = MergeTree() PARTITION BY toDate(TimeUnix) ORDER BY (ServiceName, MetricName, Attributes, toUnixTimestamp64Nano(TimeUnix)) TTL toDateTime(TimeUnix) + toIntervalDay(180) SETTINGS index_granularity = 8192, ttl_only_drop_parts = 1; + + +-- Table: otel_metrics_summary +CREATE TABLE otel_2.otel_metrics_summary (`ResourceAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `ResourceSchemaUrl` String CODEC(ZSTD(1)), `ScopeName` String CODEC(ZSTD(1)), `ScopeVersion` String CODEC(ZSTD(1)), `ScopeAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `ScopeDroppedAttrCount` UInt32 CODEC(ZSTD(1)), `ScopeSchemaUrl` String CODEC(ZSTD(1)), `ServiceName` LowCardinality(String) CODEC(ZSTD(1)), `MetricName` String CODEC(ZSTD(1)), `MetricDescription` String CODEC(ZSTD(1)), `MetricUnit` String CODEC(ZSTD(1)), `Attributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `StartTimeUnix` DateTime64(9) CODEC(Delta(8), ZSTD(1)), `TimeUnix` DateTime64(9) CODEC(Delta(8), ZSTD(1)), `Count` UInt64 CODEC(Delta(8), ZSTD(1)), `Sum` Float64 CODEC(ZSTD(1)), `ValueAtQuantiles.Quantile` Array(Float64) CODEC(ZSTD(1)), `ValueAtQuantiles.Value` Array(Float64) CODEC(ZSTD(1)), `Flags` UInt32 CODEC(ZSTD(1)), INDEX idx_res_attr_key mapKeys(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_res_attr_value mapValues(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_scope_attr_key mapKeys(ScopeAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_scope_attr_value mapValues(ScopeAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_attr_key mapKeys(Attributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_attr_value mapValues(Attributes) TYPE bloom_filter(0.01) GRANULARITY 1) ENGINE = MergeTree() PARTITION BY toDate(TimeUnix) ORDER BY (ServiceName, MetricName, Attributes, toUnixTimestamp64Nano(TimeUnix)) TTL toDateTime(TimeUnix) + toIntervalDay(180) SETTINGS index_granularity = 8192, ttl_only_drop_parts = 1; + + +-- Table: otel_raw_traces +CREATE TABLE otel_2.otel_raw_traces (`Timestamp` DateTime64(9), `ProjectId` String, `TraceId` String, `ParentSpanId` String, `ResourceAttributes` Map(LowCardinality(String), String), `ScopeName` String, `ScopeVersion` String, `ServiceName` LowCardinality(String), `SpanAttributes` Map(LowCardinality(String), String), `SpanId` String, `SpanKind` LowCardinality(String), `SpanName` LowCardinality(String), `StatusCode` LowCardinality(String), `StatusMessage` String, `TraceState` String, `Duration` Int64, `Events.Attributes` Array(Map(LowCardinality(String), String)), `Events.Name` Array(LowCardinality(String)), `Events.Timestamp` Array(DateTime64(9)), `Links.Attributes` Array(Map(LowCardinality(String), String)), `Links.SpanId` Array(String), `Links.TraceId` Array(String), `Links.TraceState` Array(String)) ENGINE = MergeTree() ORDER BY Timestamp SETTINGS index_granularity = 8192; + + +-- Table: otel_raw_traces_trace_id_ts +CREATE TABLE otel_2.otel_raw_traces_trace_id_ts (`TraceId` String CODEC(ZSTD(1)), `Start` DateTime CODEC(Delta(4), ZSTD(1)), `End` DateTime CODEC(Delta(4), ZSTD(1)), INDEX idx_trace_id TraceId TYPE bloom_filter(0.01) GRANULARITY 1) ENGINE = MergeTree() PARTITION BY toDate(Start) ORDER BY (TraceId, Start) TTL toDate(Start) + toIntervalHour(12) SETTINGS index_granularity = 8192, ttl_only_drop_parts = 1; + + +-- Table: otel_traces +CREATE TABLE otel_2.otel_traces (`Timestamp` DateTime64(9) CODEC(Delta(8), ZSTD(1)), `project_id` String MATERIALIZED ResourceAttributes['agentops.project.id'], `TraceId` String CODEC(ZSTD(1)), `SpanId` String CODEC(ZSTD(1)), `ParentSpanId` String CODEC(ZSTD(1)), `TraceState` String CODEC(ZSTD(1)), `SpanName` LowCardinality(String) CODEC(ZSTD(1)), `SpanKind` LowCardinality(String) CODEC(ZSTD(1)), `ServiceName` LowCardinality(String) CODEC(ZSTD(1)), `ResourceAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `ScopeName` String CODEC(ZSTD(1)), `ScopeVersion` String CODEC(ZSTD(1)), `SpanAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `Duration` UInt64 CODEC(ZSTD(1)), `StatusCode` LowCardinality(String) CODEC(ZSTD(1)), `StatusMessage` String CODEC(ZSTD(1)), `Events.Timestamp` Array(DateTime64(9)) CODEC(ZSTD(1)), `Events.Name` Array(LowCardinality(String)) CODEC(ZSTD(1)), `Events.Attributes` Array(Map(LowCardinality(String), String)) CODEC(ZSTD(1)), `Links.TraceId` Array(String) CODEC(ZSTD(1)), `Links.SpanId` Array(String) CODEC(ZSTD(1)), `Links.TraceState` Array(String) CODEC(ZSTD(1)), `Links.Attributes` Array(Map(LowCardinality(String), String)) CODEC(ZSTD(1)), INDEX idx_trace_id TraceId TYPE bloom_filter(0.001) GRANULARITY 16, INDEX idx_span_id SpanId TYPE bloom_filter(0.01) GRANULARITY 32, INDEX idx_project_id project_id TYPE bloom_filter(0.001) GRANULARITY 16) ENGINE = MergeTree() PARTITION BY toYYYYMM(Timestamp) ORDER BY (project_id, Timestamp) SETTINGS index_granularity = 8192; + + +-- Table: otel_traces_0403251619 +CREATE TABLE otel_2.otel_traces_0403251619 (`Timestamp` DateTime64(9) CODEC(Delta(8), ZSTD(1)), `project_id` String MATERIALIZED ResourceAttributes['agentops.project.id'], `TraceId` String CODEC(ZSTD(1)), `SpanId` String CODEC(ZSTD(1)), `ParentSpanId` String CODEC(ZSTD(1)), `TraceState` String CODEC(ZSTD(1)), `SpanName` LowCardinality(String) CODEC(ZSTD(1)), `SpanKind` LowCardinality(String) CODEC(ZSTD(1)), `ServiceName` LowCardinality(String) CODEC(ZSTD(1)), `ResourceAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `ScopeName` String CODEC(ZSTD(1)), `ScopeVersion` String CODEC(ZSTD(1)), `SpanAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `Duration` UInt64 CODEC(ZSTD(1)), `StatusCode` LowCardinality(String) CODEC(ZSTD(1)), `StatusMessage` String CODEC(ZSTD(1)), `Events.Timestamp` Array(DateTime64(9)) CODEC(ZSTD(1)), `Events.Name` Array(LowCardinality(String)) CODEC(ZSTD(1)), `Events.Attributes` Array(Map(LowCardinality(String), String)) CODEC(ZSTD(1)), `Links.TraceId` Array(String) CODEC(ZSTD(1)), `Links.SpanId` Array(String) CODEC(ZSTD(1)), `Links.TraceState` Array(String) CODEC(ZSTD(1)), `Links.Attributes` Array(Map(LowCardinality(String), String)) CODEC(ZSTD(1)), INDEX idx_trace_id TraceId TYPE bloom_filter(0.001) GRANULARITY 16, INDEX idx_span_id SpanId TYPE bloom_filter(0.01) GRANULARITY 32, INDEX idx_project_id project_id TYPE bloom_filter(0.001) GRANULARITY 16) ENGINE = MergeTree() PARTITION BY toYYYYMM(Timestamp) ORDER BY (project_id, Timestamp) SETTINGS index_granularity = 8192; + + +-- Table: otel_traces_legacy +CREATE TABLE otel_2.otel_traces_legacy (`Timestamp` DateTime64(9), `ProjectId` String, `TraceId` String, `ParentSpanId` String, `ResourceAttributes` Map(LowCardinality(String), String), `ScopeName` String, `ScopeVersion` String, `ServiceName` LowCardinality(String), `SpanAttributes` Map(LowCardinality(String), String), `SpanId` String, `SpanKind` LowCardinality(String), `SpanName` LowCardinality(String), `StatusCode` LowCardinality(String), `StatusMessage` String, `TraceState` String, `Duration` Int64, `Events.Attributes` Array(Map(LowCardinality(String), String)), `Events.Name` Array(LowCardinality(String)), `Events.Timestamp` Array(DateTime64(9)), `Links.Attributes` Array(Map(LowCardinality(String), String)), `Links.SpanId` Array(String), `Links.TraceId` Array(String), `Links.TraceState` Array(String), `project_id` String MATERIALIZED ResourceAttributes['agentops.project.id'], INDEX idx_trace_id TraceId TYPE bloom_filter(0.001) GRANULARITY 1, INDEX idx_span_id SpanId TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_project_id project_id TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_span_attr_key mapKeys(SpanAttributes) TYPE bloom_filter(0.01) GRANULARITY 8, INDEX idx_span_attr_value mapValues(SpanAttributes) TYPE bloom_filter(0.01) GRANULARITY 8) ENGINE = MergeTree() ORDER BY Timestamp SETTINGS index_granularity = 8192; + + +-- Table: otel_traces_trace_id_ts +CREATE TABLE otel_2.otel_traces_trace_id_ts (`TraceId` String CODEC(ZSTD(1)), `Start` DateTime CODEC(Delta(4), ZSTD(1)), `End` DateTime CODEC(Delta(4), ZSTD(1)), INDEX idx_trace_id TraceId TYPE bloom_filter(0.01) GRANULARITY 1) ENGINE = MergeTree() PARTITION BY toDate(Start) ORDER BY (TraceId, Start) TTL toDate(Start) + toIntervalHour(12) SETTINGS index_granularity = 8192, ttl_only_drop_parts = 1; + + +-- Table: otel_traces_with_project +CREATE TABLE otel_2.otel_traces_with_project (`Timestamp` DateTime64(9) CODEC(Delta(8), ZSTD(1)), `ProjectId` String CODEC(ZSTD(1)), `TraceId` String CODEC(ZSTD(1)), `SpanId` String CODEC(ZSTD(1)), `ParentSpanId` String CODEC(ZSTD(1)), `TraceState` String CODEC(ZSTD(1)), `SpanName` LowCardinality(String) CODEC(ZSTD(1)), `SpanKind` LowCardinality(String) CODEC(ZSTD(1)), `ServiceName` LowCardinality(String) CODEC(ZSTD(1)), `ResourceAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `ScopeName` String CODEC(ZSTD(1)), `ScopeVersion` String CODEC(ZSTD(1)), `SpanAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `Duration` Int64 CODEC(ZSTD(1)), `StatusCode` LowCardinality(String) CODEC(ZSTD(1)), `StatusMessage` String CODEC(ZSTD(1)), `Events.Timestamp` Array(DateTime64(9)) CODEC(ZSTD(1)), `Events.Name` Array(LowCardinality(String)) CODEC(ZSTD(1)), `Events.Attributes` Array(Map(LowCardinality(String), String)) CODEC(ZSTD(1)), `Links.TraceId` Array(String) CODEC(ZSTD(1)), `Links.SpanId` Array(String) CODEC(ZSTD(1)), `Links.TraceState` Array(String) CODEC(ZSTD(1)), `Links.Attributes` Array(Map(LowCardinality(String), String)) CODEC(ZSTD(1)), INDEX idx_project_id ProjectId TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_trace_id TraceId TYPE bloom_filter(0.001) GRANULARITY 1, INDEX idx_res_attr_key mapKeys(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_res_attr_value mapValues(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_span_attr_key mapKeys(SpanAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_span_attr_value mapValues(SpanAttributes) TYPE bloom_filter(0.01) GRANULARITY 1, INDEX idx_duration Duration TYPE minmax GRANULARITY 1) ENGINE = MergeTree() PARTITION BY toDate(Timestamp) ORDER BY (ServiceName, SpanName, toDateTime(Timestamp), ProjectId) TTL toDate(Timestamp) + toIntervalDay(180) SETTINGS index_granularity = 8192, ttl_only_drop_parts = 1; + + +-- Table: otel_traces_with_supabase_project_id +CREATE TABLE otel_2.otel_traces_with_supabase_project_id (`Timestamp` DateTime64(9) CODEC(Delta(8), ZSTD(1)), `project_id` String MATERIALIZED ResourceAttributes['agentops.project.id'], `TraceId` String CODEC(ZSTD(1)), `SpanId` String CODEC(ZSTD(1)), `ParentSpanId` String CODEC(ZSTD(1)), `TraceState` String CODEC(ZSTD(1)), `SpanName` LowCardinality(String) CODEC(ZSTD(1)), `SpanKind` LowCardinality(String) CODEC(ZSTD(1)), `ServiceName` LowCardinality(String) CODEC(ZSTD(1)), `ResourceAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `ScopeName` String CODEC(ZSTD(1)), `ScopeVersion` String CODEC(ZSTD(1)), `SpanAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)), `Duration` UInt64 CODEC(ZSTD(1)), `StatusCode` LowCardinality(String) CODEC(ZSTD(1)), `StatusMessage` String CODEC(ZSTD(1)), `Events.Timestamp` Array(DateTime64(9)) CODEC(ZSTD(1)), `Events.Name` Array(LowCardinality(String)) CODEC(ZSTD(1)), `Events.Attributes` Array(Map(LowCardinality(String), String)) CODEC(ZSTD(1)), `Links.TraceId` Array(String) CODEC(ZSTD(1)), `Links.SpanId` Array(String) CODEC(ZSTD(1)), `Links.TraceState` Array(String) CODEC(ZSTD(1)), `Links.Attributes` Array(Map(LowCardinality(String), String)) CODEC(ZSTD(1)), INDEX idx_trace_id TraceId TYPE bloom_filter(0.001) GRANULARITY 16, INDEX idx_span_id SpanId TYPE bloom_filter(0.01) GRANULARITY 32, INDEX idx_project_id project_id TYPE bloom_filter(0.001) GRANULARITY 16) ENGINE = MergeTree() PARTITION BY toYYYYMM(Timestamp) ORDER BY (project_id, Timestamp) SETTINGS index_granularity = 8192; + + +-- Table: otel_raw_traces_trace_id_ts_mv +CREATE MATERIALIZED VIEW otel_2.otel_raw_traces_trace_id_ts_mv TO otel_2.otel_raw_traces_trace_id_ts (`TraceId` String, `Start` DateTime64(9), `End` DateTime64(9)) AS SELECT TraceId, min(Timestamp) AS Start, max(Timestamp) AS End FROM otel_2.otel_raw_traces WHERE TraceId != '' GROUP BY TraceId; + + +-- Table: otel_traces_project_idx +CREATE MATERIALIZED VIEW otel_2.otel_traces_project_idx (`Timestamp` DateTime64(9), `TraceId` String, `SpanId` String, `project_id` String) ENGINE = MergeTree() PARTITION BY toYYYYMM(Timestamp) ORDER BY (project_id, TraceId, SpanId) SETTINGS index_granularity = 8192 AS SELECT Timestamp, TraceId, SpanId, ResourceAttributes['agentops.project.id'] AS project_id FROM otel_2.otel_traces WHERE (ResourceAttributes['agentops.project.id']) != ''; + + +-- Table: otel_traces_trace_id_ts_mv +CREATE MATERIALIZED VIEW otel_2.otel_traces_trace_id_ts_mv TO otel_2.otel_traces_trace_id_ts (`TraceId` String, `Start` DateTime64(9), `End` DateTime64(9)) AS SELECT TraceId, min(Timestamp) AS Start, max(Timestamp) AS End FROM otel_2.otel_traces WHERE TraceId != '' GROUP BY TraceId; + diff --git a/app/clickhouse/schema_dump.sql b/app/clickhouse/schema_dump.sql new file mode 100644 index 000000000..29c7feb06 --- /dev/null +++ b/app/clickhouse/schema_dump.sql @@ -0,0 +1,17 @@ +-- This query generates a schema dump for the 'otel_2' database in ClickHouse. +-- We replace 'SharedMergeTree' with 'MergeTree' in the output, since that's only +-- available on Clickhouse Cloud and this is intended for local use. + +SELECT concat( + '-- Table: ', name, '\n', + CASE + WHEN position('SharedMergeTree' IN create_table_query) > 0 + THEN replaceRegexpAll(create_table_query, 'SharedMergeTree\\(([^)]*?)\\)', 'MergeTree()') + ELSE create_table_query + END, + ';\n\n' +) AS schema +FROM system.tables +WHERE database = 'otel_2' AND NOT startsWith(name, '.inner_id') +ORDER BY if(engine='MaterializedView', 2, if(engine='View', 1, 0)), name +FORMAT TSVRaw; \ No newline at end of file diff --git a/app/compose.yaml b/app/compose.yaml new file mode 100644 index 000000000..bd00d4c08 --- /dev/null +++ b/app/compose.yaml @@ -0,0 +1,71 @@ +include: + - opentelemetry-collector/compose.yaml +services: + api: + build: + context: ./api + dockerfile: Dockerfile + ports: + - '8000:8000' + environment: + SUPABASE_URL: ${NEXT_PUBLIC_SUPABASE_URL} + SUPABASE_KEY: ${SUPABASE_SERVICE_ROLE_KEY} + APP_URL: ${APP_URL} + SENTRY_DSN: ${SENTRY_DSN} + SENTRY_ENVIRONMENT: ${SENTRY_ENVIRONMENT} + LOGGING_LEVEL: ${LOGGING_LEVEL} + JWT_SECRET_KEY: ${JWT_SECRET_KEY} + # Clickhouse Configuration + CLICKHOUSE_HOST: ${CLICKHOUSE_HOST} + CLICKHOUSE_PORT: ${CLICKHOUSE_PORT} + CLICKHOUSE_USER: ${CLICKHOUSE_USER} + CLICKHOUSE_PASSWORD: ${CLICKHOUSE_PASSWORD} + CLICKHOUSE_DATABASE: ${CLICKHOUSE_DATABASE} + CLICKHOUSE_SECURE: ${CLICKHOUSE_SECURE} + CLICKHOUSE_ENDPOINT: ${CLICKHOUSE_ENDPOINT} + CLICKHOUSE_USERNAME: ${CLICKHOUSE_USERNAME} + network_mode: 'host' + volumes: + - ./api:/app/api + + dashboard: + profiles: ['dashboard'] + build: + context: ./dashboard + dockerfile: Dockerfile + ports: + - '3000:3000' + environment: + # Supabase Configuration + NEXT_PUBLIC_SUPABASE_URL: ${NEXT_PUBLIC_SUPABASE_URL} + NEXT_PUBLIC_SUPABASE_ANON_KEY: ${NEXT_PUBLIC_SUPABASE_ANON_KEY} + SUPABASE_SERVICE_ROLE_KEY: ${SUPABASE_SERVICE_ROLE_KEY} + SUPABASE_PROJECT_ID: ${SUPABASE_PROJECT_ID} + + # Application URLs + NEXT_PUBLIC_APP_URL: ${APP_URL} + NEXT_PUBLIC_SITE_URL: ${NEXT_PUBLIC_SITE_URL} + + # Analytics and Monitoring + NEXT_PUBLIC_POSTHOG_KEY: ${NEXT_PUBLIC_POSTHOG_KEY} + NEXT_PUBLIC_POSTHOG_HOST: ${NEXT_PUBLIC_POSTHOG_HOST} + NEXT_PUBLIC_SENTRY_DSN: ${NEXT_PUBLIC_SENTRY_DSN} + NEXT_PUBLIC_SENTRY_ORG: ${NEXT_PUBLIC_SENTRY_ORG} + NEXT_PUBLIC_SENTRY_PROJECT: ${NEXT_PUBLIC_SENTRY_PROJECT} + NEXT_PUBLIC_SENTRY_ENVIRONMENT: ${NEXT_PUBLIC_SENTRY_ENVIRONMENT} + + # Application Configuration + NEXT_PUBLIC_SIGNIN_METHODS: ${NEXT_PUBLIC_SIGNIN_METHODS} + NEXT_PUBLIC_ENVIRONMENT_TYPE: ${NEXT_PUBLIC_ENVIRONMENT_TYPE} + NEXT_PUBLIC_FALLBACK_API_KEY: ${NEXT_PUBLIC_FALLBACK_API_KEY} + NEXT_PUBLIC_PLAYGROUND: ${NEXT_PUBLIC_PLAYGROUND} + + # Stripe Configuration + NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY: ${NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY} + STRIPE_SECRET_KEY: ${NEXT_STRIPE_SECRET_KEY} + STRIPE_WEBHOOK_SECRET: ${NEXT_STRIPE_WEBHOOK_SECRET} + network_mode: 'host' + depends_on: + - api + volumes: + - ./dashboard:/app/ diff --git a/app/dashboard/.cursor/rules/design.mdc b/app/dashboard/.cursor/rules/design.mdc new file mode 100644 index 000000000..c45bea546 --- /dev/null +++ b/app/dashboard/.cursor/rules/design.mdc @@ -0,0 +1,30 @@ +--- +description: All tasks related to updating frontend components, CSS, and general styling +globs: +alwaysApply: false +--- +# Typography Guidelines + +## Fonts +- **Figtree**: Main font used for UI elements +- **Menlo**: Used for code blocks + +## Font Sizes +- **Page title (Primary)**: 32px +- **Page title**: 16px +- **Paragraph**: 14px +- **Label (Secondary)**: 14px + +## Usage +- Primary styling should be used for main headings and important UI elements +- Secondary styling should be used for supporting content and labels + +## Colors +- Primary font: rgba(20, 27, 52, 1) +- Secondary font: rgba(20, 27, 52, 0.74) +- Icons: rgba(20, 27, 52, 0.68) +- Border: rgba(222, 224, 244, 1) +- Font/Icon White: rgba(225, 226, 242, 1) +- Success: rgba(75, 196, 152, 1) +- Warning: rgba(237, 216, 103, 1) +- Error: rgba(230, 90, 126, 1) \ No newline at end of file diff --git a/app/dashboard/.cursor/rules/general.mdc b/app/dashboard/.cursor/rules/general.mdc new file mode 100644 index 000000000..b2686159a --- /dev/null +++ b/app/dashboard/.cursor/rules/general.mdc @@ -0,0 +1,8 @@ +--- +description: +globs: +alwaysApply: true +--- +## Exclusions + +No need to run the app. It's already up. i.e. no `bun dev` or `bun run build` \ No newline at end of file diff --git a/app/dashboard/.eslintignore b/app/dashboard/.eslintignore new file mode 100644 index 000000000..9963a062c --- /dev/null +++ b/app/dashboard/.eslintignore @@ -0,0 +1,13 @@ +bundle_analytics/ +.eslintignore +.prettierignore +package.json +package-lock.json +**/*.md + +cypress/fixtures +cypress/screenshots/* +cypress/videos/* +cypress/downloads/* +.nyc_output +coverage/* \ No newline at end of file diff --git a/app/dashboard/.eslintrc.json b/app/dashboard/.eslintrc.json new file mode 100644 index 000000000..0821359d9 --- /dev/null +++ b/app/dashboard/.eslintrc.json @@ -0,0 +1,6 @@ +{ + "extends": "../.eslintrc.json", + "rules": { + "react-hooks/exhaustive-deps": "off" + } +} \ No newline at end of file diff --git a/app/dashboard/.nvmrc b/app/dashboard/.nvmrc new file mode 100644 index 000000000..85aee5a53 --- /dev/null +++ b/app/dashboard/.nvmrc @@ -0,0 +1 @@ +v20 \ No newline at end of file diff --git a/app/dashboard/.prettierignore b/app/dashboard/.prettierignore new file mode 100644 index 000000000..aa81c1bd2 --- /dev/null +++ b/app/dashboard/.prettierignore @@ -0,0 +1,4 @@ +bundle_analytics/ +package-lock.json +.eslintignore +.prettierignore \ No newline at end of file diff --git a/app/dashboard/Dockerfile b/app/dashboard/Dockerfile new file mode 100644 index 000000000..513abc2cf --- /dev/null +++ b/app/dashboard/Dockerfile @@ -0,0 +1,54 @@ +# Builder stage +FROM node:20-alpine as builder + +# Declare ARG variables that will be used during build +ARG NEXT_PUBLIC_SUPABASE_URL +ARG NEXT_PUBLIC_SUPABASE_ANON_KEY +ARG NEXT_PUBLIC_API_URL +ARG NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY + +# Set working directory +WORKDIR /app + +# Copy package files +COPY package*.json ./ + +# Install dependencies with cache mount +RUN npm install + +# Copy project files +COPY . . + +# Build the Next.js application with build-time env vars +ENV NEXT_PUBLIC_SUPABASE_URL=$NEXT_PUBLIC_SUPABASE_URL +ENV NEXT_PUBLIC_SUPABASE_ANON_KEY=$NEXT_PUBLIC_SUPABASE_ANON_KEY +ENV NEXT_PUBLIC_API_URL=$NEXT_PUBLIC_API_URL +ENV NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=$NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY + +RUN --mount=type=cache,id=s/17c760dd-6886-4c45-a5c1-0b8a9b99a63d-/app/.next/cache,target=/app/.next/cache \ + npm run build + +# Production stage +FROM node:20-alpine + +WORKDIR /app + +# Copy necessary files from builder +COPY --from=builder /app/package*.json ./ +COPY --from=builder /app/.next ./.next +COPY --from=builder /app/public ./public +COPY --from=builder /app/node_modules ./node_modules +COPY --from=builder /app/next.config.js ./next.config.js + +# Expose port 3000 +EXPOSE 3000 + +# Runtime environment variables +ENV NEXT_PUBLIC_SUPABASE_URL="" +ENV NEXT_PUBLIC_SUPABASE_ANON_KEY="" +ENV NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY="" + +# Start the application +CMD echo "Runtime SUPABASE_URL: $NEXT_PUBLIC_SUPABASE_URL" && \ + echo "Runtime SUPABASE_KEY: ${NEXT_PUBLIC_SUPABASE_ANON_KEY:0:8}..." && \ + npm run start diff --git a/app/dashboard/README.md b/app/dashboard/README.md new file mode 100644 index 000000000..d06894802 --- /dev/null +++ b/app/dashboard/README.md @@ -0,0 +1,241 @@ +> **Note:** This project uses shared development configurations (linting, formatting) defined in the repository root. Please see the [root README.md](../../README.md#development-setup) for initial setup instructions and tooling details (ESLint, Prettier). + +This is a [Next.js](https://nextjs.org/) project bootstrapped with [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app). + +## Getting Started šŸš€ + +This project uses [Bun](https://bun.sh/) as the runtime and package manager. Make sure you have it installed! + +First, ensure you have the necessary environment variables set up. Copy the example file: + +```bash +cp .env.example .env.local +``` + +Then, **edit `.env.local`** and fill in the required values. + +#### Required Environment Variables + +The following variables are **required** for the dashboard to function: + +**Supabase Configuration:** +```bash +NEXT_PUBLIC_SUPABASE_URL="https://your-project-id.supabase.co" +NEXT_PUBLIC_SUPABASE_ANON_KEY="your-supabase-anon-key" +SUPABASE_SERVICE_ROLE_KEY="your-supabase-service-role-key" +``` + +**API Configuration:** +```bash +NEXT_PUBLIC_API_URL="http://localhost:8000" # Backend API URL +NEXT_PUBLIC_APP_URL="http://localhost:3000" # Frontend URL +``` + +#### Optional Environment Variables + +**Stripe (for billing features):** +```bash +NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY="pk_test_your_stripe_publishable_key" +``` + +**Analytics & Monitoring:** +```bash +NEXT_PUBLIC_POSTHOG_KEY="your-posthog-key" +NEXT_PUBLIC_SENTRY_DSN="your-sentry-dsn" +``` + +**Feature Flags:** +```bash +NEXT_PUBLIC_ENVIRONMENT_TYPE="development" +NEXT_PUBLIC_PLAYGROUND="true" +``` + +See the `.env.example` file for the complete list of available configuration options. + +Next, install the frontend dependencies: + +```bash +bun install +``` + +### Backend API Setup (Crucial!) ā— + +The dashboard frontend relies **exclusively** on the backend API server (located in the `api/` directory) for all data fetching and actions after user authentication. + +**You MUST run the backend API locally** before starting the frontend development server to test features correctly. + +Follow the setup instructions in the [`api/README.md`](../api/README.md) to run the backend either natively (Python) or using Docker. Ensure the API is running and accessible at the URL specified in your `NEXT_PUBLIC_API_URL` environment variable (typically `http://localhost:8000`). + +## Billing & Subscription Features šŸ’³ + +The dashboard includes comprehensive billing and subscription management features powered by Stripe integration. This section covers the frontend billing components and their functionality. + +### Billing Architecture (Frontend) + +The billing system in the dashboard follows this flow: +1. **User Authentication** via Supabase provides JWT tokens +2. **Billing Pages** (`/settings/organization`) display organization subscription status +3. **Stripe Elements** handle secure payment processing +4. **Real-time Updates** via polling and webhook-triggered data refetch +5. **Backend API** manages all Stripe operations and subscription state + +### Key Billing Components + +#### Billing Settings Page (`app/(with-layout)/settings/organization/`) +- **Main Page** (`page.tsx`): Orchestrates billing operations and state management +- **OrganizationsList** (`components/OrganizationsList.tsx`): Displays subscription status and management options +- **EmbeddedCheckoutForm** (`components/EmbeddedCheckoutForm.tsx`): Stripe Elements integration for payments + +#### Billing Features + +### Backend Integration + +**For complete billing setup including Stripe configuration, webhook handling, and API endpoints, see:** +āž”ļø **[`../api/README.md#billing--subscription-management`](../api/README.md#billing--subscription-management)** + +### Environment Variables (Frontend) + +```bash +# Required for billing features +NEXT_PUBLIC_SUPABASE_URL=your_supabase_url +NEXT_PUBLIC_SUPABASE_ANON_KEY=your_supabase_anon_key +NEXT_PUBLIC_API_URL=http://localhost:8000 # Backend API URL +``` + +### Testing Billing Features + +For local development: +1. **Backend Setup**: Follow [`../api/README.md`](../api/README.md) for complete Stripe configuration (the docker version is best for billing see the -s option on just api-build/run) +2. **Test Mode**: Use Stripe test keys and test card numbers (e.g., `4242424242424242`) +3. **Webhook Testing**: Use `stripe listen` to forward webhooks to local backend +4. **Frontend Testing**: Access `/settings/organization` to test the complete flow + +### Billing Component Architecture + +``` +app/(with-layout)/settings/organization/ +ā”œā”€ā”€ page.tsx # Main billing page & state management +ā”œā”€ā”€ components/ +ā”‚ ā”œā”€ā”€ OrganizationsList.tsx # Subscription status & management UI +ā”‚ ā””ā”€ā”€ EmbeddedCheckoutForm.tsx # Stripe Elements payment form +ā””ā”€ā”€ hooks/ + ā”œā”€ā”€ useStripeConfig.ts # Stripe configuration fetching + ā””ā”€ā”€ useStripePricing.ts # Pricing information +``` + +### Key Hooks & Utilities + +- **`useOrgs()`**: Fetches organization data including subscription status +- **`useStripeConfig()`**: Retrieves Stripe publishable keys and configuration +- **`useStripePricing()`**: Gets current pricing information +- **`fetchAuthenticatedApi()`**: Makes authenticated requests to billing endpoints + +### Billing Error Handling + +The frontend includes comprehensive error handling: +- **Network Errors**: Retry mechanisms and user-friendly messages +- **Payment Failures**: Clear error display and recovery options +- **State Synchronization**: Polling to ensure UI reflects actual subscription state +- **Permission Errors**: Appropriate messaging for non-admin users + +### Running the Frontend Dev Server + +Once the backend API is running and frontend dependencies are installed (`bun install`), start the frontend development server: + +```bash +bun run dev +``` + +Open [http://localhost:3000](http://localhost:3000) with your browser to see the magic happen āœØ. + +The page auto-updates as you edit files. Hot reloading is pretty sweet, eh? + +This project uses [`next/font`](https://nextjs.org/docs/basic-features/font-optimization) to automatically optimize and load Inter, a custom Google Font. + +## Development Workflow šŸ› ļø + +Working on the dashboard? Here are some helpful commands: + +- **Run Dev Server:** `bun run dev` (You already know this one!) +- **Build for Production:** `bun run build` (Checks for build errors) +- **Linting:** `bun run lint` (Keep the code style consistent, please! šŸ™) +- **Type Checking:** `bunx tsc --noEmit` + - This command is your best friend for finding _all_ TypeScript errors at once, unlike `bun run build` which might stop at the first error. + - **Important:** Make sure you run this command from _within_ the `dashboard` directory so it can find the `tsconfig.json`. + +## Project Structure šŸ—ŗļø + +Navigating the codebase? Here's a quick lay of the land: + +- **`app/`**: The heart of the Next.js App Router. Contains layouts, pages, route handlers (APIs), and loading/error components. + - `(with-layout)/`: Routes in here share the main application layout (header, sidebar, etc.). + - Other folders often correspond directly to URL paths. +- **`components/`**: Reusable UI components used across the application. Organized by feature or UI pattern. + - `ui/`: Generally contains lower-level, shadcn-ui based components (Button, Card, etc.). +- **`lib/`**: Utility functions, type definitions (`types_db.ts`), constants, and external service integrations (like Supabase client setup in `lib/supabase/`). +- **`hooks/`**: Custom React hooks, especially for data fetching (like `useMetrics`, `useTraces`). They often rely on the context providers. +- **`public/`**: Static assets served directly (images, fonts). +- **`tests/`**: Unit and integration tests (using Jest, potentially). +- **`styles/`**: Global styles (though most styling is done via Tailwind CSS within components). + +_(This is a brief overview, feel free to explore!)_ + +## Learn More + +To learn more about Next.js, take a look at the following resources: + +- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API. +- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial. + +You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js/) - your feedback and contributions are welcome! + +## Deploy on Vercel + +The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js. + +Check out our [Next.js deployment documentation](https://nextjs.org/docs/deployment) for more details. + +## Frontend Data Fetching & Auth Architecture šŸ—ļø (Revised) + +This section outlines the revised architecture for handling authentication, API communication, and state management in the dashboard frontend. + +**Core Principles:** + +1. **Authentication via Supabase:** User sign-up, sign-in, and session management are handled using the `@supabase/ssr` library on the client and server-side middleware. After successful authentication, a JWT is obtained from the Supabase session. +2. **Backend API as Single Source of Truth:** All data requests (user details, projects, orgs, traces, metrics, etc.) after login are directed exclusively to the backend API server (running at `NEXT_PUBLIC_API_URL`). The frontend **does not** make direct calls to the Supabase database (except for specific auth actions like sign-in, sign-out, password reset, MFA management). +3. **JWT for API Authorization:** Every request to the backend API includes the Supabase JWT in the `Authorization: Bearer ` header. +4. **Centralized API Client:** A dedicated function, `fetchAuthenticatedApi` (in `lib/api-client.ts`), handles all communication with the backend API. It automatically retrieves the current JWT from the Supabase session (`supabase.auth.getSession()`) and attaches the `Authorization` header. +5. **React Query for Server State:** `@tanstack/react-query` is used to manage server state, including data fetching (`useQuery`), caching, background updates, and mutations (`useMutation`). +6. **Custom Hooks for Data Fetching:** Data fetching logic is primarily encapsulated in custom hooks (located in `hooks/queries/`, e.g., `useUser`, `useProjects`, `useOrgs`, and directly in `hooks/` for `useTraces`, `useMetrics`). These hooks utilize `useQuery` or `useMutation` from React Query. +7. **API Helper Functions:** For many common operations (User, Org, Project CRUD), hooks call dedicated API helper functions (e.g., `fetchUserAPI`, `createOrgAPI`, `updateProjectAPI`) defined in `lib/api/`. These helper functions then use `fetchAuthenticatedApi` internally to perform the actual request. +8. **Direct API Client Usage in Hooks:** For more complex queries like fetching traces (`useTraces`) or metrics (`useMetrics`), the hooks often call `fetchAuthenticatedApi` directly, constructing the necessary endpoint and query parameters based on context (e.g., selected project ID, date range, filters). +9. **Shared Client State:** Shared cross-component state, such as the currently selected project and date range, is managed using React Context via dedicated providers (e.g., `ProjectProvider` defined within `app/(with-layout)/projects-manager.tsx`, `DashboardStateProvider` in `app/(with-layout)/dashboard-state-provider.tsx`). + +**Simplified Flow (Example: Fetching User Data):** + +1. User authenticates using Supabase UI/client functions. +2. Frontend gets Supabase session and JWT. +3. Component needs user profile data. +4. Component calls relevant hook (e.g., `useUser()`). +5. `useUser` hook calls `useQuery` with a query function that calls the API helper (`fetchUserAPI`). +6. `fetchUserAPI` calls `fetchAuthenticatedApi('/opsboard/users/me')` with `method: 'GET'`. +7. `fetchAuthenticatedApi` retrieves the JWT from `supabase.auth.getSession()`. +8. `fetchAuthenticatedApi` makes the `fetch` call to `http://localhost:8000/opsboard/users/me` with the `Authorization: Bearer ` header. +9. Backend API (`api/`) validates the JWT using `Depends(get_current_user)`. +10. Backend fetches user data from the database. +11. Backend returns data (JSON). +12. `fetchAuthenticatedApi` parses the JSON response. +13. `fetchUserAPI` returns the data to the `useQuery` hook. +14. React Query manages the state, component re-renders with the fetched user data. + +**Key Changes from Previous Architecture:** + +* Removed direct Supabase database calls from frontend components (except for auth-specific actions). +* Removed the `OperationalTokenProvider` and the concept of a separate operational token. +* All authenticated data API calls use the Supabase JWT and go through `fetchAuthenticatedApi`, either directly or via helper functions in `lib/api/`. + +## Cypress E2E Testing šŸ§Ŗ + +For details on setting up and running End-to-End tests with Cypress, please refer to the dedicated README: + +āž”ļø [`cypress/README.md`](./cypress/README.md) diff --git a/app/dashboard/app/(with-layout)/(requires-project)/layout.tsx b/app/dashboard/app/(with-layout)/(requires-project)/layout.tsx new file mode 100644 index 000000000..07ee73960 --- /dev/null +++ b/app/dashboard/app/(with-layout)/(requires-project)/layout.tsx @@ -0,0 +1,76 @@ +import { redirect } from 'next/navigation'; +import { cookies } from 'next/headers'; + +// Define a minimal Project type (adapt if needed based on API response) +interface Project { + id: string; + name: string; + // add other relevant fields +} + +// Server-side helper to fetch authenticated API data +// NOTE: This duplicates some logic from api-client.ts but avoids making layout.tsx a client component +// Consider extracting shared logic if this pattern repeats often. +async function fetchServerSideApi(endpoint: string): Promise { + const cookieStore = await cookies(); + const sessionId = cookieStore.get('session_id')?.value; + + if (!sessionId) { + // If called from a protected context, this implies an issue, maybe redirect? + // Or let the API call fail with 401, which might be handled by the caller. + throw new Error('User is not authenticated (no session cookie found server-side).'); + } + + const apiUrl = process.env.NEXT_PUBLIC_API_URL; + if (!apiUrl) { + throw new Error('NEXT_PUBLIC_API_URL environment variable is not set.'); + } + + const targetUrl = `${apiUrl}${endpoint}`; + const response = await fetch(targetUrl, { + headers: { + // Send session_id as Bearer token + Authorization: `Bearer ${sessionId}`, + 'Content-Type': 'application/json', + }, + cache: 'no-store', // Prevent caching sensitive data by default + }); + + if (!response.ok) { + let errorBody = `API request failed with status ${response.status}`; + try { + const body = await response.json(); + errorBody = body.detail || JSON.stringify(body); + } catch (e) { + /* ignore */ + } + // Consider custom error class like ApiError used client-side + throw new Error(errorBody); + } + + if (response.status === 204) { + return undefined as T; + } + return response.json(); +} + +export default async function RequiresProjectLayout({ children }: { children: React.ReactNode }) { + try { + // Replace getProjects call with server-side API fetch + const projects = await fetchServerSideApi('/opsboard/projects'); + + if (!projects || projects.length === 0) { + // If no projects, redirect to a page where they can create one + redirect('/get-started'); // Or /create-project? + } + } catch (error) { + console.error('Error fetching projects in layout:', error); + // Handle error appropriately - maybe redirect to signin or an error page? + // If fetchServerSideApi throws due to no cookie, middleware *should* have caught it, + // but maybe redirect just in case. + redirect('/signin?error=project_load_failed'); + } + + // If projects exist, render children + return <>{children}; +} diff --git a/app/dashboard/app/(with-layout)/account/api/route.ts b/app/dashboard/app/(with-layout)/account/api/route.ts new file mode 100644 index 000000000..b6c10ef74 --- /dev/null +++ b/app/dashboard/app/(with-layout)/account/api/route.ts @@ -0,0 +1,52 @@ +import { NextRequest, NextResponse } from 'next/server'; + +interface UserDetails { + id: string; + email?: string; +} + +export async function GET(request: NextRequest) { + // Read cookie directly from the request object + const sessionId = request.cookies.get('session_id')?.value; + + if (!sessionId) { + return new NextResponse(JSON.stringify({ error: 'Unauthorized' }), { + status: 401, + headers: { 'Content-Type': 'application/json' }, + }); + } + + try { + const apiUrl = process.env.NEXT_PUBLIC_API_URL; + if (!apiUrl) { + throw new Error('API URL not configured'); + } + + // Fetch user details from backend, forwarding the session ID + const response = await fetch(`${apiUrl}/auth/user-details`, { + // Endpoint needs to exist on backend + headers: { + Authorization: `Bearer ${sessionId}`, + }, + cache: 'no-store', + }); + + if (!response.ok) { + // Proxy the error status and message from the backend if possible + const errorBody = await response.text(); + return new NextResponse(errorBody || `Error fetching user details: ${response.statusText}`, { + status: response.status, + headers: { 'Content-Type': response.headers.get('content-type') || 'application/json' }, + }); + } + + const userDetails: UserDetails = await response.json(); + return NextResponse.json(userDetails); + } catch (error: any) { + console.error('[API Route /account/api] Error:', error); + return new NextResponse(JSON.stringify({ error: 'Internal Server Error' }), { + status: 500, + headers: { 'Content-Type': 'application/json' }, + }); + } +} diff --git a/app/dashboard/app/(with-layout)/account/page.tsx b/app/dashboard/app/(with-layout)/account/page.tsx new file mode 100644 index 000000000..53ed3e41d --- /dev/null +++ b/app/dashboard/app/(with-layout)/account/page.tsx @@ -0,0 +1,5 @@ +import { redirect } from 'next/navigation'; + +export default function AccountPage() { + redirect('/settings/account'); +} diff --git a/app/dashboard/app/(with-layout)/deploy/AlphaWarningModal.tsx b/app/dashboard/app/(with-layout)/deploy/AlphaWarningModal.tsx new file mode 100644 index 000000000..a85748a9d --- /dev/null +++ b/app/dashboard/app/(with-layout)/deploy/AlphaWarningModal.tsx @@ -0,0 +1,92 @@ +'use client'; + +import React, { useState, useEffect } from 'react'; +import { Button } from '@/components/ui/button'; +import { Checkbox } from '@/components/ui/checkbox'; +import { AlertTriangle, Rocket } from 'lucide-react'; + +interface AlphaWarningModalProps { + isOpen: boolean; + onClose: () => void; + onContinue: () => void; +} + +export default function AlphaWarningModal({ isOpen, onClose, onContinue }: AlphaWarningModalProps) { + const [hasJoinedAlpha, setHasJoinedAlpha] = useState(false); + + if (!isOpen) return null; + + return ( +
+
+
+ {/* Header */} +
+
+ +
+
+

+ Alpha Program +

+

+ Early access to deploy features +

+
+
+ + {/* Content */} +
+
+ +
+

+ Deploy is currently in Alpha +

+

+ This feature is still in development and may have limited functionality or stability issues. + By joining the alpha program, you{"'"}ll get early access to new features and help us improve the product. +

+
+
+ +
+
+ setHasJoinedAlpha(checked as boolean)} + className="mt-1" + /> + +
+
+
+ + {/* Actions */} +
+ + +
+
+
+
+ ); +} \ No newline at end of file diff --git a/app/dashboard/app/(with-layout)/deploy/GithubConnectModal.tsx b/app/dashboard/app/(with-layout)/deploy/GithubConnectModal.tsx new file mode 100644 index 000000000..be1d7ecc9 --- /dev/null +++ b/app/dashboard/app/(with-layout)/deploy/GithubConnectModal.tsx @@ -0,0 +1,146 @@ +import React, { useState } from 'react'; +import { Dialog, DialogTrigger, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogDescription, DialogClose } from '@/components/ui/dialog'; +import { Button } from '@/components/ui/button'; +import { Rocket } from 'lucide-react'; +import { IProject } from '@/types/IProject'; +import { IOrg } from '@/types/IOrg'; +import { getDerivedPermissions } from '@/types/IPermissions'; + +interface GithubConnectModalProps { + open: boolean; + onOpenChange: (open: boolean) => void; + project: IProject; + org: IOrg; + zoomingRocketId?: string | null; + setZoomingRocketId?: (id: string | null) => void; +} + +const GithubConnectModal: React.FC = ({ + open, + onOpenChange, + project, + org, + zoomingRocketId, + setZoomingRocketId, +}) => { + const [isRedirecting, setIsRedirecting] = useState(false); + const tier = getDerivedPermissions(org).tierName; + + const handleConnectGithub = () => { + setIsRedirecting(true) + // Store projectId in localStorage + if (project?.id) { + localStorage.setItem('github_connect_project_id', project.id); + } + const clientId = process.env.NEXT_PUBLIC_GITHUB_OAUTH_CLIENT_ID; + const redirectUri = encodeURIComponent(process.env.NEXT_PUBLIC_GITHUB_OAUTH_CALLBACK_URL || 'https://app.agentops.ai/deploy/github-callback'); + const scope = 'repo'; // Full control of private repositories + const state = Math.random().toString(36).substring(2); + + window.location.href = + `https://github.com/login/oauth/authorize?client_id=${clientId}&redirect_uri=${redirectUri}&scope=${scope}&state=${state}` + }; + + if (tier === 'free') { + // Hobby org: show upgrade modal + return ( + + + + + + + Agent hosting is only available to AgentOps Pro orgs! + + Upgrade your organization to unlock agent hosting and deployment features. + + + + + + + + + + + + + ); + } + + // Pro/Enterprise org: show normal connect modal + return ( + + + + + + + Connect your GitHub repo + + Would you like to connect your GitHub repository to deploy {project.name}? + + + + + + + + + + + ); +}; + +export default GithubConnectModal; \ No newline at end of file diff --git a/app/dashboard/app/(with-layout)/deploy/[proj_id]/AgentHttpClient.tsx b/app/dashboard/app/(with-layout)/deploy/[proj_id]/AgentHttpClient.tsx new file mode 100644 index 000000000..881e0fb07 --- /dev/null +++ b/app/dashboard/app/(with-layout)/deploy/[proj_id]/AgentHttpClient.tsx @@ -0,0 +1,333 @@ +import React, { useState, useEffect, useRef } from 'react'; +import dynamic from 'next/dynamic'; +import { PlayIcon } from 'hugeicons-react'; + +// Dynamically import Monaco Editor to avoid SSR issues +const MonacoEditor = dynamic(() => import('@monaco-editor/react'), { + ssr: false, + loading: () => ( +
+
Loading editor...
+
+ ), +}); + +interface AgentHttpClientProps { + proj_id: string; + api_key?: string; +} + +interface JobStatus { + job_id: string; + status: string; + message: string; + timestamp: string; +} + +const AgentHttpClient: React.FC = ({ proj_id }) => { + const [jsonInput, setJsonInput] = useState('{"inputs":{}}'); + const [isLoading, setIsLoading] = useState(false); + const [error, setError] = useState(null); + const [success, setSuccess] = useState(null); + const [currentJob, setCurrentJob] = useState(null); + const [jobEvents, setJobEvents] = useState([]); + const [isPolling, setIsPolling] = useState(false); + const pollingIntervalRef = useRef(null); + + // Cleanup polling on unmount + useEffect(() => { + return () => { + if (pollingIntervalRef.current) { + clearInterval(pollingIntervalRef.current); + } + }; + }, []); + + const startPolling = (jobId: string) => { + setIsPolling(true); + setJobEvents([]); + + // Poll every 2 seconds + pollingIntervalRef.current = setInterval(async () => { + try { + const apiUrl = process.env.NEXT_PUBLIC_API_URL; + if (!apiUrl) { + throw new Error('NEXT_PUBLIC_API_URL is not set'); + } + const response = await fetch(`${apiUrl}/deploy/deployments/${proj_id}/jobs/${jobId}/status`, { + credentials: 'include', + }); + + if (!response.ok) { + // Stop polling and report error + stopPolling(); + setError(`Failed to fetch job status: HTTP ${response.status}`); + return; + } + + const data = await response.json(); + const events = data.events || []; + + setJobEvents(events); + + // Update current job status with the latest event + if (events.length > 0) { + const latestEvent = events[0]; + setCurrentJob({ + job_id: jobId, + status: latestEvent.status, + message: latestEvent.message, + timestamp: latestEvent.timestamp, + }); + + // Stop polling if job is completed or failed + if (["completed", "failed", "error"].includes(latestEvent.status.toLowerCase())) { + stopPolling(); + } + } + } catch (error) { + // Stop polling and report error + stopPolling(); + const errorMessage = error instanceof Error ? error.message : 'An error occurred while polling job status'; + setError(errorMessage); + console.error('Error polling job status:', error); + } + }, 2000); + }; + + const stopPolling = () => { + setIsPolling(false); + if (pollingIntervalRef.current) { + clearInterval(pollingIntervalRef.current); + pollingIntervalRef.current = null; + } + }; + + const getStatusColor = (status: string) => { + const statusLower = status.toLowerCase(); + if (['completed', 'success'].includes(statusLower)) return 'text-green-600'; + if (['failed', 'error'].includes(statusLower)) return 'text-red-600'; + if (['running', 'processing'].includes(statusLower)) return 'text-blue-600'; + if (['queued', 'pending'].includes(statusLower)) return 'text-yellow-600'; + return 'text-gray-600'; + }; + + const getStatusIcon = (status: string) => { + const statusLower = status.toLowerCase(); + if (['completed', 'success'].includes(statusLower)) return 'āœ…'; + if (['failed', 'error'].includes(statusLower)) return 'āŒ'; + if (['running', 'processing'].includes(statusLower)) return 'šŸ”„'; + if (['queued', 'pending'].includes(statusLower)) return 'ā³'; + return 'šŸ“‹'; + }; + + const handleRunAgent = async () => { + if (!validateJson(jsonInput)) { + setError('Invalid JSON format'); + return; + } + + setIsLoading(true); + setError(null); + setSuccess(null); + setCurrentJob(null); + setJobEvents([]); + stopPolling(); + + try { + const apiUrl = process.env.NEXT_PUBLIC_API_URL; + if (!apiUrl) { + throw new Error('NEXT_PUBLIC_API_URL is not set'); + } + const response = await fetch(`${apiUrl}/deploy/deployments/${proj_id}/run`, { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + }, + body: jsonInput, + credentials: 'include', // This includes the session cookie + }); + + if (!response.ok) { + const errorData = await response.json().catch(() => ({})); + throw new Error(errorData.message || `HTTP error! status: ${response.status}`); + } + + const result = await response.json(); + setSuccess(`Job queued successfully! Job ID: ${result.job_id}`); + console.log('Job queued:', result.job_id); + + // Start polling for job updates + startPolling(result.job_id); + } catch (error) { + const errorMessage = error instanceof Error ? error.message : 'An error occurred while running the agent'; + setError(errorMessage); + console.error('Error running agent:', error); + } finally { + setIsLoading(false); + } + }; + + const handleEditorChange = (value: string | undefined) => { + setJsonInput(value || '{"inputs":{}}'); + // Clear previous error/success messages when user starts typing + if (error || success) { + setError(null); + setSuccess(null); + } + }; + + const validateJson = (jsonString: string) => { + try { + JSON.parse(jsonString); + return true; + } catch { + return false; + } + }; + + return ( +
+
+ +

Run Your Agent

+
+
+ +
+
+ POST /deploy/deployments/{proj_id}/run +
+
+
+
+ +
+ +
+ {!validateJson(jsonInput) && ( +
+ Invalid JSON format +
+ )} +
+ + {/* Status Messages */} + {error && ( +
+ {error} +
+ )} + {success && ( +
+ {success} +
+ )} + + {/* Job Status Display */} + {currentJob && ( +
+
+ {getStatusIcon(currentJob.status)} +

Job Status

+ {isPolling && ( +
+
+ Live +
+ )} +
+
+
+ Status: + + {currentJob.status} + +
+
+ Job ID: + {currentJob.job_id} +
+ {currentJob.message && ( +
+ Message: + {currentJob.message} +
+ )} +
+
+ )} + + {/* Job Events History */} + {jobEvents.length > 0 && ( +
+

Job Events

+
+ {jobEvents.map((event, index) => ( +
+
+ {getStatusIcon(event.status)} + + {event.status} + + + {new Date(event.timestamp).toLocaleTimeString()} + +
+ {event.message && ( +

{event.message}

+ )} +
+ ))} +
+
+ )} + + {/* Run Agent and Docs Buttons */} +
+ + +
+
+ ); +}; + +export default AgentHttpClient; \ No newline at end of file diff --git a/app/dashboard/app/(with-layout)/deploy/[proj_id]/DeploymentHistory.tsx b/app/dashboard/app/(with-layout)/deploy/[proj_id]/DeploymentHistory.tsx new file mode 100644 index 000000000..8982f5d7c --- /dev/null +++ b/app/dashboard/app/(with-layout)/deploy/[proj_id]/DeploymentHistory.tsx @@ -0,0 +1,230 @@ +import React from 'react'; +import { ArrowDown01Icon as ChevronDownIcon, MoreHorizontalIcon as MoreVerticalIcon, CheckmarkCircle01Icon as CheckIcon, StarIcon, Globe02Icon as GlobeIcon, MapPinIcon, CloudServerIcon as ServerIcon } from 'hugeicons-react'; +import { useDeploymentHistory } from '@/hooks/queries/useProjects'; + +interface DeploymentHistoryProps { + projectId: string; +} + +const DeploymentHistory: React.FC = ({ projectId }) => { + const { data: historyData, isLoading, error } = useDeploymentHistory(projectId); + + const getStatusColor = (status: string) => { + switch (status.toLowerCase()) { + case 'active': + case 'running': + case 'success': + return 'bg-green-600 text-white'; + case 'failed': + case 'error': + return 'bg-red-600 text-white'; + case 'pending': + case 'queued': + return 'bg-yellow-600 text-white'; + case 'skipped': + case 'cancelled': + return 'bg-gray-500 text-white'; + default: + return 'bg-gray-500 text-white'; + } + }; + + const getStatusDisplay = (status: string) => { + switch (status.toLowerCase()) { + case 'active': + case 'running': + return 'RUNNING'; + case 'success': + return 'SUCCESS'; + case 'failed': + case 'error': + return 'FAILED'; + case 'pending': + case 'queued': + return 'PENDING'; + case 'skipped': + return 'SKIPPED'; + case 'cancelled': + return 'CANCELLED'; + default: + return status.toUpperCase(); + } + }; + + if (isLoading) { + return ( +
+
+
+
+
+
+
+ {[...Array(3)].map((_, i) => ( +
+
+
+
+
+
+
+ ))} +
+
+
+
+ ); + } + + if (error) { + return ( +
+
+
+

Deployment History

+
+
+
+ Failed to load deployment history. Please try again later. +
+
+
+
+ ); + } + + const jobs = historyData?.jobs || []; + const currentJob = jobs.find(job => job.status.toLowerCase() === 'running' || job.status.toLowerCase() === 'active'); + const historicalJobs = jobs.filter(job => job.status.toLowerCase() !== 'running' && job.status.toLowerCase() !== 'active'); + + return ( +
+
+ {/* Card Header */} +
+

Deployment History

+
+ + {/* Card Content */} +
+ {/* Information Banner */} + {/*
+
+ + + The deployment configuration was automatically modified to ignore deprecated regions.{' '} + + +
+
*/} + + {/* Current Deployment Section */} + {currentJob && ( +
+
+
+
+ + {getStatusDisplay(currentJob.status)} + +
+
+ JD +
+
+ šŸ™ +
+
+
+
+ + +
+
+ +
+

+ {currentJob.message || 'Deployment in progress'} +

+

+ {new Date(currentJob.queued_at).toLocaleString()} via GitHub +

+
+ + {currentJob.status.toLowerCase() === 'success' && ( +
+ + Deployment successful +
+ )} + + +
+
+ )} + + {/* History Section */} +
+
+

HISTORY

+ +
+ + {historicalJobs.length === 0 ? ( +
+ No deployment history available +
+ ) : ( +
+ {historicalJobs.map((job) => ( +
+
+
+ + {getStatusDisplay(job.status)} + +
+
+ JD +
+
+ šŸ™ +
+
+
+ +
+ +
+

+ {job.message || 'Deployment job'} +

+

+ {new Date(job.queued_at).toLocaleString()} via GitHub +

+
+
+ ))} +
+ )} +
+
+
+
+ ); +}; + +export default DeploymentHistory; \ No newline at end of file diff --git a/app/dashboard/app/(with-layout)/deploy/[proj_id]/HostingMetrics.tsx b/app/dashboard/app/(with-layout)/deploy/[proj_id]/HostingMetrics.tsx new file mode 100644 index 000000000..ac66dabc3 --- /dev/null +++ b/app/dashboard/app/(with-layout)/deploy/[proj_id]/HostingMetrics.tsx @@ -0,0 +1,53 @@ +import React, { useMemo } from 'react'; +import { useMetrics } from '@/hooks/useMetrics'; +import { CommonChart } from '@/components/charts/common-chart'; + +const latencyChartConfig = { + latency: { + label: 'Latency (ms)', + color: 'hsl(var(--chart-2))', + }, +}; + +export default function HostingMetrics() { + const { metrics, metricsLoading } = useMetrics(); + + // Fake latency line chart data + const latencyData = [ + { name: 'Mon', latency: 120 }, + { name: 'Tue', latency: 110 }, + { name: 'Wed', latency: 140 }, + { name: 'Thu', latency: 100 }, + { name: 'Fri', latency: 130 }, + { name: 'Sat', latency: 90 }, + { name: 'Sun', latency: 105 }, + ]; + + return ( +
+

Hosting Metrics

+
+ {/* Trace Count Stat */} +
+
Trace Count
+
+ {metricsLoading ? ... : metrics?.trace_count ?? '--'} +
+
+ {/* Latency Line Chart */} +
+
Latency (ms)
+ +
+
+
+ ); +} \ No newline at end of file diff --git a/app/dashboard/app/(with-layout)/deploy/[proj_id]/LoadingSkeleton.tsx b/app/dashboard/app/(with-layout)/deploy/[proj_id]/LoadingSkeleton.tsx new file mode 100644 index 000000000..97f2ffdc0 --- /dev/null +++ b/app/dashboard/app/(with-layout)/deploy/[proj_id]/LoadingSkeleton.tsx @@ -0,0 +1,78 @@ +import React from 'react'; + +// Loading Skeleton Components +const LoadingSkeleton = () => { + return ( +
+ {/* Header Actions Skeleton */} +
+
+
+
+ + {/* Title and Status Skeleton */} +
+
+
+
+
+
+
+ + {/* Organization Name Skeleton */} +
+ + {/* Main Content Skeleton */} +
+ {/* Left Column - Hosting Metrics */} +
+
+
+
+
+ {[...Array(4)].map((_, i) => ( +
+
+
+
+ ))} +
+
+
+
+ + {/* Right Column - Agent HTTP Client */} +
+
+
+
+
+
+
+
+
+
+
+ + {/* Deployment History Skeleton */} +
+
+
+
+ {[...Array(3)].map((_, i) => ( +
+
+
+
+
+
+
+ ))} +
+
+
+
+ ); +}; + +export default LoadingSkeleton; \ No newline at end of file diff --git a/app/dashboard/app/(with-layout)/deploy/[proj_id]/page.tsx b/app/dashboard/app/(with-layout)/deploy/[proj_id]/page.tsx new file mode 100644 index 000000000..449e26bfe --- /dev/null +++ b/app/dashboard/app/(with-layout)/deploy/[proj_id]/page.tsx @@ -0,0 +1,130 @@ +"use client" +import React from 'react'; +import { useParams, useRouter } from 'next/navigation'; +import { useEffect } from 'react'; +import { useDeployment } from '@/hooks/queries/useProjects'; +import { Key01Icon, ArrowLeft01Icon } from 'hugeicons-react'; +import { useState } from 'react'; +import dynamic from 'next/dynamic'; +import HostingMetrics from './HostingMetrics'; +import AgentHttpClient from './AgentHttpClient'; +import { Settings01Icon } from 'hugeicons-react'; +import Link from 'next/link'; +import DeploymentHistory from './DeploymentHistory'; +import LoadingSkeleton from './LoadingSkeleton'; + +export default function DeployProjectPage() { + const params = useParams(); + const router = useRouter(); + const proj_id = params.proj_id as string; + + const { deployment, isLoading: deploymentsLoading } = useDeployment(proj_id); + + const [showTooltip, setShowTooltip] = useState(false); + const [copied, setCopied] = useState(false); + + useEffect(() => { + if (!deploymentsLoading && !deployment) { + router.replace('/deploy'); + } + }, [deploymentsLoading, deployment, router]); + + // Show loading skeleton while data is loading + if (deploymentsLoading || !deployment) { + return ; + } + + const handleCopy = () => { + if (deployment?.api_key) { + navigator.clipboard.writeText(deployment.api_key); + setCopied(true); + setTimeout(() => setCopied(false), 1200); + } + }; + + return ( +
+ + + {/* Back Button */} +
+ +
+ +
+ + + + + + +
+ +
+

{deployment?.name}

+ + + Running + +
+
+ {deployment?.org?.name} Organization +
+ +
+
+
+ +
+
+ +
+ +
+
+ + +
+ ); +} \ No newline at end of file diff --git a/app/dashboard/app/(with-layout)/deploy/[proj_id]/setup/RepoDropdown.tsx b/app/dashboard/app/(with-layout)/deploy/[proj_id]/setup/RepoDropdown.tsx new file mode 100644 index 000000000..07f7e5cd3 --- /dev/null +++ b/app/dashboard/app/(with-layout)/deploy/[proj_id]/setup/RepoDropdown.tsx @@ -0,0 +1,109 @@ +import React from 'react'; + +export interface RepoDropdownProps { + orgsWithRepos: Array<{ org: string; repos: any[] }>; + onSelect: (repo: any) => void; + isOpen: boolean; + onClose: () => void; +} + +const RepoDropdown: React.FC = ({ orgsWithRepos, onSelect, isOpen, onClose }) => { + const [filter, setFilter] = React.useState(''); + const filteredOrgsWithRepos = React.useMemo(() => { + if (!filter.trim()) { + // Sort repos for each org alphabetically by repo name + return orgsWithRepos.map(org => ({ + ...org, + repos: [...org.repos].sort((a, b) => { + const aName = ((a.full_name || '').split('/')[1] || a.full_name || a.name || '').toLowerCase(); + const bName = ((b.full_name || '').split('/')[1] || b.full_name || b.name || '').toLowerCase(); + return aName.localeCompare(bName); + }) + })); + } + const filterWords = filter.toLowerCase().split(/\s+/).filter(Boolean); + return orgsWithRepos.map(org => { + // Sort repos before filtering + const sortedRepos = [...org.repos].sort((a, b) => { + const aName = ((a.full_name || '').split('/')[1] || a.full_name || a.name || '').toLowerCase(); + const bName = ((b.full_name || '').split('/')[1] || b.full_name || b.name || '').toLowerCase(); + return aName.localeCompare(bName); + }); + return { + ...org, + repos: sortedRepos.filter(repo => { + const repoName = (repo.full_name || '').split('/')[1] || repo.full_name || repo.name || ''; + const orgName = org.org || ''; + const fullName = (repo.full_name || '') + ' ' + orgName; + const target = [repoName, orgName, fullName].join(' ').toLowerCase(); + // All filter words must be present somewhere in the target string + return filterWords.every(word => target.includes(word)); + }) + }; + }).filter(org => org.repos.length > 0); + }, [orgsWithRepos, filter]); + + if (!isOpen) return null; + + const clearFilter = () => { + setFilter(''); + }; + + return ( +
+ {/* Filter input */} +
+
+ setFilter(e.target.value)} + className="w-full px-3 py-2 pr-8 text-[14px] border border-[rgba(222,224,244,1)] rounded focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-transparent" + autoFocus + /> + {filter && ( + + )} +
+
+ {/* Scrollable repo list */} +
+ {filteredOrgsWithRepos.length === 0 && ( +
+ {filter ? 'No repositories match your filter.' : 'No repositories found.'} +
+ )} + {filteredOrgsWithRepos.map((org) => ( +
+
{org.org}
+ {org.repos.map((repo) => { + const repoName = (repo.full_name || '').split('/')[1] || repo.full_name || repo.name; + return ( +
{ onSelect(repo); onClose(); }} + > + {/* GitHub logo SVG */} + + {repoName} +
+ ); + })} +
+ ))} +
+
+ ); +}; + +export default RepoDropdown; \ No newline at end of file diff --git a/app/dashboard/app/(with-layout)/deploy/[proj_id]/setup/SecretsManager.tsx b/app/dashboard/app/(with-layout)/deploy/[proj_id]/setup/SecretsManager.tsx new file mode 100644 index 000000000..cd9ad66fe --- /dev/null +++ b/app/dashboard/app/(with-layout)/deploy/[proj_id]/setup/SecretsManager.tsx @@ -0,0 +1,357 @@ +"use client" +import React, { useState, useEffect } from 'react'; +import { Alert01Icon as WarningIcon, Delete01Icon as TrashIcon } from 'hugeicons-react'; + +interface Secret { + name: string; +} + +interface SecretsManagerProps { + projectId: string; +} + +export default function SecretsManager({ projectId }: SecretsManagerProps) { + const [activeTab, setActiveTab] = useState<'env' | 'individual'>('individual'); + const [secrets, setSecrets] = useState([]); + const [envContent, setEnvContent] = useState(''); + const [newKey, setNewKey] = useState(''); + const [newValue, setNewValue] = useState(''); + const [isLoading, setIsLoading] = useState(false); + const [isSaving, setIsSaving] = useState(false); + const [isDeleting, setIsDeleting] = useState(null); + const [error, setError] = useState(null); + const [showDeleteModal, setShowDeleteModal] = useState(false); + const [secretToDelete, setSecretToDelete] = useState(null); + + const apiUrl = process.env.NEXT_PUBLIC_API_URL; + + // Load existing secrets + const loadSecrets = async () => { + setIsLoading(true); + setError(null); + try { + const response = await fetch(`${apiUrl}/deploy/deployments/${projectId}/secrets`, { + method: 'GET', + credentials: 'include', + }); + + if (response.ok) { + const data = await response.json(); + setSecrets(data.secrets || []); + + // Convert secrets to .env format + const envString = data.secrets?.map((secret: Secret) => `${secret.name}=`).join('\n') || ''; + setEnvContent(envString); + } else { + setError('Failed to load secrets'); + } + } catch (err) { + setError('Error loading secrets'); + console.error('Error loading secrets:', err); + } finally { + setIsLoading(false); + } + }; + + useEffect(() => { + loadSecrets(); + }, [projectId]); + + // Save secret from .env format + const saveEnvSecrets = async () => { + setIsSaving(true); + setError(null); + + try { + const lines = envContent.split('\n').filter(line => line.trim()); + const secretsToSave = lines.map(line => { + const [key, ...valueParts] = line.split('='); + const value = valueParts.join('='); // Handle values that might contain '=' + return { name: key.trim(), value: value.trim() }; + }).filter(secret => secret.name && secret.value); + + // Save each secret + for (const secret of secretsToSave) { + const response = await fetch(`${apiUrl}/deploy/deployments/${projectId}/secrets`, { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + }, + credentials: 'include', + body: JSON.stringify(secret), + }); + + if (!response.ok) { + throw new Error(`Failed to save secret ${secret.name}`); + } + } + + // Reload secrets to update the list + await loadSecrets(); + } catch (err) { + setError('Error saving secrets'); + console.error('Error saving secrets:', err); + } finally { + setIsSaving(false); + } + }; + + // Save individual secret + const saveIndividualSecret = async () => { + if (!newKey.trim() || !newValue.trim()) { + setError('Both key and value are required'); + return; + } + + setIsSaving(true); + setError(null); + + try { + const response = await fetch(`${apiUrl}/deploy/deployments/${projectId}/secrets`, { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + }, + credentials: 'include', + body: JSON.stringify({ + name: newKey.trim(), + value: newValue.trim(), + }), + }); + + if (response.ok) { + setNewKey(''); + setNewValue(''); + await loadSecrets(); + } else { + setError('Failed to save secret'); + } + } catch (err) { + setError('Error saving secret'); + console.error('Error saving secret:', err); + } finally { + setIsSaving(false); + } + }; + + // Handle delete button click + const handleDeleteClick = (secretName: string) => { + setSecretToDelete(secretName); + setShowDeleteModal(true); + }; + + // Confirm delete + const confirmDelete = async () => { + if (!secretToDelete) return; + + setIsDeleting(secretToDelete); + setError(null); + + try { + const response = await fetch(`${apiUrl}/deploy/deployments/${projectId}/secrets/${encodeURIComponent(secretToDelete)}`, { + method: 'DELETE', + credentials: 'include', + }); + + if (response.ok) { + await loadSecrets(); + setShowDeleteModal(false); + setSecretToDelete(null); + } else { + setError(`Failed to delete secret ${secretToDelete}`); + } + } catch (err) { + setError(`Error deleting secret ${secretToDelete}`); + console.error('Error deleting secret:', err); + } finally { + setIsDeleting(null); + } + }; + + // Cancel delete + const cancelDelete = () => { + setShowDeleteModal(false); + setSecretToDelete(null); + }; + + return ( +
+
+ +

Environment Variables

+
+ +

+ Manage environment variables and secrets for your deployment. These will be securely stored and made available to your application. +

+ + {/* Tab Navigation */} +
+ + +
+ + {/* Error Display */} + {error && ( +
+

{error}

+
+ )} + + {/* .env Format Tab */} + {activeTab === 'env' && ( +
+
+ +