Error Tracking

Temps includes Sentry-compatible error tracking built-in. Use your existing Sentry SDKs without code changes, and own your error data.

Overview

Track, debug, and resolve errors in production with enterprise-grade error tracking included in Temps.

What's Included

Sentry protocol compatibility
Error grouping with fingerprinting
Stack trace analysis
Source map support
Real-time error alerts
Error context (user, request, environment)
AI-powered error clustering
Session correlation

Why It Matters

No third-party services needed
Use existing Sentry SDKs
Complete data ownership
Unlimited events (no pricing tiers)
Integrated with analytics
Correlate errors with sessions
Lower latency (same infrastructure)

Key Features

Name
Drop-In Replacement
Description
Works with official Sentry SDKs (JavaScript, Python, Go, PHP, Ruby, etc.)
Name
Smart Grouping
Description
AI-powered error clustering groups similar errors automatically
Name
Rich Context
Description
Captures request details, user info, environment, custom metadata
Name
Stack Traces
Description
Full stack traces with source map support for minified code
Name
Real-Time Alerts
Description
Email, Slack, and webhook notifications for new errors
Name
Session Correlation
Description
Link errors to session replays for visual debugging

Sentry Compatibility

Temps implements the complete Sentry protocol, allowing you to use official Sentry SDKs without modification.

Supported Features

Name
Envelope Ingestion
Description
Full Sentry envelope protocol support (v7+)
Name
Error Events
Description
Exception tracking with stack traces
Name
Transaction Events
Description
Performance monitoring integration
Name
Breadcrumbs
Description
Event trail leading up to errors
Name
User Context
Description
User identification and metadata
Name
Tags & Metadata
Description
Custom tagging and context
Name
Source Maps
Description
Upload and parse source maps for minified code
Name
Releases
Description
Track errors by release version

Compatibility Matrix

Fully Supported SDKs

@sentry/browser (JavaScript)
@sentry/react (React)
@sentry/nextjs (Next.js)
@sentry/node (Node.js)
@sentry/python (Python)
@sentry/go (Go)
@sentry/php (PHP)
@sentry/ruby (Ruby)
@sentry/java (Java)
@sentry/dotnet (.NET)

Supported Platforms

Web browsers
Node.js servers
React Native
Electron
Mobile apps (iOS, Android)
Desktop apps
Serverless functions
Docker containers

Setup & Integration

Get started with error tracking in minutes using your existing Sentry SDK.

Step 1: Generate DSN

Each project gets a unique DSN (Data Source Name) for error reporting:

Generate DSN

# Generate DSN for project
temps error-tracking create-dsn --project my-app

# Output:
# DSN: https://abc123@errors.temps.sh/my-app

Step 2: Install Sentry SDK

Install the official Sentry SDK for your platform:

npm install @sentry/react

Step 3: Configure SDK

Point the Sentry SDK to your Temps instance:

Configure Sentry SDK

import * as Sentry from '@sentry/react';

Sentry.init({
  dsn: 'https://abc123@errors.temps.sh/my-app',
  environment: 'production',
  release: 'my-app@1.0.0',

  // Performance monitoring
  tracesSampleRate: 1.0,

  // Session replay integration
  integrations: [new Sentry.BrowserTracing()],

  beforeSend(event, hint) {
    // Filter sensitive data
    return event;
  }
});

Step 4: Test Error Tracking

Trigger a test error to verify setup:

Test Error Tracking

// Throw test error
Sentry.captureException(new Error('Test error from Temps'));

// Capture message
Sentry.captureMessage('Test message', 'info');

// Add breadcrumb
Sentry.addBreadcrumb({
  message: 'User clicked button',
  level: 'info',
  data: { button: 'signup' }
});

Error Grouping

Temps automatically groups similar errors together using smart fingerprinting and AI-powered clustering.

Grouping Strategies

Name
Stack Trace Fingerprinting
Description
Groups errors with identical stack traces (default)
Name
Exception Type
Description
Groups by exception class/type (TypeError, ReferenceError, etc.)
Name
Error Message
Description
Groups by error message pattern (parameterized)
Name
AI Clustering
Description
Uses OpenAI embeddings to find semantically similar errors
Name
Custom Fingerprinting
Description
Define custom grouping rules via fingerprint tags

Custom Fingerprinting

Override default grouping with custom fingerprints:

Custom Fingerprinting

Sentry.captureException(error, {
  fingerprint: ['database-error', 'connection-timeout'],
});

// Dynamic fingerprint
Sentry.captureException(error, {
  fingerprint: ['api-error', error.response?.status],
});

Merge & Split Groups

Merge Groups

Combine multiple error groups that should be treated as one:

temps error-tracking merge \
  --groups error-1,error-2,error-3 \
  --target error-1

Split Groups

Separate errors that were incorrectly grouped:

temps error-tracking split \
  --group error-1 \
  --event-ids evt-123,evt-456

Error Details

Each error event captures comprehensive context for debugging.

Error Anatomy

Name
Exception Info
Description
Type, message, stack trace with line numbers
Name
Request Context
Description
URL, method, headers, query params, request body
Name
User Context
Description
User ID, email, IP address, custom properties
Name
Environment
Description
Browser/runtime version, OS, device type
Name
Tags
Description
Custom tags (environment, version, feature flags)
Name
Breadcrumbs
Description
Event trail leading to error (clicks, API calls, console logs)
Name
Additional Data
Description
Custom metadata, local variables, state snapshots

Enrich Error Context

Add custom context to errors:

Add Context

Sentry.setUser({
  id: 'user-123',
  email: 'user@example.com',
  username: 'johndoe',
  subscription: 'pro'
});

Source Maps

Upload source maps to debug minified production code with readable stack traces.

Generate Source Maps

Build Configuration

// webpack.config.js
module.exports = {
  devtool: 'source-map', // or 'hidden-source-map'
  output: {
    sourceMapFilename: '[file].map',
  },
};

Upload Source Maps

# Upload source maps for release
temps error-tracking upload-sourcemaps \
  --project my-app \
  --release 1.0.0 \
  --path ./dist

# Upload with glob pattern
temps error-tracking upload-sourcemaps \
  --project my-app \
  --release 1.0.0 \
  --files "dist/**/*.map"

Source Map Security

Security Best Practice: Use hidden source maps in production to prevent exposing source code:

Build with hidden-source-map devtool
Upload source maps to Temps
Don't deploy .map files to production
Source maps are only accessible to authenticated users

Alerts & Notifications

Get notified when errors occur in production.

Notification Channels

Name
Email
Description
Send error alerts to team email addresses
Name
Slack
Description
Post errors to Slack channels with rich formatting
Name
Webhooks
Description
Send HTTP POST requests to custom endpoints (PagerDuty, Opsgenie, etc.)
Name
Dashboard
Description
Real-time error feed in the Temps dashboard

Configure Alerts

Alert Configuration

# config/error-alerts.yml
alerts:
  - name: "Critical Errors"
    condition:
      level: ["error", "fatal"]
      environment: "production"
      first_occurrence: true

    channels:
      - type: email
        recipients: ["devteam@example.com"]

      - type: slack
        webhook: "https://hooks.slack.com/services/..."
        channel: "#alerts"

      - type: webhook
        url: "https://pagerduty.com/webhook"
        headers:
          Authorization: "Token abc123"

    rate_limit:
      max_per_hour: 10
      max_per_group: 3

  - name: "New Error Types"
    condition:
      first_occurrence: true
      min_users_affected: 5

    channels:
      - type: slack
        webhook: "https://hooks.slack.com/..."

Alert Conditions

Create sophisticated alert rules:

// Alert when error affects multiple users
{
  "condition": {
    "minUsersAffected": 10,
    "timeWindow": "5m"
  }
}

// Alert on regression (error recurred after being resolved)
{
  "condition": {
    "regression": true,
    "resolvedWithin": "7d"
  }
}

// Alert on spike in error rate
{
  "condition": {
    "spike": {
      "threshold": 5, // 5x normal rate
      "baseline": "1h" // Compare to last hour
    }
  }
}

Error Resolution

Manage error lifecycle from discovery to resolution.

Error States

Name
Unresolved
Description
New or ongoing errors (default state)
Name
Resolved
Description
Marked as fixed (manually or automatically)
Name
Ignored
Description
Known errors that should be suppressed
Name
Regressed
Description
Error recurred after being resolved

Mark as Resolved

Resolve Errors

# Resolve error group
temps error-tracking resolve --group error-123

# Resolve in specific release
temps error-tracking resolve --group error-123 --in-release 1.0.1

# Resolve multiple groups
temps error-tracking resolve --groups error-123,error-456,error-789

Auto-Resolution

Configure automatic resolution rules:

# Auto-resolve errors
auto_resolution:
  # Resolve if no new events for X days
  no_events_for: 30

  # Resolve when new release is deployed
  on_release: true

  # Resolve when error rate drops below threshold
  rate_threshold:
    errors_per_hour: 1
    duration: 24h

Ignore Errors

Suppress known errors you don't want to track:

Ignore Errors

Sentry.init({
  dsn: '...',
  ignoreErrors: [
    // Ignore specific error messages
    'ResizeObserver loop limit exceeded',
    'Non-Error promise rejection',

    // Ignore error patterns
    /^Loading chunk [\d]+ failed$/,
  ],

  // Ignore errors from specific URLs
  denyUrls: [
    /extensions\//i,
    /^chrome:\/\//i,
  ],

  beforeSend(event, hint) {
    // Custom ignore logic
    if (event.exception) {
      const error = hint.originalException;
      if (error.message?.includes('Network error')) {
        return null; // Don't send to Temps
      }
    }
    return event;
  }
});

Additional Resources

Analytics & Session Replay

Uptime Monitoring

Error Tracking API