Sentry SDK开发与集成指南：全栈应用监控-优快云博客

Sentry SDK开发与集成指南：全栈应用监控

【免费下载链接】sentry getsentry/sentry: 是一个开源的错误追踪和监控工具，用于收集、分析和监控应用的错误和性能数据。它可以帮助开发者快速发现和解决应用中的问题，提高应用的稳定性和性能。特点包括实时监控、多渠道通知、支持多种编程语言和平台等。项目地址: https://gitcode.com/GitHub_Trending/sen/sentry

本文全面介绍了Sentry SDK在全栈应用中的开发与集成方法，涵盖了JavaScript/TypeScript、Python Django/Flask以及移动端iOS/Android平台的SDK配置和最佳实践。详细讲解了错误捕获、性能监控、用户会话管理等核心功能，并提供了丰富的代码示例和配置方案，帮助开发者构建完整的应用监控体系。

JavaScript/TypeScript SDK深度集成

在现代Web应用开发中，JavaScript和TypeScript已经成为前端开发的主流选择。Sentry为这两种语言提供了强大的SDK支持，能够帮助开发者实时监控应用错误、性能问题和用户体验。本文将深入探讨Sentry JavaScript/TypeScript SDK的核心集成技术和最佳实践。

SDK架构与核心组件

Sentry JavaScript SDK采用模块化设计，支持多种框架和运行环境。其核心架构包含以下关键组件：

mermaid

基础集成配置

初始化配置

import * as Sentry from "@sentry/browser";
import { BrowserTracing } from "@sentry/tracing";

Sentry.init({
  dsn: "https://your-dsn@sentry.io/your-project",
  integrations: [new BrowserTracing()],
  tracesSampleRate: 0.2,
  environment: process.env.NODE_ENV,
  release: "my-project@" + process.env.npm_package_version,
  beforeSend(event) {
    // 过滤敏感信息
    if (event.user) {
      delete event.user.email;
    }
    return event;
  }
});

TypeScript类型安全配置

import * as Sentry from '@sentry/react';
import { Integrations } from '@sentry/tracing';

interface CustomError extends Error {
  code?: number;
  status?: string;
}

Sentry.init({
  dsn: process.env.REACT_APP_SENTRY_DSN,
  integrations: [new Integrations.BrowserTracing()],
  environment: process.env.NODE_ENV,
  release: `my-app@${process.env.REACT_APP_VERSION}`,
  normalizeDepth: 10,
  attachStacktrace: true,
  maxValueLength: 10000,
});

错误捕获与处理策略

全局错误处理

// 全局未捕获异常处理
window.addEventListener('error', (event) => {
  Sentry.captureException(event.error, {
    tags: {
      error_type: 'unhandled_error',
      component: 'global_handler'
    }
  });
});

// Promise拒绝处理
window.addEventListener('unhandledrejection', (event) => {
  Sentry.captureException(event.reason, {
    tags: {
      error_type: 'unhandled_rejection',
      component: 'promise_handler'
    }
  });
});

React错误边界集成

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

class ErrorBoundary extends React.Component {
  constructor(props) {
    super(props);
    this.state = { hasError: false };
  }

  static getDerivedStateFromError(error) {
    return { hasError: true };
  }

  componentDidCatch(error, errorInfo) {
    Sentry.withScope((scope) => {
      scope.setExtras(errorInfo);
      Sentry.captureException(error, {
        tags: {
          component: 'react_error_boundary'
        }
      });
    });
  }

  render() {
    if (this.state.hasError) {
      return <h1>Something went wrong.</h1>;
    }
    return this.props.children;
  }
}

export default ErrorBoundary;

性能监控与追踪

分布式追踪配置

import { Integrations } from '@sentry/tracing';

Sentry.init({
  dsn: process.env.SENTRY_DSN,
  integrations: [
    new Integrations.BrowserTracing({
      tracingOrigins: [
        'localhost',
        'your-api-domain.com',
        /^\//
      ],
      beforeNavigate: (context) => {
        return {
          ...context,
          name: window.location.pathname,
        };
      }
    })
  ],
  tracesSampleRate: 0.2,
  tracesSampler: (samplingContext) => {
    const { transactionContext } = samplingContext;
    
    // 重要事务全量采样
    if (transactionContext.name.includes('checkout')) {
      return 1.0;
    }
    
    // 其他事务按比例采样
    return 0.2;
  }
});

自定义性能指标

// 自定义事务追踪
const transaction = Sentry.startTransaction({
  name: "User Registration",
  op: "task",
});

// 创建span跟踪具体操作
const span = transaction.startChild({
  op: "db.query",
  description: "Create user record",
});

try {
  // 执行数据库操作
  await createUser(userData);
  span.finish();
} catch (error) {
  span.setStatus('internal_error');
  span.finish();
  Sentry.captureException(error);
  throw error;
} finally {
  transaction.finish();
}

用户会话与上下文管理

用户信息关联

// 设置用户信息
Sentry.setUser({
  id: '12345',
  username: 'john_doe',
  email: 'john@example.com',
  ip_address: '{{auto}}'
});

// 设置上下文信息
Sentry.setContext('application', {
  version: '1.2.3',
  environment: 'production',
  locale: navigator.language
});

Sentry.setContext('device', {
  name: navigator.platform,
  type: /Mobile|iP(hone|od|ad)/.test(navigator.userAgent) ? 'mobile' : 'desktop'
});

// 自定义标签
Sentry.setTag('page_locale', 'zh-CN');
Sentry.setTag('user_role', 'premium');
Sentry.setTag('browser', navigator.userAgent);

高级配置与优化

采样策略配置

Sentry.init({
  dsn: process.env.SENTRY_DSN,
  integrations: integrations,
  tracesSampleRate: 0.1,
  replaysSessionSampleRate: 0.01,
  replaysOnErrorSampleRate: 0.5,
  
  // 自定义采样函数
  tracesSampler: (samplingContext) => {
    const { transactionContext } = samplingContext;
    
    // 关键业务操作全量采样
    if (transactionContext.name.includes('purchase') || 
        transactionContext.name.includes('payment')) {
      return 1.0;
    }
    
    // 静态资源请求不采样
    if (transactionContext.name.includes('/static/') ||
        transactionContext.name.includes('/assets/')) {
      return 0.0;
    }
    
    // 默认采样率
    return 0.1;
  }
});

面包屑配置

Sentry.init({
  dsn: process.env.SENTRY_DSN,
  integrations: [
    new Sentry.Integrations.Breadcrumbs({
      console: true,
      dom: true,
      fetch: true,
      history: true,
      sentry: true,
      xhr: true,
    })
  ],
  beforeBreadcrumb(breadcrumb, hint) {
    // 过滤敏感信息的breadcrumb
    if (breadcrumb.category === 'xhr' && breadcrumb.data) {
      const url = breadcrumb.data.url;
      if (url && url.includes('/api/auth')) {
        return null;
      }
    }
    return breadcrumb;
  }
});

框架特定集成

Next.js集成示例

// sentry.client.config.js
import * as Sentry from '@sentry/nextjs';

Sentry.init({
  dsn: process.env.NEXT_PUBLIC_SENTRY_DSN,
  environment: process.env.NODE_ENV,
  release: process.env.NEXT_PUBLIC_SENTRY_RELEASE,
  tracesSampleRate: 0.1,
  integrations: [
    new Sentry.Integrations.BrowserTracing({
      tracingOrigins: [
        'localhost',
        process.env.NEXT_PUBLIC_API_URL,
      ],
    }),
  ],
});

// sentry.server.config.js
import * as Sentry from '@sentry/nextjs';

Sentry.init({
  dsn: process.env.SENTRY_DSN,
  environment: process.env.NODE_ENV,
  release: process.env.SENTRY_RELEASE,
  tracesSampleRate: 0.1,
  integrations: [
    new Sentry.Integrations.Http({ tracing: true }),
  ],
});

Vue.js集成示例

import Vue from 'vue';
import * as Sentry from '@sentry/vue';
import { Integrations } from '@sentry/tracing';

Sentry.init({
  Vue,
  dsn: process.env.VUE_APP_SENTRY_DSN,
  integrations: [
    new Integrations.BrowserTracing({
      routingInstrumentation: Sentry.vueRouterInstrumentation(router),
    }),
  ],
  tracesSampleRate: 0.2,
  logErrors: true,
});

// Vue错误处理
Vue.config.errorHandler = (error, vm, info) => {
  Sentry.withScope((scope) => {
    scope.setExtra('component', vm.$options.name);
    scope.setExtra('lifecycleHook', info);
    Sentry.captureException(error);
  });
};

监控数据流分析

通过Sentry JavaScript/TypeScript SDK收集的数据遵循特定的处理流程：

mermaid

最佳实践总结

环境区分：为开发、测试、生产环境配置不同的DSN和采样率
敏感信息过滤：使用beforeSend回调过滤敏感数据
采样策略优化：根据业务重要性设置不同的采样率
上下文丰富：为用户会话添加丰富的上下文信息
性能监控：结合分布式追踪优化应用性能
错误边界：在React应用中合理使用错误边界
版本管理：正确设置release版本以便追踪问题

通过深度集成Sentry JavaScript/TypeScript SDK，开发团队可以获得全面的应用监控能力，从错误追踪到性能优化，从用户行为分析到业务指标监控，为现代Web应用提供全方位的可观测性支持。

Python Django/Flask应用监控

Python作为Web开发的主流语言，Django和Flask框架在企业级应用中占据重要地位。Sentry为这两个框架提供了深度集成，能够自动捕获错误、追踪性能、分析日志，并提供完整的监控解决方案。

安装与配置

Django应用集成

Django应用的Sentry集成非常简单，首先安装带有django扩展的sentry-sdk：

pip install "sentry-sdk[django]"

在Django的settings.py文件中进行配置：

import sentry_sdk
from sentry_sdk.integrations.django import DjangoIntegration

sentry_sdk.init(
    dsn="https://your-dsn@sentry.io/your-project",
    integrations=[DjangoIntegration()],
    # 启用性能监控
    traces_sample_rate=1.0,
    # 启用用户分析
    profiles_sample_rate=1.0,
    # 发送默认PII信息
    send_default_pii=True,
    # 启用日志监控
    enable_logs=True,
)

Flask应用集成

Flask应用的配置同样简洁：

pip install "sentry-sdk[flask]"

在Flask应用初始化时配置：

import sentry_sdk
from sentry_sdk.integrations.flask import FlaskIntegration
from flask import Flask

sentry_sdk.init(
    dsn="https://your-dsn@sentry.io/your-project",
    integrations=[FlaskIntegration()],
    traces_sample_rate=1.0,
    profiles_sample_rate=1.0,
    send_default_pii=True,
    enable_logs=True,
)

app = Flask(__name__)

监控功能详解

错误监控

Sentry自动捕获Django和Flask应用中的未处理异常：

# Django视图示例
from django.http import JsonResponse

def user_profile(request, user_id):
    try:
        user = User.objects.get(id=user_id)
        return JsonResponse({'name': user.name, 'email': user.email})
    except User.DoesNotExist:
        # Sentry自动捕获此异常
        return JsonResponse({'error': 'User not found'}, status=404)

# Flask路由示例
@app.route('/api/users/<int:user_id>')
def get_user(user_id):
    user = User.query.get(user_id)
    if not user:
        # 自动捕获404异常
        abort(404)
    return jsonify(user.to_dict())

性能追踪

Sentry提供详细的性能追踪，包括请求处理时间、数据库查询、缓存操作等：

mermaid

数据库查询监控

Sentry自动追踪ORM操作，帮助识别性能瓶颈：

# Django ORM查询示例
def get_user_activities(user_id):
    # Sentry会追踪这个复杂查询的性能
    activities = Activity.objects.filter(
        user_id=user_id,
        created_at__gte=timezone.now() - timedelta(days=30)
    ).select_related('project').prefetch_related('tags')
    
    return activities

# SQLAlchemy查询示例（Flask）
def get_project_stats(project_id):
    stats = db.session.query(
        func.count(Event.id),
        func.avg(Event.duration)
    ).filter(Event.project_id == project_id).group_by(Event.type).all()
    
    return stats

高级配置选项

Django集成配置

from sentry_sdk.integrations.django import DjangoIntegration
import django.db.models.signals

sentry_sdk.init(
    dsn=DSN,
    integrations=[
        DjangoIntegration(
            transaction_style='url',
            middleware_spans=True,      # 追踪中间件性能
            signals_spans=True,         # 追踪信号处理
            signals_denylist=[          # 排除特定信号
                django.db.models.signals.pre_init,
                django.db.models.signals.post_init,
            ],
            cache_spans=True,           # 追踪缓存操作
            http_methods_to_capture=("GET", "POST", "PUT", "DELETE"),
        )
    ],
    traces_sample_rate=0.5,            # 50%的请求进行性能采样
    profiles_sample_rate=0.1,          # 10%的性能分析采样
)

Flask集成配置

from sentry_sdk.integrations.flask import FlaskIntegration

sentry_sdk.init(
    dsn=DSN,
    integrations=[
        FlaskIntegration(
            transaction_style='endpoint',  # 使用端点名称命名事务
            http_methods_to_capture=("GET", "POST", "PUT", "DELETE"),
        )
    ],
    # 自定义采样函数
    traces_sampler=lambda sampling_context: (
        0.1 if sampling_context.get('transaction_context', {}).get('name', '').startswith('healthcheck') 
        else 0.5
    ),
)

用户上下文与面包屑

Sentry自动收集用户信息和操作历史：

# Django中间件示例
class SentryUserMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        if request.user.is_authenticated:
            sentry_sdk.set_user({
                'id': request.user.id,
                'email': request.user.email,
                'username': request.user.username,
            })
        
        # 添加自定义面包屑
        sentry_sdk.add_breadcrumb(
            category='auth',
            message=f'User {request.user.username} accessed {request.path}',
            level='info'
        )
        
        return self.get_response(request)

# Flask上下文处理器
@app.context_processor
def inject_user_to_sentry():
    if hasattr(g, 'user') and g.user:
        sentry_sdk.set_user({
            'id': g.user.id,
            'email': g.user.email,
        })
    return {}

自定义监控与指标

业务指标监控

from sentry_sdk import metrics

def process_order(order_id):
    with metrics.timing("order.processing.time"):
        order = Order.objects.get(id=order_id)
        
        # 业务逻辑处理
        result = order.process()
        
        metrics.incr("orders.processed", tags={"status": result.status})
        metrics.incr(f"order.type.{order.type}", amount=1)
        
        return result

# 自定义性能span
def complex_calculation(data):
    with sentry_sdk.start_span(op="business.complex_calculation") as span:
        span.set_tag("data_size", len(data))
        span.set_data("input", data[:100])  # 只记录前100个字符
        
        result = perform_calculation(data)
        
        span.set_tag("result_size", len(result))
        return result

异步任务监控

# Celery任务监控
from celery import shared_task
import sentry_sdk

@shared_task
def process_background_task(task_data):
    # 关联任务ID到Sentry
    sentry_sdk.set_tag("celery_task_id", process_background_task.request.id)
    
    try:
        with sentry_sdk.start_transaction(op="task", name="process_background_task"):
            # 任务处理逻辑
            result = heavy_computation(task_data)
            return result
    except Exception as e:
        sentry_sdk.capture_exception(e)
        raise

监控数据表格

下表展示了Sentry为Django/Flask应用收集的关键监控指标：

监控类别	采集指标	说明	配置选项
错误监控	异常堆栈、请求上下文、用户信息	自动捕获未处理异常	`send_default_pii=True`
性能追踪	请求耗时、DB查询、缓存操作	全链路性能分析	`traces_sample_rate=1.0`
数据库监控	查询时间、查询次数、慢查询	ORM操作性能分析	`cache_spans=True`
用户行为	用户ID、访问路径、操作序列	用户操作轨迹追踪	自定义中间件
日志集成	应用日志、错误日志、调试信息	日志作为面包屑记录	`enable_logs=True`
自定义指标	业务指标、性能指标、计数指标	自定义业务监控	`metrics` API

部署最佳实践

生产环境配置

# production.py
import sentry_sdk
from sentry_sdk.integrations.django import DjangoIntegration
from sentry_sdk.integrations.redis import RedisIntegration

sentry_sdk.init(
    dsn=os.environ.get('SENTRY_DSN'),
    integrations=[
        DjangoIntegration(
            transaction_style='url',
            middleware_spans=True,
            cache_spans=True,
        ),
        RedisIntegration(),
    ],
    environment=os.environ.get('ENVIRONMENT', 'production'),
    release=os.environ.get('RELEASE_VERSION', '1.0.0'),
    traces_sample_rate=0.2,  # 生产环境降低采样率
    profiles_sample_rate=0.05,
    send_default_pii=False,  # 生产环境谨慎处理PII
)

多环境配置

# 环境特定的配置
def configure_sentry():
    environment = os.environ.get('ENVIRONMENT', 'development')
    
    sentry_sdk.init(
        dsn=os.environ.get('SENTRY_DSN'),
        integrations=[DjangoIntegration()],
        environment=environment,
        release=os.environ.get('RELEASE_VERSION'),
        traces_sample_rate=0.1 if environment == 'production' else 1.0,
        debug=environment == 'development',
    )

通过以上配置和最佳实践，Sentry能够为Python Django和Flask应用提供全面的监控解决方案，从错误追踪到性能分析，从用户行为监控到业务指标统计，帮助开发团队快速发现和解决应用中的问题。

移动端iOS/Android SDK配置

在现代化移动应用开发中，Sentry提供了全面的错误监控和性能追踪解决方案。针对iOS和Android平台，Sentry提供了专门的SDK来帮助开发者捕获应用崩溃、性能问题和用户反馈。本节将详细介绍如何配置和使用Sentry的移动端SDK。

SDK核心配置参数

移动端SDK配置主要围绕以下几个核心参数展开：

配置参数	类型	说明	必需
`dsn`	String	数据源名称，用于标识项目	是
`debug`	Boolean	启用调试模式	否
`environment`	String	环境标识（development/staging/production）	否
`release`	String	应用版本号	否
`tracesSampleRate`	Number	性能追踪采样率（0.0-1.0）	否
`enableAutoSessionTracking`	Boolean	自动会话追踪	否

Android SDK配置

Gradle依赖配置

在Android项目的build.gradle文件中添加Sentry依赖：

dependencies {
    implementation 'io.sentry:sentry-android:7.4.0'
}

AndroidManifest.xml配置

在AndroidManifest.xml中添加必要的权限：

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

Application类初始化

在自定义Application类的onCreate方法中初始化Sentry：

import io.sentry.android.core.SentryAndroid

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        
        SentryAndroid.init(this) { options ->
            options.dsn = "https://examplePublicKey@o0.ingest.sentry.io/0"
            options.environment = "production"
            options.release = "com.example.app@1.0.0+1"
            options.tracesSampleRate = 1.0
            options.debug = BuildConfig.DEBUG
            options.enableAutoSessionTracking = true
        }
    }
}

构建变体配置

针对不同的构建变体配置不同的DSN：

val environment = when {
    BuildConfig.DEBUG -> "development"
    BuildConfig.FLAVOR == "staging" -> "staging"
    else -> "production"
}

val dsn = when {
    BuildConfig.DEBUG -> "https://debugPublicKey@o0.ingest.sentry.io/0"
    BuildConfig.FLAVOR == "staging" -> "https://stagingPublicKey@o0.ingest.sentry.io/0"
    else -> "https://productionPublicKey@o0.ingest.sentry.io/0"
}

SentryAndroid.init(this) { options ->
    options.dsn = dsn
    options.environment = environment
    options.release = "${BuildConfig.APPLICATION_ID}@${BuildConfig.VERSION_NAME}+${BuildConfig.VERSION_CODE}"
}

iOS SDK配置

CocoaPods依赖

在Podfile中添加Sentry依赖：

pod 'Sentry', :git => 'https://github.com/getsentry/sentry-cocoa.git', :tag => '8.2.0'

Swift初始化

在AppDelegate中初始化Sentry：

import Sentry

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(_ application: UIApplication, 
                   didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        
        SentrySDK.start { options in
            options.dsn = "https://examplePublicKey@o0.ingest.sentry.io/0"
            options.debug = true
            options.environment = "development"
            options.releaseName = "com.example.app@1.0.0"
            options.tracesSampleRate = 1.0
            options.enableAutoSessionTracking = true
        }
        
        return true
    }
}

Objective-C初始化

#import <Sentry/Sentry.h>

- (BOOL)application:(UIApplication *)application 
didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    
    [SentrySDK startWithConfigureOptions:^(SentryOptions *options) {
        options.dsn = @"https://examplePublicKey@o0.ingest.sentry.io/0";
        options.debug = @YES;
        options.environment = @"development";
        options.releaseName = @"com.example.app@1.0.0";
        options.tracesSampleRate = @1.0;
        options.enableAutoSessionTracking = @YES;
    }];
    
    return YES;
}

高级配置选项

性能监控配置

mermaid

错误捕获配置

// Android配置示例
SentryAndroid.init(this) { options ->
    options.beforeSend = { event, hint ->
        // 过滤敏感信息
        if (event.tags?.containsKey("sensitive") == true) {
            return@beforeSend null
        }
        event
    }
    
    options.beforeBreadcrumb = { breadcrumb, hint ->
        // 过滤特定类型的breadcrumb
        if (breadcrumb.category == "http") {
            return@beforeBreadcrumb null
        }
        breadcrumb
    }
}

环境特定的配置管理

建议使用不同的配置文件管理不同环境的DSN：

# sentry.properties
development.dsn=https://devPublicKey@o0.ingest.sentry.io/0
staging.dsn=https://stagingPublicKey@o0.ingest.sentry.io/0  
production.dsn=https://productionPublicKey@o0.ingest.sentry.io/0

最佳实践

版本管理：确保每个版本都有唯一的release名称，便于问题追踪
环境隔离：为开发、测试、生产环境使用不同的DSN
性能优化：合理设置采样率，避免过多性能数据影响用户体验
安全考虑：不要在代码中硬编码DSN，使用环境变量或配置文件
错误过滤：使用beforeSend回调过滤敏感信息和不重要的错误

故障排除

常见问题及解决方案：

问题	可能原因	解决方案
SDK初始化失败	DSN格式错误	检查DSN格式是否正确
数据无法上报	网络权限问题	检查网络权限配置
性能数据缺失	采样率设置过低	调整tracesSampleRate
会话追踪异常	自动会话追踪未启用	设置enableAutoSessionTracking=true

通过合理的配置，Sentry移动端SDK能够为iOS和Android应用提供全面的错误监控和性能洞察能力，帮助开发团队快速发现和解决应用中的问题。

自定义事件与性能指标上报

Sentry SDK提供了强大的自定义事件和性能指标上报能力，让开发者能够灵活地监控应用的各个方面。通过自定义事件，您可以捕获特定的业务逻辑错误、用户行为数据或任何您认为重要的信息。而性能指标则帮助您追踪应用的关键性能指标，如响应时间、吞吐量和资源使用情况。

自定义事件上报

Sentry SDK提供了多种方式来上报自定义事件，最常用的是capture_message和capture_event方法。

使用capture_message上报简单消息

capture_message适用于上报简单的文本消息，通常用于记录信息性事件或调试信息：

import sentry_sdk

# 上报信息级别的消息
sentry_sdk.capture_message("用户完成了购买流程", level="info")

# 上报警告级别的消息  
sentry_sdk.capture_message("库存不足警告", level="warning")

# 上报错误级别的消息
sentry_sdk.capture_message("支付处理失败", level="error")

使用capture_event上报结构化事件

对于更复杂的事件，可以使用capture_event方法上报完整的结构化事件：

import sentry_sdk
from datetime import datetime

custom_event = {
    "message": "自定义业务事件: 订单创建",
    "level": "info",
    "timestamp": datetime.utcnow().isoformat(),
    "tags": {
        "business_event": "order_created",
        "user_id": "12345",
        "order_amount": "199.99"
    },
    "extra": {
        "order_details": {
            "items": ["product_a", "product_b"],
            "payment_method": "credit_card",
            "shipping_address": "123 Main St"
        }
    }
}

sentry_sdk.capture_event(custom_event)

事件数据结构

自定义事件支持丰富的字段来提供完整的上下文信息：

字段名	类型	描述	示例
message	string	事件的主要描述	"用户注册成功"
level	string	事件级别	"info", "warning", "error"
timestamp	string	事件时间戳	ISO 8601格式
tags	object	键值对标签	{"user_type": "premium"}
extra	object	额外的上下文数据	{"page_load_time": 2.5}
contexts	object	运行时上下文	{"browser": {"name": "Chrome"}}

性能指标上报

Sentry提供了强大的性能指标监控能力，支持多种类型的指标：

计数器指标（Counter）

计数器用于统计事件发生的次数：

from sentry_sdk import metrics

# 统计API调用次数
metrics.incr("api.calls", tags={"endpoint": "/users"})

# 统计用户注册次数
metrics.incr("user.registrations", amount=1, tags={"source": "web"})

分布指标（Distribution）

分布指标用于记录数值的分布情况，如响应时间：

from sentry_sdk import metrics
import time

def process_order():
    start_time = time.time()
    # 订单处理逻辑
    processing_time = time.time() - start_time
    
    # 记录处理时间分布
    metrics.distribution("order.processing_time", processing_time, 
                        tags={"order_type": "standard"})

测量指标（Gauge）

测量指标用于记录瞬时值，如内存使用量：

import psutil
from sentry_sdk import metrics

# 记录内存使用量
memory_usage = psutil.virtual_memory().percent
metrics.gauge("system.memory_usage", memory_usage)

高级事件定制

自定义错误上下文

您可以为事件添加上下文信息，帮助更好地理解事件发生的环境：

import sentry_sdk

with sentry_sdk.configure_scope() as scope:
    scope.set_tag("environment", "production")
    scope.set_tag("release", "v2.1.0")
    scope.set_context("user", {
        "id": "user_123",
        "email": "user@example.com",
        "subscription": "premium"
    })
    scope.set_extra("debug_info", {
        "page_url": "https://example.com/checkout",
        "browser": "Chrome 91"
    })
    
    # 上报事件时会包含所有上下文信息
    sentry_sdk.capture_message("支付处理完成")

性能事务追踪

对于复杂的操作，可以使用事务来追踪性能：

import sentry_sdk

transaction = sentry_sdk.start_transaction(op="task", name="process_batch")
try:
    # 执行批处理任务
    process_batch_data()
    transaction.finish()
except Exception as e:
    transaction.finish(status="internal_error")
    raise

指标聚合与查询

Sentry支持强大的指标聚合功能，您可以在Sentry界面中创建仪表盘来可视化这些指标：

mermaid

最佳实践

有意义的标签：使用有意义的标签来区分不同的指标维度
适当的采样率：对于高频率的指标，设置合适的采样率以避免数据过载
上下文丰富：为事件提供充足的上下文信息以便于调试
错误处理：确保指标上报不会影响主业务流程
性能考虑：批量上报指标以减少网络开销

示例：完整的电商订单监控

import sentry_sdk
from sentry_sdk import metrics
import time

def track_order_creation(order_data):
    # 开始性能事务
    transaction = sentry_sdk.start_transaction(
        op="ecommerce", 
        name="create_order"
    )
    
    try:
        # 记录业务指标
        metrics.incr("orders.created", tags={
            "payment_method": order_data["payment_method"],
            "currency": order_data["currency"]
        })
        
        # 处理订单创建逻辑
        start_time = time.time()
        order_id = create_order_in_db(order_data)
        processing_time = time.time() - start_time
        
        # 记录性能指标
        metrics.distribution("order.processing_time", processing_time)
        
        # 上报成功事件
        sentry_sdk.capture_message(
            f"订单创建成功: {order_id}",
            level="info",
            tags={
                "order_id": order_id,
                "amount": order_data["amount"]
            }
        )
        
        transaction.finish(status="ok")
        return order_id
        
    except Exception as e:
        # 记录错误指标
        metrics.incr("orders.failed", tags={
            "error_type": type(e).__name__
        })
        
        # 上报错误事件
        sentry_sdk.capture_exception(e)
        
        transaction.finish(status="internal_error")
        raise

通过灵活运用Sentry的自定义事件和性能指标功能，您可以构建完整的应用监控体系，从业务逻辑到性能表现的全方位监控。

总结

通过本文的全面介绍，我们可以看到Sentry SDK为全栈应用提供了强大的监控能力。从前端的JavaScript/TypeScript到后端的Python Django/Flask，再到移动端的iOS/Android，Sentry都提供了深度集成的解决方案。通过合理的配置和最佳实践，开发者可以实现从错误追踪到性能分析，从用户行为监控到业务指标统计的全方位监控体系，帮助团队快速发现和解决应用中的问题，提升应用质量和用户体验。

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考