Instrument Logs

PostHogOfficialCreated by PostHog

Skill
Tool integration
Data and AI
MIT
Low risk

From the author

Add PostHog log capture to track application logs. Use after implementing features or reviewing PRs to ensure meaningful log events are captured with structured properties. Also handles initial OTLP exporter setup if not yet configured.

— the description by PostHog

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill guides the integration of PostHog log capture into various application stacks. It automates the setup of OTLP exporters and provides instructions for adding structured logging alongside existing application logs. The skill ensures that log events are captured with meaningful properties, facilitating better observability and debugging within the PostHog platform.

What it does

Detects the application platform and existing logging infrastructure.
Configures the OpenTelemetry (OTLP) exporter for PostHog ingestion.
Integrates PostHog log capture without replacing existing logging handlers.
Ensures logs are captured with structured key-value properties.
Manages environment variable configuration for API tokens and host URLs.
Provides platform-specific guidance for SDK-native log capture.

When to use it

After implementing new features that require observability.
During code reviews when you identify a need for better log coverage.
When setting up initial log export for a new project.
When migrating from standard logging to structured, centralized log management.

Advantages

Maintains existing logging architecture without disruptive changes.
Supports a wide range of languages and frameworks via OpenTelemetry.
Enables structured logging for improved search and filtering in PostHog.
Automates the configuration of environment variables and ingestion endpoints.

Usage examples

“Add PostHog log capture to my Node.js application.”: The agent will analyze your package.json, install necessary OpenTelemetry dependencies, configure the OTLP exporter, and guide you through adding PostHog logging calls to your code.
“I need to start tracking logs in my Android app using PostHog.”: The agent will verify your Android SDK setup, configure the PostHogAndroidConfig for logs, and show you how to use PostHog.logger to capture structured events.

Install

Download the skill as a ZIP:
https://autogineer.com/agent-skills/posthog/instrument-logs/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip instrument-logs.zip -d .agents/skills

Documentation by PostHog

Add PostHog log capture

Use this skill to add PostHog log capture for new or changed code. Use it after implementing features or reviewing PRs to ensure meaningful log events are captured with structured properties. If PostHog log export is not yet configured, this skill also covers initial OTLP exporter setup. Supports any platform or language.

Supported platforms: Next.js, Node.js, Python, Go, Java, Datadog, Android, React Native, iOS, and any language via OpenTelemetry.

Instructions

Follow these steps IN ORDER:

STEP 1: Analyze the codebase and detect the platform.

Detect the language, framework, and existing logging setup.
Look for dependency files and project files (package.json, Podfile, Package.swift, requirements.txt, go.mod, pom.xml, etc.).
Look for log libraries (winston, pino, logging module, logrus, log4j, serilog, os_log, Logger, etc.).
Look for lockfiles (pnpm-lock.yaml, package-lock.json, yarn.lock, bun.lockb, go.sum, Podfile.lock, Package.resolved, etc.) to determine the package manager.
Check for existing PostHog log export setup. If the OTLP exporter is already configured, skip to STEP 5 to add log capture for new code.

STEP 2: Research log capture. (Skip if PostHog log export is already configured.) 2.1. Find the reference file below that matches the detected platform — it is the source of truth for OTLP exporter configuration and integration with existing logging. Read it now. 2.2. If no reference matches, use the "Other Languages" reference as a fallback — it covers the generic OpenTelemetry approach.

STEP 3: Install dependencies. (Skip if PostHog log export is already configured.)

Install the OpenTelemetry SDK and OTLP exporter packages for the detected platform.
Do not manually edit dependency files — use the package manager's install command.

STEP 4: Configure the OTLP exporter. (Skip if PostHog log export is already configured.)

PostHog logs use the OpenTelemetry protocol. Set up an OTLP exporter pointed at PostHog's ingest endpoint.
For SDK-native log support such as Android, React Native, and iOS, follow the platform reference instead of adding a separate OTLP exporter.
Follow the platform-specific reference for the exact configuration.

STEP 5: Integrate with existing logging.

Add the PostHog log exporter alongside existing logging. Don't replace existing log handlers or outputs.
Do not alter the fundamental architecture of existing files. Make additions minimal and targeted.
You must read a file immediately before attempting to write it.

STEP 6: Add structured properties.

Ensure logs include structured key-value properties for filtering and search in PostHog.
Prefer structured log formats with key-value properties over plain text messages.

STEP 7: Set up environment variables.

Check if the project already has PostHog environment variables configured (e.g. in .env, .env.local, or framework-specific env files). If valid values already exist, skip this step.
If the PostHog project token is missing, use the PostHog MCP server's projects-get tool to retrieve the project's api_token. If multiple projects are returned, ask the user which project to use. If the MCP server is not connected or not authenticated, ask the user for their PostHog project token instead.
For the PostHog host URL: check the projects-get MCP response for a region field — US maps to https://us.i.posthog.com, EU maps to https://eu.i.posthog.com. If the region is not available from the MCP response or from existing project configuration, ask the user: "Are you on PostHog US Cloud or EU Cloud?" Do not assume US Cloud.
For the OpenTelemetry endpoint, use https://us.i.posthog.com/v1 (US) or https://eu.i.posthog.com/v1 (EU), matching the region determined above.
Write these values to the appropriate env file using the framework's naming convention.
Reference these environment variables in code instead of hardcoding them.

Reference files

references/nextjs.md - Next.js logs installation
references/nodejs.md - Node.js logs installation
references/python.md - Python logs installation
references/go.md - Go logs installation
references/java.md - Java logs installation
references/datadog.md - Datadog logs installation
references/android.md - Android logs installation
references/react-native.md - React native logs installation
references/ios.md - Ios logs installation
references/flutter.md - Flutter logs installation
references/other.md - Other languages logs installation
references/start-here.md - Getting started with logs
references/search.md - Search logs
references/best-practices.md - Logging best practices
references/troubleshooting.md - Logs troubleshooting
references/link-session-replay.md - Link session replay
references/mcp.md - Use logs over PostHog mcp
references/COMMANDMENTS.md - Framework-specific rules the integration must follow

Each platform reference contains specific OTLP configuration, SDK setup, and integration patterns. Find the one matching the user's stack.

Key principles

Environment variables: Always use environment variables for PostHog keys and OpenTelemetry endpoints. Never hardcode them.
Minimal changes: Add log export alongside existing logging. Don't replace or restructure existing logging code.
OpenTelemetry: PostHog logs use the OpenTelemetry protocol. Configure an OTLP exporter pointed at PostHog's ingest endpoint unless the platform SDK provides native log capture.
SDK-native logs: For Android, React Native, and iOS, use the SDK logger/capture APIs from the platform reference instead of adding a separate OTLP exporter.
Structured logging: Prefer structured log formats with key-value properties over plain text messages.

Files

ATTRIBUTION.mdAdded by AutoGineer931 B
LICENSELicence file added by AutoGineer1.0 KiB
SKILL.md6.1 KiB
references/COMMANDMENTS.md1.5 KiB
references/android.md9.2 KiB
references/best-practices.md25.2 KiB
references/datadog.md3.8 KiB
references/flutter.md20.4 KiB
references/go.md4.9 KiB
references/ios.md11.1 KiB
references/java.md4.7 KiB
references/link-session-replay.md6.4 KiB
references/mcp.md4.1 KiB
references/nextjs.md6.9 KiB
references/nodejs.md4.8 KiB
references/other.md3.5 KiB
references/python.md4.7 KiB
references/react-native.md10.8 KiB
references/search.md8.0 KiB
references/start-here.md10.2 KiB
references/troubleshooting.md6.5 KiB

references/go.md

AI agents: this is one page from PostHog's docs. Full index of Markdown docs for LLMs: https://posthog.com/llms.txt

Go Logs installation

Canonical URL: https://posthog.com/docs/logs/installation/go

Cloud region: This page uses US Cloud hosts. For an EU Cloud project, use https://eu.i.posthog.com instead of https://us.i.posthog.com (ingestion host), and use https://eu.posthog.com instead of https://app.posthog.com (app host for links).

Install OpenTelemetry packages

Required

go get go.opentelemetry.io/otel/sdk/log
go get go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp

2
Get your project token
Required
You'll need your PostHog project token to authenticate log requests. This is the same key you use for capturing events and exceptions with the PostHog SDK.
Important: Use your project token which starts with phc_. Do not use a personal API key (which starts with phx_).
You can find your project token in Project Settings.

Configure the SDK

Required

Set up the OpenTelemetry SDK to send logs to PostHog.

package main

import (
    "os"
    "context"
    "log"
    "log/slog"

    "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp"
    "go.opentelemetry.io/otel/exporters/stdout/stdoutlog"
    "go.opentelemetry.io/contrib/bridges/otelslog"
    otellog "go.opentelemetry.io/otel/sdk/log"
    "go.opentelemetry.io/otel/log/global"
)

func main() {
    ctx := context.Background()

    // Create OTLP HTTP exporter
    exporter, err := otlploghttp.New(ctx,
        otlploghttp.WithEndpoint("us.i.posthog.com"),
        otlploghttp.WithURLPath("/i/v1/logs"),
        otlploghttp.WithHeaders(map[string]string{
            "Authorization": "Bearer <ph_project_token>",
        }),
    )
    if err != nil {
        panic(err)
    }

    // you could also set this outside your application
    os.Setenv("OTEL_SERVICE_NAME", "my-service")

    stdoutExporter, _ := stdoutlog.New()

    // Create logger provider
    loggerProvider := otellog.NewLoggerProvider(
        otellog.WithProcessor(otellog.NewBatchProcessor(exporter)),
        // optional, also log to stdout
        otellog.WithProcessor(otellog.NewSimpleProcessor(stdoutExporter)),
    )
    defer func() {
        loggerProvider.Shutdown(context.Background())
    }()

    global.SetLoggerProvider(loggerProvider)
    slog.SetDefault(otelslog.NewLogger(""))

    log.Println("this is a log line")
}

Alternatively, you can pass the API key as a query parameter by modifying the URL path:

otlploghttp.WithURLPath("/i/v1/logs?token=<ph_project_token>")

Use OpenTelemetry logging

Required

Now you can start logging with OpenTelemetry:

import (
    "go.opentelemetry.io/otel/log"
)

logger := otel.GetLoggerProvider().Logger("my-app")

logger.Info(ctx, "User action",
    log.String("userId", "123"),
    log.String("action", "login"),
)

5
Test your setup
Recommended
Once everything is configured, test that logs are flowing into PostHog:
1. Send a test log from your application
2. Check the PostHog Logs interface for your log entries
3. Verify the logs appear in your project
View your logs in PostHog

Next steps

Checkpoint

What you can do with your logs

Action	Description
Why you need logs	What logs show you that nothing else does
Search logs	Use the search interface to find specific log entries
Filter by level	Filter by `INFO`, `WARN`, `ERROR`, etc.
Link session replay	Connect logs to users and session replays by passing `posthogDistinctId` and `sessionId`
Link logs to a person	Surface every log emitted on behalf of a user on their PostHog person profile
Logging best practices	Learn what to log, how to structure logs, and patterns that make logs useful in production

Troubleshoot common issues

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs an MCP server, Needs Python, Needs Node.js

Security

What our scanner noticed· Low risk

Instructions that use the network

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by

PostHog

Publisher

PostHog (Official)

Source

PostHog/skills · skills/omnibus/instrument-logs · commit a5d30e7

Licence

MIT License (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-09

AutoGineer is not affiliated with or endorsed by PostHog or PostHog.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download instrument-logs.zip

From the author

AutoGineer summary

What it does

When to use it

Advantages

Usage examples

Install

Documentation by PostHog

Add PostHog log capture

Instructions

Reference files

Key principles

Files

references/go.md

Go Logs installation

On this page

Install OpenTelemetry packages

Get your project token

Configure the SDK

Use OpenTelemetry logging

Test your setup

Next steps

Requirements and compatibility

Security

Attribution and licence

Related skills

Claude API

Transformers

Open Notebook

Vision Sft

LLM Evaluation

Lora Qlora Recipes

Download ZIP