Sentry

Overview

Sentry provides a suite of tools for monitoring application health, focusing on real-time error tracking and performance analysis for development and operations teams. The platform captures exceptions, crashes, and performance bottlenecks as they occur in production environments, offering immediate insights into the impact on end-users. Sentry's approach centralizes error data from various applications and services, making it accessible through a unified interface for debugging and resolution.

The core functionality includes detailed stack traces, environmental context, and user information associated with each error event. This data helps developers understand the precise conditions under which an error occurred, reducing the time spent reproducing issues. Beyond error tracking, Sentry incorporates application performance monitoring (APM) to track transaction durations, identify slow database queries, and pinpoint inefficient code paths. This allows teams to optimize application responsiveness and user experience proactively.

Sentry is designed for integration into existing developer workflows, supporting a wide array of programming languages, frameworks, and deployment environments through its comprehensive SDKs. These SDKs automatically instrument applications to report errors and performance data with minimal configuration. The platform also offers features like release tracking, which correlates errors with specific code deployments, and suspect commits, which identifies the potential code changes responsible for new issues. This integration facilitates a faster feedback loop between development, testing, and production. Sentry's compliance certifications, including SOC 2 Type II, GDPR, and HIPAA compliance details, address data security and privacy requirements for various industries.

The platform is particularly beneficial for teams managing complex distributed systems, where errors might originate from multiple microservices or third-party integrations. By aggregating all relevant events, Sentry assists in tracing issues across service boundaries. Furthermore, its session replay feature allows developers to visually reconstruct user interactions leading up to an error, providing a contextual understanding of the user experience. This capability helps bridge the gap between technical error reports and the actual user journey, offering a more complete picture for debugging. For example, understanding how a user navigated through an application before encountering a JavaScript error can be critical for frontend issue resolution.

Key features

• Error Monitoring: Captures and aggregates exceptions, crashes, and unhandled errors from applications, providing stack traces, context, and user data for each event.
• Performance Monitoring: Tracks application performance metrics such as transaction duration, throughput, and resource utilization to identify bottlenecks and optimize code execution.
• Session Replay: Records and reconstructs user sessions, allowing developers to visually observe user interactions leading up to an error or performance issue.
• Alerts & Notifications: Configurable alerts based on error rates, new errors, or performance thresholds, with integrations for communication platforms like Slack, PagerDuty, and email.
• Release Tracking: Correlates errors and performance regressions with specific code releases, enabling teams to quickly identify the impact of new deployments.
• Suspect Commits: Automatically identifies the Git commits likely responsible for introducing new errors, streamlining the code review and rollback process.
• Code Coverage: Provides insights into which parts of the codebase are being executed and where potential gaps in testing or monitoring exist.
• Custom Integrations: Supports webhooks and API access for integrating with custom tools and workflows, extending its capabilities beyond the core platform.
• Extensive SDK Support: Offers Software Development Kits for over 30 languages and frameworks, facilitating easy integration into diverse tech stacks.

Pricing

Sentry offers a free developer tier and scales its paid plans based on event volume. Pricing information below is current as of May 2026.

Additional details and custom pricing options are available on the Sentry pricing page.

Common integrations

• Issue Tracking: Jira, GitHub Issues, GitLab, Azure DevOps, Asana, Trello (for creating and linking issues directly from Sentry errors).
• Alerting & Notifications: Slack, PagerDuty, Microsoft Teams, Opsgenie, VictorOps (for real-time incident response).
• Version Control: GitHub, GitLab, Bitbucket, Azure Repos (for linking errors to code, suspect commits, and pull requests).
• Customer Support: Zendesk, Intercom (for connecting error data with user support tickets).
• Cloud Platforms: AWS Lambda, Google Cloud Functions, Vercel, Netlify (for monitoring serverless and edge functions).
• Data & Analytics: Mixpanel, Segment (for enriching error data with user analytics).
• APM & Observability: Datadog, New Relic (for combining Sentry's error context with broader infrastructure monitoring, though Sentry itself provides performance monitoring, as described in Sentry's platform overview).

Alternatives

• Datadog: A comprehensive monitoring platform offering APM, infrastructure monitoring, log management, and security monitoring.
• New Relic: Provides a full-stack observability platform with APM, infrastructure monitoring, log management, and browser monitoring capabilities.
• Bugsnag: Focuses on error monitoring and crash reporting for web, mobile, and backend applications, with features for error grouping and alerting.
• Cloudflare Logpush and Analytics: Offers logging and analytics for Cloudflare Workers and other services, providing insights into edge application performance and errors, often used in conjunction with more specialized error trackers.

Getting started

To integrate Sentry into a Python application, you typically install the Sentry SDK and initialize it with your Data Source Name (DSN). The following example demonstrates basic setup for a Python application to capture unhandled exceptions:

import sentry_sdk

sentry_sdk.init(
    dsn="YOUR_SENTRY_DSN",
    # Set traces_sample_rate to 1.0 to capture 100% of transactions for performance monitoring.
    # We recommend adjusting this value in production.
    traces_sample_rate=1.0,
    # Set profiles_sample_rate to 1.0 to profile 100% of sampled transactions.
    # We recommend adjusting this value in production.
    profiles_sample_rate=1.0,
    # To set a uniform sample rate for session replay, set `replays_session_sample_rate`
    # to a value like 0.1 (10% of sessions will be recorded).
    replays_session_sample_rate=0.1,
    # To set a uniform sample rate for error-triggered session replays, set `replays_error_sample_rate`
    # to a value like 1.0 (100% of error-triggered sessions will be recorded).
    replays_error_sample_rate=1.0,
)

def divide_by_zero():
    return 1 / 0

def main():
    try:
        divide_by_zero()
    except Exception as e:
        sentry_sdk.capture_exception(e)
        print("An error occurred and was reported to Sentry.")

if __name__ == "__main__":
    main()

Replace "YOUR_SENTRY_DSN" with the actual DSN obtained from your Sentry project settings. The traces_sample_rate and profiles_sample_rate parameters control the sampling rate for performance monitoring and profiling, respectively. The replays_session_sample_rate and replays_error_sample_rate parameters manage the sampling for session replay functionality. For more detailed instructions and SDKs for other languages, refer to the Sentry documentation portal.