Astro OpenTelemetry Integration

An Astro integration that provides comprehensive OpenTelemetry observability for your Astro site running on Node.js. This integration automatically instruments your application with metrics, traces, and logs, supporting multiple exporters including Prometheus, OTLP (HTTP/gRPC), and console output.

Features

• Automatic HTTP instrumentation: Tracks request count, duration, and server response metrics
• Multiple exporter support: Prometheus, OTLP (HTTP/gRPC/Proto), and console exporters
• Comprehensive metrics: HTTP requests, durations, and host-level system metrics
• Distributed tracing: Full request tracing with automatic span creation
• Flexible configuration: Environment variables and programmatic configuration
• Zero-config defaults: Works out of the box with sensible defaults
• Auto-instrumentation: Automatic Node.js instrumentation for comprehensive observability

Requirements

• This integration currently requires the @astrojs/node adapter. OpenTelemetry metrics and traces require a persistent Node.js server process to aggregate and export telemetry data.
• Not supported: Serverless adapters (such as Vercel, Netlify, Cloudflare, etc.) are not compatible with this integration. In serverless environments, each request runs in isolation, so telemetry cannot be aggregated across requests.

Note: If you deploy to a serverless platform, telemetry will not be accurate or useful, as each request is handled by a separate, stateless server instance.

Future Support

Future versions of this integration will add support for:

• Deno adapter: Full OpenTelemetry support for Deno-based Astro applications
• Serverless environments: Optimized telemetry collection for serverless deployments

Installation

Automatic (Recommended)

pnpm astro add astro-opentelemetry-integration @astrojs/node
# or
npx astro add astro-opentelemetry-integration @astrojs/node
# or
yarn astro add astro-opentelemetry-integration @astrojs/node

Manual

1. Install the packages:

pnpm add astro-opentelemetry-integration @astrojs/node
# or
npm install astro-opentelemetry-integration @astrojs/node
# or
yarn add astro-opentelemetry-integration @astrojs/node

2. Add the integration to your astro.config.mjs or astro.config.mts:

import { defineConfig } from "astro/config";
import node from "@astrojs/node";
import otelIntegration from "astro-opentelemetry-integration";

export default defineConfig({
  integrations: [
    otelIntegration(),
  ],
  adapter: node({
    mode: "standalone",
  }),
});

Usage

Prerequisite

Configure the SDK to send metrics to your collector with the OTEL_EXPORTER_OTLP_ENDPOINT environment variable.

OTEL_EXPORTER_OTLP_ENDPOINT="http://your-collector.example.com:4317" node ./dist/server/entry.mjs"

or in your package.json

"scripts": {
  "dev": "OTEL_EXPORTER_OTLP_ENDPOINT=\"http://your-collector.example.com:4317\" astro dev",
}

More information https://opentelemetry.io/docs/languages/sdk-configuration/otlp-exporter/

Minimal Example

// astro.config.mjs or astro.config.mts
import { defineConfig } from "astro/config";
import node from "@astrojs/node";
import otelIntegration from "astro-opentelemetry-integration";

export default defineConfig({
  integrations: [
    otelIntegration(),
  ],
  adapter: node({
    mode: "standalone",
  }),
});

Advanced Example

import { defineConfig } from "astro/config";
import node from "@astrojs/node";
import otelIntegration from "astro-opentelemetry-integration";

export default defineConfig({
  integrations: [
    otelIntegration({
      enabled: true, // Enable/disable integration
      otel: {
        serviceName: "my-astro-app",
        serviceVersion: "1.0.0",
      },
      presets: {
        metricExporter: "prometheus", // or "http", "grpc", "proto", "none"
        traceExporter: "http", // or "grpc", "proto", "console"
        prometheusConfig: {
          host: "0.0.0.0",
          port: 9464,
          endpoint: "/metrics",
          prefix: "myapp_",
          appendTimestamp: true,
          withResourceConstantLabels: "/service/",
        },
      },
    }),
  ],
  adapter: node({
    mode: "standalone",
  }),
});

Default Configuration

When you set up the integration with an empty configuration (otelIntegration()), it uses these defaults:

{
  enabled: true,
  otel: {
    serviceName: "unknown_service",
    serviceVersion: "unknown_version"
  },
  presets: {
    metricExporter: "none",        // No metrics exported by default
    traceExporter: "console",      // Traces output to console
    prometheusConfig: {
      host: "0.0.0.0",
      port: 9464,
      endpoint: "/metrics",
      prefix: "metrics",
      appendTimestamp: true,
      withResourceConstantLabels: "/service/"
    }
  }
}

This means:

• Metrics: Disabled by default (no metrics collection)
• Traces: Enabled with console output (visible in your terminal)
• Service Info: Uses generic service name and version
• Prometheus: Ready to use but not active until metricExporter: "prometheus" is set

To enable metrics collection, you need to explicitly configure an exporter:

otelIntegration({
  presets: {
    metricExporter: "prometheus"  // Enable Prometheus metrics
  }
})

Configuration Options

otel Configuration

presets Configuration

prometheusConfig Configuration

Environment Variables

You can configure the integration using environment variables instead of or in addition to the configuration object. This integration supports both custom environment variables and standard OpenTelemetry environment variables.

Integration-Specific Variables

Standard OpenTelemetry Variables

The integration also supports standard OpenTelemetry environment variables:

General Configuration

Tracing Configuration

OTLP Endpoint Configuration

Metrics Configuration

Advanced Configuration

For more details, see the OpenTelemetry Environment Variable Specification.

Metrics Provided

The integration provides the following OpenTelemetry metrics:

Host Metrics

When using Prometheus exporter, the integration also provides comprehensive host-level metrics:

• CPU metrics: Usage, load averages, and core counts
• Memory metrics: Usage, available, and swap information
• Disk metrics: Read/write operations and space usage
• Network metrics: Interface statistics and connection counts
• Process metrics: Memory usage, file descriptors, and uptime

Exporter Types

Prometheus Exporter

Exposes metrics in Prometheus format on a dedicated HTTP server:

otelIntegration({
  presets: {
    metricExporter: "prometheus",
    prometheusConfig: {
      port: 9464,
      endpoint: "/metrics",
    },
  },
})

Access metrics at: http://localhost:9464/metrics

OTLP Exporters

Send telemetry data to OpenTelemetry collectors or backends:

HTTP Exporter

otelIntegration({
  presets: {
    metricExporter: "http",
    traceExporter: "http",
  },
})

Environment variables:

export OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"
export OTEL_EXPORTER_OTLP_ENDPOINT="http://localhost:4318"
# Or specify separate endpoints:
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT="http://localhost:4318/v1/traces"
export OTEL_EXPORTER_OTLP_METRICS_ENDPOINT="http://localhost:4318/v1/metrics"

gRPC Exporter

otelIntegration({
  presets: {
    metricExporter: "grpc",
    traceExporter: "grpc",
  },
})

Environment variables:

export OTEL_EXPORTER_OTLP_PROTOCOL="grpc"
export OTEL_EXPORTER_OTLP_ENDPOINT="http://localhost:4317"
# Or specify separate endpoints:
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT="http://localhost:4317"
export OTEL_EXPORTER_OTLP_METRICS_ENDPOINT="http://localhost:4317"

Proto Exporter

otelIntegration({
  presets: {
    metricExporter: "proto",
    traceExporter: "proto",
  },
})

Environment variables:

export OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"
export OTEL_EXPORTER_OTLP_ENDPOINT="https://api.honeycomb.io:443"

Console Exporter

Output telemetry data to the console (useful for development):

otelIntegration({
  presets: {
    traceExporter: "console",
  },
})

Tracing

The integration automatically creates traces for HTTP requests with the following features:

• Automatic span creation: Each request gets a root span
• Nested spans: Automatic instrumentation creates child spans for various operations
• Custom attributes: Request method, URL, status code, and response details
• Error tracking: Exceptions are automatically recorded in spans
• Performance timing: Request duration and TTLB measurements

Trace Attributes

Each span includes these attributes:

• http.request.method: HTTP method (GET, POST, etc.)
• http.request.url: Full request URL
• http.response.status_code: HTTP status code
• http.response.status_text: HTTP status text
• service.name: Service name from configuration
• service.version: Service version from configuration

Auto-Instrumentation

When using Prometheus metrics, the integration automatically enables comprehensive Node.js auto-instrumentation:

• HTTP/HTTPS: Request/response instrumentation
• File System: File operations monitoring
• DNS: DNS resolution tracking
• Network: Socket and connection monitoring
• Express: Express.js middleware instrumentation
• Connect: Connect middleware instrumentation

This provides deep observability into your application's behavior without additional configuration.

Development vs Production

Development Mode

In development (astro dev), the integration:

• Automatically imports the OpenTelemetry SDK
• Uses console exporter for traces by default
• Provides detailed logging for debugging

Production Mode

In production (astro build), the integration:

• Prepends the OpenTelemetry SDK to your built application
• Uses configured exporters for telemetry export
• Optimizes for performance and minimal overhead

Contributing

This project is a monorepo:

• playgrounds/: Example Astro apps for testing the integration
• packages/astro-opentelemetry-integration/: The integration source code

Setup

pnpm install --frozen-lockfile
pnpm otel-integration:dev
pnpm playground:dev

• Edit files in packages/astro-opentelemetry-integration/
• The playground will reload on changes

License

MIT Licensed. Made with ❤️ by Danilo Velasquez.

Acknowledgements

• Built with astro-integration-template
• Uses OpenTelemetry for comprehensive observability
• Inspired by the OpenTelemetry Node.js SDK