Skip to main content

5-Minute Quick Start

Get Scout up and running in less than 5 minutes. This guide will help you deploy an OpenTelemetry collector, configure it to send data to Scout, and start collecting telemetry from your applications and infrastructure.

Time to Complete​

5-10 minutes

What You'll Accomplish​

  • Deploy an OpenTelemetry collector in your environment
  • Configure the Scout exporter to send data to the Scout backend
  • Start collecting telemetry data from your applications and components
  • Verify data is flowing to Scout

Prerequisites​

  • Access to your Scout account and API credentials
  • Docker, Kubernetes, or Linux environment for collector deployment
  • Basic familiarity with YAML configuration files

Step 1: Deploy the OpenTelemetry Collector​

Deploy the OpenTelemetry collector in your environment based on your infrastructure. Choose from Docker, Kubernetes, Linux, or AWS ECS options.

Docker Compose​

Perfect for local development and testing environments. Download the configuration and deploy using Docker Compose.

See the Docker Compose Setup Guide for detailed instructions.

Kubernetes​

Ideal for production deployments on EKS, GKE, or AKS. Install using Helm charts for simplified deployment and management.

See the Kubernetes Helm Setup Guide for detailed instructions.

Linux​

For direct installation on Linux servers or virtual machines. Download and install the collector binary with automated setup scripts.

See the Linux Setup Guide for detailed instructions.

AWS ECS​

For containerized applications running on Amazon ECS. Deploy as a sidecar or daemon on Fargate and EC2 launch types.

See the ECS Setup Guide for detailed instructions on Fargate and EC2 deployments.

Step 2: Configure the OpenTelemetry Collector​

Once your collector is deployed, configure it to receive telemetry and send data to Scout. Here's a complete configuration example:

# Extensions provide additional capabilities to the collector
extensions:
  oauth2client:
    client_id: __YOUR_CLIENT_ID__
    client_secret: __YOUR_CLIENT_SECRET__
    endpoint_params:
      audience: b14collector
    token_url: https://id.b14.dev/realms/__YOUR_TENANT__/protocol/openid-connect/token
    tls:
      insecure_skip_verify: true

# Receivers define how telemetry data enters the collector
receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318

# Processors modify or enrich telemetry data
processors:
  resource:
    attributes:
      - key: deployment.environment
        value: production
        action: upsert
      - key: service.namespace
        value: my-namespace
        action: upsert

# Exporters define where telemetry data is sent
exporters:
  otlp/scout:
    endpoint: https://api.scout.base14.io:4317
    auth:
      authenticator: oauth2client
    tls:
      insecure_skip_verify: true

# Service section ties everything together
service:
  extensions: [oauth2client]
  pipelines:
    traces:
      receivers: [otlp]
      processors: [resource]
      exporters: [otlp/scout]
    metrics:
      receivers: [otlp]
      processors: [resource]
      exporters: [otlp/scout]
    logs:
      receivers: [otlp]
      processors: [resource]
      exporters: [otlp/scout]

Configuration Breakdown​

  • OAuth Extension: Handles authentication with Scout using OAuth2 client credentials flow
  • OTLP Receiver: Accepts telemetry data on ports 4317 (gRPC) and 4318 (HTTP)
  • Resource Processor: Adds environment metadata to all telemetry signals
  • Scout Exporter: Sends data to Scout backend using authenticated OTLP

Quick Setup Steps​

  1. Get your OAuth credentials (client ID and secret) from the Scout dashboard
  2. Update the configuration with your credentials
  3. Save the configuration to otel-collector-config.yaml
  4. Restart the collector to apply changes

See the Scout Exporter Configuration Guide for complete details and authentication options.

Step 3: Start Collecting Data​

Now that your collector is running, start sending telemetry data:

From Applications​

Instrument your applications to send traces, metrics, and logs:

From Components​

Collect metrics and logs from your infrastructure components:

From AWS Infrastructure​

Monitor your AWS resources automatically:

Verification​

  1. Log in to your Scout dashboard
  2. Navigate to the Traces, Metrics, or Logs section
  3. Verify that data is appearing from your collector
  4. Explore the service map to see your application topology

What's Next?​

Now that you have Scout running, explore these topics:

Troubleshooting​

If you're not seeing data in Scout:

  1. Check collector logs: Verify the collector is running without errors
  2. Verify connectivity: Ensure your collector can reach the Scout backend
  3. Check credentials: Confirm your API token is valid and properly configured
  4. Review configuration: Validate your YAML configuration syntax
Was this page helpful?