Crash Tracking

pub struct CrashEvent {
    pub id: CrashEventId,
    pub org_id: OrgId,
    pub project_id: ProjectId,
    pub issue_id: Option<IssueId>,
    
    // Identity
    pub person_id: Option<PersonId>,
    pub distinct_id: String,
    
    // Error
    pub exception_type: String,
    pub exception_value: String,
    pub stacktrace: Stacktrace,
    
    // Context
    pub release: Option<String>,
    pub environment: String,
    pub platform: Platform,
    pub tags: HashMap<String, String>,
    pub active_flags: HashMap<String, String>,
    pub breadcrumbs: Vec<Breadcrumb>,
}

pub struct Issue {
    pub id: IssueId,
    pub short_id: String,           // "PROJ-123"
    pub fingerprint: String,        // SHA256 hash
    pub title: String,
    pub status: IssueStatus,
    pub level: IssueLevel,
    pub event_count: u64,
    pub user_count: u64,
    pub first_seen: DateTime<Utc>,
    pub last_seen: DateTime<Utc>,
}

pub enum Platform {
    JavaScript,  // Browser
    Node,        // Node.js
    Rust,
}

[dependencies]
loom-crash = { version = "0.1" }
loom-analytics = { version = "0.1" }  # Optional: for identity
loom-flags = { version = "0.1" }      # Optional: for flag capture

use loom_crash::CrashClient;
use loom_analytics::AnalyticsClient;
use loom_flags::FlagsClient;

// Initialize crash client with integrations
let crash = CrashClient::builder()
    .api_key("loom_crash_xxx")
    .base_url("https://loom.example.com")
    .project("my-rust-app")
    .release(env!("CARGO_PKG_VERSION"))
    // Integrate with analytics for person identity
    .analytics(&analytics_client)
    // Integrate with flags to capture active flags
    .flags(&flags_client)
    .build()?;

// Install panic hook (captures all panics)
crash.install_panic_hook();

// Set user context
crash.set_user(UserContext {
    id: Some(user.id.to_string()),
    email: Some(user.email.clone()),
    ..Default::default()
});

// Add global tags
crash.set_tag("environment", "production");
crash.set_tag("server", hostname);

// Manual capture
if let Err(e) = do_something() {
    crash.capture_error(&e);
}

// Capture breadcrumb
crash.add_breadcrumb(Breadcrumb {
    category: "http".into(),
    message: Some("GET /api/users".into()),
    level: BreadcrumbLevel::Info,
    ..Default::default()
});

// Scoped context
crash.with_scope(|scope| {
    scope.set_tag("handler", "create_user");
    scope.set_extra("request_id", json!(request_id));
    process_request()?;
    Ok(())
})?;

// Shutdown (flushes pending events)
crash.shutdown().await?;

npm install @loom/crash

import { CrashClient } from '@loom/crash';
import { AnalyticsClient } from '@loom/analytics';
import { FlagsClient } from '@loom/flags';

const crash = new CrashClient({
  apiKey: 'loom_crash_xxx',
  baseUrl: 'https://loom.example.com',
  project: 'my-web-app',
  release: '1.2.3',
  environment: 'production',
  
  // Integrate with other SDKs
  analytics,
  flags,
  
  // Options
  maxBreadcrumbs: 100,
  beforeSend: (event) => {
    // Filter or modify events before sending
    if (event.exception_value.includes('ResizeObserver')) {
      return null; // Drop this event
    }
    return event;
  },
});

// Install global handlers
crash.installGlobalHandler();

// Set user context
crash.setUser({
  id: user.id,
  email: user.email,
});

// Manual capture
try {
  await riskyOperation();
} catch (error) {
  crash.captureException(error, {
    tags: { operation: 'risky' },
    extra: { attemptNumber: 3 },
  });
}

// Add breadcrumb
crash.addBreadcrumb({
  category: 'navigation',
  message: 'User navigated to /dashboard',
  level: 'info',
});

import { CrashBoundary } from '@loom/crash/react';

function App() {
  return (
    <CrashBoundary
      client={crash}
      fallback={<ErrorPage />}
      onError={(error, errorInfo) => {
        console.log('Crash captured:', error);
      }}
    >
      <MyApp />
    </CrashBoundary>
  );
}

// vite.config.ts
import { loomSourceMaps } from '@loom/crash-vite';

export default {
  plugins: [
    loomSourceMaps({
      project: 'my-app',
      release: process.env.GIT_SHA,
      apiKey: process.env.LOOM_CRASH_API_KEY,
    }),
  ],
};

TypeError | handleClick@App.tsx | onClick@Button.tsx

{
  "fingerprint_rules": [
    {
      "match_type": "exception_message",
      "pattern": "rate limit exceeded.*",
      "fingerprint": ["rate-limit-error"]
    },
    {
      "match_type": "module",
      "pattern": "third_party::*",
      "fingerprint": ["third-party-error", "{{ module }}"]
    }
  ]
}

const eventSource = new EventSource(
  'https://loom.example.com/api/crash/projects/proj-123/stream',
  { headers: { Authorization: 'Bearer <token>' } }
);

eventSource.addEventListener('issue.regressed', (event) => {
  const data = JSON.parse(event.data);
  console.log(`Issue ${data.short_id} regressed!`);
  showNotification(`Issue regressed: ${data.title}`);
});

{
  "function": "handleSubmit",
  "module": "components/Form",
  "filename": "Form.tsx",
  "lineno": 42,
  "colno": 15,
  "context_line": "    const result = await api.submit(data);",
  "pre_context": [
    "  async handleSubmit(data) {",
    "    try {",
    "      setLoading(true);"
  ],
  "post_context": [
    "      setSuccess(true);",
    "    } catch (error) {",
    "      setError(error);"
  ],
  "in_app": true
}