home / skills / jeremylongshore / claude-code-plugins-plus-skills / posthog-ci-integration

This skill automates PostHog CI/CD integration setup with GitHub Actions, tests, and secrets configuration for streamlined automated testing.

npx playbooks add skill jeremylongshore/claude-code-plugins-plus-skills --skill posthog-ci-integration

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.8 KB
---
name: posthog-ci-integration
description: |
  Configure PostHog CI/CD integration with GitHub Actions and testing.
  Use when setting up automated testing, configuring CI pipelines,
  or integrating PostHog tests into your build process.
  Trigger with phrases like "posthog CI", "posthog GitHub Actions",
  "posthog automated tests", "CI posthog".
allowed-tools: Read, Write, Edit, Bash(gh:*)
version: 1.0.0
license: MIT
author: Jeremy Longshore <[email protected]>
---

# PostHog CI Integration

## Overview
Set up CI/CD pipelines for PostHog integrations with automated testing.

## Prerequisites
- GitHub repository with Actions enabled
- PostHog test API key
- npm/pnpm project configured

## Instructions

### Step 1: Create GitHub Actions Workflow
Create `.github/workflows/posthog-integration.yml`:

```yaml
name: PostHog Integration Tests

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

env:
  POSTHOG_API_KEY: ${{ secrets.POSTHOG_API_KEY }}

jobs:
  test:
    runs-on: ubuntu-latest
    env:
      POSTHOG_API_KEY: ${{ secrets.POSTHOG_API_KEY }}
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      - run: npm ci
      - run: npm test -- --coverage
      - run: npm run test:integration
```

### Step 2: Configure Secrets
```bash
gh secret set POSTHOG_API_KEY --body "sk_test_***"
```

### Step 3: Add Integration Tests
```typescript
describe('PostHog Integration', () => {
  it.skipIf(!process.env.POSTHOG_API_KEY)('should connect', async () => {
    const client = getPostHogClient();
    const result = await client.healthCheck();
    expect(result.status).toBe('ok');
  });
});
```

## Output
- Automated test pipeline
- PR checks configured
- Coverage reports uploaded
- Release workflow ready

## Error Handling
| Issue | Cause | Solution |
|-------|-------|----------|
| Secret not found | Missing configuration | Add secret via `gh secret set` |
| Tests timeout | Network issues | Increase timeout or mock |
| Auth failures | Invalid key | Check secret value |

## Examples

### Release Workflow
```yaml
on:
  push:
    tags: ['v*']

jobs:
  release:
    runs-on: ubuntu-latest
    env:
      POSTHOG_API_KEY: ${{ secrets.POSTHOG_API_KEY_PROD }}
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - run: npm ci
      - name: Verify PostHog production readiness
        run: npm run test:integration
      - run: npm run build
      - run: npm publish
```

### Branch Protection
```yaml
required_status_checks:
  - "test"
  - "posthog-integration"
```

## Resources
- [GitHub Actions Documentation](https://docs.github.com/en/actions)
- [PostHog CI Guide](https://docs.posthog.com/ci)

## Next Steps
For deployment patterns, see `posthog-deploy-integration`.

Overview

This skill configures PostHog CI/CD integration for GitHub Actions and automated testing. It provides a ready-to-use workflow, secret configuration guidance, and examples for integration and release pipelines. The goal is to ensure PostHog health checks and integration tests run as part of PRs and releases. Use it to add reliable telemetry and integration verification to your build process.

How this skill works

The skill creates a GitHub Actions workflow that installs dependencies, runs unit tests with coverage, and executes PostHog integration tests that require a test API key. It instructs how to store the PostHog API key as a repository secret and how to conditionally skip integration tests when the key is not present. It also shows a release job example that runs integration checks before publishing and suggests branch protection rules to enforce checks on PRs.

When to use it

  • Adding PostHog integration tests to CI for new or existing projects
  • Ensuring PostHog connectivity is verified on pull requests and releases
  • Automating test coverage and integration checks in GitHub Actions
  • Configuring branch protection to require PostHog-related status checks

Best practices

  • Store API keys in repository secrets (e.g., POSTHOG_API_KEY) and never commit them
  • Run integration tests conditionally so local dev and forks don’t leak secrets
  • Use CI caching (npm/pnpm) and node-version pinning to keep runs stable
  • Mock network calls in unit tests and reserve integration tests for CI
  • Add reasonable timeouts and retries for flaky network-related tests

Example use cases

  • Create .github/workflows/posthog-integration.yml to run tests on push and PR to main
  • Add gh secret set POSTHOG_API_KEY --body "sk_test_***" in CI setup scripts
  • Write an integration test that performs a PostHog health check and skips if no key
  • Define a release workflow that runs integration tests before npm publish
  • Enforce branch protection requiring test and posthog-integration status checks

FAQ

What if integration tests run in forks or contributors' PRs?

Keep integration tests conditional on the presence of POSTHOG_API_KEY so forks without the secret skip those tests.

How do I add the PostHog API key to GitHub?

Use gh secret set POSTHOG_API_KEY --body "sk_test_***" or add it through Settings → Secrets in the repository UI.

How can I avoid flaky network tests in CI?

Increase timeouts, add retries, and mock external calls in unit tests while reserving full integration checks for CI.