Error Handling

curl -X GET 'https://api.satsuma.ai/product?latitude=37.7749&longitude=-122.4194' \
  -H 'Authorization: your-api-key' \
  -H 'Content-Type: application/json' \
  -w "Response Code: %{http_code}\n" \
  -s | jq '.'

# Example error response for invalid API key:
# {
#   "error": {
#     "code": "INVALID_API_KEY",
#     "message": "The provided API key is invalid or expired",
#     "request_id": "req_abc123xyz789"
#   }
# }

# Retry with exponential backoff using a simple script
#!/bin/bash
url="https://api.satsuma.ai/product?latitude=37.7749&longitude=-122.4194"
api_key="your-api-key"
max_retries=3

for attempt in $(seq 0 $max_retries); do
  response=$(curl -s -w "%{http_code}" \
    -H "Authorization: $api_key" \
    -H "Content-Type: application/json" \
    "$url")
  
  http_code="${response: -3}"
  body="${response%???}"
  
  # Success
  if [[ "$http_code" =~ ^2[0-9][0-9]$ ]]; then
    echo "$body" | jq '.'
    exit 0
  fi
  
  # Don't retry 4xx errors (except 429)
  if [[ "$http_code" =~ ^4[0-9][0-9]$ ]] && [ "$http_code" != "429" ]; then
    echo "Client error $http_code: $body" >&2
    exit 1
  fi
  
  # Calculate delay for retry
  if [ "$attempt" -lt "$max_retries" ]; then
    delay=$((2**attempt))
    echo "Retrying in ${delay}s (attempt $((attempt + 1))/$((max_retries + 1)))" >&2
    sleep $delay
  fi
done

echo "Max retries exceeded: $body" >&2
exit 1

# Error handling in bash script
handle_error() {
  local error_code="$1"
  local error_body="$2"
  
  case "$error_code" in
    "INVALID_API_KEY")
      echo "ERROR: Invalid API key. Please check your credentials." >&2
      # Log security incident
      logger "Security: Invalid API key used"
      exit 1
      ;;
    "INSUFFICIENT_INVENTORY")
      available=$(echo "$error_body" | jq -r '.error.available_quantity // "unknown"')
      echo "ERROR: Insufficient inventory. Available: $available" >&2
      exit 1
      ;;
    "PAYMENT_FAILED")
      reason=$(echo "$error_body" | jq -r '.error.decline_reason // "unknown"')
      echo "ERROR: Payment failed. Reason: $reason" >&2
      exit 1
      ;;
    "RATE_LIMIT_EXCEEDED")
      retry_after=$(echo "$error_body" | jq -r '.error.retry_after // 60')
      echo "Rate limit exceeded. Retry after ${retry_after}s" >&2
      return $retry_after
      ;;
    *)
      echo "ERROR: Unexpected API error: $error_code" >&2
      exit 1
      ;;
  esac
}

# Simple circuit breaker state management in bash
#!/bin/bash
CIRCUIT_STATE_FILE="/tmp/satsuma_circuit_state"
FAILURE_THRESHOLD=5
TIMEOUT_DURATION=60

get_circuit_state() {
  if [ -f "$CIRCUIT_STATE_FILE" ]; then
    cat "$CIRCUIT_STATE_FILE"
  else
    echo "CLOSED:0:0"
  fi
}

update_circuit_state() {
  local state="$1"
  local failures="$2"
  local next_attempt="$3"
  echo "$state:$failures:$next_attempt" > "$CIRCUIT_STATE_FILE"
}

execute_with_circuit_breaker() {
  local url="$1"
  local api_key="$2"
  
  IFS=':' read -r state failures next_attempt <<< "$(get_circuit_state)"
  current_time=$(date +%s)
  
  # Check if circuit is open and timeout hasn't expired
  if [ "$state" = "OPEN" ] && [ "$current_time" -lt "$next_attempt" ]; then
    echo "Circuit breaker is OPEN. Retry after: $((next_attempt - current_time))s" >&2
    return 1
  fi
  
  # Make the request
  response=$(curl -s -w "%{http_code}" \
    -H "Authorization: $api_key" \
    "$url")
  
  http_code="${response: -3}"
  
  if [[ "$http_code" =~ ^2[0-9][0-9]$ ]]; then
    # Success - reset circuit breaker
    update_circuit_state "CLOSED" "0" "0"
    echo "${response%???}"  # Return response body
    return 0
  else
    # Failure - increment counter
    failures=$((failures + 1))
    if [ "$failures" -ge "$FAILURE_THRESHOLD" ]; then
      # Open circuit
      next_attempt=$((current_time + TIMEOUT_DURATION))
      update_circuit_state "OPEN" "$failures" "$next_attempt"
      echo "Circuit breaker opened due to failures" >&2
    else
      update_circuit_state "CLOSED" "$failures" "0"
    fi
    return 1
  fi
}

# Error tracking in bash with logging
track_error() {
  local error_code="$1"
  local error_message="$2"
  local status_code="$3"
  local request_id="$4"
  local endpoint="$5"
  local user_id="${6:-unknown}"
  local retry_attempt="${7:-0}"
  
  # Create error data JSON
  local error_data=$(jq -n \
    --arg timestamp "$(date -Iseconds)" \
    --arg error_code "$error_code" \
    --arg error_message "$error_message" \
    --arg status_code "$status_code" \
    --arg request_id "$request_id" \
    --arg user_id "$user_id" \
    --arg endpoint "$endpoint" \
    --arg retry_attempt "$retry_attempt" \
    '{
      timestamp: $timestamp,
      error_code: $error_code,
      error_message: $error_message,
      status_code: ($status_code | tonumber),
      request_id: $request_id,
      user_id: $user_id,
      endpoint: $endpoint,
      retry_attempt: ($retry_attempt | tonumber)
    }')
  
  # Log to file
  echo "$error_data" >> /var/log/satsuma_errors.log
  
  # Send to monitoring service (replace with your monitoring endpoint)
  curl -s -X POST "https://monitoring.yourservice.com/api/errors" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $MONITORING_TOKEN" \
    -d "$error_data" > /dev/null
  
  # Alert on critical errors
  if [ "$status_code" -ge 500 ] || [ "$error_code" = "PAYMENT_FAILED" ]; then
    # Send alert (replace with your alerting service)
    curl -s -X POST "https://alerts.yourservice.com/api/critical" \
      -H "Content-Type: application/json" \
      -d "$error_data" > /dev/null
  fi
}

#!/bin/bash
# Health check script
API_KEY="your-api-key"
HEALTH_ENDPOINT="https://api.satsuma.ai/product?latitude=37.7749&longitude=-122.4194"
METRICS_ENDPOINT="https://metrics.yourservice.com/api/gauge"

health_check() {
  local timestamp=$(date +%s)
  
  # Make health check request with timeout
  response=$(timeout 5 curl -s -w "%{http_code}" \
    -H "Authorization: $API_KEY" \
    "$HEALTH_ENDPOINT")
  
  local exit_code=$?
  local http_code="${response: -3}"
  
  if [ $exit_code -eq 0 ] && [[ "$http_code" =~ ^2[0-9][0-9]$ ]]; then
    # Healthy
    local health_data=$(jq -n \
      --arg status "healthy" \
      --arg timestamp "$timestamp" \
      '{ status: $status, timestamp: ($timestamp | tonumber) }')
    
    echo "$health_data"
    
    # Send metrics (1 = healthy)
    curl -s -X POST "$METRICS_ENDPOINT" \
      -H "Content-Type: application/json" \
      -d '{"metric": "api_health", "value": 1, "timestamp": '$timestamp'}' \
      > /dev/null
    
    return 0
  else
    # Unhealthy
    local error_msg="HTTP $http_code or timeout"
    local health_data=$(jq -n \
      --arg status "unhealthy" \
      --arg error "$error_msg" \
      --arg timestamp "$timestamp" \
      '{ status: $status, error: $error, timestamp: ($timestamp | tonumber) }')
    
    echo "$health_data"
    
    # Send metrics (0 = unhealthy)
    curl -s -X POST "$METRICS_ENDPOINT" \
      -H "Content-Type: application/json" \
      -d '{"metric": "api_health", "value": 0, "timestamp": '$timestamp'}' \
      > /dev/null
    
    return 1
  fi
}

# Run health check
health_check

# For continuous monitoring, add to cron:
# */1 * * * * /path/to/health_check.sh