hi，我是南哥。
最近在给公司项目接入 Sentry 错误跟踪，涉及到三个不同的服务：Python 写的后端 API、Go 写的微服务、React 写的前端。
折腾了一周，踩了不少坑，也发现了一些有意思的地方。
今天就跟你聊聊 Sentry 在这三种语言里的接入方式有什么区别。
一、为什么选择 Sentry
先说说为啥要用 Sentry。
我们团队之前是把错误日志打到文件里，然后用 ELK 收集。
问题是：
Sentry 能解决这些痛点：
而且 Sentry 开源，可以自己部署，数据不出境。
二、三种语言的接入对比
先给你个直观的对比表：
总体来说：
Python 最省心，集成简单，自动捕获，开箱即用。
Go 最灵活，性能最好，但需要手动处理错误。
JavaScript 最全面，支持各种框架，但打包体积需要注意。
三、Python：开箱即用的体验
Python 的 Sentry SDK 是三个里面最好用的。
安装
一行命令搞定：
pip install sentry-sdk
基础配置
代码也超简单：
import sentry_sdk
sentry_sdk.init(
dsn="https://your-key@sentry.io/project-id",
traces_sample_rate=1.0, # 性能监控采样率
profiles_sample_rate=1.0, # 性能分析采样率
)
就这三行，错误跟踪就启用了。
自动捕获异常
这是最爽的地方。
你的代码不用改，Sentry 会自动捕获所有未处理的异常：
# 这个异常会自动发送到 Sentry
defprocess_payment():
raise ValueError("Invalid payment amount")
不需要 try-catch，不需要手动上报，全自动。
框架集成
Python 的框架集成是最丰富的。
Django 示例：
import sentry_sdk
from sentry_sdk.integrations.django import DjangoIntegration
sentry_sdk.init(
dsn="your-dsn",
integrations=[DjangoIntegration()],
)
加一行 DjangoIntegration()，Django 的所有错误、性能数据都自动上报了。
FastAPI 示例：
import sentry_sdk
from sentry_sdk.integrations.fastapi import FastApiIntegration
sentry_sdk.init(
dsn="your-dsn",
integrations=[FastApiIntegration()],
)
FastAPI、Flask、Celery、Redis、SQLAlchemy...主流框架全支持。
我数了一下，Python SDK 支持 50+ 个框架和库。
手动上报
有时你想手动记录一些信息：
# 记录一条消息
sentry_sdk.capture_message("User checkout completed")
# 记录异常
try:
risky_operation()
except Exception as e:
sentry_sdk.capture_exception(e)
# 添加上下文
with sentry_sdk.push_scope() as scope:
scope.set_tag("payment_method", "credit_card")
scope.set_user({"id": user_id, "email": user_email})
sentry_sdk.capture_message("Payment processed")
性能监控
Sentry 不仅能追踪错误，还能监控性能：
import sentry_sdk
# 自动监控数据库查询
with sentry_sdk.start_transaction(name="checkout"):
user = User.objects.get(id=user_id) # 自动记录查询时间
process_payment(user)
数据库查询、HTTP 请求、Redis 操作，都会自动记录耗时。
踩坑经验
坑 1：采样率别设太高
刚开始我把 traces_sample_rate 设成 1.0，结果性能数据量爆炸。
生产环境建议设成 0.1 或 0.2，采样 10-20% 就够了。
坑 2：敏感信息过滤
错误堆栈可能包含密码、Token 等敏感信息。
要配置过滤规则：
sentry_sdk.init(
dsn="your-dsn",
before_send=lambda event, hint: filter_sensitive_data(event),
)
deffilter_sensitive_data(event):
# 过滤密码字段
if'request'in event and'data'in event['request']:
event['request']['data'] = {
k: '***'if'password'in k.lower() else v
for k, v in event['request']['data'].items()
}
return event
四、Go：性能优先的设计
Go 的 Sentry SDK 设计理念和 Python 不同。
Go 强调显式错误处理，SDK 也遵循这个哲学。
安装
go get github.com/getsentry/sentry-go
基础配置
package main
import (
"github.com/getsentry/sentry-go"
"log"
"time"
)
funcmain() {
err := sentry.Init(sentry.ClientOptions{
Dsn: "https://your-key@sentry.io/project-id",
TracesSampleRate: 1.0,
})
if err != nil {
log.Fatalf("Sentry initialization failed: %v", err)
}
// 确保程序退出前上报所有错误
defer sentry.Flush(2 * time.Second)
}
注意最后的 defer sentry.Flush()，这个很重要。
Go 程序退出很快，不加这个可能错误还没发送出去，程序就结束了。
手动捕获错误
Go 不会自动捕获 panic，你得手动处理：
// 方式 1：捕获 error
if err != nil {
sentry.CaptureException(err)
return err
}
// 方式 2：捕获 panic
deferfunc() {
if r := recover(); r != nil {
sentry.CurrentHub().Recover(r)
sentry.Flush(2 * time.Second)
}
}()
HTTP 中间件
Go 的 Web 框架集成需要手动加中间件。
net/http 示例：
import (
"net/http"
sentryhttp "github.com/getsentry/sentry-go/http"
)
funcmain() {
sentryHandler := sentryhttp.New(sentryhttp.Options{})
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
// 业务逻辑
})
http.ListenAndServe(":8080", sentryHandler.Handle(http.DefaultServeMux))
}
Gin 示例：
import (
"github.com/gin-gonic/gin"
"github.com/getsentry/sentry-go"
)
funcmain() {
r := gin.Default()
// 添加 Sentry 中间件
r.Use(func(c *gin.Context) {
deferfunc() {
if err := recover(); err != nil {
sentry.CurrentHub().Recover(err)
c.AbortWithStatus(500)
}
}()
c.Next()
})
r.Run(":8080")
}
性能监控
Go 的性能监控需要手动创建 Span：
span := sentry.StartSpan(ctx, "database.query")
defer span.Finish()
// 执行数据库查询
result := db.Query("SELECT * FROM users")
span.SetData("rows_affected", result.RowsAffected)
没有 Python 那么自动化，但性能开销更小。
踩坑经验
坑 1：忘记 Flush
Go 程序退出时，如果没有 sentry.Flush()，错误可能丢失。
我之前就踩过这个坑，明明触发了 panic，Sentry 里却看不到。
坑 2：Goroutine 里的 panic
Goroutine 里的 panic 不会被主协程捕获，要单独处理：
gofunc() {
deferfunc() {
if r := recover(); r != nil {
sentry.CurrentHub().Recover(r)
}
}()
// 你的代码
}()
坑 3：Context 传递
Go 的 Sentry Hub 是绑定到 Context 的。
如果你的函数需要上报错误，记得传 Context：
funcprocessPayment(ctx context.Context, amount float64)error {
if amount < 0 {
hub := sentry.GetHubFromContext(ctx)
hub.CaptureMessage("Negative payment amount")
return errors.New("invalid amount")
}
returnnil
}
五、JavaScript：框架适配的典范
JavaScript 的 Sentry SDK 是最复杂的，因为要支持太多环境。
浏览器、Node.js、React、Next.js、Vue、Svelte...每个都有专门的包。
浏览器端
安装：
npm install @sentry/browser
配置：
import * as Sentry from"@sentry/browser";
Sentry.init({
dsn: "https://your-key@sentry.io/project-id",
tracesSampleRate: 1.0,
});
浏览器端会自动捕获：
React 集成
安装：
npm install @sentry/react
配置：
import * as Sentry from"@sentry/react";
import { BrowserTracing } from"@sentry/tracing";
Sentry.init({
dsn: "your-dsn",
integrations: [new BrowserTracing()],
tracesSampleRate: 1.0,
});
React 特有的功能：
错误边界（Error Boundary）：
import * as Sentry from"@sentry/react";
functionApp() {
return (
<Sentry.ErrorBoundaryfallback={<ErrorFallback />}>
<YourApp />
</Sentry.ErrorBoundary>
);
}
组件内的错误会自动捕获并上报。
性能监控：
import { withProfiler } from"@sentry/react";
// 自动监控组件渲染性能
exportdefault withProfiler(MyComponent);
Next.js 集成
Next.js 最复杂，因为同时有客户端和服务端。
安装：
npx @sentry/wizard@latest -i nextjs
向导会自动创建三个配置文件：
sentry.client.config.ts（客户端）：
import * as Sentry from"@sentry/nextjs";
Sentry.init({
dsn: "your-dsn",
tracesSampleRate: 1.0,
});
sentry.server.config.ts（服务端）：
import * as Sentry from"@sentry/nextjs";
Sentry.init({
dsn: "your-dsn",
tracesSampleRate: 1.0,
});
sentry.edge.config.ts（Edge Runtime）：
import * as Sentry from"@sentry/nextjs";
Sentry.init({
dsn: "your-dsn",
tracesSampleRate: 1.0,
});
Next.js 的 API 路由、Server Components、App Router 都会自动上报错误。
Node.js 后端
安装：
npm install @sentry/node
配置：
const Sentry = require("@sentry/node");
Sentry.init({
dsn: "your-dsn",
tracesSampleRate: 1.0,
});
// Express 中间件
app.use(Sentry.Handlers.requestHandler());
app.use(Sentry.Handlers.tracingHandler());
// 业务路由
app.get("/api/users", (req, res) => {
// ...
});
// 错误处理中间件（必须放最后）
app.use(Sentry.Handlers.errorHandler());
踩坑经验
坑 1：打包体积
Sentry 的浏览器 SDK 大约 50KB（gzip 后）。
如果你的应用对体积敏感，可以用懒加载：
// 懒加载 Sentry
const loadSentry = async () => {
if (process.env.NODE_ENV === 'production') {
const Sentry = awaitimport('@sentry/browser');
Sentry.init({ dsn: 'your-dsn' });
}
};
坑 2：Source Maps
浏览器端的错误堆栈是压缩混淆后的，看不懂。
要上传 Source Maps：
npm install @sentry/webpack-plugin
# webpack.config.js
const { sentryWebpackPlugin } = require("@sentry/webpack-plugin");
module.exports = {
devtool: 'hidden-source-map',
plugins: [
sentryWebpackPlugin({
authToken: process.env.SENTRY_AUTH_TOKEN,
org: "your-org",
project: "your-project",
}),
],
};
坑 3：Next.js 的 Edge Runtime
Next.js 的 Edge Runtime 限制很多，部分 Sentry 功能不可用。
比如 sentry.flush() 在 Edge Runtime 里不能用。
六、实战对比：同一个场景的实现
假设场景：记录用户支付失败的错误，包含用户 ID、支付金额、支付方式。
Python 实现：
import sentry_sdk
defprocess_payment(user_id, amount, method):
try:
payment_api.charge(amount, method)
except PaymentError as e:
with sentry_sdk.push_scope() as scope:
scope.set_user({"id": user_id})
scope.set_tag("payment_method", method)
scope.set_extra("amount", amount)
sentry_sdk.capture_exception(e)
raise
Go 实现：
funcProcessPayment(ctx context.Context, userID string, amount float64, method string)error {
hub := sentry.GetHubFromContext(ctx)
err := paymentAPI.Charge(amount, method)
if err != nil {
hub.WithScope(func(scope *sentry.Scope) {
scope.SetUser(sentry.User{ID: userID})
scope.SetTag("payment_method", method)
scope.SetExtra("amount", amount)
hub.CaptureException(err)
})
return err
}
returnnil
}
JavaScript 实现：
import * as Sentry from"@sentry/browser";
asyncfunctionprocessPayment(userId, amount, method) {
try {
await paymentAPI.charge(amount, method);
} catch (error) {
Sentry.withScope((scope) => {
scope.setUser({ id: userId });
scope.setTag("payment_method", method);
scope.setExtra("amount", amount);
Sentry.captureException(error);
});
throw error;
}
}
三种语言的 API 设计非常相似，学习成本低。
七、选择建议
如果你要选一个，我的建议：
Python 项目：闭眼选 Sentry，集成最简单，功能最全。
Go 项目：如果追求性能，用 Sentry；如果追求简单，考虑其他方案（如只打日志）。
JavaScript 项目：看场景。
- Node.js API：看团队习惯，Sentry 或 Winston + ELK 都可以
多语言项目：统一用 Sentry，有利于跨团队协作。
八、总结
Sentry 在三种语言里的接入方式各有特点：
Python：自动化程度最高，开箱即用，最省心。
Go：需要手动处理更多细节，但性能最好，开销最小。
JavaScript：支持的框架和场景最多，但配置也最复杂。
不管哪种语言，Sentry 的核心价值是一样的：
如果你的项目还在裸奔（错误靠打日志），不妨试试 Sentry。
开源免费，自己部署，数据不出境。
好啦，感谢阅读，我们下一期见。
参考资源：
Sentry Python SDK：https://github.com/getsentry/sentry-python
Sentry Go SDK：https://github.com/getsentry/sentry-go
Sentry JavaScript SDK：https://github.com/getsentry/sentry-javascript
官方文档：https://docs.sentry.io/
