➕ OpenTelemetry Demo with Elastic Observability

Run the Astronomy Shop, a microservice demo that generates traffic automatically, and explore its traces, metrics, and logs in Elastic Observability.

This fork uses Elastic Distributions of OpenTelemetry (EDOT) for selected language agents and Elastic Agent for OpenTelemetry collection. Upstream Collector modes can also send telemetry to Elastic.

Explore without installing: Open the hosted OpenTelemetry demo in Elastic Observability to browse the Astronomy Shop's services and traces without deploying the demo yourself.

Choose your setup

Goal	Start command	Backend
Docker with Elastic Agent	./demo.sh docker	Elastic Cloud
Everything on your machine	./demo.sh docker self-hosted	Local Elastic Stack via start-local
Docker with upstream Collector	./demo.sh docker upstream	Elastic Cloud
Kubernetes with Elastic Agent	./demo.sh k8s	Elastic Cloud
Kubernetes with upstream OpenTelemetry	./demo.sh k8s upstream	Elastic Cloud

For your first run, follow Docker. To run without a Cloud account, choose local Elastic Stack.

• Get the demo
• Elastic Cloud credentials
• Docker
• Kubernetes
• Verify telemetry and explore
• Troubleshooting
• Clean up
• Advanced configuration
• How this fork differs

Get the demo

Install Git, then clone the Elastic fork:

git clone https://github.com/elastic/opentelemetry-demo.git
cd opentelemetry-demo

Run the commands below from this repository's root directory.

Elastic Cloud credentials

Complete this section for any Elastic Cloud setup. Skip it for start-local.

1. Use an existing Elastic Cloud Observability deployment or create one at Elastic Cloud. Choose an Observability project for Serverless, or an Observability deployment for Hosted.
2. In Elastic Observability, open Add data and select the OpenTelemetry application onboarding instructions. See the Elastic OpenTelemetry quickstarts for your deployment type.
3. Copy the OTEL_EXPORTER_OTLP_ENDPOINT value and create an API key using the onboarding instructions. Keep both available for the startup prompts.

Use the OTLP ingestion endpoint provided by onboarding. The collector is configured to export OTLP over HTTP; an Elasticsearch REST URL or Kibana URL is not a substitute for that endpoint.

The startup script prompts for the endpoint and API key unless saved values already exist in .env.override. The API key is hidden while you type it. Docker and Kubernetes Elastic Agent setups save these values in .env.override:

ELASTIC_OTLP_ENDPOINT="<your-OTLP-endpoint>"
ELASTIC_OTLP_API_KEY="<your-API-key>"

To change credentials, edit these values before running the script again. Keep API keys out of commits. Kubernetes setup also creates a Secret in the cluster.

Docker

Docker prerequisites

• Install Docker and Docker Compose v2.
• Start Docker and confirm docker info and docker compose version work.
• Review the upstream Docker deployment requirements for resource requirements. Running a local Elastic Stack requires additional resources; see start-local.
• Keep port 8080 available for the shop. start-local also uses ports 9200 and 5601.

Docker with Elastic Agent

1. Prepare your Elastic Cloud credentials.

2. Start the demo and enter the endpoint and API key when prompted:

   ./demo.sh docker

   The first run builds images and can take several minutes.

3. Open the shop at http://localhost:8080 and your Cloud deployment's Observability UI. Continue with Verify telemetry and explore.

To remove the demo later, use ./demo.sh destroy docker. See Clean up for what this deletes.

Docker Elastic Agent architecture

---
title: Docker with Elastic Agent
---
%%{init: {"theme": "base", "flowchart": {"htmlLabels": true, "titleTopMargin": 24}, "markdownAutoWrap": false, "themeVariables": {"darkMode": true, "fontSize": "16px", "background": "#07101F", "primaryColor": "#0A2342", "primaryTextColor": "#E3E8F2", "primaryBorderColor": "#61A2FF", "lineColor": "#61A2FF", "textColor": "#E3E8F2", "edgeLabelBackground": "#111C2C", "clusterBkg": "#0B1628", "clusterBorder": "#485975"}}}%%
flowchart LR
    subgraph ARCH[" "]
        direction LR
        subgraph DEMO["Demo Docker network"]
            APP["<b>Demo services</b><br/><br/><i>EDOT + OpenTelemetry</i><br/>Traces, metrics and logs"]
            COLLECTOR["<b>Elastic Agent</b><br/><i>Demo collector</i><br/><br/>Process and export<br/>telemetry"]
            APP -->|OTLP| COLLECTOR
        end
        HOST["<b>Infrastructure telemetry</b><br/><br/>Host metrics<br/>Frontend HTTP check"]
        HOST -->|Collect| COLLECTOR
        CLOUD["<b>Elastic Cloud</b><br/><i>OTLP ingestion endpoint</i><br/><br/>Storage in Elasticsearch<br/>Explore in Kibana"]
        COLLECTOR -->|"OTLP/HTTP export<br/>API key authentication"| CLOUD
    end

    class APP application
    class COLLECTOR agent
    class HOST source
    class CLOUD backend
    style DEMO fill:#0B1628,stroke:#485975,color:#E3E8F2
    classDef application fill:#0A2342,stroke:#61A2FF,color:#E3E8F2,font-size:16px
    classDef agent fill:#03282B,stroke:#16C5C0,color:#E3E8F2,font-size:16px
    classDef source fill:#351725,stroke:#EE72A6,color:#E3E8F2,font-size:14px
    classDef backend fill:#111C2C,stroke:#16C5C0,color:#E3E8F2,font-size:16px

    style ARCH fill:#07101F,stroke:#2B394F,color:#E3E8F2
    linkStyle default stroke:#61A2FF,stroke-width:2px

Loading

Local Elastic Stack with start-local

start-local runs Elasticsearch, Kibana, and Elastic Agent on your machine for local testing.

1. Start the Elastic Stack with OpenTelemetry collection enabled:

   curl -fsSL https://elastic.co/start-local | sh -s -- --edot

   Keep the Kibana login credentials printed by the installer. The generated files are placed in elastic-start-local/.

2. Start the demo:

   ./demo.sh docker self-hosted

   This mode forwards telemetry through the start-local Elastic Agent and does not prompt for Cloud credentials.

3. Open the shop at http://localhost:8080 and Kibana at http://localhost:5601. Continue with Verify telemetry and explore.

The telemetry path is: demo services → demo Elastic Agent → start-local Elastic Agent → Elasticsearch. See Clean up to stop or remove both stacks.

Local Elastic Stack architecture

---
title: Local Elastic Stack with start-local
---
%%{init: {"theme": "base", "flowchart": {"htmlLabels": true, "titleTopMargin": 24}, "markdownAutoWrap": false, "themeVariables": {"darkMode": true, "fontSize": "16px", "background": "#07101F", "primaryColor": "#0A2342", "primaryTextColor": "#E3E8F2", "primaryBorderColor": "#61A2FF", "lineColor": "#61A2FF", "textColor": "#E3E8F2", "edgeLabelBackground": "#111C2C", "clusterBkg": "#0B1628", "clusterBorder": "#485975"}}}%%
flowchart LR
    subgraph ARCH[" "]
        direction LR
        subgraph DEMO["Demo Docker network"]
            APP["<b>Demo services</b><br/><br/><i>EDOT + OpenTelemetry</i><br/>Traces, metrics and logs"]
            COLLECTOR["<b>Elastic Agent</b><br/><i>Demo collector</i><br/><br/>Process and export<br/>telemetry"]
            APP -->|OTLP| COLLECTOR
        end
        HOST["<b>Infrastructure telemetry</b><br/><br/>Host metrics<br/>Frontend HTTP check"]
        HOST -->|Collect| COLLECTOR
        subgraph LOCAL["elastic-start-local_default network"]
            LOCAL_AGENT["<b>Elastic Agent</b><br/><i>start-local collector</i><br/><br/>Process and export<br/>telemetry"]
            ES["<b>Elasticsearch</b><br/><br/>Store telemetry"]
            KIBANA["<b>Kibana</b><br/><br/>Explore local telemetry"]
            LOCAL_AGENT -->|Export| ES
            ES -->|"Telemetry data"| KIBANA
        end
        COLLECTOR -->|"OTLP/HTTP · port 4318"| LOCAL_AGENT
    end

    class APP application
    class HOST source
    class COLLECTOR,LOCAL_AGENT agent
    class ES,KIBANA backend
    style DEMO fill:#0B1628,stroke:#485975,color:#E3E8F2
    style LOCAL fill:#111C2C,stroke:#485975,color:#B4C1D5
    classDef application fill:#0A2342,stroke:#61A2FF,color:#E3E8F2,font-size:16px
    classDef agent fill:#03282B,stroke:#16C5C0,color:#E3E8F2,font-size:16px
    classDef source fill:#351725,stroke:#EE72A6,color:#E3E8F2,font-size:14px
    classDef backend fill:#111C2C,stroke:#16C5C0,color:#E3E8F2,font-size:16px

    style ARCH fill:#07101F,stroke:#2B394F,color:#E3E8F2
    linkStyle default stroke:#61A2FF,stroke-width:2px

Loading

The demo collector joins both Docker networks to reach the start-local collector. This local forwarding path does not require Elastic Cloud credentials.

Contributors can run the Elastic integration tests locally before pushing changes.

Docker with upstream Collector

Prepare your Elastic Cloud credentials, then run:

./demo.sh docker upstream

This mode uses the upstream OpenTelemetry Collector Contrib distribution and the default service Dockerfiles. Cart and Accounting retain their upstream OpenTelemetry instrumentation. The mode ignores .env.override for Compose configuration, although the script can reuse credentials from that file. Telemetry is exported to Elastic over OTLP HTTP.

Open http://localhost:8080, then verify telemetry. Some Elastic dashboards may show less data than with Elastic Agent. Remove the demo with ./demo.sh destroy docker when finished.

Docker upstream architecture

---
title: Docker with upstream Collector
---
%%{init: {"theme": "base", "flowchart": {"htmlLabels": true, "titleTopMargin": 24}, "markdownAutoWrap": false, "themeVariables": {"darkMode": true, "fontSize": "16px", "background": "#07101F", "primaryColor": "#0A2342", "primaryTextColor": "#E3E8F2", "primaryBorderColor": "#61A2FF", "lineColor": "#61A2FF", "textColor": "#E3E8F2", "edgeLabelBackground": "#111C2C", "clusterBkg": "#0B1628", "clusterBorder": "#485975"}}}%%
flowchart LR
    subgraph ARCH[" "]
        direction LR
        subgraph DEMO["Demo Docker network"]
            APP["<b>Demo services</b><br/><br/><i>Upstream OpenTelemetry</i><br/>Traces, metrics and logs"]
            COLLECTOR["<b>OpenTelemetry Collector</b><br/><i>Contrib distribution</i><br/><br/>Process and export<br/>telemetry"]
            APP -->|OTLP| COLLECTOR
        end
        HOST["<b>Infrastructure telemetry</b><br/><br/>Host and container metrics<br/>Service metrics"]
        HOST -->|Collect| COLLECTOR
        CLOUD["<b>Elastic Cloud</b><br/><i>OTLP ingestion endpoint</i><br/><br/>Storage in Elasticsearch<br/>Explore in Kibana"]
        COLLECTOR -->|"OTLP/HTTP export<br/>API key authentication"| CLOUD
    end

    class APP application
    class COLLECTOR agent
    class HOST source
    class CLOUD backend
    style DEMO fill:#0B1628,stroke:#485975,color:#E3E8F2
    classDef application fill:#0A2342,stroke:#61A2FF,color:#E3E8F2,font-size:16px
    classDef agent fill:#03282B,stroke:#16C5C0,color:#E3E8F2,font-size:16px
    classDef source fill:#351725,stroke:#EE72A6,color:#E3E8F2,font-size:14px
    classDef backend fill:#111C2C,stroke:#16C5C0,color:#E3E8F2,font-size:16px

    style ARCH fill:#07101F,stroke:#2B394F,color:#E3E8F2
    linkStyle default stroke:#61A2FF,stroke-width:2px

Loading

Kubernetes

Kubernetes prerequisites

• A running Kubernetes cluster with enough resources for the demo; review the upstream Kubernetes deployment requirements.
• kubectl configured to access the cluster, and Helm installed.
• Elastic Cloud credentials.

Check the cluster you will deploy to:

kubectl config current-context
kubectl get nodes
helm version

The demo is installed in your current Kubernetes namespace. The Elastic Agent stack is installed in opentelemetry-operator-system.

Kubernetes with Elastic Agent

./demo.sh k8s

Enter the endpoint and API key when prompted. The script installs the Elastic Agent stack and the demo using the chart versions pinned in demo.sh.

Kubernetes with upstream OpenTelemetry

./demo.sh k8s upstream

This installs the demo with upstream instrumentation and its bundled collector, configured to export telemetry to Elastic. The credential Secret is created in your current namespace. Some Elastic dashboards may show less data than in Elastic Agent mode.

Kubernetes upstream architecture

---
title: Kubernetes with upstream OpenTelemetry
---
%%{init: {"theme": "base", "flowchart": {"htmlLabels": true, "titleTopMargin": 24}, "markdownAutoWrap": false, "themeVariables": {"darkMode": true, "fontSize": "16px", "background": "#07101F", "primaryColor": "#0A2342", "primaryTextColor": "#E3E8F2", "primaryBorderColor": "#61A2FF", "lineColor": "#61A2FF", "textColor": "#E3E8F2", "edgeLabelBackground": "#111C2C", "clusterBkg": "#0B1628", "clusterBorder": "#485975"}}}%%
flowchart LR
    subgraph ARCH[" "]
        direction LR
        subgraph K8S["Kubernetes cluster · demo namespace"]
            APP["<b>Demo services</b><br/><br/><i>Upstream OpenTelemetry</i><br/>Traces, metrics and logs"]
            COLLECTOR["<b>OpenTelemetry Collector</b><br/><i>Bundled with demo chart</i><br/><br/>Process and export<br/>telemetry"]
            SECRET["<b>Kubernetes Secret</b><br/><br/>elastic-secret-otel<br/>Endpoint and API key"]
            APP -->|OTLP| COLLECTOR
            SECRET -.->|Configure| COLLECTOR
        end
        CLOUD["<b>Elastic Cloud</b><br/><i>OTLP ingestion endpoint</i><br/><br/>Storage in Elasticsearch<br/>Explore in Kibana"]
        COLLECTOR -->|"OTLP/HTTP export<br/>API key authentication"| CLOUD
    end

    class APP application
    class COLLECTOR agent
    class SECRET source
    class CLOUD backend
    style K8S fill:#0B1628,stroke:#485975,color:#E3E8F2
    classDef application fill:#0A2342,stroke:#61A2FF,color:#E3E8F2,font-size:16px
    classDef agent fill:#03282B,stroke:#16C5C0,color:#E3E8F2,font-size:16px
    classDef source fill:#351725,stroke:#EE72A6,color:#E3E8F2,font-size:14px
    classDef backend fill:#111C2C,stroke:#16C5C0,color:#E3E8F2,font-size:16px

    style ARCH fill:#07101F,stroke:#2B394F,color:#E3E8F2
    linkStyle default stroke:#61A2FF,stroke-width:2px

Loading

Open the shop

Check the demo pods and find the frontend proxy Service:

kubectl get pods -l app.kubernetes.io/instance=my-otel-demo
kubectl get services -l app.kubernetes.io/instance=my-otel-demo

Copy the Service name containing frontend-proxy and substitute it below:

kubectl port-forward service/<frontend-proxy-service-name> 8080:8080

Keep the command running while you visit http://localhost:8080. If you installed in another namespace, add -n <namespace> to the commands. Continue with Verify telemetry and explore. See Clean up for removal instructions.

Kubernetes Elastic Agent architecture

---
title: OpenTelemetry Demo with Elastic Observability
---
%%{init: {"theme": "base", "flowchart": {"htmlLabels": true, "titleTopMargin": 24}, "markdownAutoWrap": false, "themeVariables": {"darkMode": true, "fontSize": "16px", "background": "#07101F", "primaryColor": "#0A2342", "primaryTextColor": "#E3E8F2", "primaryBorderColor": "#61A2FF", "lineColor": "#61A2FF", "textColor": "#E3E8F2", "edgeLabelBackground": "#111C2C", "clusterBkg": "#0B1628", "clusterBorder": "#485975"}}}%%
flowchart LR
    subgraph ARCH[" "]
        direction LR
        subgraph K8S["Kubernetes cluster"]
            direction LR

            APP["<b>Demo services</b><br/><br/><i>OpenTelemetry SDKs</i><br/>Ad · Payment · Shipping · …"]
            NODE["<b>Node telemetry</b><br/><br/>Container logs<br/>Host and kubelet metrics"]

            subgraph AGENTS["opentelemetry-operator-system"]
                direction LR

                DAEMON["<b>Node Elastic Agent</b><br/><i>DaemonSet · one per node</i><br/><br/>Collect and forward<br/>app and node telemetry"]

                CLUSTER["<b>Cluster Elastic Agent</b><br/><i>Deployment</i><br/><br/>Collect and forward<br/>cluster metrics and events"]

                GATEWAY["<b>Gateway Elastic Agent</b><br/><i>Deployment</i><br/><br/>Process and export<br/>telemetry"]
            end

            APP -->|"OTLP: traces, metrics, logs"| DAEMON
            NODE -->|Collect| DAEMON
            DAEMON -->|OTLP| GATEWAY
            CLUSTER -->|OTLP| GATEWAY
        end

        CLOUD["<b>Elastic Cloud</b><br/><i>OTLP ingestion endpoint</i><br/><br/>Storage in Elasticsearch<br/>Explore in Kibana"]
        GATEWAY -->|"OTLP export<br/>API key authentication"| CLOUD

    end

    classDef application fill:#0A2342,stroke:#61A2FF,color:#E3E8F2,font-size:16px
    classDef node fill:#03282B,stroke:#16C5C0,color:#E3E8F2,font-size:16px
    classDef cluster fill:#351725,stroke:#EE72A6,color:#E3E8F2,font-size:16px
    classDef cloud fill:#111C2C,stroke:#16C5C0,color:#E3E8F2,font-size:16px

    classDef source font-size:14px

    class APP,DAEMON application
    class APP,NODE source
    class NODE,GATEWAY node
    class CLUSTER cluster
    class CLOUD cloud

    style ARCH fill:#07101F,stroke:#2B394F,color:#E3E8F2
    style K8S fill:#0B1628,stroke:#485975,color:#E3E8F2
    style AGENTS fill:#111C2C,stroke:#485975,color:#B4C1D5
    linkStyle default stroke:#61A2FF,stroke-width:2px

Loading

Demo services send telemetry to the per-node Elastic Agent, which also collects container logs and host and kubelet metrics. A separate Elastic Agent gathers cluster metrics and Kubernetes events. Both forward telemetry through the gateway Elastic Agent to the Elastic Cloud OTLP endpoint.

The diagram highlights each instance's role. Configuration details are summarized below:

Elastic Agent role	Configuration details
Node	OTLP receiver; filelog, hostmetrics, and kubeletstats receivers; Kubernetes metadata, resource detection, and batching
Cluster	Cluster metrics and Kubernetes events receivers; Kubernetes metadata enrichment
Gateway	OTLP receiver; span sanitization; OTLP exporters; API key from a Kubernetes Secret

Verify telemetry and explore

The load generator automatically browses products, adds items to carts, and checks out. You can also browse the shop and complete a checkout with fake payment details to generate your own requests.

1. Open your Elastic Observability UI (Cloud), or http://localhost:5601 (start-local).
2. Select a recent time range, such as the last 15 minutes, and open the APM Services view. Allow a few minutes for initial telemetry to appear and refresh the view.
3. Find frontend or checkout, open its transactions, and inspect a trace sample. A checkout trace should include calls to other shop services such as cart, payment, or shipping.
4. Open the service map to explore dependencies. If services or traces are missing, follow Troubleshooting.

Use these views to explore further. Navigation names and available dashboards can vary by Elastic deployment and version.

View	What to explore
APM services	Latency, throughput, errors, and transaction traces
Service map	Dependencies between the shop's services
Logs / Discover	Service logs and correlation with trace IDs
Hosts	CPU, memory, disk, and network metrics collected by Elastic Agent
Infrastructure	Available container, pod, and node telemetry
Dashboards	[System] OTel Host Metrics and, for Kubernetes, [Kubernetes] Cluster Overview, when installed

Example screenshots

These screenshots show the hosted demo in Elastic's dark theme. Its live data and enabled features may differ from your own deployment. Click an image to view it at full size.

Service map

Explore service dependencies and identify services with active alerts or violated SLOs. Explore the live service map.

Checkout trace

Follow a checkout request across services. The waterfall shows time spent in each operation and a payment error propagating back through checkout and the frontend. Explore live checkout traces.

Service inventory

Compare latency, throughput, and failed transaction rates to decide which service to investigate first. Explore the live service inventory.

Logs

Inspect the load generator's shopping activity alongside service and Kubernetes metadata. Explore live service logs.

Troubleshooting

Symptom	What to check
Docker cannot start containers	Run docker info; start Docker if needed. Check available memory against the deployment requirements.
Port already in use	Free port 8080 for the shop; for start-local, also check 9200 and 5601. Stop another demo before switching modes.
No services or traces in Elastic	Check the UI time range, generate a checkout, and inspect collector logs for export errors.
Collector reports HTTP 401 or 403	Check the API key and its ingestion permissions. Update .env.override and rerun the selected startup command.
Collector reports connection or endpoint errors	Use the OTLP HTTP endpoint from onboarding and check connectivity from the collector's environment.
Self-hosted startup reports a missing network	Run start-local with --edot first; the demo expects the elastic-start-local_default Docker network.
Kubernetes pods stay Pending or restart	Inspect pod events and logs for resource, image-pull, or configuration errors.

For Docker, inspect container status and collector logs:

docker ps -a --filter name=otel-collector
docker logs --tail 100 otel-collector

For Kubernetes, inspect the demo and collector pods:

kubectl get pods -l app.kubernetes.io/instance=my-otel-demo
kubectl get pods -n opentelemetry-operator-system
kubectl describe pod <pod-name> -n <namespace>
kubectl logs <collector-pod-name> -n <namespace> --tail=100

For upstream mode, find the collector in the demo namespace. For start-local installation problems, see the start-local troubleshooting guidance.

Clean up

Run cleanup from the repository root.

Docker demo

./demo.sh destroy docker

This removes the demo containers and its Compose volumes through make stop. It does not remove the separately installed start-local backend.

Local Elastic Stack

After removing the demo, stop Elasticsearch, Kibana, and the local collector:

./elastic-start-local/stop.sh

To uninstall the local Elastic Stack and permanently delete its data:

./elastic-start-local/uninstall.sh

Kubernetes demo

For Elastic Agent mode:

./demo.sh destroy k8s

Run this in the namespace used for installation. It removes the demo release, the collector stack, its credential Secret, and the opentelemetry-operator-system namespace. Use this cleanup only when that namespace is dedicated to this demo.

For upstream mode, remove the demo release and its Secret in the demo namespace:

helm uninstall my-otel-demo
kubectl delete secret elastic-secret-otel

These commands do not delete telemetry already stored in Elastic Cloud.

Advanced configuration

Manual Docker configuration

Prepare your Elastic Cloud credentials, then edit .env.override with your endpoint and API key. Keep the Elastic image, Dockerfile, and collector overrides provided by this fork.

Start the demo with the same Compose layers used by the automated Elastic Agent setup:

docker compose --env-file .env --env-file .env.override \
  -f compose.yaml -f compose.full.yaml \
  -f compose.extras.yaml -f docker-compose.elastic.yml \
  up --build --force-recreate --remove-orphans --detach

Manual Kubernetes configuration

Follow the Elastic OpenTelemetry Kubernetes quickstart for your Elastic deployment type. The demo's Helm values expect the collector at opentelemetry-kube-stack-daemon-collector.opentelemetry-operator-system.svc.cluster.local. If your collector uses a different name or namespace, update default.envOverrides in those values before installation.

Use the demo chart version pinned by DEMO_HELM_VERSION in demo.sh:

helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts
helm repo update open-telemetry
helm upgrade --install my-otel-demo open-telemetry/opentelemetry-demo \
  --version <DEMO_HELM_VERSION> -f kubernetes/elastic-helm/demo.yml

Enable Kubernetes browser traffic

Browser traffic generation is disabled in the Elastic Agent demo values. To enable it:

1. Set LOCUST_BROWSER_TRAFFIC_ENABLED to "true" in demo.yml.

2. Configure CORS on the daemon collector's OTLP HTTP receiver to allow the simulated browser's origin:

   receivers:
     otlp:
       protocols:
         http:
           cors:
             allowed_origins:
               - http://frontend-proxy:8080

3. Apply the collector configuration through your Helm values and upgrade the demo release with the updated demo.yml.

Test a custom collector component

Build a collector image following the Elastic collector components instructions. Define the component in the collector configuration and include it in the relevant service.pipelines entry.

For Docker, set COLLECTOR_CONTRIB_IMAGE and OTEL_COLLECTOR_CONFIG in .env.override, then use manual Docker setup. The automated Cloud Elastic Agent command resets those two values.

For Kubernetes, customize the collector image and configuration in kube-stack-overrides.yml using the values supported by the pinned kube-stack chart, then upgrade the collector release. See demo.sh for the release, chart version, and values files used by automated setup.

Optional agentic services

The chatbot, agent, and MCP services demonstrate an AI-assisted shopping workflow. See the agent README and chatbot README for startup instructions and how to configure an OpenAI-compatible LLM.

How this fork differs

This fork currently includes the following EDOT instrumentation:

Language	Services	Implementation
Java	Ad, Fraud Detection, Kafka	EDOT Java agent in the Elastic Docker setup
.NET	Cart, Accounting	EDOT .NET zero-code instrumentation in each service's Dockerfile.elastic
Node.js	Payment	EDOT Node.js installed in Dockerfile.elastic
PHP	Quote	EDOT PHP in Dockerfile.elastic

Cart and Accounting keep their upstream .NET source for the standard Docker build. Their Elastic Dockerfiles apply the Cart and Accounting build patches before restoring packages. If an upstream change makes a patch inapplicable, the Elastic image build stops so the change can be reviewed.

See each service's Dockerfile.elastic and docker-compose.elastic.yml for configuration. Elastic Agent includes the OpenTelemetry Collector used by this fork. The Docker upstream mode uses Collector Contrib and the default service Dockerfiles. The Kubernetes upstream mode uses the upstream demo chart and Collector Contrib distribution.

For general application documentation, see the upstream demo documentation. To contribute, read CONTRIBUTING.md.