# Health check configuration
health_checks:
  - name: "api-service"
    type: "http"
    url: "http://api-service:8080/health"
    interval: "10s"
    timeout: "5s"
    failure_threshold: 3
    success_threshold: 2
    
    actions:
      on_failure:
        - remove_from_discovery
        - notify_team
        - trigger_circuit_breaker
      on_recovery:
        - add_to_discovery
        - reset_circuit_breaker
        - log_recovery

# Configuration hierarchy
global:
  database:
    connection_timeout: 30s
    max_connections: 100
    
environment:
  production:
    database:
      max_connections: 200
      ssl_required: true
  development:
    database:
      max_connections: 10
      ssl_required: false
      
service:
  user-service:
    database:
      name: "users_db"
    cache:
      ttl: "1h"

# Kubernetes service definition
apiVersion: v1
kind: Service
metadata:
  name: user-service
  annotations:
    eden.hub/register: "true"
    eden.hub/health-check: "/health"
    eden.hub/load-balancer: "least_connections"
spec:
  selector:
    app: user-service
  ports:
    - port: 8080
      targetPort: 8080

# Python SDK example
from eden_hub import ServiceRegistry

registry = ServiceRegistry(
    api_url="https://eden-hub.company.com",
    token=os.environ['EDEN_TOKEN']
)

# Register service
service = registry.register(
    name="user-service",
    address="10.0.1.100",
    port=8080,
    tags=["api", "users", "v2"],
    health_check={
        "type": "http",
        "url": "/health",
        "interval": "10s"
    },
    metadata={
        "version": "2.1.0",
        "environment": "production"
    }
)

# Discover services
api_services = registry.discover("api-gateway")
for service in api_services:
    print(f"Found service: {service.address}:{service.port}")

# GitHub Actions integration
- name: Register Service
  uses: eden-hub/register-action@v1
  with:
    api-token: ${{ secrets.EDEN_TOKEN }}
    service-name: "user-service"
    service-port: 8080
    health-check: "/health"
    tags: "api,users,production"
    
- name: Update Configuration
  uses: eden-hub/config-action@v1
  with:
    api-token: ${{ secrets.EDEN_TOKEN }}
    config-path: "services/user-service"
    config-file: "production.yaml"
    validate: true

# Multi-environment configuration
environments:
  development:
    replicas: 1
    resources:
      cpu: "0.5"
      memory: "512Mi"
    database_url: "dev-db.company.com"
    
  staging:
    replicas: 2
    resources:
      cpu: "1"
      memory: "1Gi"
    database_url: "staging-db.company.com"
    
  production:
    replicas: 5
    resources:
      cpu: "2"
      memory: "2Gi"
    database_url: "prod-db.company.com"
    high_availability: true

┌─────────────────────────────────────────────────────────────────┐
│                    Service Registration Layer                   │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐│
│  │   Manual    │ │  Automatic  │ │ Container   │ │ Third-Party ││
│  │Registration │ │Registration │ │Integration  │ │ Integration ││
│  └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘│
├─────────────────────────────────────────────────────────────────┤
│                   Service Registry Core                        │
│  ┌─────────────────────────────────────────────────────────────┐│
│  │  Service Catalog • Health Status • Configuration Store     ││
│  └─────────────────────────────────────────────────────────────┘│
├─────────────────────────────────────────────────────────────────┤
│                    Discovery & Routing                         │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐│
│  │   Service   │ │    Load     │ │   Health    │ │   Circuit   ││
│  │  Discovery  │ │  Balancing  │ │  Checking   │ │  Breakers   ││
│  └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘│
├─────────────────────────────────────────────────────────────────┤
│                 Configuration Management                       │
│  ┌─────────────────────────────────────────────────────────────┐│
│  │   Hierarchical Config • Real-time Updates • Version Control││
│  └─────────────────────────────────────────────────────────────┘│
├─────────────────────────────────────────────────────────────────┤
│                   Integration Layer                            │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐│
│  │ Service     │ │     API     │ │ Kubernetes  │ │   Cloud     ││
│  │   Mesh      │ │   Gateway   │ │Integration  │ │ Platforms   ││
│  └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘│
└─────────────────────────────────────────────────────────────────┘

# Install Eden Hub CLI
curl -L https://github.com/ataivadev/eden/releases/latest/download/eden-hub -o eden-hub
chmod +x eden-hub && sudo mv eden-hub /usr/local/bin/

# Authenticate
eden auth login --email [email protected]

# Register a service
eden hub register \
  --name "user-service" \
  --address "10.0.1.100" \
  --port 8080 \
  --tags "api,users,v2" \
  --health-check "/health"

# Discover services
eden hub discover --service "api-gateway"
eden hub discover --tag "database"

# service-config.yaml
service:
  name: "user-service"
  version: "2.1.0"
  
  registration:
    address: "auto"  # Auto-detect IP address
    port: 8080
    tags: ["api", "users", "production"]
    
  health_checks:
    - name: "http-health"
      type: "http"
      url: "/health"
      interval: "10s"
      timeout: "5s"
      failure_threshold: 3
      
    - name: "database-health"
      type: "tcp"
      address: "db.company.com"
      port: 5432
      interval: "30s"
      
  load_balancing:
    algorithm: "least_connections"
    weights:
      - instance: "10.0.1.100:8080"
        weight: 100
      - instance: "10.0.1.101:8080"
        weight: 150
        
  configuration:
    database:
      url: "{{ vault.get('DATABASE_URL') }}"
      max_connections: 20
      timeout: "30s"
      
    cache:
      redis_url: "{{ vault.get('REDIS_URL') }}"
      ttl: "1h"
      
    features:
      new_user_flow: true
      advanced_search: false

# hierarchical-config.yaml
# Global configuration (applies to all services)
global:
  logging:
    level: "info"
    format: "json"
  
  monitoring:
    metrics_enabled: true
    tracing_enabled: true
    
  security:
    tls_required: true
    jwt_validation: true

# Environment-specific overrides
environments:
  development:
    logging:
      level: "debug"
    monitoring:
      metrics_enabled: false
    security:
      tls_required: false
      
  production:
    logging:
      level: "warn"
    monitoring:
      sampling_rate: 0.1
    security:
      strict_mode: true

# Service-specific configuration
services:
  user-service:
    database:
      name: "users"
      pool_size: 10
    cache:
      enabled: true
      ttl: "30m"
      
  order-service:
    database:
      name: "orders"
      pool_size: 20
    payment:
      timeout: "10s"
      retry_attempts: 3

# kubernetes-integration.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
  annotations:
    eden.hub/register: "true"
    eden.hub/service-name: "user-service"
    eden.hub/health-check: "/health"
    eden.hub/tags: "api,users,production"
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
      annotations:
        eden.hub/port: "8080"
        eden.hub/load-balancer: "round_robin"
    spec:
      containers:
      - name: user-service
        image: company/user-service:v2.1.0
        ports:
        - containerPort: 8080
        env:
        - name: EDEN_HUB_URL
          value: "https://eden-hub.company.com"
        - name: EDEN_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: eden-credentials
              key: token
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5

---
apiVersion: v1
kind: Service
metadata:
  name: user-service
  annotations:
    eden.hub/external-discovery: "true"
spec:
  selector:
    app: user-service
  ports:
    - port: 8080
      targetPort: 8080
  type: ClusterIP

// Go SDK example
package main

import (
    "context"
    "log"
    "github.com/ataivadev/eden-hub-go"
)

func main() {
    // Initialize Eden Hub client
    client, err := edenhub.NewClient(&edenhub.Config{
        Address: "https://eden-hub.company.com",
        Token:   os.Getenv("EDEN_HUB_TOKEN"),
    })
    if err != nil {
        log.Fatal(err)
    }

    // Register service
    service := &edenhub.ServiceRegistration{
        Name:    "user-service",
        Address: "10.0.1.100",
        Port:    8080,
        Tags:    []string{"api", "users", "v2"},
        HealthCheck: &edenhub.HealthCheck{
            Type:     "http",
            URL:      "/health",
            Interval: "10s",
        },
    }
    
    err = client.Register(context.Background(), service)
    if err != nil {
        log.Fatal(err)
    }

    // Discover services
    services, err := client.Discover(context.Background(), "api-gateway")
    if err != nil {
        log.Fatal(err)
    }
    
    for _, svc := range services {
        log.Printf("Found service: %s at %s:%d", svc.Name, svc.Address, svc.Port)
    }

    // Get configuration
    config, err := client.GetConfig(context.Background(), "user-service")
    if err != nil {
        log.Fatal(err)
    }
    
    log.Printf("Database URL: %s", config.Get("database.url"))
}

# Service management
eden hub services list
eden hub services describe user-service
eden hub services health user-service

# Configuration management
eden hub config get user-service
eden hub config set user-service database.pool_size 25
eden hub config history user-service

# Health monitoring
eden hub health status
eden hub health checks user-service
eden hub health failures --last 24h

# Load balancing
eden hub lb status user-service
eden hub lb weights user-service --set "10.0.1.100:8080=100,10.0.1.101:8080=150"
eden hub lb algorithm user-service --set least_connections

# Service discovery
eden hub discover --service api-gateway
eden hub discover --tag database --healthy-only
eden hub topology --service user-service --depth 2

# monitoring-config.yaml
monitoring:
  metrics:
    enabled: true
    endpoint: "/metrics"
    format: "prometheus"
    
  health_checks:
    aggregate_status: true
    detailed_reporting: true
    
  service_topology:
    enabled: true
    update_interval: "30s"
    max_depth: 5

alerts:
  - name: "Service Down"
    condition: "service_health == 'critical'"
    duration: "2m"
    channels: ["pagerduty", "slack"]
    
  - name: "High Error Rate"
    condition: "error_rate > 5%"
    duration: "5m"
    channels: ["slack"]
    
  - name: "Configuration Drift"
    condition: "config_version != expected_version"
    channels: ["email"]

dashboards:
  - name: "Service Overview"
    widgets:
      - type: "service_map"
        title: "Service Topology"
        
      - type: "health_status"
        title: "Service Health"
        
      - type: "configuration_status"
        title: "Configuration Versions"
        
      - type: "load_balancing"
        title: "Traffic Distribution"