# Copyright The OpenTelemetry Authors
# SPDX-License-Identifier: Apache-2.0

# Core/minimal demo services. Run alone for the smallest footprint.
# Layer additional files on top with -f:
#   Full demo (adds Kafka, accounting, fraud-detection):
#     docker compose -f compose.yaml -f compose.full.yaml up
#   With observability stack (Jaeger, Prometheus, OpenSearch, Grafana, OpAMP):
#     docker compose -f compose.yaml -f compose.observability.yaml up
#   Default (full + observability):
#     docker compose -f compose.yaml -f compose.full.yaml -f compose.observability.yaml up
#   With extras (vendor customizations, additional components):
#     docker compose -f compose.yaml [-f compose.full.yaml] -f compose.observability.yaml -f compose.extras.yaml up

x-default-logging: &logging
  driver: "json-file"
  options:
    max-size: "5m"
    max-file: "2"

networks:
  default:
    name: opentelemetry-demo
    driver: bridge

services:
  # ******************
  # Core Demo Services
  # ******************

  # AdService
  ad:
    image: ${IMAGE_NAME}:${DEMO_VERSION}-ad
    container_name: ad
    build:
      context: ./
      dockerfile: ${AD_DOCKERFILE}
      cache_from:
        - ${IMAGE_NAME}:${IMAGE_VERSION}-ad
      args:
        OTEL_JAVA_AGENT_VERSION: ${OTEL_JAVA_AGENT_VERSION}
    deploy:
      resources:
        limits:
          memory: 300M
    restart: unless-stopped
    ports:
      - "${AD_PORT}"
      - "${AD_PROMETHEUS_PORT}"
    environment:
      - AD_PORT
      - AD_PROMETHEUS_PORT
      - FLAGD_HOST
      - FLAGD_PORT
      - OTEL_EXPORTER_OTLP_ENDPOINT=http://${OTEL_COLLECTOR_HOST}:${OTEL_COLLECTOR_PORT_HTTP}
      - OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE
      - OTEL_RESOURCE_ATTRIBUTES=${OTEL_RESOURCE_ATTRIBUTES},service.criticality=medium
      - OTEL_LOGS_EXPORTER=otlp
      - OTEL_SERVICE_NAME=ad
      # Opt in to experimental OTel SDK self-observability metrics (otel.sdk.*)
      # feeding the "self-observability" Grafana dashboard.
      - OTEL_EXPERIMENTAL_SDK_TELEMETRY_VERSION=latest
      # Workaround on OSX for https://bugs.openjdk.org/browse/JDK-8345296
      - _JAVA_OPTIONS
    healthcheck:
      test: ["CMD-SHELL", "bash -c 'echo > /dev/tcp/localhost/${AD_PORT}'"]
      start_period: 20s
      interval: 5s
      timeout: 5s
      retries: 20
    depends_on:
      otel-collector:
        condition: service_started
      flagd:
        condition: service_started
    logging: *logging

  # Cart service
  cart:
    image: ${IMAGE_NAME}:${DEMO_VERSION}-cart
    container_name: cart
    build:
      context: ./
      dockerfile: ${CART_DOCKERFILE}
      cache_from:
        - ${IMAGE_NAME}:${IMAGE_VERSION}-cart
    deploy:
      resources:
        limits:
          memory: 160M
    restart: unless-stopped
    ports:
      - "${CART_PORT}"
    environment:
      - CART_PORT
      - FLAGD_HOST
      - FLAGD_PORT
      - VALKEY_ADDR
      - OTEL_EXPORTER_OTLP_ENDPOINT
      - OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE
      - OTEL_RESOURCE_ATTRIBUTES=${OTEL_RESOURCE_ATTRIBUTES},service.criticality=high
      - OTEL_SERVICE_NAME=cart
      - ASPNETCORE_URLS=http://*:${CART_PORT}
    depends_on:
      valkey-cart:
        condition: service_healthy
      otel-collector:
        condition: service_started
      flagd:
        condition: service_started
    logging: *logging

  # Checkout service
  checkout:
    image: ${IMAGE_NAME}:${DEMO_VERSION}-checkout
    container_name: checkout
    build:
      context: ./
      dockerfile: ${CHECKOUT_DOCKERFILE}
      cache_from:
        - ${IMAGE_NAME}:${IMAGE_VERSION}-checkout
    deploy:
      resources:
        limits:
          memory: 20M
    restart: unless-stopped
    ports:
      - "${CHECKOUT_PORT}"
    environment:
      - FLAGD_HOST
      - FLAGD_PORT
      - CHECKOUT_PORT
      - CART_ADDR
      - CURRENCY_ADDR
      - EMAIL_ADDR
      - PAYMENT_ADDR
      - PRODUCT_CATALOG_ADDR
      - SHIPPING_ADDR
      - GOMEMLIMIT=16MiB
      - OTEL_EXPORTER_OTLP_ENDPOINT=http://${OTEL_COLLECTOR_HOST}:${OTEL_COLLECTOR_PORT_HTTP}
      - OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
      - OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE
      - OTEL_RESOURCE_ATTRIBUTES=${OTEL_RESOURCE_ATTRIBUTES},service.criticality=critical
      - OTEL_SERVICE_NAME=checkout
    healthcheck:
      test: ["CMD", "/bin/grpc_health_probe", "-addr=:${CHECKOUT_PORT}"]
      start_period: 10s
      interval: 5s
      timeout: 5s
      retries: 20
    depends_on:
      cart:
        condition: service_started
      currency:
        condition: service_healthy
      email:
        condition: service_healthy
      payment:
        condition: service_healthy
      product-catalog:
        condition: service_started
      shipping:
        condition: service_started
      otel-collector:
        condition: service_started
      flagd:
        condition: service_started
    read_only: true
    tmpfs:
      - /tmp
    logging: *logging

  # Currency service
  currency:
    image: ${IMAGE_NAME}:${DEMO_VERSION}-currency
    container_name: currency
    build:
      context: ./
      dockerfile: ${CURRENCY_DOCKERFILE}
      cache_from:
        - ${IMAGE_NAME}:${IMAGE_VERSION}-currency
      args:
        OPENTELEMETRY_CPP_VERSION: ${OPENTELEMETRY_CPP_VERSION}
    deploy:
      resources:
        limits:
          memory: 20M
    restart: unless-stopped
    ports:
      - "${CURRENCY_PORT}"
    environment:
      - CURRENCY_PORT
      - IPV6_ENABLED
      - VERSION=${IMAGE_VERSION}
      - OTEL_EXPORTER_OTLP_ENDPOINT
      - OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE
      - OTEL_RESOURCE_ATTRIBUTES=${OTEL_RESOURCE_ATTRIBUTES},service.criticality=high
      - OTEL_SERVICE_NAME=currency
    healthcheck:
      test: ["CMD-SHELL", "nc -z localhost ${CURRENCY_PORT}"]
      start_period: 10s
      interval: 5s
      timeout: 5s
      retries: 20
    depends_on:
      otel-collector:
        condition: service_started
    logging: *logging

  # Email service
  email:
    image: ${IMAGE_NAME}:${DEMO_VERSION}-email
    container_name: email
    build:
      context: ./
      dockerfile: ${EMAIL_DOCKERFILE}
      cache_from:
        - ${IMAGE_NAME}:${IMAGE_VERSION}-email
    deploy:
      resources:
        limits:
          memory: 100M
    restart: unless-stopped
    ports:
      - "${EMAIL_PORT}"
    environment:
      - APP_ENV=production
      - EMAIL_PORT
      - FLAGD_HOST
      - FLAGD_PORT
      - OTEL_EXPORTER_OTLP_ENDPOINT=http://${OTEL_COLLECTOR_HOST}:${OTEL_COLLECTOR_PORT_HTTP}
      - OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE
      - OTEL_RESOURCE_ATTRIBUTES=${OTEL_RESOURCE_ATTRIBUTES},service.criticality=medium
      - OTEL_SERVICE_NAME=email
    healthcheck:
      test: ["CMD", "ruby", "-e", "require 'socket'; TCPSocket.new('localhost', ${EMAIL_PORT}).close"]
      start_period: 10s
      interval: 5s
      timeout: 5s
      retries: 20
    depends_on:
      otel-collector:
        condition: service_started
    logging: *logging

  # Frontend
  frontend:
    image: ${IMAGE_NAME}:${DEMO_VERSION}-frontend
    container_name: frontend
    build:
      context: ./
      dockerfile: ${FRONTEND_DOCKERFILE}
      cache_from:
        - ${IMAGE_NAME}:${IMAGE_VERSION}-frontend
    deploy:
      resources:
        limits:
          memory: 250M
    restart: unless-stopped
    ports:
      - "${FRONTEND_PORT}"
    environment:
      - PORT=${FRONTEND_PORT}
      - FRONTEND_ADDR
      - AD_ADDR
      - CART_ADDR
      - CHECKOUT_ADDR
      - CURRENCY_ADDR
      - PRODUCT_CATALOG_ADDR
      - RECOMMENDATION_ADDR
      - SHIPPING_ADDR
      - OTEL_EXPORTER_OTLP_ENDPOINT
      - OTEL_RESOURCE_ATTRIBUTES=${OTEL_RESOURCE_ATTRIBUTES},service.criticality=critical
      - ENV_PLATFORM
      - OTEL_SERVICE_NAME=frontend
      - PUBLIC_OTEL_EXPORTER_OTLP_TRACES_ENDPOINT
      - OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE
      - WEB_OTEL_SERVICE_NAME=frontend-web
      - OTEL_COLLECTOR_HOST
      - FLAGD_HOST
      - FLAGD_PORT
      # Monoscope RUM (browser traces, web vitals, session replay). Leave
      # MONOSCOPE_API_KEY unset to run the demo with RUM switched off; the
      # frontend skips SDK init entirely rather than failing.
      - MONOSCOPE_API_KEY
      - MONOSCOPE_OTLP_ENDPOINT
      - MONOSCOPE_APP_URL
      - MONOSCOPE_REPLAY_SAMPLE_RATE
    healthcheck:
      test: ["CMD", "/nodejs/bin/node", "-e", "require('net').connect(${FRONTEND_PORT},require('os').hostname(),function(){process.exit(0)}).on('error',function(){process.exit(1)})"]
      start_period: 60s
      interval: 10s
      timeout: 10s
      retries: 5
    depends_on:
      ad:
        condition: service_healthy
      cart:
        condition: service_started
      checkout:
        condition: service_started
      currency:
        condition: service_healthy
      product-catalog:
        condition: service_started
      quote:
        condition: service_healthy
      recommendation:
        condition: service_healthy
      shipping:
        condition: service_started
      otel-collector:
        condition: service_started
      image-provider:
        condition: service_healthy
      flagd:
        condition: service_started
    logging: *logging

  # Frontend Proxy (Envoy)
  frontend-proxy:
    image: ${IMAGE_NAME}:${DEMO_VERSION}-frontend-proxy
    container_name: frontend-proxy
    build:
      context: ./
      dockerfile: ${FRONTEND_PROXY_DOCKERFILE}
      cache_from:
        - ${IMAGE_NAME}:${IMAGE_VERSION}-frontend-proxy
    deploy:
      resources:
        limits:
          memory: 90M
    restart: unless-stopped
    ports:
      - "${ENVOY_PORT}:${ENVOY_PORT}"
      - "${ENVOY_ADMIN_PORT}:${ENVOY_ADMIN_PORT}"
    environment:
      - FRONTEND_PORT
      - FRONTEND_HOST
      - GRAFANA_PORT
      - GRAFANA_HOST
      - JAEGER_UI_PORT
      - JAEGER_HOST
      - OPAMP_SERVER_HOST
      - OPAMP_SERVER_UI_PORT
      - OTEL_COLLECTOR_HOST
      - IMAGE_PROVIDER_HOST
      - IMAGE_PROVIDER_PORT
      - OTEL_COLLECTOR_PORT_GRPC
      - OTEL_COLLECTOR_PORT_HTTP
      - OTEL_RESOURCE_ATTRIBUTES=${OTEL_RESOURCE_ATTRIBUTES},service.criticality=critical
      - OTEL_SERVICE_NAME=frontend-proxy
      - OTEL_SERVICE_NAMESPACE
      - ENVOY_PORT
      - ENVOY_ADDR
      - ENVOY_ADMIN_PORT
      - FIREPIT_HOST
      - FIREPIT_PORT
      - FLAGD_HOST
      - FLAGD_PORT
      - FLAGD_UI_HOST
      - FLAGD_UI_PORT
      - TELEMETRY_DOCS_HOST
      - TELEMETRY_DOCS_PORT
      - CHATBOT_HOST
      - CHATBOT_PORT
    healthcheck:
      test: ["CMD", "bash", "-c", "echo > /dev/tcp/localhost/${ENVOY_PORT}"]
      start_period: 10s
      interval: 5s
      timeout: 5s
      retries: 20
    depends_on:
      frontend:
        condition: service_healthy
      flagd-ui:
        condition: service_healthy
      telemetry-docs:
        condition: service_healthy
    dns_search: ""

  # image-provider
  image-provider:
    image: ${IMAGE_NAME}:${DEMO_VERSION}-image-provider
    container_name: image-provider
    build:
      context: ./
      dockerfile: ${IMAGE_PROVIDER_DOCKERFILE}
      cache_from:
        - ${IMAGE_NAME}:${IMAGE_VERSION}-image-provider
    deploy:
      resources:
        limits:
          memory: 120M
    restart: unless-stopped
    ports:
      - "${IMAGE_PROVIDER_PORT}"
    environment:
      - IMAGE_PROVIDER_PORT
      - OTEL_COLLECTOR_HOST
      - OTEL_COLLECTOR_PORT_GRPC
      - OTEL_RESOURCE_ATTRIBUTES=${OTEL_RESOURCE_ATTRIBUTES},service.criticality=low
      - OTEL_SERVICE_NAME=image-provider
    healthcheck:
      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost:${IMAGE_PROVIDER_PORT}/status"]
      start_period: 10s
      interval: 5s
      timeout: 5s
      retries: 20
    depends_on:
      otel-collector:
        condition: service_started
    logging: *logging

  # Load Generator
  load-generator:
    image: ${IMAGE_NAME}:${DEMO_VERSION}-load-generator
    container_name: load-generator
    build:
      context: ./
      dockerfile: ${LOAD_GENERATOR_DOCKERFILE}
      cache_from:
        - ${IMAGE_NAME}:${IMAGE_VERSION}-load-generator
    deploy:
      resources:
        limits:
          memory: 512M
    restart: unless-stopped
    environment:
      - LOAD_GENERATOR_VUS
      - K6_TARGET_URL
      - OTEL_EXPORTER_OTLP_ENDPOINT=http://${OTEL_COLLECTOR_HOST}:${OTEL_COLLECTOR_PORT_HTTP}
      - OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
      - OTEL_RESOURCE_ATTRIBUTES=${OTEL_RESOURCE_ATTRIBUTES},service.criticality=low
      - OTEL_SERVICE_NAME=load-generator
      - FLAGD_HOST
      - FLAGD_PORT
      - FLAGD_OFREP_PORT
      - K6_OTEL_EXPORTER_PROTOCOL=http/protobuf
      - K6_OTEL_HTTP_EXPORTER_ENDPOINT=${OTEL_COLLECTOR_HOST}:${OTEL_COLLECTOR_PORT_HTTP}
      - K6_OTEL_HTTP_EXPORTER_INSECURE=true
      - K6_BROWSER_ENABLED=true
      - K6_BROWSER_ARGS=no-sandbox,disable-dev-shm-usage
      - K6_OTEL_METRIC_PREFIX=k6.
    healthcheck:
      test: ["CMD-SHELL", "pgrep k6"]
      start_period: 10s
      interval: 5s
      timeout: 5s
      retries: 5
    depends_on:
      frontend:
        condition: service_healthy
      frontend-proxy:
        condition: service_healthy
      flagd:
        condition: service_started
    logging: *logging

  # Payment service
  payment:
    image: ${IMAGE_NAME}:${DEMO_VERSION}-payment
    container_name: payment
    build:
      context: ./
      dockerfile: ${PAYMENT_DOCKERFILE}
      cache_from:
        - ${IMAGE_NAME}:${IMAGE_VERSION}-payment
    deploy:
      resources:
        limits:
          memory: 140M
    restart: unless-stopped
    ports:
      - "${PAYMENT_PORT}"
    environment:
      - IPV6_ENABLED
      - PAYMENT_PORT
      - FLAGD_HOST
      - FLAGD_PORT
      - NODE_OPTIONS=--require @opentelemetry/auto-instrumentations-node/register
      - OTEL_EXPORTER_OTLP_ENDPOINT
      - OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE
      - OTEL_EXPORTER_OTLP_PROTOCOL=grpc
      - OTEL_RESOURCE_ATTRIBUTES=${OTEL_RESOURCE_ATTRIBUTES},service.criticality=critical
      - OTEL_SERVICE_NAME=payment
    healthcheck:
      test:
        - "CMD"
        - "/nodejs/bin/node"
        - "-e"
        - >-
          const net=require('net');const c=new net.Socket();
          c.setTimeout(2000);
          c.connect(${PAYMENT_PORT},'127.0.0.1',()=>{c.destroy();process.exit(0)});
          c.on('error',()=>process.exit(1));
          c.on('timeout',()=>process.exit(1))
      start_period: 10s
      interval: 5s
      timeout: 5s
      retries: 20
    depends_on:
      otel-collector:
        condition: service_started
      flagd:
        condition: service_started
    logging: *logging

  # Product Catalog service
  product-catalog:
    image: ${IMAGE_NAME}:${DEMO_VERSION}-product-catalog
    container_name: product-catalog
    build:
      context: ./
      dockerfile: ${PRODUCT_CATALOG_DOCKERFILE}
      cache_from:
        - ${IMAGE_NAME}:${IMAGE_VERSION}-product-catalog
    deploy:
      resources:
        limits:
          memory: 20M
    restart: unless-stopped
    ports:
      - "${PRODUCT_CATALOG_PORT}"
    environment:
      - PRODUCT_CATALOG_PORT
      - FLAGD_HOST
      - FLAGD_PORT
      - GOMEMLIMIT=16MiB
      - OTEL_EXPORTER_OTLP_ENDPOINT
      - OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE
      - OTEL_RESOURCE_ATTRIBUTES=${OTEL_RESOURCE_ATTRIBUTES},service.criticality=high
      - OTEL_SERVICE_NAME=product-catalog
      - OTEL_CONFIG_FILE=/otel-config.yml
      - OTEL_SEMCONV_STABILITY_OPT_IN=database
      - DB_CONNECTION_STRING=postgres://astronomy_user:${POSTGRES_ASTRONOMY_PASSWORD}@${POSTGRES_HOST}/astronomy_db?sslmode=disable
    healthcheck:
      test: ["CMD", "/bin/grpc_health_probe", "-addr=:${PRODUCT_CATALOG_PORT}"]
      start_period: 10s
      interval: 5s
      timeout: 5s
      retries: 20
    depends_on:
      otel-collector:
        condition: service_started
      flagd:
        condition: service_started
      astronomy-db:
        condition: service_healthy
    volumes:
      - ./otel-config.yml:/otel-config.yml
    read_only: true
    tmpfs:
      - /tmp
    logging: *logging

  # Quote service
  quote:
    image: ${IMAGE_NAME}:${DEMO_VERSION}-quote
    container_name: quote
    build:
      context: ./
      dockerfile: ${QUOTE_DOCKERFILE}
      cache_from:
        - ${IMAGE_NAME}:${IMAGE_VERSION}-quote
    deploy:
      resources:
        limits:
          memory: 40M
    restart: unless-stopped
    ports:
      - "${QUOTE_PORT}"
    environment:
      - IPV6_ENABLED
      - OTEL_EXPORTER_OTLP_ENDPOINT=http://${OTEL_COLLECTOR_HOST}:${OTEL_COLLECTOR_PORT_HTTP}
      - OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE
      - OTEL_PHP_AUTOLOAD_ENABLED=true
      - QUOTE_PORT
      - OTEL_PHP_INTERNAL_METRICS_ENABLED=true
      - OTEL_RESOURCE_ATTRIBUTES=${OTEL_RESOURCE_ATTRIBUTES},service.criticality=low
      - OTEL_SERVICE_NAME=quote
    healthcheck:
      test: ["CMD", "php", "-r", "fsockopen('localhost', ${QUOTE_PORT}) or die('fail');"]
      start_period: 10s
      interval: 5s
      timeout: 5s
      retries: 20
    depends_on:
      otel-collector:
        condition: service_started
    logging: *logging

  # Recommendation service
  recommendation:
    image: ${IMAGE_NAME}:${DEMO_VERSION}-recommendation
    container_name: recommendation
    build:
      context: ./
      dockerfile: ${RECOMMENDATION_DOCKERFILE}
      cache_from:
        - ${IMAGE_NAME}:${IMAGE_VERSION}-recommendation
    deploy:
      resources:
        limits:
          memory: 500M               # This is high to enable supporting the recommendationCache feature flag use case
    restart: unless-stopped
    ports:
      - "${RECOMMENDATION_PORT}"
    environment:
      - RECOMMENDATION_PORT
      - PRODUCT_CATALOG_ADDR
      - FLAGD_HOST
      - FLAGD_PORT
      - OTEL_PYTHON_LOG_CORRELATION=true
      - OTEL_EXPORTER_OTLP_ENDPOINT
      - OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE
      - OTEL_RESOURCE_ATTRIBUTES=${OTEL_RESOURCE_ATTRIBUTES},service.criticality=medium
      - OTEL_SERVICE_NAME=recommendation
      - PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION=python
    healthcheck:
      test: ["CMD-SHELL", "nc -z localhost ${RECOMMENDATION_PORT}"]
      start_period: 10s
      interval: 5s
      timeout: 5s
      retries: 20
    depends_on:
      product-catalog:
        condition: service_started
      otel-collector:
        condition: service_started
      flagd:
        condition: service_started
    logging: *logging

  # Shipping service
  shipping:
    image: ${IMAGE_NAME}:${DEMO_VERSION}-shipping
    container_name: shipping
    build:
      context: ./
      dockerfile: ${SHIPPING_DOCKERFILE}
      cache_from:
        - ${IMAGE_NAME}:${IMAGE_VERSION}-shipping
    deploy:
      resources:
        limits:
          memory: 20M
    restart: unless-stopped
    ports:
      - "${SHIPPING_PORT}"
    environment:
      - IPV6_ENABLED
      - SHIPPING_PORT
      - QUOTE_ADDR
      - FLAGD_HOST
      - FLAGD_PORT
      - OTEL_EXPORTER_OTLP_ENDPOINT=http://${OTEL_COLLECTOR_HOST}:${OTEL_COLLECTOR_PORT_HTTP}
      - OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
      - OTEL_RESOURCE_ATTRIBUTES=${OTEL_RESOURCE_ATTRIBUTES},service.criticality=high
      - OTEL_SERVICE_NAME=shipping
      - OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE
    healthcheck:
      test: ["CMD", "/app/healthcheck"]
      start_period: 10s
      interval: 5s
      timeout: 5s
      retries: 20
    depends_on:
      otel-collector:
        condition: service_started
      flagd:
        condition: service_started
    read_only: true
    tmpfs:
      - /tmp
    logging: *logging

  # ******************
  # Dependent Services
  # ******************

  # Flagd, feature flagging service
  flagd:
    image: ${FLAGD_IMAGE}
    container_name: flagd
    deploy:
      resources:
        limits:
          memory: 75M
    restart: unless-stopped
    environment:
      - OTEL_EXPORTER_OTLP_ENDPOINT=http://${OTEL_COLLECTOR_HOST}:${OTEL_COLLECTOR_PORT_HTTP}
      - OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
      - GOMEMLIMIT=60MiB
      - OTEL_RESOURCE_ATTRIBUTES=${OTEL_RESOURCE_ATTRIBUTES},service.criticality=low
      - OTEL_SERVICE_NAME=flagd
    command: [
      "start",
      "--uri",
      "file:./etc/flagd/demo.flagd.json"
    ]
    ports:
      - "${FLAGD_PORT}"
      - "${FLAGD_OFREP_PORT}"
    volumes:
      - ./src/flagd:/etc/flagd
    logging: *logging

  # Flagd UI for configuring the feature flag service
  flagd-ui:
    image: ${IMAGE_NAME}:${DEMO_VERSION}-flagd-ui
    container_name: flagd-ui
    build:
      context: ./
      dockerfile: ${FLAGD_UI_DOCKERFILE}
      cache_from:
        - ${IMAGE_NAME}:${IMAGE_VERSION}-flagd-ui
    deploy:
      resources:
        limits:
          memory: 200M
    restart: always
    environment:
      - FLAGD_UI_PORT
      - OTEL_EXPORTER_OTLP_ENDPOINT=http://${OTEL_COLLECTOR_HOST}:${OTEL_COLLECTOR_PORT_HTTP}
      - OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE
      - OTEL_RESOURCE_ATTRIBUTES=${OTEL_RESOURCE_ATTRIBUTES},service.criticality=low
      - OTEL_SERVICE_NAME=flagd-ui
      - SECRET_KEY_BASE=yYrECL4qbNwleYInGJYvVnSkwJuSQJ4ijPTx5tirGUXrbznFIBFVJdPl5t6O9ASw
      - PHX_HOST=localhost
    ports:
      - "${FLAGD_UI_PORT}"
    healthcheck:
      test: ["CMD", "bash", "-c", "echo > /dev/tcp/localhost/${FLAGD_UI_PORT}"]
      start_period: 10s
      interval: 5s
      timeout: 5s
      retries: 20
    depends_on:
      otel-collector:
        condition: service_started
      flagd:
        condition: service_started
    volumes:
      - ./src/flagd:/app/data

  # Telemetry Documentation service
  telemetry-docs:
    image: ${IMAGE_NAME}:${DEMO_VERSION}-telemetry-docs
    container_name: telemetry-docs
    build:
      context: ./
      dockerfile: ${TELEMETRY_DOCS_DOCKERFILE}
      cache_from:
        - ${IMAGE_NAME}:${IMAGE_VERSION}-telemetry-docs
    deploy:
      resources:
        limits:
          memory: 100M
    restart: unless-stopped
    ports:
      - "${TELEMETRY_DOCS_PORT}"
    environment:
      - TELEMETRY_DOCS_PORT
      - OTEL_COLLECTOR_HOST
      - OTEL_COLLECTOR_PORT_GRPC
      - OTEL_SERVICE_NAME=telemetry-docs
    healthcheck:
      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost:${TELEMETRY_DOCS_PORT}/"]
      start_period: 10s
      interval: 5s
      timeout: 5s
      retries: 20
    logging: *logging

  # PostgreSQL database for the astronomy demo
  astronomy-db:
    image: ${POSTGRES_IMAGE}
    container_name: astronomy-db
    deploy:
      resources:
        limits:
          memory: 80M
    restart: unless-stopped
    ports:
      - ${POSTGRES_PORT}
    command: postgres -c shared_preload_libraries=pg_stat_statements
    environment:
      - POSTGRES_PASSWORD
    healthcheck:
      test: ["CMD-SHELL", "pg_isready"]
      start_period: 10s
      interval: 5s
      timeout: 5s
      retries: 10
    volumes:
      - ./src/postgresql/init.sql:/docker-entrypoint-initdb.d/init.sql
    logging: *logging

  # Valkey used by Cart service
  valkey-cart:
    image: ${VALKEY_IMAGE}
    container_name: valkey-cart
    user: valkey
    deploy:
      resources:
        limits:
          memory: 20M
    restart: unless-stopped
    ports:
      - "${VALKEY_PORT}"
    healthcheck:
      test: ["CMD-SHELL", "valkey-cli ping"]
      start_period: 5s
      interval: 5s
      timeout: 3s
      retries: 10
    logging: *logging

  # ********************
  # Telemetry Components
  # ********************

  # OpenTelemetry Collector
  # Base configuration: receives and processes telemetry, exports to debug only.
  # Add compose.observability.yaml to enable Jaeger, Prometheus, OpenSearch, Grafana, and OpAMP.
  otel-collector:
    image: ${COLLECTOR_CONTRIB_IMAGE}
    container_name: otel-collector
    deploy:
      resources:
        limits:
          memory: 400M
    restart: unless-stopped
    command:
      - --config=/etc/otelcol-config.yml
      - --config=/etc/otelcol-config-extras.yml
      - --feature-gates=service.profilesSupport
    user: 0:0
    volumes:
      - ${HOST_FILESYSTEM}:/hostfs:ro
      - ${DOCKER_SOCK}:/var/run/docker.sock:ro
      - ${OTEL_COLLECTOR_CONFIG}:/etc/otelcol-config.yml
      - ${OTEL_COLLECTOR_CONFIG_EXTRAS}:/etc/otelcol-config-extras.yml
    ports:
      - "${OTEL_COLLECTOR_PORT_GRPC}"
      - "${OTEL_COLLECTOR_PORT_HTTP}"
    logging: *logging
    environment:
      - AD_PROMETHEUS_PORT
      - FRONTEND_PROXY_ADDR
      - HOST_FILESYSTEM
      - IMAGE_PROVIDER_HOST
      - IMAGE_PROVIDER_PORT
      - OTEL_COLLECTOR_HOST
      - OTEL_COLLECTOR_PORT_GRPC
      - OTEL_COLLECTOR_PORT_HTTP
      - POSTGRES_HOST
      - POSTGRES_PORT
      - POSTGRES_MONITORING_PASSWORD
      - GOMEMLIMIT=160MiB