docker run -d --name bloop \
  -p 5332:5332 \
  -v bloop_data:/data \
  -e BLOOP__AUTH__HMAC_SECRET=your-secret-here \
  ghcr.io/jaikoo/bloop:latest

git clone https://github.com/jaikoo/bloop.git
cd bloop
cargo build --release
./target/release/bloop --config config.toml

cargo build --release --features analytics

# Your project API key (from Settings → Projects)
API_KEY="bloop_abc123..."

# Compute HMAC signature using the project key
BODY='{"timestamp":1700000000,"source":"api","environment":"production","release":"1.0.0","error_type":"RuntimeError","message":"Something went wrong"}'
SIG=$(echo -n "$BODY" | openssl dgst -sha256 -hmac "$API_KEY" | awk '{print $2}')

# Send to bloop
curl -X POST http://localhost:5332/v1/ingest \
  -H "Content-Type: application/json" \
  -H "X-Project-Key: $API_KEY" \
  -H "X-Signature: $SIG" \
  -d "$BODY"

# ── Server ──
[server]
host = "0.0.0.0"
port = 5332

# ── Database ──
[database]
path = "bloop.db"       # SQLite file path
pool_size = 4            # deadpool-sqlite connections

# ── Ingestion ──
[ingest]
max_payload_bytes = 32768   # Max single request body
max_stack_bytes = 8192      # Max stack trace length
max_metadata_bytes = 4096   # Max metadata JSON size
max_message_bytes = 2048    # Max error message length
max_batch_size = 50         # Max events per batch request
channel_capacity = 8192     # MPSC channel buffer size

# ── Pipeline ──
[pipeline]
flush_interval_secs = 2     # Flush timer
flush_batch_size = 500       # Events per batch write
sample_reservoir_size = 5   # Sample occurrences kept per fingerprint

# ── Retention ──
[retention]
raw_events_days = 7         # Raw event TTL
prune_interval_secs = 3600  # How often to run cleanup

# ── Auth ──
[auth]
hmac_secret = "change-me-in-production"
rp_id = "localhost"                     # WebAuthn relying party ID
rp_origin = "http://localhost:5332"      # WebAuthn origin
session_ttl_secs = 604800                 # Session lifetime (7 days)

# ── Rate Limiting ──
[rate_limit]
per_second = 100
burst_size = 200

# ── Alerting ──
[alerting]
cooldown_secs = 900        # Min seconds between re-fires

# ── SMTP (for email alerts) ──
[smtp]
enabled = false
host = "smtp.example.com"
port = 587
username = ""
password = ""
from = "bloop@example.com"
starttls = true

interface IngestEvent {
  timestamp: number;          // Unix epoch seconds
  source: "ios" | "android" | "api";
  environment: string;        // "production", "staging", etc.
  release: string;            // Semver or build ID
  error_type: string;         // Exception class name
  message: string;            // Error message
  app_version?: string;       // Display version
  build_number?: string;      // Build number
  route_or_procedure?: string; // API route or RPC method
  screen?: string;            // Mobile screen name
  stack?: string;             // Stack trace
  http_status?: number;       // HTTP status code
  request_id?: string;        // Correlation ID
  user_id_hash?: string;      // Hashed user identifier
  device_id_hash?: string;    // Hashed device identifier
  fingerprint?: string;       // Custom fingerprint (overrides auto)
  metadata?: Record<string, unknown>; // Arbitrary extra data
}

npm install @bloop/sdk

import { BloopClient } from "@bloop/sdk";

const bloop = new BloopClient({
  endpoint: "https://errors.myapp.com",
  projectKey: "bloop_abc123...",   // From project settings
  environment: "production",
  release: "1.2.0",
});

// Install global handlers to catch uncaught exceptions & unhandled rejections
bloop.installGlobalHandlers();

// Capture an Error object
try {
  riskyOperation();
} catch (err) {
  bloop.captureError(err, {
    route: "POST /api/users",
    httpStatus: 500,
  });
}

// Capture a structured event
bloop.capture({
  errorType: "ValidationError",
  message: "Invalid email format",
  route: "POST /api/users",
  httpStatus: 422,
});

// Express middleware
import express from "express";

const app = express();
app.use(bloop.errorMiddleware());

// Flush on shutdown
await bloop.shutdown();

async function sendToBloop(
  endpoint: string,
  projectKey: string,
  event: Record<string, unknown>,
) {
  const body = JSON.stringify(event);
  const encoder = new TextEncoder();
  const key = await crypto.subtle.importKey(
    "raw", encoder.encode(projectKey),
    { name: "HMAC", hash: "SHA-256" }, false, ["sign"],
  );
  const sig = await crypto.subtle.sign("HMAC", key, encoder.encode(body));
  const hex = [...new Uint8Array(sig)]
    .map(b => b.toString(16).padStart(2, "0")).join("");

  await fetch(`${endpoint}/v1/ingest`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-Project-Key": projectKey,
      "X-Signature": hex,
    },
    body,
  });
}

// Usage
await sendToBloop("https://errors.myapp.com", "bloop_abc123...", {
  timestamp: Math.floor(Date.now() / 1000),
  source: "api",
  environment: "production",
  release: "1.2.0",
  error_type: "TypeError",
  message: "Cannot read property of undefined",
});

// Automatically added to metadata:
{
  metadata: {
    unhandled: true,
    mechanism: "uncaughtException"  // or "unhandledRejection"
  }
}

.package(url: "https://github.com/jaikoo/bloop-swift.git", from: "0.4.0")

import Bloop

// Configure once at app launch (e.g. in AppDelegate or @main App.init)
BloopClient.configure(
    endpoint: "https://errors.myapp.com",
    secret: "your-hmac-secret",
    projectKey: "bloop_abc123...",  // From Settings → Projects
    environment: "production",
    release: "2.1.0"
)

// Install crash handler (captures SIGABRT, SIGSEGV, etc.)
BloopClient.shared?.installCrashHandler()

// Install lifecycle handlers (flush on background/terminate)
BloopClient.shared?.installLifecycleHandlers()

// Capture an error manually
do {
    try riskyOperation()
} catch {
    BloopClient.shared?.capture(
        error: error,
        screen: "HomeViewController"
    )
}

// Capture a structured event
BloopClient.shared?.capture(
    errorType: "NetworkError",
    message: "Request timed out",
    screen: "HomeViewController"
)

// Synchronous flush (e.g. before a crash report is sent)
BloopClient.shared?.flushSync()

// Close the client (flushes remaining events)
BloopClient.shared?.close()

import Foundation
import CommonCrypto

struct BloopClient {
    let url: URL
    let projectKey: String  // From Settings → Projects

    func send(event: [String: Any]) async throws {
        let body = try JSONSerialization.data(withJSONObject: event)
        let signature = hmacSHA256(data: body, key: projectKey)

        var request = URLRequest(url: url.appendingPathComponent("/v1/ingest"))
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.setValue(projectKey, forHTTPHeaderField: "X-Project-Key")
        request.setValue(signature, forHTTPHeaderField: "X-Signature")
        request.httpBody = body

        let (_, response) = try await URLSession.shared.data(for: request)
        guard let http = response as? HTTPURLResponse,
              http.statusCode == 200 else {
            return // Fire and forget — don't crash the app
        }
    }

    private func hmacSHA256(data: Data, key: String) -> String {
        let keyData = key.data(using: .utf8)!
        var digest = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
        keyData.withUnsafeBytes { keyBytes in
            data.withUnsafeBytes { dataBytes in
                CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256),
                       keyBytes.baseAddress, keyData.count,
                       dataBytes.baseAddress, data.count,
                       &digest)
            }
        }
        return digest.map { String(format: "%02x", $0) }.joined()
    }
}

// Usage
let client = BloopClient(
    url: URL(string: "https://errors.myapp.com")!,
    projectKey: "bloop_abc123..."
)

try await client.send(event: [
    "timestamp": Int(Date().timeIntervalSince1970),
    "source": "ios",
    "environment": "production",
    "release": "2.1.0",
    "error_type": "NetworkError",
    "message": "Request timed out",
    "screen": "HomeViewController",
])

implementation("com.jaikoo.bloop:bloop-client:0.1.0")

import com.jaikoo.bloop.BloopClient

// Configure once in Application.onCreate()
BloopClient.configure(
    endpoint = "https://errors.myapp.com",
    secret = "your-hmac-secret",
    projectKey = "bloop_abc123...",  // From Settings → Projects
    environment = "production",
    release = "3.0.1",
)

// Install uncaught exception handler
BloopClient.shared?.installUncaughtExceptionHandler()

// Capture a throwable
try {
    riskyOperation()
} catch (e: Exception) {
    BloopClient.shared?.capture(e, screen = "ProfileFragment")
}

// Capture a structured event
BloopClient.shared?.capture(
    errorType = "IllegalStateException",
    message = "Fragment not attached to activity",
    screen = "ProfileFragment",
)

// Synchronous flush (e.g. before process death)
BloopClient.shared?.flushSync()

// Async flush
BloopClient.shared?.flush()

import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody
import org.json.JSONObject
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec

class BloopClient(
    private val baseUrl: String,
    private val projectKey: String,  // From Settings → Projects
) {
    private val client = OkHttpClient()
    private val json = "application/json".toMediaType()

    fun send(event: JSONObject) {
        val body = event.toString()
        val signature = hmacSha256(body, projectKey)

        val request = Request.Builder()
            .url("$baseUrl/v1/ingest")
            .post(body.toRequestBody(json))
            .addHeader("X-Project-Key", projectKey)
            .addHeader("X-Signature", signature)
            .build()

        // Fire and forget on background thread
        client.newCall(request).enqueue(object : Callback {
            override fun onFailure(call: Call, e: IOException) {}
            override fun onResponse(call: Call, response: Response) {
                response.close()
            }
        })
    }

    private fun hmacSha256(data: String, key: String): String {
        val mac = Mac.getInstance("HmacSHA256")
        mac.init(SecretKeySpec(key.toByteArray(), "HmacSHA256"))
        return mac.doFinal(data.toByteArray())
            .joinToString("") { "%02x".format(it) }
    }
}

// Usage
val bloop = BloopClient("https://errors.myapp.com", "bloop_abc123...")
bloop.send(JSONObject().apply {
    put("timestamp", System.currentTimeMillis() / 1000)
    put("source", "android")
    put("environment", "production")
    put("release", "3.0.1")
    put("error_type", "IllegalStateException")
    put("message", "Fragment not attached to activity")
    put("screen", "ProfileFragment")
})

pip install bloop-sdk

from bloop import BloopClient

# Initialize — auto-captures uncaught exceptions via sys.excepthook
client = BloopClient(
    endpoint="https://errors.myapp.com",
    project_key="bloop_abc123...",  # From Settings → Projects
    environment="production",
    release="1.0.0",
)

# Capture an exception with full traceback
try:
    risky_operation()
except Exception as e:
    client.capture_exception(e,
        route_or_procedure="POST /api/process",
    )
    # Extracts: error_type, message, and full stack trace automatically

# Capture a structured event (no exception object needed)
client.capture(
    error_type="ValidationError",
    message="Invalid email format",
    route_or_procedure="POST /api/users",
)

# Context manager for graceful shutdown
with BloopClient(endpoint="...", project_key="...") as bloop:
    bloop.capture(error_type="TestError", message="Hello")
# flush + close happen automatically

import hmac, hashlib, json, time
from urllib.request import Request, urlopen

def send_to_bloop(endpoint, project_key, event):
    body = json.dumps(event).encode()
    sig = hmac.new(
        project_key.encode(), body, hashlib.sha256
    ).hexdigest()

    req = Request(
        f"{endpoint}/v1/ingest",
        data=body,
        headers={
            "Content-Type": "application/json",
            "X-Project-Key": project_key,
            "X-Signature": sig,
        },
    )
    urlopen(req)

# Usage
send_to_bloop("https://errors.myapp.com", "bloop_abc123...", {
    "timestamp": int(time.time()),
    "source": "api",
    "environment": "production",
    "release": "1.0.0",
    "error_type": "ValueError",
    "message": "Invalid input",
})

gem install bloop

require "bloop"

client = Bloop::Client.new(
  endpoint: "https://errors.myapp.com",
  project_key: "bloop_abc123...",  # From Settings → Projects
  environment: "production",
  release: "1.0.0",
)

# Capture an exception
begin
  risky_operation
rescue => e
  client.capture_exception(e, route_or_procedure: "POST /api/orders")
end

# Structured event capture
client.capture(
  error_type: "ValidationError",
  message: "Invalid email format",
  route_or_procedure: "POST /api/users",
)

# Block-based error capture
client.with_error_capture(route_or_procedure: "POST /api/checkout") do
  process_payment
end
# If process_payment raises, the exception is captured and re-raised

# Graceful shutdown
client.close

# Rails — config/application.rb
require "bloop"

BLOOP_CLIENT = Bloop::Client.new(
  endpoint: "https://errors.myapp.com",
  project_key: "bloop_abc123...",
  environment: Rails.env,
  release: "1.0.0",
)
config.middleware.use Bloop::RackMiddleware, client: BLOOP_CLIENT

# Sinatra
require "bloop"

client = Bloop::Client.new(
  endpoint: "https://errors.myapp.com",
  project_key: "bloop_abc123...",
  environment: "production",
  release: "1.0.0",
)
use Bloop::RackMiddleware, client: client

require "net/http"
require "json"
require "openssl"

def send_to_bloop(endpoint, project_key, event)
  body = event.to_json
  sig  = OpenSSL::HMAC.hexdigest("SHA256", project_key, body)

  uri = URI("#{endpoint}/v1/ingest")
  req = Net::HTTP::Post.new(uri)
  req["Content-Type"]  = "application/json"
  req["X-Project-Key"] = project_key
  req["X-Signature"]   = sig
  req.body = body

  Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
    http.request(req)
  end
end

# Usage
send_to_bloop("https://errors.myapp.com", "bloop_abc123...", {
  timestamp: Time.now.to_i,
  source: "api",
  environment: "production",
  release: "1.0.0",
  error_type: "RuntimeError",
  message: "Something went wrong",
})

npm install @bloop/react-native

import { useBloop, BloopErrorBoundary } from "@bloop/react-native";

function App() {
  const bloop = useBloop({
    endpoint: "https://errors.myapp.com",
    projectKey: "bloop_abc123...",
    environment: "production",
    release: "1.0.0",
    appVersion: "1.0.0",
    buildNumber: "42",
  });
  // useBloop automatically installs all three global handlers:
  // 1. ErrorUtils global handler (uncaught JS exceptions)
  // 2. Promise rejection handler
  // 3. AppState handler (flushes on background/inactive)

  return (
    <BloopErrorBoundary
      client={bloop}
      fallback={<ErrorScreen />}
    >
      <Navigation />
    </BloopErrorBoundary>
  );
}

import { BloopRNClient } from "@bloop/react-native";

const bloop = new BloopRNClient({ /* ... */ });

// Flushes buffered events when the app goes to background or inactive
bloop.installAppStateHandler();

// Captures unhandled promise rejections as error events
bloop.installPromiseRejectionHandler();

// Clean up all handlers when done
await bloop.shutdown();

[
  {
    "fingerprint": "a1b2c3d4e5f6",
    "project_id": "proj_abc123",
    "release": "1.2.0",
    "environment": "production",
    "error_type": "RuntimeError",
    "message": "connection refused at ::",
    "source": "api",
    "total_count": 42,
    "first_seen": 1700000000000,
    "last_seen": 1700086400000,
    "status": "unresolved"
  }
]

{
  "aggregates": [
    {
      "fingerprint": "a1b2c3d4",
      "release": "1.2.0",
      "environment": "production",
      "total_count": 42,
      "status": "unresolved",
      "first_seen": 1700000000000,
      "last_seen": 1700086400000
    }
  ],
  "samples": [
    {
      "source": "api",
      "release": "1.2.0",
      "stack": "Error: connection refused\n  at fetch (/app/src/api.js:42:5)",
      "metadata": {},
      "captured_at": 1700086400000,
      "deobfuscated_stack": [
        {
          "raw_frame": "  at fetch (/app/dist/bundle.min.js:1:2345)",
          "original_file": "src/api.ts",
          "original_line": 42,
          "original_column": 5,
          "original_name": "fetchData"
        }
      ]
    }
  ]
}

[
  { "hour_bucket": 1700006400000, "count": 12 },
  { "hour_bucket": 1700010000000, "count": 5 },
  { "hour_bucket": 1700013600000, "count": 23 }
]

curl -X POST http://localhost:5332/v1/tokens \
  -H "Content-Type: application/json" \
  -H "Cookie: bloop_session=YOUR_SESSION_TOKEN" \
  -d '{
    "name": "CI Pipeline",
    "project_id": "PROJECT_UUID",
    "scopes": ["errors:read", "sourcemaps:write"],
    "expires_in_days": 90
  }'

{
  "id": "tok_abc123",
  "name": "CI Pipeline",
  "token": "bloop_tk_aBcDeFgHiJk...",
  "token_prefix": "bloop_tk_aBcDeFg",
  "project_id": "PROJECT_UUID",
  "scopes": ["errors:read", "sourcemaps:write"],
  "created_at": 1700000000,
  "expires_at": 1707776000
}

# List errors for the token's project
curl -H "Authorization: Bearer bloop_tk_aBcDeFgHiJk..." \
  https://errors.myapp.com/v1/errors

# Resolve an error (requires errors:write scope)
curl -X POST -H "Authorization: Bearer bloop_tk_aBcDeFgHiJk..." \
  https://errors.myapp.com/v1/errors/FINGERPRINT/resolve

# Upload a source map (requires sourcemaps:write scope)
curl -X POST -H "Authorization: Bearer bloop_tk_aBcDeFgHiJk..." \
  -F "release=1.2.0" -F "file=@dist/app.js.map" \
  https://errors.myapp.com/v1/projects/my-app/sourcemaps

# List tokens for a project (never shows the plaintext token)
curl -H "Cookie: bloop_session=YOUR_SESSION_TOKEN" \
  "https://errors.myapp.com/v1/tokens?project_id=PROJECT_UUID"

# Revoke a token
curl -X DELETE -H "Cookie: bloop_session=YOUR_SESSION_TOKEN" \
  https://errors.myapp.com/v1/tokens/TOKEN_ID

curl -X POST http://localhost:5332/v1/alerts \
  -H "Content-Type: application/json" \
  -H "Cookie: session=YOUR_SESSION_TOKEN" \
  -d '{
    "name": "New production issues",
    "config": {
      "type": "new_issue",
      "environment": "production"
    }
  }'

{
  "alert_rule": "New production issues",
  "fingerprint": "a1b2c3d4e5f6",
  "error_type": "RuntimeError",
  "message": "Something went wrong",
  "environment": "production",
  "source": "api",
  "timestamp": 1700000000
}

# Add a Slack channel to a rule
curl -X POST http://localhost:5332/v1/alerts/1/channels \
  -H "Content-Type: application/json" \
  -H "Cookie: session=YOUR_SESSION_TOKEN" \
  -d '{"config": {"type": "slack", "webhook_url": "https://hooks.slack.com/services/XXX"}}'

# Add a generic webhook channel
curl -X POST http://localhost:5332/v1/alerts/1/channels \
  -H "Content-Type: application/json" \
  -H "Cookie: session=YOUR_SESSION_TOKEN" \
  -d '{"config": {"type": "webhook", "url": "https://api.pagerduty.com/..."}}'

# Add an email channel
curl -X POST http://localhost:5332/v1/alerts/1/channels \
  -H "Content-Type: application/json" \
  -H "Cookie: session=YOUR_SESSION_TOKEN" \
  -d '{"config": {"type": "email", "to": "oncall@example.com"}}'

# Test a rule's notifications
curl -X POST http://localhost:5332/v1/alerts/1/test \
  -H "Cookie: session=YOUR_SESSION_TOKEN"

curl -X POST http://localhost:5332/v1/alerts \
  -H "Content-Type: application/json" \
  -H "Cookie: session=YOUR_SESSION_TOKEN" \
  -d '{
    "name": "High error rate on checkout",
    "config": {
      "type": "threshold",
      "threshold": 100,
      "window_secs": 3600
    },
    "project_id": "proj_abc123"
  }'

curl -X POST http://localhost:5332/v1/alerts/1/channels \
  -H "Content-Type: application/json" \
  -H "Cookie: session=YOUR_SESSION_TOKEN" \
  -d '{"config":{"type":"slack","webhook_url":"https://hooks.slack.com/services/T00/B00/xxx"}}'

# ── SMTP (for email alerts) ──
[smtp]
enabled = true
host = "smtp.example.com"
port = 587
username = "alerts@example.com"
password = "your-smtp-password"
from = "bloop@example.com"
starttls = true

BLOOP__SMTP__ENABLED=true
BLOOP__SMTP__HOST=smtp.example.com
BLOOP__SMTP__PORT=587
BLOOP__SMTP__USERNAME=alerts@example.com
BLOOP__SMTP__PASSWORD=your-smtp-password
BLOOP__SMTP__FROM=bloop@example.com
BLOOP__SMTP__STARTTLS=true

curl -X POST http://localhost:5332/v1/alerts/1/channels \
  -H "Content-Type: application/json" \
  -H "Cookie: session=YOUR_SESSION_TOKEN" \
  -d '{"config": {"type": "email", "to": "oncall@example.com"}}'

# Promote a user to admin
curl -X PUT http://localhost:5332/v1/admin/users/USER_ID/role \
  -H "Content-Type: application/json" \
  -H "Cookie: bloop_session=YOUR_SESSION_TOKEN" \
  -d '{"is_admin": true}'

# Demote an admin to regular user
curl -X PUT http://localhost:5332/v1/admin/users/USER_ID/role \
  -H "Content-Type: application/json" \
  -H "Cookie: bloop_session=YOUR_SESSION_TOKEN" \
  -d '{"is_admin": false}'

# Get current retention config + storage stats
curl http://localhost:5332/v1/admin/retention \
  -H "Cookie: bloop_session=YOUR_SESSION_TOKEN"

# Update retention settings
curl -X PUT http://localhost:5332/v1/admin/retention \
  -H "Content-Type: application/json" \
  -H "Cookie: bloop_session=YOUR_SESSION_TOKEN" \
  -d '{
    "raw_events_days": 14,
    "hourly_counts_days": 90,
    "per_project": [
      {"project_id": "proj_abc123", "raw_events_days": 30}
    ]
  }'

# Trigger immediate purge
curl -X POST http://localhost:5332/v1/admin/retention/purge \
  -H "Content-Type: application/json" \
  -H "Cookie: bloop_session=YOUR_SESSION_TOKEN" \
  -d '{"confirm": true}'

{
  "global": {
    "raw_events_days": 7,
    "hourly_counts_days": 90
  },
  "per_project": [
    {
      "project_id": "proj_abc123",
      "project_name": "Mobile App",
      "raw_events_days": 30
    }
  ],
  "storage": {
    "db_size_bytes": 12345678,
    "raw_events_count": 50000,
    "hourly_counts_count": 8760
  }
}

curl -X POST http://localhost:5332/v1/projects \
  -H "Content-Type: application/json" \
  -H "Cookie: session=YOUR_SESSION_TOKEN" \
  -d '{"name": "Mobile App", "slug": "mobile-app"}'

{
  "id": "proj_abc123",
  "name": "Mobile App",
  "slug": "mobile-app",
  "api_key": "bloop_7f3a..."
}

const bloop = new BloopClient({
  endpoint: "https://errors.myapp.com",
  projectKey: "bloop_7f3a...",
  environment: "production",
  release: "1.0.0",
});

curl -X POST http://localhost:5332/v1/projects/my-app/sourcemaps \
  -H "Cookie: session=YOUR_SESSION_TOKEN" \
  -F "release=1.2.0" \
  -F "file=@dist/app.js.map"

# After building your app
for map in dist/*.map; do
  curl -X POST https://errors.myapp.com/v1/projects/my-app/sourcemaps \
    -H "Cookie: session=$BLOOP_SESSION" \
    -F "release=$VERSION" \
    -F "file=@$map"
done

# Upload all maps from a build
for map in dist/*.map; do
  curl -X POST https://errors.myapp.com/v1/projects/my-app/sourcemaps \
    -H "Cookie: session=$BLOOP_SESSION" \
    -F "release=2.1.0" \
    -F "file=@$map"
done

# ── Analytics (optional) ──
[analytics]
enabled = true
cache_ttl_secs = 60           # In-memory cache TTL for results (seconds)
zscore_threshold = 2.5        # Z-score threshold for spike detection

curl -H "Authorization: Bearer bloop_tk_..." \
  "https://errors.myapp.com/v1/analytics/spikes?hours=24&environment=production"

{
  "spikes": [
    {
      "fingerprint": "a1b2c3",
      "error_type": "TimeoutError",
      "message": "Request timed out",
      "hour_bucket": 1700006400000,
      "count": 145,
      "mean": 12.3,
      "stddev": 8.1,
      "zscore": 16.4
    }
  ],
  "threshold": 2.5,
  "window_hours": 24
}

curl -H "Authorization: Bearer bloop_tk_..." \
  "https://errors.myapp.com/v1/analytics/movers?hours=24&limit=10"

{
  "movers": [
    {
      "fingerprint": "d4e5f6",
      "error_type": "ConnectionError",
      "message": "Database connection refused",
      "count_current": 89,
      "count_previous": 3,
      "delta": 86,
      "delta_pct": 2866.7
    }
  ],
  "window_hours": 24
}

curl -H "Authorization: Bearer bloop_tk_..." \
  "https://errors.myapp.com/v1/analytics/correlations?hours=72"

{
  "pairs": [
    {
      "fingerprint_a": "a1b2c3",
      "fingerprint_b": "d4e5f6",
      "message_a": "Redis connection timeout",
      "message_b": "Cache miss on user session",
      "correlation": 0.94
    }
  ],
  "window_hours": 72
}

curl -H "Authorization: Bearer bloop_tk_..." \
  "https://errors.myapp.com/v1/analytics/releases?limit=5"

{
  "releases": [
    {
      "release": "2.3.0",
      "first_seen": 1700000000000,
      "error_count": 342,
      "unique_fingerprints": 12,
      "new_fingerprints": 5,
      "error_delta": 180,
      "impact_score": 8.7
    }
  ]
}

curl -H "Authorization: Bearer bloop_tk_..." \
  "https://errors.myapp.com/v1/analytics/environments?hours=168"

{
  "environments": [
    {
      "environment": "production",
      "total_count": 1250,
      "unique_errors": 34,
      "pct_of_total": 78.1,
      "p50_hourly": 7.0,
      "p90_hourly": 23.0,
      "p99_hourly": 89.0
    }
  ],
  "total_count": 1600
}

# Health check — use this for uptime monitoring
curl -sf https://errors.yourapp.com/health | jq .

# Expected response:
# { "status": "ok", "db_ok": true, "buffer_usage": 0.002 }

# Alert if buffer_usage > 0.5 or db_ok is false

# Replace with your actual values
API_KEY="your-project-api-key"
ENDPOINT="https://errors.yourapp.com"

BODY='{"timestamp":'$(date +%s)',"source":"api","environment":"production","release":"1.0.0","error_type":"TestError","message":"Hello from Bloop!"}'
SIG=$(echo -n "$BODY" | openssl dgst -sha256 -hmac "$API_KEY" | awk '{print $2}')

curl -s -w "\nHTTP %{http_code}\n" \
  -X POST "$ENDPOINT/v1/ingest" \
  -H "Content-Type: application/json" \
  -H "X-Signature: $SIG" \
  -H "X-Project-Key: $API_KEY" \
  -d "$BODY"

# Expected: HTTP 200
# Check the dashboard — your test error should appear within 2 seconds

docker run -d --name bloop \
  --restart unless-stopped \
  -p 5332:5332 \
  -v bloop_data:/data \
  -e BLOOP__AUTH__HMAC_SECRET=$(openssl rand -hex 32) \
  -e BLOOP__AUTH__RP_ID=errors.yourapp.com \
  -e BLOOP__AUTH__RP_ORIGIN=https://errors.yourapp.com \
  -e BLOOP__DATABASE__PATH=/data/bloop.db \
  -e RUST_LOG=bloop=info \
  ghcr.io/jaikoo/bloop:latest

# docker-compose.yml
services:
  bloop:
    image: ghcr.io/jaikoo/bloop:latest
    restart: unless-stopped
    ports:
      - "5332:5332"
    volumes:
      - bloop_data:/data
    environment:
      BLOOP__AUTH__HMAC_SECRET: "${BLOOP_SECRET}"
      BLOOP__AUTH__RP_ID: errors.yourapp.com
      BLOOP__AUTH__RP_ORIGIN: https://errors.yourapp.com
      BLOOP__DATABASE__PATH: /data/bloop.db
      RUST_LOG: bloop=info
    healthcheck:
      test: ["CMD", "curl", "-sf", "http://localhost:5332/health"]
      interval: 30s
      timeout: 5s
      retries: 3

volumes:
  bloop_data:

server {
    listen 443 ssl http2;
    server_name errors.yourapp.com;

    ssl_certificate     /etc/letsencrypt/live/errors.yourapp.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/errors.yourapp.com/privkey.pem;

    location / {
        proxy_pass http://127.0.0.1:5332;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # Important for large source map uploads
        client_max_body_size 50m;
    }
}

# From the host (Docker)
docker exec bloop sqlite3 /data/bloop.db ".backup /data/backup.db"
docker cp bloop:/data/backup.db ./bloop-backup-$(date +%Y%m%d).db

# Or directly on the volume
sqlite3 /var/lib/docker/volumes/bloop_data/_data/bloop.db \
  ".backup /tmp/bloop-backup.db"

#!/bin/bash
# /opt/bloop/backup.sh — run via cron

BACKUP_DIR="/opt/bloop/backups"
KEEP_DAYS=14

mkdir -p "$BACKUP_DIR"

# Create backup
docker exec bloop sqlite3 /data/bloop.db \
  ".backup /data/backup-tmp.db"
docker cp bloop:/data/backup-tmp.db \
  "$BACKUP_DIR/bloop-$(date +%Y%m%d-%H%M).db"
docker exec bloop rm /data/backup-tmp.db

# Prune old backups
find "$BACKUP_DIR" -name "bloop-*.db" -mtime +$KEEP_DAYS -delete

echo "Backup complete: $(ls -lh $BACKUP_DIR/bloop-*.db | tail -1)"

# Add to crontab: daily at 3 AM
echo "0 3 * * * /opt/bloop/backup.sh >> /var/log/bloop-backup.log 2>&1" | crontab -

# Connect to Railway service shell
railway shell

# Inside the container
sqlite3 /data/bloop.db ".backup /data/bloop-backup.db"

# Download via Railway CLI
railway volume download /data/bloop-backup.db

# Stop the server first
docker stop bloop

# Replace the database
docker cp ./bloop-backup-20240115.db bloop:/data/bloop.db

# Restart
docker start bloop

# Resolve
curl -X POST http://localhost:5332/v1/errors/FINGERPRINT/resolve \
  -H "Cookie: session=YOUR_SESSION_TOKEN"

# Mute
curl -X POST http://localhost:5332/v1/errors/FINGERPRINT/mute \
  -H "Cookie: session=YOUR_SESSION_TOKEN"

# Unresolve
curl -X POST http://localhost:5332/v1/errors/FINGERPRINT/unresolve \
  -H "Cookie: session=YOUR_SESSION_TOKEN"

# View status history
curl http://localhost:5332/v1/errors/FINGERPRINT/history \
  -H "Cookie: session=YOUR_SESSION_TOKEN"

curl http://localhost:5332/health | jq .

# Response:
# {
#   "status": "ok",
#   "db_ok": true,
#   "buffer_usage": 0.002
# }

# Enable detailed logging
RUST_LOG=bloop=debug cargo run

# Or in Docker
docker run -e RUST_LOG=bloop=debug ...