Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

6.4 KB
Raw Blame
import { OnboardingComponentsContext, createInstallation } from 'scenes/onboarding/shared/OnboardingDocsContentWrapper'

import { StepDefinition } from '../steps'

export const getGoSteps = (ctx: OnboardingComponentsContext): StepDefinition[] => {
    const { CodeBlock, Markdown, dedent } = ctx

    return [
        {
            title: 'Install dependencies',
            badge: 'required',
            content: (
                <>
                    <Markdown>
                        PostHog logs uses the standard OpenTelemetry SDK. No PostHog-specific packages required.
                    </Markdown>
                    <CodeBlock
                        blocks={[
                            {
                                language: 'bash',
                                file: 'go',
                                code: dedent`
                                    go get go.opentelemetry.io/otel
                                    go get go.opentelemetry.io/otel/sdk
                                    go get go.opentelemetry.io/otel/log
                                    go get go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp
                                    go get go.opentelemetry.io/otel/sdk/log
                                `,
                            },
                        ]}
                    />
                </>
            ),
        },
        {
            title: 'Configure the OTLP log exporter',
            badge: 'required',
            content: (
                <>
                    <Markdown>Configure the OpenTelemetry log exporter to send logs to PostHog:</Markdown>
                    <CodeBlock
                        blocks={[
                            {
                                language: 'go',
                                file: 'instrumentation.go',
                                code: dedent`
                                    package main

                                    import (
                                        "context"

                                        "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp"
                                        "go.opentelemetry.io/otel/log/global"
                                        sdklog "go.opentelemetry.io/otel/sdk/log"
                                        "go.opentelemetry.io/otel/sdk/resource"
                                        semconv "go.opentelemetry.io/otel/semconv/v1.26.0"
                                    )

                                    func setupLogging(ctx context.Context) (*sdklog.LoggerProvider, error) {
                                        exporter, err := otlploghttp.New(ctx,
                                            otlploghttp.WithEndpointURL("<ph_client_api_host>/i/v1/logs"),
                                            otlploghttp.WithHeaders(map[string]string{
                                                "Authorization": "Bearer <ph_project_token>",
                                            }),
                                        )
                                        if err != nil {
                                            return nil, err
                                        }

                                        res := resource.NewWithAttributes(
                                            semconv.SchemaURL,
                                            semconv.ServiceName("my-app"),
                                        )

                                        provider := sdklog.NewLoggerProvider(
                                            sdklog.WithProcessor(sdklog.NewBatchProcessor(exporter)),
                                            sdklog.WithResource(res),
                                        )

                                        global.SetLoggerProvider(provider)
                                        return provider, nil
                                    }
                                `,
                            },
                        ]}
                    />
                </>
            ),
        },
        {
            title: 'Send a log',
            badge: 'required',
            content: (
                <>
                    <Markdown>Use the OpenTelemetry logger to emit logs from your application:</Markdown>
                    <CodeBlock
                        blocks={[
                            {
                                language: 'go',
                                file: 'main.go',
                                code: dedent`
                                    package main

                                    import (
                                        "context"
                                        "log"

                                        "go.opentelemetry.io/otel/attribute"
                                        otellog "go.opentelemetry.io/otel/log"
                                        "go.opentelemetry.io/otel/log/global"
                                    )

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

                                        provider, err := setupLogging(ctx)
                                        if err != nil {
                                            log.Fatal(err)
                                        }
                                        defer provider.Shutdown(ctx)

                                        logger := global.Logger("my-app")

                                        var record otellog.Record
                                        record.SetSeverity(otellog.SeverityInfo)
                                        record.SetBody(attribute.StringValue("Application started"))
                                        record.AddAttributes(
                                            attribute.Int64("server.port", 8080),
                                        )
                                        logger.Emit(ctx, record)
                                    }
                                `,
                            },
                        ]}
                    />
                    <Markdown>
                        Logs appear in PostHog within a few seconds. Use the [Logs page](https://app.posthog.com/logs)
                        to search and filter by service name, severity, or any attribute you attach.
                    </Markdown>
                </>
            ),
        },
    ]
}

export const GoInstallation = createInstallation(getGoSteps)