Integration Patterns (SDK-First)

package main

import (
	"context"
	"log"
	"net/http"
	"time"

	"github.com/tripswitch-dev/tripswitch-go"
)

func main() {
	// Initialize the client with project credentials.
	// NewClient blocks until the initial breaker state is synced via SSE.
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	ts, err := tripswitch.NewClient(ctx, "proj_abc123",
		tripswitch.WithAPIKey("eb_pk_live_..."),
		tripswitch.WithIngestSecret("your-64-char-hex-secret"),
	)
	if err != nil {
		log.Fatalf("Failed to initialize Tripswitch: %v", err)
	}
	defer ts.Close(context.Background())

	// Execute a protected call
	resp, err := tripswitch.Execute(
		ts,
		context.Background(),
		func() (*http.Response, error) {
			return http.Get("https://payments.example.com/charge")
		},
		// Gate on this breaker's state
		tripswitch.WithBreakers("payment-gateway"),
		// Route samples to this router
		tripswitch.WithRouter("rtr_uuid_from_dashboard"),
		// Auto-report latency
		tripswitch.WithMetrics(map[string]any{
			"latency": tripswitch.Latency,
		}),
	)

	// Handle the result
	if err != nil {
		if tripswitch.IsBreakerError(err) {
			// Breaker is open — the call was never attempted
			log.Println("Payment gateway unavailable, using fallback")
			return
		}
		// The call was attempted but failed
		log.Printf("Payment failed: %v", err)
		return
	}

	// Success
	defer resp.Body.Close()
	log.Printf("Payment succeeded: %d", resp.StatusCode)
}

import logging

import httpx
import tripswitch

logging.basicConfig(level=logging.INFO)
log = logging.getLogger(__name__)

# Initialize the client with project credentials.
# The context manager blocks until the initial breaker state is synced via SSE.
with tripswitch.Client(
    "proj_abc123",
    api_key="eb_pk_live_...",
    ingest_secret="your-64-char-hex-secret",
    timeout=10.0,
) as ts:

    # Execute a protected call
    try:
        resp = ts.execute(
            lambda: httpx.get("https://payments.example.com/charge"),
            # Gate on this breaker's state
            breakers=["payment-gateway"],
            # Route samples to this router
            router="rtr_uuid_from_dashboard",
            # Auto-report latency
            metrics={"latency": tripswitch.Latency},
        )
    except tripswitch.BreakerOpenError:
        # Breaker is open — the call was never attempted
        log.info("Payment gateway unavailable, using fallback")
    except httpx.HTTPError as exc:
        # The call was attempted but failed
        log.error("Payment failed: %s", exc)
    else:
        # Success
        log.info("Payment succeeded: %d", resp.status_code)

import { Client, Latency, BreakerOpenError } from "@tripswitch-dev/tripswitch";

async function main() {
  // Initialize the client with project credentials.
  // Client.create() blocks until the initial breaker state is synced via SSE.
  const ts = await Client.create({
    projectId: "proj_abc123",
    apiKey: "eb_pk_live_...",
    ingestSecret: "your-64-char-hex-secret",
    timeout: 10_000,
  });

  try {
    // Execute a protected call
    const resp = await ts.execute(
      () => fetch("https://payments.example.com/charge"),
      {
        // Gate on this breaker's state
        breakers: ["payment-gateway"],
        // Route samples to this router
        router: "rtr_uuid_from_dashboard",
        // Auto-report latency
        metrics: { latency: Latency },
      },
    );

    // Success
    console.log(`Payment succeeded: ${resp.status}`);
  } catch (err) {
    if (err instanceof BreakerOpenError) {
      // Breaker is open — the call was never attempted
      console.warn("Payment gateway unavailable, using fallback");
      return;
    }
    // The call was attempted but failed
    console.error("Payment failed:", err);
  } finally {
    await ts.close();
  }
}

main();

# In your supervision tree (application.ex)
children = [
  {Tripswitch.Client,
    project_id: "proj_abc123",
    api_key: "eb_pk_live_...",
    ingest_secret: "your-64-char-hex-secret",
    name: MyApp.Tripswitch}
]

# Execute a protected call
result =
  Tripswitch.execute(
    MyApp.Tripswitch,
    fn -> HTTPClient.get("https://payments.example.com/charge") end,
    # Gate on this breaker's state
    breakers: ["payment-gateway"],
    # Route samples to this router
    router: "rtr_uuid_from_dashboard",
    # Auto-report latency
    metrics: %{"latency" => :latency}
  )

# Handle the result
case result do
  {:error, :breaker_open} ->
    # Breaker is open — the call was never attempted
    Logger.warning("Payment gateway unavailable, using fallback")

  {:error, reason} ->
    # The call was attempted but failed
    Logger.error("Payment failed: #{inspect(reason)}")

  {:ok, resp} ->
    Logger.info("Payment succeeded: #{resp.status}")
end

import dev.tripswitch.*;
import java.net.URI;
import java.net.http.*;
import java.time.Duration;
import java.util.Map;

// Create client (blocks until SSE state sync completes)
try (TripSwitch ts = TripSwitch.builder("proj_abc123")
        .apiKey("eb_pk_live_...")
        .ingestSecret("ik_...")
        .build(Duration.ofSeconds(10))) {

    var httpClient = HttpClient.newHttpClient();
    var request = HttpRequest.newBuilder()
        .uri(URI.create("https://payments.example.com/charge"))
        .build();

    try {
        // Execute a protected call
        String body = ts.execute(
            () -> httpClient.send(request, HttpResponse.BodyHandlers.ofString()).body(),
            // Gate on this breaker's state
            TripSwitch.withBreakers("payment-gateway"),
            // Route samples to this router
            TripSwitch.withRouter("rtr_uuid_from_dashboard"),
            // Auto-report latency
            TripSwitch.withMetrics(Map.of("latency", TripSwitch.LATENCY))
        );
        // Success
        System.out.println("Payment succeeded");
    } catch (BreakerOpenException e) {
        // Breaker is open — the call was never attempted
        System.out.println("Payment gateway unavailable, using fallback");
    } catch (Exception e) {
        // The call was attempted but failed
        System.out.println("Payment failed: " + e.getMessage());
    }
}

use tripswitch::{Client, ExecuteOptions, MetricValue};
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create client (blocks until SSE state sync completes)
    let client = Client::builder("proj_abc123")
        .api_key("eb_pk_live_...")
        .ingest_secret("ik_...")
        .init_timeout(Duration::from_secs(10))
        .build()
        .await?;

    // Execute a protected call
    let result = client
        .execute(
            || async {
                reqwest::get("https://payments.example.com/charge")
                    .await?
                    .text()
                    .await
            },
            ExecuteOptions::new()
                // Gate on this breaker's state
                .breakers(&["payment-gateway"])
                // Route samples to this router
                .router("rtr_uuid_from_dashboard")
                // Auto-report latency
                .metric("latency", MetricValue::Latency),
        )
        .await;

    // Handle the result
    match result {
        Ok(body) => println!("Payment succeeded: {}", body),
        Err(e) if e.is_breaker_error() => {
            // Breaker is open — the call was never attempted
            println!("Payment gateway unavailable, using fallback");
        }
        Err(e) => println!("Payment failed: {e}"),
    }

    client.close().await;
    Ok(())
}

import qualified Data.Map.Strict as Map
import Network.HTTP.Simple (httpBS, parseRequest)
import Tripswitch

main :: IO ()
main = do
  let cfg = defaultConfig
        { cfgProjectID    = "proj_abc123"
        , cfgApiKey       = "eb_pk_live_..."
        , cfgIngestSecret = "ik_..."
        }

  -- withClient blocks until SSE state sync completes
  withClient cfg $ \client -> do
    req <- parseRequest "https://payments.example.com/charge"

    -- Execute a protected call
    result <- execute client defaultExecConfig
      { -- Gate on this breaker's state
        ecBreakers = ["payment-gateway"]
        -- Route samples to this router
      , ecRouterID = "rtr_uuid_from_dashboard"
        -- Auto-report latency
      , ecMetrics  = Map.singleton "latency" MetricLatency
      }
      (httpBS req)

    -- Handle the result
    case result of
      Left ErrBreakerOpen ->
        -- Breaker is open — the call was never attempted
        putStrLn "Payment gateway unavailable, using fallback"
      Left err ->
        -- The call was attempted but failed
        print err
      Right _resp ->
        putStrLn "Payment succeeded"

resp, err := tripswitch.Execute(ts, ctx, callPaymentAPI,
	tripswitch.WithBreakers("payment-gateway"),
	tripswitch.WithRouter("rtr_uuid"),
	tripswitch.WithErrorEvaluator(func(err error) bool {
		// Don't count client errors as breaker failures
		var httpErr *HTTPError
		if errors.As(err, &httpErr) {
			return httpErr.StatusCode >= 500
		}
		return err != nil
	}),
)

resp = ts.execute(
    call_payment_api,
    breakers=["payment-gateway"],
    router="rtr_uuid",
    error_evaluator=lambda e: (
        # Don't count client errors as breaker failures
        e.status_code >= 500 if isinstance(e, HTTPError) else True
    ),
)

const resp = await ts.execute(callPaymentAPI, {
  breakers: ["payment-gateway"],
  errorEvaluator: (err) => {
    // Don't count client errors as breaker failures
    if (err instanceof HTTPError) {
      return err.statusCode >= 500;
    }
    return true;
  },
});

Tripswitch.execute(
  MyApp.Tripswitch,
  fn -> call_payment_api() end,
  breakers: ["payment-gateway"],
  router: "rtr_uuid",
  error_evaluator: fn
    # Don't count client errors as breaker failures
    {:error, %HTTPError{status: status}} -> status >= 500
    {:error, _} -> true
    _ -> false
  end
)

String body = ts.execute(
    () -> callPaymentAPI(),
    TripSwitch.withBreakers("payment-gateway"),
    TripSwitch.withRouter("rtr_uuid"),
    TripSwitch.withErrorEvaluator(e -> {
        // Don't count client errors as breaker failures
        if (e instanceof HttpResponseException hre) {
            return hre.getStatusCode() >= 500;
        }
        return true; // non-HTTP errors are failures
    })
);

let result = client
    .execute(
        || async { call_payment_api().await },
        ExecuteOptions::new()
            .breakers(&["payment-gateway"])
            .router("rtr_uuid")
            .error_evaluator(|err| {
                // Don't count client errors as breaker failures
                !err.to_string().contains("status: 4")
            }),
    )
    .await;

result <- execute client defaultExecConfig
  { ecBreakers       = ["payment-gateway"]
  , ecRouterID       = "rtr_uuid"
  , ecErrorEvaluator = Just $ \ex ->
      -- Don't count client errors as breaker failures
      case fromException ex of
        Just (HttpError status _) -> status >= 500
        Nothing                   -> True -- non-HTTP errors are failures
  }
  callPaymentAPI

stats := ts.Stats()
if !stats.SSEConnected {
	log.Println("WARNING: Tripswitch state sync disconnected, operating on stale data")
}

stats = ts.stats()
if not stats.sse_connected:
    logger.warning("Tripswitch state sync disconnected, operating on stale data")

const { sseConnected } = ts.stats;
if (!sseConnected) {
  console.warn("Tripswitch state sync disconnected, operating on stale data");
}

stats = Tripswitch.stats(MyApp.Tripswitch)
unless stats.sse_connected do
  Logger.warning("Tripswitch state sync disconnected, operating on stale data")
end

SDKStats stats = ts.stats();
if (!stats.sseConnected()) {
    log.warn("Tripswitch state sync disconnected, operating on stale data");
}

let stats = client.stats();
if !stats.sse_connected {
    log::warn!("Tripswitch state sync disconnected, operating on stale data");
}

stats <- getStats client
unless (sseConnected stats) $
    putStrLn "WARNING: Tripswitch state sync disconnected, operating on stale data"

// Wrong: Calling the dependency anyway
resp, err := tripswitch.Execute(ts, ctx, callDependency,
	tripswitch.WithBreakers("my-breaker"),
)
if err != nil {
	resp, err = callDependency() // Defeats the purpose
}

# Wrong: Calling the dependency anyway
try:
    resp = ts.execute(call_dependency, breakers=["my-breaker"])
except tripswitch.BreakerOpenError:
    resp = call_dependency()  # Defeats the purpose

// Wrong: Calling the dependency anyway
try {
  const resp = await ts.execute(callDependency, { breakers: ["my-service"] });
} catch (err) {
  const resp = await callDependency(); // Defeats the purpose
}

# Wrong: Calling the dependency anyway
case Tripswitch.execute(MyApp.Tripswitch, fn -> call_dependency() end,
       breakers: ["my-breaker"]
     ) do
  {:error, :breaker_open} ->
    call_dependency()  # Defeats the purpose

  result ->
    result
end

// Wrong: Calling the dependency anyway
try {
    result = ts.execute(
        () -> callDependency(),
        TripSwitch.withBreakers("my-breaker")
    );
} catch (BreakerOpenException e) {
    result = callDependency(); // Defeats the purpose
}

// Wrong: Calling the dependency anyway
let result = client
    .execute(
        || async { call_dependency().await },
        ExecuteOptions::new().breakers(&["my-breaker"]),
    )
    .await;
if result.is_err() {
    let _result = call_dependency().await; // Defeats the purpose
}

-- Wrong: Calling the dependency anyway
result <- execute client defaultExecConfig
  { ecBreakers = ["my-breaker"] }
  callDependency
case result of
  Left ErrBreakerOpen ->
    callDependency  -- Defeats the purpose
  Left err  -> throwIO err
  Right val -> pure val

// Wrong: Success reported even when response is unusable
resp, _ := tripswitch.Execute(ts, ctx, func() (*Response, error) {
	r, err := callAPI()
	if err != nil {
		return nil, err
	}
	return r, nil // Reported as success even if r.Status == 500
},
	tripswitch.WithBreakers("my-breaker"),
	tripswitch.WithRouter("rtr_uuid"),
)

# Wrong: Success reported even when response is unusable
def call():
    r = call_api()
    return r  # Reported as success even if r.status_code == 500

resp = ts.execute(call, breakers=["my-breaker"])

// Wrong: Success reported even when response is unusable
const resp = await ts.execute(
  async () => {
    const r = await callAPI();
    return r; // Reported as success even if r.status === 500
  },
  { breakers: ["my-service"] },
);

# Wrong: Success reported even when response is unusable
Tripswitch.execute(
  MyApp.Tripswitch,
  fn ->
    {:ok, resp} = call_api()
    {:ok, resp}  # Reported as success even if resp.status == 500
  end,
  breakers: ["my-breaker"],
  router: "rtr_uuid"
)

// Wrong: Success reported even when response is unusable
try {
    HttpResponse<String> resp = ts.execute(
        () -> httpClient.send(request, HttpResponse.BodyHandlers.ofString()),
        TripSwitch.withBreakers("my-breaker"),
        TripSwitch.withRouter("rtr_uuid")
        // Missing: withErrorEvaluator to check resp.statusCode() >= 500
    );
    // Reported as success even if resp.statusCode() == 500
} catch (BreakerOpenException e) { /* ... */ }

// Wrong: Success reported even when response is unusable
let result = client
    .execute(
        || async {
            let r = call_api().await?;
            Ok::<_, reqwest::Error>(r) // Reported as success even if r.status() == 500
        },
        ExecuteOptions::new()
            .breakers(&["my-breaker"])
            .router("rtr_uuid"),
        // Missing: .error_evaluator to check response status
    )
    .await;

-- Wrong: Success reported even when response is unusable
result <- execute client defaultExecConfig
  { ecBreakers = ["my-breaker"]
  , ecRouterID = "rtr_uuid"
  -- Missing: ecErrorEvaluator to check response status
  }
  (do
    r <- callAPI
    pure r  -- Reported as success even if responseStatus r == 500
  )