Open Telemetry and Nginx Error

docker-compose.yml

version: "3.9"

services:
  opentelemetry:
    depends_on:
      - jaeger
    container_name: otel
    image: otel/opentelemetry-collector:latest
    command: ["--config=/etc/otel-collector-config.yml"] 
    volumes:
      - ~/source/repos/CritterTrackerProject/DockerServices/OpenTelemetry/otel-collector-config.yml:/etc/otel-collector-config.yml
    ports:
      - 4317:4317
      - 13133:13133
      # - 14250:14250
      # - 14268:14268
      - 55678-55679:55678-55679
      # - 8888:8888
      # - 8889:8889
      # - 9411:9411
    extra_hosts:
      - "host.docker.internal:host-gateway"
    networks:
      - my-network

  jaeger:
    # restart: unless-stopped
    container_name: jaeger
    image: jaegertracing/all-in-one:latest
    ports:
      - 16686:16686
      - 16685:16685
      - 14250:14250
      - 14268:14268
      - 5775:5775/udp
      - 6831:6831/udp
      - 6832:6832/udp
      - 5778:5778
      - 9411:9411
      - 4137:55680
    extra_hosts:
      - "host.docker.internal:host-gateway"
    networks:
      - my-network

  postgres:
   restart: always
   container_name: postgres
   image: postgres:latest
   environment:
     - POSTGRES_USER=code
     - POSTGRES_PASSWORD=code
   ports:
     - 5432:5432
   volumes: 
     - postgres:/var/lib/postgresql/data
   extra_hosts:
     - "host.docker.internal:host-gateway"
   networks:
     - my-network

  # yarp:
  #   # restart: unless-stopped
  #   container_name: yarp
  #   image: yarp:latest
  #   build: 
  #     context: ~/source/repos/CritterTrackerProject
  #     dockerfile: Yarp/Dockerfile
  #   env_file:
  #     - ~/source/repos/CritterTrackerProject/Yarp/user.secrets
  #   ports:
  #     - 80:80
  #     - 443:443
  #   # volumes:
  #   #   - ~/.aspnet/https:/https/
  #   extra_hosts:
  #     - "host.docker.internal:host-gateway"
  #   networks:
  #     - my-network
    


  nginx:
    restart: always
    container_name: webserver
    image: nginx:latest
    build:
      context: ~/source/repos/CritterTrackerProject
      dockerfile: DockerServices/Nginx/Dockerfile
    ports:
      - 80:80
      - 443:443
    extra_hosts:
      - "host.docker.internal:host-gateway"
    networks:
      - my-network

volumes:
  postgres:

networks:
  my-network:
    external: true
    name: my-network

nginx.conf

load_module /etc/nginx/modules/otel_ngx_module.so;

worker_processes 1;

events { worker_connections 1024; }


http {

    error_log /var/log/nginx/error.log;
    access_log /var/log/nginx/access.log;
    
    sendfile on;
    keepalive_timeout 50;
    large_client_header_buffers 4 32k;
    
    allow 172.18.0.1;
    allow 127.0.0.1;
    deny 45.169.31.9;
    deny all;

    limit_req_zone $binary_remote_addr zone=websites:10m rate=10r/s;
    limit_req_zone $binary_remote_addr zone=identity:10m rate=20r/s;

    opentelemetry_config /etc/nginx/otel_config.toml;


upstream identity {
server 172.18.0.1:5000;
}

upstream critter {

server 172.18.0.1:5028;
}

upstream apigateway {
server 172.18.0.1:5013;
}

upstream email {
server 172.18.0.1:5011;
}



    server {
        listen 80;
        limit_req zone=identity burst=10 nodelay;
        server_name development.identity.fullstackindie.net;

        location / {
        opentelemetry_propagate;
            return 301 https://$host$request_uri;
        }

    }



    server {
        listen 443 ssl;
        limit_req zone=websites burst=5 nodelay;
        server_name development.identity.fullstackindie.net;

        ssl_certificate /etc/letsencrypt/live/development.identity.fullstackindie.net/fullchain.pem;
        ssl_certificate_key /etc/letsencrypt/live/development.identity.fullstackindie.net/privkey.pem;

        location / {
            opentelemetry_propagate;
            proxy_pass         http://identity;
            proxy_redirect     off;
            proxy_http_version 1.1;
            proxy_cache_bypass $http_upgrade;
            proxy_set_header   Upgrade $http_upgrade;
            proxy_set_header   Connection keep-alive;
            proxy_set_header   Host $host;
            proxy_set_header   X-Real-IP $remote_addr;
            proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header   X-Forwarded-Proto $scheme;
            proxy_set_header   X-Forwarded-Host $server_name;
            proxy_buffer_size           128k;
            proxy_buffers               4 256k;
            proxy_busy_buffers_size     256k;
        }
    }

#     server {
#         listen 80;
#         server_name development.gateway.fullstackindie.net;

# # location /send-email {
# #   proxy_pass http://email/api/email/send;
# # }
#         location / {
#             return 301 https://$host$request_uri;
#         }


#     }

    server {
        listen 443 ssl;
        limit_req zone=websites burst=5 nodelay;
        server_name development.gateway.fullstackindie.net;

        ssl_certificate /etc/letsencrypt/live/development.gateway.fullstackindie.net/fullchain.pem;
        ssl_certificate_key /etc/letsencrypt/live/development.gateway.fullstackindie.net/privkey.pem;

             location / {
            opentelemetry_propagate;
            proxy_pass         http://apigateway;
            proxy_redirect     off;
            proxy_http_version 1.1;
            proxy_cache_bypass $http_upgrade;
            proxy_set_header   Upgrade $http_upgrade;
            proxy_set_header   Connection keep-alive;
            proxy_set_header   Host $host;
            proxy_set_header   X-Real-IP $remote_addr;
            proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header   X-Forwarded-Proto $scheme;
            proxy_set_header   X-Forwarded-Host $server_name;
            proxy_buffer_size           128k;
            proxy_buffers               4 256k;
            proxy_busy_buffers_size     256k;
        }
    }

    server {
        listen 80;
        limit_req zone=websites burst=5 nodelay;
        server_name development.crittertracker.fullstackindie.net;

        location / {
            return 301 https://$host$request_uri;
        }
    }

    server {
        listen 443 ssl;
        limit_req zone=websites burst=5 nodelay;
        server_name development.crittertracker.fullstackindie.net;

        ssl_certificate /etc/letsencrypt/live/development.crittertracker.fullstackindie.net/fullchain.pem;
        ssl_certificate_key /etc/letsencrypt/live/development.crittertracker.fullstackindie.net/privkey.pem;

        location / {
            proxy_pass         http://critter;
            proxy_redirect     off;
            proxy_http_version 1.1;
            proxy_cache_bypass $http_upgrade;
            proxy_set_header   Upgrade $http_upgrade;
            proxy_set_header   Connection keep-alive;
            proxy_set_header   Host $host;
            proxy_set_header   X-Real-IP $remote_addr;
            proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header   X-Forwarded-Proto $scheme;
            proxy_set_header   X-Forwarded-Host $server_name;
            proxy_buffer_size           128k;
            proxy_buffers               4 256k;
            proxy_busy_buffers_size     256k;
        }
    }


#     server {
#         listen 80;
#         server_name development.email.fullstackindie.net;

# #    location /api/email/send {
# #             proxy_pass  https://email;
# #         }

#         location / {
#             return 301 https://$host$request_uri;
#         }
#     }

    server {
        listen 443 ssl;
        limit_req zone=websites burst=5 nodelay;
        server_name development.email.fullstackindie.net;

        ssl_certificate /etc/letsencrypt/live/development.email.fullstackindie.net/fullchain.pem;
        ssl_certificate_key /etc/letsencrypt/live/development.email.fullstackindie.net/privkey.pem;

        location / {
            proxy_pass         http://email;
            proxy_redirect     off;
            proxy_http_version 1.1;
            proxy_cache_bypass $http_upgrade;
            proxy_set_header   Upgrade $http_upgrade;
            proxy_set_header   Connection keep-alive;
            proxy_set_header   Host $host;
            proxy_set_header   X-Real-IP $remote_addr;
            proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header   X-Forwarded-Proto $scheme;
            proxy_set_header   X-Forwarded-Host $server_name;
            proxy_buffer_size           128k;
            proxy_buffers               4 256k;
            proxy_busy_buffers_size     256k;
        }
    }

}

otel-collector-config.yml

receivers:   
  otlp:
    protocols:
      http:
      grpc:
        endpoint: "http://localhost:4317"
  # jaeger:
  #   protocols:
  #     grpc:

exporters:
  jaeger:
    endpoint: jaeger:14268
    insecure: true


processors:
  batch:

extensions:
  health_check:
  pprof:
  zpages:

service:
  extensions: [pprof, zpages, health_check]
  pipelines:
    traces:
      receivers: [otlp]
      # receivers: [otlp, jaeger]
      exporters: [jaeger]
      processors: [batch]

otel_config.toml

exporter = "otlp"
processor = "batch"

[exporters.otlp]
# Alternatively the OTEL_EXPORTER_OTLP_ENDPOINT environment variable can also be used.
host = "localhost"
port = 4317
# Optional: enable SSL, for endpoints that support it
# use_ssl = true
# Optional: set a filesystem path to a pem file to be used for SSL encryption
# (when use_ssl = true)
# ssl_cert_path = "/path/to/cert.pem"

[processors.batch]
max_queue_size = 2048
schedule_delay_millis = 5000
max_export_batch_size = 512

[service]
name = "nginx-proxy" # Opentelemetry resource name

[sampler]
name = "AlwaysOn" # Also: AlwaysOff, TraceIdRatioBased
ratio = 0.1
parent_based = false