docker-compose.yml

---

x-logging: &default-logging
  driver: "json-file"
  options:
    max-size: "10m"
    max-file: "3"

networks:
  discogsography:
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.0.0/16

services:
  # Message broker
  rabbitmq:
    image: rabbitmq:4-management
    container_name: discogsography-rabbitmq
    hostname: rabbitmq
    ulimits:
      nofile:
        soft: 65536
        hard: 65536
    environment:
      RABBITMQ_DEFAULT_PASS: discogsography
      # Set default queue type to quorum for RabbitMQ 4.2+
      RABBITMQ_DEFAULT_QUEUE_TYPE: quorum
      RABBITMQ_DEFAULT_USER: discogsography
      RABBITMQ_DEFAULT_VHOST: /
      # Enable management stats (disabled by default in RabbitMQ 4.x) so the
      # dashboard can display queue depths, publish rates, and ack rates.
      # Raise max_message_size to 128 MB (default 16 MB) for large MusicBrainz
      # records such as "Various Artists" that can exceed 50 MB.
      RABBITMQ_SERVER_ADDITIONAL_ERL_ARGS: >-
        -rabbit log_levels [{connection,error},{default,warning}]
        -rabbit max_message_size 134217728
        -rabbitmq_management disable_management_stats false
    ports:
      - "5672:5672"      # AMQP port
      - "15672:15672"    # Management UI
    volumes:
      - rabbitmq_data:/var/lib/rabbitmq
    networks:
      discogsography:
        aliases:
          - message-broker
          - amqp
    healthcheck:
      test: ["CMD", "rabbitmq-diagnostics", "-q", "ping"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 90s
    restart: unless-stopped
    logging: *default-logging

  # PostgreSQL database
  postgres:
    image: postgres:18-alpine
    container_name: discogsography-postgres
    hostname: postgres
    command:
      - "postgres"
      - "-c"
      - "max_wal_size=4GB"
      - "-c"
      - "checkpoint_completion_target=0.9"
    environment:
      PGDATA: /var/lib/postgresql/data/pgdata
      POSTGRES_DB: discogsography
      POSTGRES_INITDB_ARGS: "--encoding=UTF8 --lc-collate=en_US.UTF-8 --lc-ctype=en_US.UTF-8"
      POSTGRES_PASSWORD: discogsography
      POSTGRES_USER: discogsography
    ports:
      - "5433:5432"  # Changed from 5432 to avoid conflict
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      discogsography:
        aliases:
          - postgres-db
          - database
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U discogsography -d discogsography -h localhost"]
      interval: 10s
      timeout: 5s
      retries: 10
      start_period: 45s
    restart: unless-stopped
    logging: *default-logging
    security_opt:
      - no-new-privileges:true

  # Neo4j graph database
  neo4j:
    image: neo4j:2026-community
    container_name: discogsography-neo4j
    hostname: neo4j
    ulimits:
      nofile:
        soft: 65536
        hard: 65536
    environment:
      JAVA_TOOL_OPTIONS: '--enable-native-access=ALL-UNNAMED'
      NEO4J_ACCEPT_LICENSE_AGREEMENT: 'yes'
      NEO4J_apoc_export_file_enabled: 'true'
      NEO4J_apoc_import_file_enabled: 'true'
      NEO4J_apoc_import_file_use__neo4j__config: 'true'
      NEO4J_AUTH: neo4j/discogsography
      NEO4J_db_checkpoint_iops_limit: '2000'
      NEO4J_db_logs_query_enabled: 'INFO'
      NEO4J_db_logs_query_threshold: '10s'
      NEO4J_db_transaction_timeout: '120s'
      NEO4J_dbms_logs_debug_level: WARN
      NEO4J_dbms_memory_transaction_total_max: 6G
      NEO4J_dbms_security_procedures_unrestricted: 'apoc.*'
      NEO4J_PLUGINS: '["apoc"]'
      NEO4J_server_memory_heap_initial__size: 1G
      NEO4J_server_memory_heap_max__size: 2G
      NEO4J_server_memory_pagecache_size: 1G
    ports:
      - "7474:7474"      # HTTP
      - "7687:7687"      # Bolt
    volumes:
      - neo4j_data:/data
      - neo4j_logs:/logs
      - neo4j_import:/var/lib/neo4j/import
      - neo4j_plugins:/plugins
    networks:
      discogsography:
        aliases:
          - graph-db
          - neo4j-db
    healthcheck:
      test: ["CMD", "cypher-shell", "-u", "neo4j", "-p", "discogsography", "RETURN 1 as health"]
      interval: 15s
      timeout: 10s
      retries: 10
      start_period: 60s
    restart: unless-stopped
    logging: *default-logging
    security_opt:
      - no-new-privileges:true

  # Redis cache
  redis:
    image: redis:7-alpine
    container_name: discogsography-redis
    hostname: redis
    command: redis-server --appendonly yes --maxmemory 512mb --maxmemory-policy allkeys-lru
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    networks:
      discogsography:
        aliases:
          - cache
          - redis-cache
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 10s
    restart: unless-stopped
    logging: *default-logging
    security_opt:
      - no-new-privileges:true

  # Schema initializer — one-shot service that creates all Neo4j and PostgreSQL
  # schema before any other service starts.  Docker Compose waits for it to exit
  # successfully (service_completed_successfully) before starting dependents.
  schema-init:
    build:
      context: .
      dockerfile: schema-init/Dockerfile
      args:
        PYTHON_VERSION: ${PYTHON_VERSION:-3.13}
        UID: ${UID:-1000}
        GID: ${GID:-1000}
    image: discogsography/schema-init:latest
    container_name: discogsography-schema-init
    hostname: schema-init
    user: "${UID:-1000}:${GID:-1000}"
    environment:
      LOG_LEVEL: INFO
      NEO4J_HOST: neo4j
      NEO4J_PASSWORD: discogsography
      NEO4J_USERNAME: neo4j
      POSTGRES_DATABASE: discogsography
      POSTGRES_HOST: postgres
      POSTGRES_PASSWORD: discogsography
      POSTGRES_USERNAME: discogsography
      PYTHONUNBUFFERED: "1"
    volumes:
      - schema_init_logs:/logs
    depends_on:
      postgres:
        condition: service_healthy
      neo4j:
        condition: service_healthy
    networks:
      - discogsography
    restart: "no"
    logging: *default-logging
    security_opt:
      - no-new-privileges:true
    cap_drop:
      - ALL
    read_only: true
    tmpfs:
      - /tmp

  # API service — user accounts, JWT, Discogs OAuth
  api:
    build:
      context: .
      dockerfile: api/Dockerfile
      args:
        PYTHON_VERSION: ${PYTHON_VERSION:-3.13}
        UID: ${UID:-1000}
        GID: ${GID:-1000}
    image: discogsography/api:latest
    container_name: discogsography-api
    hostname: api
    user: "${UID:-1000}:${GID:-1000}"
    environment:
      JWT_ALGORITHM: HS256
      JWT_EXPIRE_MINUTES: "60"
      # IMPORTANT: Override JWT_SECRET_KEY with a random 256-bit key in production!
      JWT_SECRET_KEY: "dev-secret-change-in-production-use-a-256-bit-random-key"
      LOG_LEVEL: INFO
      NEO4J_HOST: neo4j
      NEO4J_PASSWORD: discogsography
      NEO4J_USERNAME: neo4j
      POSTGRES_DATABASE: discogsography
      POSTGRES_HOST: postgres
      POSTGRES_PASSWORD: discogsography
      POSTGRES_USERNAME: discogsography
      PYTHONUNBUFFERED: "1"
      RABBITMQ_HOST: rabbitmq
      RABBITMQ_PASSWORD: discogsography
      RABBITMQ_USERNAME: discogsography
      REDIS_HOST: redis
      STARTUP_DELAY: "5"
      DISCOGS_DATA_ROOT: /discogs-data
      MUSICBRAINZ_DATA_ROOT: /musicbrainz-data
      DB_PROFILING: "${DB_PROFILING:-true}"
      # NLQ (Natural Language Queries) — disabled by default
      NLQ_ENABLED: "${NLQ_ENABLED:-false}"
      NLQ_API_KEY: "${NLQ_API_KEY:-}"
      NLQ_MODEL: "${NLQ_MODEL:-claude-sonnet-4-20250514}"
      # Email notifications (optional — when not set, reset links are logged instead)
      # BREVO_API_KEY: "${BREVO_API_KEY:-}"
      # BREVO_SENDER_EMAIL: "${BREVO_SENDER_EMAIL:-noreply@discogsography.com}"
      # BREVO_SENDER_NAME: "${BREVO_SENDER_NAME:-Discogsography}"
      # Encryption master key (optional — required for TOTP 2FA, derives OAuth + TOTP keys via HKDF)
      # ENCRYPTION_MASTER_KEY: "${ENCRYPTION_MASTER_KEY:-}"
    ports:
      - "8004:8004"      # Auth API
      - "8005:8005"      # Health check
    volumes:
      - api_logs:/logs
      - discogs_data:/discogs-data:ro
      - musicbrainz_data:/musicbrainz-data:ro
    depends_on:
      schema-init:
        condition: service_completed_successfully
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      neo4j:
        condition: service_healthy
    networks:
      - discogsography
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8005/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s
    restart: unless-stopped
    logging: *default-logging
    security_opt:
      - no-new-privileges:true
    cap_drop:
      - ALL
    read_only: true
    tmpfs:
      - /tmp

  # Rust-based extractor service for Discogs data
  extractor-discogs:
    build:
      context: .
      dockerfile: extractor/Dockerfile
    image: discogsography/extractor:latest
    container_name: discogsography-extractor-discogs
    hostname: extractor-discogs
    command: ["--source", "discogs"]
    user: "1000:1000"
    environment:
      DISCOGS_ROOT: /discogs-data
      FORCE_REPROCESS: "false"
      LOG_LEVEL: info
      PERIODIC_CHECK_DAYS: "5"
      RABBITMQ_HOST: rabbitmq
      RABBITMQ_PASSWORD: discogsography
      RABBITMQ_USERNAME: discogsography
      STARTUP_DELAY: "30"
      DATA_QUALITY_RULES: /discogs-data/extraction-rules.yaml
    volumes:
      - discogs_data:/discogs-data
      - extractor_discogs_logs:/logs
      - ./extractor/extraction-rules.yaml:/discogs-data/extraction-rules.yaml:ro
    depends_on:
      rabbitmq:
        condition: service_healthy
    networks:
      - discogsography
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 120s
    restart: on-failure
    logging: *default-logging
    security_opt:
      - no-new-privileges:true
    cap_drop:
      - ALL

  # Rust-based extractor service for MusicBrainz data
  extractor-musicbrainz:
    build:
      context: .
      dockerfile: extractor/Dockerfile
    image: discogsography/extractor:latest
    container_name: discogsography-extractor-musicbrainz
    hostname: extractor-musicbrainz
    command: ["--source", "musicbrainz"]
    user: "1000:1000"
    environment:
      DISCOGS_HEALTH_URL: "http://extractor-discogs:8000/health"
      LOG_LEVEL: info
      MUSICBRAINZ_ROOT: /musicbrainz-data
      PERIODIC_CHECK_DAYS: "3"
      RABBITMQ_HOST: rabbitmq
      RABBITMQ_PASSWORD: discogsography
      RABBITMQ_USERNAME: discogsography
      STARTUP_DELAY: "30"
    volumes:
      - musicbrainz_data:/musicbrainz-data
      - extractor_musicbrainz_logs:/logs
    depends_on:
      rabbitmq:
        condition: service_healthy
    networks:
      - discogsography
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 120s
    restart: on-failure
    logging: *default-logging
    security_opt:
      - no-new-privileges:true
    cap_drop:
      - ALL

  # Graphinator service
  graphinator:
    build:
      context: .
      dockerfile: graphinator/Dockerfile
      args:
        PYTHON_VERSION: ${PYTHON_VERSION:-3.13}
        UID: ${UID:-1000}
        GID: ${GID:-1000}
    image: discogsography/graphinator:latest
    container_name: discogsography-graphinator
    hostname: graphinator
    user: "${UID:-1000}:${GID:-1000}"
    environment:
      CONSUMER_CANCEL_DELAY: "300"     # 5 minutes before canceling idle consumers
      LOG_LEVEL: INFO
      NEO4J_BATCH_FLUSH_INTERVAL: "2.0"  # Reduced from 5.0 for faster flushing
      NEO4J_BATCH_MODE: "true"
      NEO4J_BATCH_SIZE: "500"          # Increased from 100 to 500
      NEO4J_HOST: neo4j
      NEO4J_PASSWORD: discogsography
      NEO4J_USERNAME: neo4j
      PYTHONUNBUFFERED: "1"
      QUEUE_CHECK_INTERVAL: "3600"      # 1 hour between queue checks when idle
      RABBITMQ_HOST: rabbitmq
      RABBITMQ_PASSWORD: discogsography
      RABBITMQ_USERNAME: discogsography
      STARTUP_DELAY: "15"
    depends_on:
      schema-init:
        condition: service_completed_successfully
      rabbitmq:
        condition: service_healthy
      neo4j:
        condition: service_healthy
    networks:
      - discogsography
    healthcheck:
      test: ["CMD", "curl", "-sf", "http://localhost:8001/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s
    restart: on-failure
    logging: *default-logging
    security_opt:
      - no-new-privileges:true
    cap_drop:
      - ALL
    read_only: true
    tmpfs:
      - /tmp
    volumes:
      - graphinator_logs:/logs

  # Brainzgraphinator service — MusicBrainz Neo4j enrichment
  brainzgraphinator:
    build:
      context: .
      dockerfile: brainzgraphinator/Dockerfile
      args:
        PYTHON_VERSION: ${PYTHON_VERSION:-3.13}
        UID: ${UID:-1000}
        GID: ${GID:-1000}
    image: discogsography/brainzgraphinator:latest
    container_name: discogsography-brainzgraphinator
    hostname: brainzgraphinator
    user: "${UID:-1000}:${GID:-1000}"
    environment:
      CONSUMER_CANCEL_DELAY: "300"
      LOG_LEVEL: INFO
      NEO4J_BATCH_FLUSH_INTERVAL: "2.0"
      NEO4J_BATCH_MODE: "true"
      NEO4J_BATCH_SIZE: "500"
      NEO4J_HOST: neo4j
      NEO4J_PASSWORD: discogsography
      NEO4J_USERNAME: neo4j
      PYTHONUNBUFFERED: "1"
      QUEUE_CHECK_INTERVAL: "3600"
      RABBITMQ_HOST: rabbitmq
      RABBITMQ_PASSWORD: discogsography
      RABBITMQ_USERNAME: discogsography
      STARTUP_DELAY: "20"
    depends_on:
      schema-init:
        condition: service_completed_successfully
      rabbitmq:
        condition: service_healthy
      neo4j:
        condition: service_healthy
    networks:
      - discogsography
    healthcheck:
      test: ["CMD", "curl", "-sf", "http://localhost:8011/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s
    restart: on-failure
    logging: *default-logging
    security_opt:
      - no-new-privileges:true
    cap_drop:
      - ALL
    read_only: true
    tmpfs:
      - /tmp
    volumes:
      - brainzgraphinator_logs:/logs

  # Tableinator service
  tableinator:
    build:
      context: .
      dockerfile: tableinator/Dockerfile
      args:
        PYTHON_VERSION: ${PYTHON_VERSION:-3.13}
        UID: ${UID:-1000}
        GID: ${GID:-1000}
    image: discogsography/tableinator:latest
    container_name: discogsography-tableinator
    hostname: tableinator
    user: "${UID:-1000}:${GID:-1000}"
    environment:
      CONSUMER_CANCEL_DELAY: "300"     # 5 minutes before canceling idle consumers
      LOG_LEVEL: INFO
      POSTGRES_BATCH_FLUSH_INTERVAL: "2.0"  # Reduced from 5.0 for faster flushing
      POSTGRES_BATCH_MODE: "true"
      POSTGRES_BATCH_SIZE: "500"          # Increased from 100 to 500
      POSTGRES_DATABASE: discogsography
      POSTGRES_HOST: postgres
      POSTGRES_PASSWORD: discogsography
      POSTGRES_USERNAME: discogsography
      PYTHONUNBUFFERED: "1"
      QUEUE_CHECK_INTERVAL: "3600"      # 1 hour between queue checks when idle
      RABBITMQ_HOST: rabbitmq
      RABBITMQ_PASSWORD: discogsography
      RABBITMQ_USERNAME: discogsography
      STARTUP_DELAY: "20"
    depends_on:
      schema-init:
        condition: service_completed_successfully
      rabbitmq:
        condition: service_healthy
      postgres:
        condition: service_healthy
    networks:
      - discogsography
    healthcheck:
      test: ["CMD", "curl", "-sf", "http://localhost:8002/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 90s
    restart: on-failure
    logging: *default-logging
    security_opt:
      - no-new-privileges:true
    cap_drop:
      - ALL
    read_only: true
    tmpfs:
      - /tmp
    volumes:
      - tableinator_logs:/logs

  # Brainztableinator service (MusicBrainz data to PostgreSQL)
  brainztableinator:
    build:
      context: .
      dockerfile: brainztableinator/Dockerfile
      args:
        PYTHON_VERSION: ${PYTHON_VERSION:-3.13}
        UID: ${UID:-1000}
        GID: ${GID:-1000}
    image: discogsography/brainztableinator:latest
    container_name: discogsography-brainztableinator
    hostname: brainztableinator
    user: "${UID:-1000}:${GID:-1000}"
    environment:
      CONSUMER_CANCEL_DELAY: "300"     # 5 minutes before canceling idle consumers
      LOG_LEVEL: INFO
      POSTGRES_BATCH_FLUSH_INTERVAL: "2.0"  # Reduced from 5.0 for faster flushing
      POSTGRES_BATCH_MODE: "true"
      POSTGRES_BATCH_SIZE: "500"          # Increased from 100 to 500
      POSTGRES_DATABASE: discogsography
      POSTGRES_HOST: postgres
      POSTGRES_PASSWORD: discogsography
      POSTGRES_USERNAME: discogsography
      PYTHONUNBUFFERED: "1"
      QUEUE_CHECK_INTERVAL: "3600"      # 1 hour between queue checks when idle
      RABBITMQ_HOST: rabbitmq
      RABBITMQ_PASSWORD: discogsography
      RABBITMQ_USERNAME: discogsography
      STARTUP_DELAY: "25"
    depends_on:
      schema-init:
        condition: service_completed_successfully
      rabbitmq:
        condition: service_healthy
      postgres:
        condition: service_healthy
    networks:
      - discogsography
    healthcheck:
      test: ["CMD", "curl", "-sf", "http://localhost:8010/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s
    restart: on-failure
    logging: *default-logging
    security_opt:
      - no-new-privileges:true
    cap_drop:
      - ALL
    read_only: true
    tmpfs:
      - /tmp
    volumes:
      - brainztableinator_logs:/logs

  # Dashboard service
  dashboard:
    build:
      context: .
      dockerfile: dashboard/Dockerfile
      args:
        PYTHON_VERSION: ${PYTHON_VERSION:-3.13}
        UID: ${UID:-1000}
        GID: ${GID:-1000}
    image: discogsography/dashboard:latest
    container_name: discogsography-dashboard
    hostname: dashboard
    user: "${UID:-1000}:${GID:-1000}"
    environment:
      LOG_LEVEL: INFO
      NEO4J_HOST: neo4j
      NEO4J_PASSWORD: discogsography
      NEO4J_USERNAME: neo4j
      POSTGRES_DATABASE: discogsography
      POSTGRES_HOST: postgres
      POSTGRES_PASSWORD: discogsography
      POSTGRES_USERNAME: discogsography
      PYTHONUNBUFFERED: "1"
      RABBITMQ_HOST: rabbitmq
      RABBITMQ_PASSWORD: discogsography
      RABBITMQ_USERNAME: discogsography
      REDIS_HOST: redis
      API_HOST: api
      API_PORT: "8004"
      UV_CACHE_DIR: "/tmp/.cache/uv"
    ports:
      - "8003:8003"
    depends_on:
      schema-init:
        condition: service_completed_successfully
      rabbitmq:
        condition: service_healthy
      postgres:
        condition: service_healthy
      neo4j:
        condition: service_healthy
      redis:
        condition: service_healthy
      api:
        condition: service_healthy
    networks:
      - discogsography
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8003/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 45s
    restart: unless-stopped
    logging: *default-logging
    security_opt:
      - no-new-privileges:true
    cap_drop:
      - ALL
    read_only: true
    tmpfs:
      - /tmp
      - /.cache
    volumes:
      - dashboard_logs:/logs

  # Explore service
  explore:
    build:
      context: .
      dockerfile: explore/Dockerfile
      args:
        PYTHON_VERSION: ${PYTHON_VERSION:-3.13}
        UID: ${UID:-1000}
        GID: ${GID:-1000}
    image: discogsography/explore:latest
    container_name: discogsography-explore
    hostname: explore
    user: "${UID:-1000}:${GID:-1000}"
    environment:
      API_BASE_URL: "http://api:8004"
      LOG_LEVEL: INFO
      PYTHONUNBUFFERED: "1"
    depends_on:
      schema-init:
        condition: service_completed_successfully
      api:
        condition: service_healthy
    networks:
      - discogsography
    ports:
      - "8006:8006"
      - "8007:8007"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8007/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s
    restart: unless-stopped
    logging: *default-logging
    security_opt:
      - no-new-privileges:true
    cap_drop:
      - ALL
    read_only: true
    tmpfs:
      - /tmp
    volumes:
      - explore_logs:/logs

  # Insights service — precomputed analytics and music trends
  insights:
    build:
      context: .
      dockerfile: insights/Dockerfile
      args:
        PYTHON_VERSION: ${PYTHON_VERSION:-3.13}
        UID: ${UID:-1000}
        GID: ${GID:-1000}
    image: discogsography/insights:latest
    container_name: discogsography-insights
    hostname: insights
    user: "${UID:-1000}:${GID:-1000}"
    environment:
      API_BASE_URL: "http://api:8004"
      INSIGHTS_SCHEDULE_HOURS: "24"
      LOG_LEVEL: INFO
      POSTGRES_DATABASE: discogsography
      POSTGRES_HOST: postgres
      POSTGRES_PASSWORD: discogsography
      POSTGRES_USERNAME: discogsography
      PYTHONUNBUFFERED: "1"
      REDIS_HOST: redis
      STARTUP_DELAY: "10"
      # INSIGHTS_MILESTONE_YEARS: "25,30,40,50,75,100"
    depends_on:
      api:
        condition: service_healthy
      schema-init:
        condition: service_completed_successfully
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    networks:
      - discogsography
    healthcheck:
      test: ["CMD", "curl", "-sf", "http://localhost:8009/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 90s
    restart: unless-stopped
    logging: *default-logging
    security_opt:
      - no-new-privileges:true
    cap_drop:
      - ALL
    read_only: true
    tmpfs:
      - /tmp
    volumes:
      - insights_logs:/logs

volumes:
  rabbitmq_data:
  postgres_data:
  neo4j_data:
  neo4j_logs:
  neo4j_import:
  neo4j_plugins:
  redis_data:
  discogs_data:
  extractor_discogs_logs:
  extractor_musicbrainz_logs:
  schema_init_logs:
  api_logs:
  graphinator_logs:
  brainzgraphinator_logs:
  tableinator_logs:
  dashboard_logs:
  explore_logs:
  brainztableinator_logs:
  insights_logs:
  musicbrainz_data: