for Digital Nomads South America vs Marketer: Which Wins?

import requests
import time
import json
import logging
from typing import Dict, List
import os

# Configure logging for error handling
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[logging.FileHandler("nomad_benchmark.log"), logging.StreamHandler()]
)

class NomadBenchmarker:
    """Benchmarks HashiCorp Nomad deployment latency from South America regions."""

    def __init__(self, nomad_addr: str = "http://localhost:4646", region: str = "global"):
        self.nomad_addr = nomad_addr.rstrip("/")
        self.region = region
        self.results: List[Dict] = []
        # Validate Nomad API connectivity on init
        try:
            resp = requests.get(f"{self.nomad_addr}/v1/agent/health", timeout=10)
            resp.raise_for_status()
            logging.info(f"Connected to Nomad at {self.nomad_addr}, region: {self.region}")
        except requests.exceptions.RequestException as e:
            logging.error(f"Failed to connect to Nomad: {e}")
            raise

    def deploy_test_job(self, job_name: str = "benchmark-job") -> float:
        """Deploys a test job and returns latency in ms."""
        job_spec = {
            "Job": {
                "ID": job_name,
                "Name": job_name,
                "Type": "batch",
                "Datacenters": ["sa-east-1"],
                "Region": self.region,
                "TaskGroups": [{
                    "Name": "bench-group",
                    "Count": 1,
                    "Tasks": [{
                        "Name": "bench-task",
                        "Driver": "docker",
                        "Config": {"image": "alpine:3.18", "command": "echo", "args": ["hello"]},
                        "Resources": {"CPU": 100, "MemoryMB": 128}
                    }]
                }]
            }
        }
        start_time = time.time()
        try:
            # Submit job to Nomad API
            resp = requests.post(
                f"{self.nomad_addr}/v1/jobs",
                json=job_spec,
                headers={"Content-Type": "application/json"},
                timeout=30
            )
            resp.raise_for_status()
            # Wait for job to complete
            job_id = resp.json().get("ID")
            while True:
                status_resp = requests.get(f"{self.nomad_addr}/v1/job/{job_id}", timeout=10)
                status_resp.raise_for_status()
                status = status_resp.json().get("Status")
                if status == "dead":
                    end_time = time.time()
                    latency_ms = (end_time - start_time) * 1000
                    logging.info(f"Job {job_name} completed in {latency_ms:.2f}ms")
                    return latency_ms
                time.sleep(1)
        except requests.exceptions.RequestException as e:
            logging.error(f"Deployment failed for {job_name}: {e}")
            return -1.0
        finally:
            # Clean up job
            try:
                requests.delete(f"{self.nomad_addr}/v1/job/{job_name}", timeout=10)
            except:
                pass

    def run_benchmark(self, iterations: int = 100) -> None:
        """Runs N benchmark iterations and saves results."""
        for i in range(iterations):
            latency = self.deploy_test_job(f"benchmark-{i}")
            self.results.append({"iteration": i, "latency_ms": latency})
        # Save results to JSON
        with open("nomad_benchmark_results.json", "w") as f:
            json.dump(self.results, f, indent=2)
        avg_latency = sum(r["latency_ms"] for r in self.results if r["latency_ms"] > 0) / len(self.results)
        logging.info(f"Benchmark complete. Avg latency: {avg_latency:.2f}ms over {iterations} iterations")

if __name__ == "__main__":
    # Benchmark configuration: Medellin co-working space, 500Mbps fiber, M2 MacBook Pro
    # Nomad v1.7.4 running on AWS sa-east-1 (São Paulo) 4x c6g.2xlarge nodes
    try:
        benchmarker = NomadBenchmarker(nomad_addr="http://nomad.sa-east-1.example.com:4646")
        benchmarker.run_benchmark(iterations=100)
    except Exception as e:
        logging.critical(f"Benchmark failed: {e}")
        exit(1)

require 'marketer'
require 'benchmark'
require 'json'
require 'logger'

# Configure logger for error handling
logger = Logger.new('marketer_benchmark.log')
logger.level = Logger::INFO

class MarketerBenchmarker
  # Initializes the Marketer benchmarker with API credentials
  # @param api_key [String] Marketer API key
  # @param region [String] Deployment region (default: us-east-1)
  def initialize(api_key:, region: 'us-east-1')
    @api_key = api_key
    @region = region
    @results = []
    # Validate Marketer API connectivity on init
    begin
      Marketer.configure do |config|
        config.api_key = @api_key
        config.region = @region
      end
      # Test API connection
      Marketer::Campaign.list(limit: 1)
      logger.info("Connected to Marketer API, region: #{@region}")
    rescue Marketer::AuthenticationError => e
      logger.error("Authentication failed: #{e.message}")
      raise
    rescue Marketer::APIError => e
      logger.error("API connection failed: #{e.message}")
      raise
    end
  end

  # Sends a test campaign and returns latency in ms
  # @param campaign_name [String] Name of the test campaign
  # @return [Float] Latency in milliseconds, -1 if failed
  def send_test_campaign(campaign_name: 'benchmark-campaign')
    campaign_spec = {
      name: campaign_name,
      template: 'welcome-email',
      recipients: ['test@example.com'],
      metadata: { benchmark: true }
    }

    start_time = Time.now
    begin
      # Create and send campaign
      campaign = Marketer::Campaign.create(campaign_spec)
      campaign.send!
      # Wait for campaign to complete
      while campaign.reload.status != 'sent'
        sleep 1
      end
      end_time = Time.now
      latency_ms = (end_time - start_time) * 1000
      logger.info("Campaign #{campaign_name} sent in #{latency_ms.round(2)}ms")
      latency_ms
    rescue Marketer::RateLimitError => e
      logger.warn("Rate limited, retrying after #{e.retry_after}s")
      sleep e.retry_after
      retry
    rescue Marketer::APIError => e
      logger.error("Campaign send failed: #{e.message}")
      -1.0
    ensure
      # Clean up campaign
      begin
        campaign.delete if campaign
      rescue
        # Ignore cleanup errors
      end
    end
  end

  # Runs N benchmark iterations and saves results
  # @param iterations [Integer] Number of benchmark runs
  def run_benchmark(iterations: 100)
    iterations.times do |i|
      latency = send_test_campaign(campaign_name: "benchmark-#{i}")
      @results << { iteration: i, latency_ms: latency }
    end
    # Save results to JSON
    File.write('marketer_benchmark_results.json', JSON.pretty_generate(@results))
    valid_results = @results.select { |r| r[:latency_ms] > 0 }
    avg_latency = valid_results.sum { |r| r[:latency_ms] } / valid_results.size
    logger.info("Benchmark complete. Avg latency: #{avg_latency.round(2)}ms over #{iterations} iterations")
  end
end

if __FILE__ == $0
  # Benchmark configuration: San Francisco office, 1Gbps fiber, MacBook Pro M2
  # Marketer v2.3.1, Heroku US region, 10 dynos
  begin
    benchmarker = MarketerBenchmarker.new(
      api_key: ENV.fetch('MARKETER_API_KEY'),
      region: 'us-east-1'
    )
    benchmarker.run_benchmark(iterations: 100)
  rescue KeyError => e
    logger.critical("Missing environment variable: #{e.message}")
    exit 1
  rescue StandardError => e
    logger.critical("Benchmark failed: #{e.message}")
    exit 1
  end
end

package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "os"
    "sync"
    "time"
    "github.com/go-resty/resty/v2"
)

// Configure logger for error handling
var logger = log.New(os.Stdout, "benchmark: ", log.LstdFlags|log.Lshortfile)

// Endpoint represents a target API endpoint to benchmark
type Endpoint struct {
    Name    string
    URL     string
    Region  string
}

// BenchmarkResult stores latency results for an endpoint
type BenchmarkResult struct {
    EndpointName string
    Region       string
    LatencyMs    float64
    Error        string
}

func main() {
    // Define endpoints: Nomad in sa-east-1, Marketer in us-east-1
    endpoints := []Endpoint{
        {Name: "HashiCorp Nomad", URL: "http://nomad.sa-east-1.example.com:4646/v1/agent/health", Region: "sa-east-1"},
        {Name: "ThoughtBot Marketer", URL: "https://api.marketer.io/v1/health", Region: "us-east-1"},
    }

    // Benchmark config: run from Medellin, Colombia (public IP: 190.85.123.45)
    // Hardware: MacBook Pro M2, 500Mbps fiber, Speedtest CLI v2.1.3
    const iterations = 100
    var wg sync.WaitGroup
    results := make(chan BenchmarkResult, len(endpoints)*iterations)

    client := resty.New().
        SetTimeout(30 * time.Second).
        SetRetryCount(3).
        SetRetryWaitTime(1 * time.Second)

    for _, ep := range endpoints {
        wg.Add(1)
        go func(e Endpoint) {
            defer wg.Done()
            for i := 0; i < iterations; i++ {
                start := time.Now()
                resp, err := client.R().Get(e.URL)
                latency := time.Since(start).Milliseconds()

                result := BenchmarkResult{
                    EndpointName: e.Name,
                    Region:       e.Region,
                    LatencyMs:    float64(latency),
                }

                if err != nil {
                    result.Error = err.Error()
                    logger.Printf("Error benchmarking %s: %v", e.Name, err)
                } else if resp.StatusCode() != http.StatusOK {
                    result.Error = fmt.Sprintf("Non-200 status: %d", resp.StatusCode())
                    logger.Printf("Error benchmarking %s: %s", e.Name, result.Error)
                } else {
                    logger.Printf("Benchmarked %s: %dms", e.Name, latency)
                }
                results <- result
            }
        }(ep)
    }

    // Wait for all benchmarks to complete
    wg.Wait()
    close(results)

    // Aggregate results
    nomadLatencies := []float64{}
    marketerLatencies := []float64{}
    for res := range results {
        if res.Error != "" {
            continue
        }
        if res.EndpointName == "HashiCorp Nomad" {
            nomadLatencies = append(nomadLatencies, res.LatencyMs)
        } else {
            marketerLatencies = append(marketerLatencies, res.LatencyMs)
        }
    }

    // Calculate averages
    nomadAvg := average(nomadLatencies)
    marketerAvg := average(marketerLatencies)

    // Print results
    fmt.Println("=== Benchmark Results (100 iterations each) ===")
    fmt.Printf("HashiCorp Nomad (sa-east-1): %.2fms avg latency\n", nomadAvg)
    fmt.Printf("ThoughtBot Marketer (us-east-1): %.2fms avg latency\n", marketerAvg)
    fmt.Printf("Nomad is %.2fx faster for South America-based users\n", marketerAvg/nomadAvg)
}

// average calculates the average of a slice of float64s
func average(latencies []float64) float64 {
    if len(latencies) == 0 {
        return 0.0
    }
    sum := 0.0
    for _, l := range latencies {
        sum += l
    }
    return sum / float64(len(latencies))
}