GitHub

The Woven GitHub App is what enables silent observability — it watches your repositories for schema and model changes without interrupting developers.

Once installed, it automatically detects migrations, dbt models, and schema files, and sends non-intrusive alerts to Slack whenever changes are merged.

To accomplish this, Woven needs to be integrated in all the GitHub repo(s) where data schemas (e.g. ORMs, Proto/Avro, dbt, etc.) are defined.

GitHub apps need to be installed or approved by your company's GitHub admin. If you do not have the necessary permissions, you can still request an install and wait for your admin to approve.

Woven requires GitHub Actions enabled in all repositories. This enables Woven to detect schema changes within your GitHub environment and only send metadata to Woven's servers.

Reach out to us if you cannot use GitHub actions - we can help set Woven up in your CI stack.

How to Install

• Go to app.woven.dev/github to initiate the installation. You will be asked to login to Woven.

• Choose "All repositories", or just the ones where data schemas are defined.

• Complete installation or send to admin for approval.

What to Expect

After installation:

• Woven will set a few Actions Variables and Secret for your CI to communicate to Woven's servers.

• You’ll see an auto-generated configuration PR with detected projects and dialects

• Once merged, Woven silently tracks schema evolution in every pull request

• You’ll start receiving digest notifications in Slack (after Slack setup)

If your project uses nonstandard frameworks (like SQLAlchemy), you may need to setup your application runtime to extract schemas. Reach out to us for help.

What's in the configuration PR?

The PR has two configuration files:

🧩 opendapi.config.yaml

Defines what projects and integrations to include in observability.

• Woven auto-detects your schema source integrations in the repositories and configures them. Supported integrations include Activerecord, Prisma, Protobuf, SqlAlchemy, Alembic, and Liquibase. Some integrations like SqlAlchemy may expect your application runtime to be setup to extract schema

• By default, Woven includes all projects in your repositories. You can include/exclude specfic projects or specific models.

Here is an example.

# opendapi.config.yaml

schema: https://opendapi.org/spec/0-0-3/opendapi.config.json

organization:
  name: Woven
  email_domain: woven.dev

repository:
  urn: woven.hood-ski-shop
  mainline_branch: main

dapis:
  runtimes:
    DEFAULT:
      integrations:
        - type: activerecord
          projects:
            # Automatically include all rails applications with schema.rb files
            include_all: true
            include_projects:
              - prefix:ecommerce-rails
              - exclude:regex:^admin-rails$
            artifact_path: db/structure.sql
            dialect: mysql
    
        - type: prisma
          projects:
            # Automatically include all schema.prisma files
            include_all: true
            artifact_path: prisma/schema.prisma

🗂️ .github/workflows/opendapi_ci.yaml

Creates GitHub Actions workflow to extract schemas from the application code. Only metadata is sent to Woven's servers.

• Runs on GitHub actions in your GitHub account.

• You can modify this file as needed to update runners, etc.

# .github/workflows/opendapi_ci.yml
name: metadata-extraction/woven-ai
on:
  # Invoke for every Pull Request and push to main branch
  pull_request:
    branches:
      - 'main'

  push:
    branches:
      - 'main'

env:
  GITHUB_BRANCH: ${{ github.event.pull_request.head.ref || github.ref }}
  PYPI_INDEX_URL: ${{ vars.OPENDAPI_PINNED_VERSION && 'https://test.pypi.org/simple/' || 'https://pypi.org/simple/' }}
  OPENDAPI_VERSION: ${{ vars.OPENDAPI_PINNED_VERSION || 'opendapi' }}
  WOVEN_INTEGRATION_MODE: ${{ vars.WOVEN_INTEGRATION_MODE || 'active' }}
  WOVEN_CONFIGURATION: ${{ vars.WOVEN_CONFIGURATION }}

jobs:
  run:
    runs-on: ubuntu-latest
    steps:
    - name: Checkout repository
      uses: actions/checkout@v4
      with:
        # Fetch all branches and history to help create a suggestion PR
        fetch-depth: 0
        # Checkout the working branch for PRs instead of merge branch
        ref: ${{ env.GITHUB_BRANCH }}

    - name: Set up Python
      uses: actions/setup-python@v5
      with:
        python-version: '3.10'

    - name: OpenDAPI CI
      shell: bash
      run: |
        pip install --index-url ${{ env.PYPI_INDEX_URL }}                   \
                    --extra-index-url https://pypi.org/simple               \
                    ${{ env.OPENDAPI_VERSION }}
        opendapi github github run

      env:
        DAPI_SERVER_HOST: '${{ vars.DAPI_SERVER_HOST }}'
        MAINLINE_BRANCH_NAME: "main"
        # Store credentials in Github as a secret
        DAPI_SERVER_API_KEY: ${{ secrets.DAPI_SERVER_API_KEY }}
        # Configure when DAPIs should be registered.
        # PRs do not register but only validate and provide suggestions
        REGISTER_ON_MERGE_TO_MAINLINE: True
        # Other github environment variables needed for opendapi
        GITHUB_HEAD_SHA: ${{ github.event.pull_request.head.sha || github.sha }}

After review, merge the PR — this activates silent observability for the selected projects.