docker-compose.yml

# docker-compose.yml
# Complete deployment configuration for CTV Temporal Analytics Engine

version: '3.8'

services:
  # Neo4j Database for Temporal Knowledge Graph
  neo4j:
    image: neo4j:5.15
    container_name: ctv-neo4j
    ports:
      - "7474:7474"
      - "7687:7687"
    environment:
      - NEO4J_AUTH=neo4j/ctvanalytics
      - NEO4J_PLUGINS=["apoc", "graph-data-science"]
      - NEO4J_dbms_security_procedures_unrestricted=apoc.*,gds.*
      - NEO4J_dbms_memory_heap_initial__size=2G
      - NEO4J_dbms_memory_heap_max__size=4G
    volumes:
      - neo4j_data:/data
      - neo4j_logs:/logs
      - neo4j_import:/var/lib/neo4j/import
      - neo4j_plugins:/plugins
    networks:
      - ctv-network

  # Redis for Caching and Session Management
  redis:
    image: redis:7-alpine
    container_name: ctv-redis
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    networks:
      - ctv-network

  # Apache Kafka for Event Streaming
  zookeeper:
    image: confluentinc/cp-zookeeper:7.4.0
    container_name: ctv-zookeeper
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000
    networks:
      - ctv-network

  kafka:
    image: confluentinc/cp-kafka:7.4.0
    container_name: ctv-kafka
    depends_on:
      - zookeeper
    ports:
      - "9092:9092"
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:29092,PLAINTEXT_HOST://localhost:9092
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
      KAFKA_AUTO_CREATE_TOPICS_ENABLE: true
    volumes:
      - kafka_data:/var/lib/kafka/data
    networks:
      - ctv-network

  # Kafka UI for Management
  kafka-ui:
    image: provectuslabs/kafka-ui:latest
    container_name: ctv-kafka-ui
    depends_on:
      - kafka
    ports:
      - "8080:8080"
    environment:
      KAFKA_CLUSTERS_0_NAME: local
      KAFKA_CLUSTERS_0_BOOTSTRAPSERVERS: kafka:29092
    networks:
      - ctv-network

  # InfluxDB for Time Series Metrics
  influxdb:
    image: influxdb:2.7
    container_name: ctv-influxdb
    ports:
      - "8086:8086"
    environment:
      - DOCKER_INFLUXDB_INIT_MODE=setup
      - DOCKER_INFLUXDB_INIT_USERNAME=admin
      - DOCKER_INFLUXDB_INIT_PASSWORD=ctvanalytics
      - DOCKER_INFLUXDB_INIT_ORG=ctv-analytics
      - DOCKER_INFLUXDB_INIT_BUCKET=ctv-metrics
    volumes:
      - influxdb_data:/var/lib/influxdb2
    networks:
      - ctv-network

  # Grafana for Visualization
  grafana:
    image: grafana/grafana:10.2.0
    container_name: ctv-grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=ctvanalytics
      - GF_INSTALL_PLUGINS=grafana-worldmap-panel,grafana-piechart-panel
    volumes:
      - grafana_data:/var/lib/grafana
      - ./grafana/dashboards:/etc/grafana/provisioning/dashboards
      - ./grafana/datasources:/etc/grafana/provisioning/datasources
    depends_on:
      - influxdb
    networks:
      - ctv-network

  # CTV Analytics Engine Application
  ctv-analytics:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: ctv-analytics-engine
    depends_on:
      - neo4j
      - redis
      - kafka
      - influxdb
    environment:
      - NEO4J_URI=bolt://neo4j:7687
      - NEO4J_USER=neo4j
      - NEO4J_PASSWORD=ctvanalytics
      - REDIS_URL=redis://redis:6379
      - KAFKA_SERVERS=kafka:29092
      - INFLUXDB_URL=http://influxdb:8086
      - INFLUXDB_TOKEN=your-token-here
      - INFLUXDB_ORG=ctv-analytics
      - INFLUXDB_BUCKET=ctv-metrics
      - GAM_CREDENTIALS_PATH=/app/credentials/gam-credentials.json
      - PREBID_SERVER_URL=http://prebid-server:8080
    volumes:
      - ./credentials:/app/credentials
      - ./logs:/app/logs
    networks:
      - ctv-network

  # Mock Prebid Server for Testing
  prebid-server:
    image: prebid/prebid-server:latest
    container_name: ctv-prebid-server
    ports:
      - "8081:8080"
    environment:
      - PBS_ADMIN_PORT=6060
    volumes:
      - ./prebid-config:/app/config
    networks:
      - ctv-network

  # Data Generator for Testing
  data-generator:
    build:
      context: ./data-generator
      dockerfile: Dockerfile
    container_name: ctv-data-generator
    depends_on:
      - kafka
    environment:
      - KAFKA_SERVERS=kafka:29092
      - GENERATION_RATE=100  # events per second
    networks:
      - ctv-network

volumes:
  neo4j_data:
  neo4j_logs:
  neo4j_import:
  neo4j_plugins:
  redis_data:
  kafka_data:
  influxdb_data:
  grafana_data:

networks:
  ctv-network:
    driver: bridge

---
# kubernetes-deployment.yaml
# Kubernetes deployment for production environments

apiVersion: v1
kind: Namespace
metadata:
  name: ctv-analytics

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ctv-analytics-engine
  namespace: ctv-analytics
spec:
  replicas: 3
  selector:
    matchLabels:
      app: ctv-analytics-engine
  template:
    metadata:
      labels:
        app: ctv-analytics-engine
    spec:
      containers:
      - name: ctv-analytics
        image: ctv-analytics:latest
        ports:
        - containerPort: 8000
        env:
        - name: NEO4J_URI
          valueFrom:
            secretKeyRef:
              name: ctv-secrets
              key: neo4j-uri
        - name: NEO4J_USER
          valueFrom:
            secretKeyRef:
              name: ctv-secrets
              key: neo4j-user
        - name: NEO4J_PASSWORD
          valueFrom:
            secretKeyRef:
              name: ctv-secrets
              key: neo4j-password
        resources:
          requests:
            memory: "1Gi"
            cpu: "500m"
          limits:
            memory: "4Gi"
            cpu: "2000m"
        volumeMounts:
        - name: config-volume
          mountPath: /app/config
        - name: credentials-volume
          mountPath: /app/credentials
      volumes:
      - name: config-volume
        configMap:
          name: ctv-config
      - name: credentials-volume
        secret:
          secretName: ctv-credentials

---
apiVersion: v1
kind: Service
metadata:
  name: ctv-analytics-service
  namespace: ctv-analytics
spec:
  selector:
    app: ctv-analytics-engine
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8000
  type: LoadBalancer

---
# config.yaml
# Application configuration file

database:
  neo4j:
    uri: ${NEO4J_URI}
    user: ${NEO4J_USER}
    password: ${NEO4J_PASSWORD}
    max_connection_lifetime: 3600
    max_connection_pool_size: 50
    connection_acquisition_timeout: 60

cache:
  redis:
    url: ${REDIS_URL}
    max_connections: 20
    retry_on_timeout: true
    decode_responses: true

streaming:
  kafka:
    servers: ${KAFKA_SERVERS}
    consumer_group: ctv-analytics-group
    auto_offset_reset: latest
    enable_auto_commit: false
    max_poll_records: 500
    session_timeout_ms: 30000

metrics:
  influxdb:
    url: ${INFLUXDB_URL}
    token: ${INFLUXDB_TOKEN}
    org: ${INFLUXDB_ORG}
    bucket: ${INFLUXDB_BUCKET}

integrations:
  gam:
    credentials_path: ${GAM_CREDENTIALS_PATH}
    api_version: v202311
    network_code: ${GAM_NETWORK_CODE}
    
  prebid:
    server_url: ${PREBID_SERVER_URL}
    timeout: 30
    retry_attempts: 3

optimization:
  rules:
    enabled: true
    evaluation_interval: 60  # seconds
    batch_size: 1000
    
  machine_learning:
    model_update_interval: 3600  # seconds
    training_data_window: 7  # days
    prediction_threshold: 0.8

logging:
  level: INFO
  format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
  file: /app/logs/ctv-analytics.log
  max_file_size: 100MB
  backup_count: 5

monitoring:
  health_check_interval: 30
  metrics_collection_interval: 60
  alert_thresholds:
    error_rate: 0.05
    response_time_p95: 1000  # milliseconds
    memory_usage: 0.85

topics:
  input:
    - ctv_bid_requests
    - ctv_bid_responses
    - ctv_impressions
    - ctv_viewability
    - ctv_completions
    - ctv_clicks
    - ctv_conversions
  
  output:
    - ctv_optimizations
    - ctv_alerts
    - ctv_recommendations