Code breaks, fix it faster

npx @sentry/wizard@latest -i nextjs

npx @sentry/wizard@latest -i angular

brew install getsentry/tools/sentry-wizard && sentry-wizard -i android

brew install getsentry/tools/sentry-wizard && sentry-wizard -i ios

npx @sentry/wizard@latest -i flutter

npx @sentry/wizard@latest -i reactNative

dotnet add package Sentry.Maui -v 5.11.1

pip install --upgrade sentry-sdk

import sentry_sdk

sentry_sdk.init(
 "https://<key>@sentry.io/<project>",

 # Set traces_sample_rate to 1.0 to capture 100%
 # of transactions for Tracing.
 # We recommend adjusting this value in production.
 enable_tracing=True,
 traces_sample_rate=1.0,
)

npm install @sentry/node

const Sentry = require('@sentry/node');
Sentry.init({ dsn: 'https://<key>@sentry.io/<project>' });

npm install @sentry/react

import { useEffect } from "react";
import * as Sentry from "@sentry/react";

Sentry.init({
 dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
 integrations: [
 ],
 // Set `tracePropagationTargets` to control for which URLs trace propagation should be enabled
 tracePropagationTargets: [/^\//, /^https:\/\/yourserver\.io\/api/],
});

// Sentry initialization should be imported first!
import "./instrument";
import App from "./App";
import { createRoot } from "react-dom/client";

const container = document.getElementById(“app”);
const root = createRoot(container);
root.render(<App />);

dotnet add package Sentry

using (SentrySdk.Init(o => {
 // Tells which project in Sentry to send events to:
 o.Dsn = "https://<key>@sentry.io/<project>";
 // When configuring for the first time, to see what the SDK is doing:
 o.Debug = true;
 // Set TracesSampleRate to 1.0 to capture 100% of transactions for Tracing.
 // We recommend adjusting this value in production.
 o.TracesSampleRate = 1.0; }))
{
 // App code goes here - Disposing will flush events out
}

go get "github.com/getsentry/sentry-go"

package main

import (
	"log"
	"time"

	"github.com/getsentry/sentry-go"
)

func main() {
	err := sentry.Init(sentry.ClientOptions{
		Dsn: "https://<key>@sentry.io/<project>",
 EnableTracing: true,
		// Specify a fixed sample rate:
		// We recommend adjusting this value in production
		TracesSampleRate: 1.0,
		// Or provide a custom sample rate:
		TracesSampler: sentry.TracesSampler(func(ctx sentry.SamplingContext) float64 {
			// As an example, this does not send some
			// transactions to Sentry based on their name.
			if ctx.Span.Name == "GET /health" {
				return 0.0
			}

			return 1.0
		}),
	})
	if err != nil {
		log.Fatalf("sentry.Init: %s", err)
	}
	// Flush buffered events before the program terminates.
	// Set the timeout to the maximum duration the program can afford to wait.
	defer sentry.Flush(2 * time.Second)
}

platform :ios, '9.0'
use_frameworks! # This is important

target 'YourApp' do
 pod 'Sentry', :git => 'https://github.com/getsentry/sentry-cocoa.git', :tag => '<VERSION>'
end

import Sentry // Make sure you import Sentry

func application(_ application: UIApplication,
 didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

 SentrySDK.start { options in
 options.dsn = "https://<key>@sentry.io/<project>"
 options.debug = true // Enabled debug when first installing is always helpful
 // Example uniform sample rate: capture 100% of transactions for Tracing
 options.tracesSampleRate = 1.0
 }

 return true
}

gem "sentry-ruby"

Sentry.init do |config|
 config.dsn = 'https://<key>@sentry.io/<project>'

 # Set a uniform sample rate between 0.0 and 1.0
 # We recommend adjusting the value in production:
 config.traces_sample_rate = 1.0

 # or control sampling dynamically
 config.traces_sampler = lambda do |sampling_context|
 # sampling_context[:transaction_context] contains the information about the transaction
 # sampling_context[:parent_sampled] contains the transaction's parent's sample decision
 true # return value can be a boolean or a float between 0.0 and 1.0
 end
end

composer require sentry/sentry

\Sentry\init(['dsn' => 'https://<key>@sentry.io/<project>',
 // Specify a fixed sample rate:
 'traces_sample_rate' => 0.2,
 // Or provide a custom sampler:
 'traces_sampler' => function (SentryTracingSamplingContext $context): float {
 // return a number between 0 and 1
 }, ]);

composer require sentry/sentry-laravel

<?php

use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Exceptions;
use Illuminate\Foundation\Configuration\Middleware;
use Sentry\Laravel\Integration;

return Application::configure(basePath: dirname(__DIR__))
 ->withRouting(
 web: __DIR__.'/../routes/web.php',
 commands: __DIR__.'/../routes/console.php',
 health: '/up',
 )
 ->withMiddleware(function (Middleware $middleware) {
 //
 })
 ->withExceptions(function (Exceptions $exceptions) {
 Integration::handles($exceptions);
 })->create();

// Specify a fixed sample rate:
'traces_sample_rate' => 0.2,
// Or provide a custom sampler:
'traces_sampler' => function (SentryTracingSamplingContext $context): float {
 // return a number between 0 and 1
},

php artisan sentry:publish --dsn=<paste-your-DSN-here>

dotnet add package Sentry.AspNetCore

"Sentry": {
 "Dsn": "https://examplePublicKey@o0.ingest.sentry.io/0",
 "Debug": true,
},

public static IHostBuilder CreateHostBuilder(string[] args) =>
 Host.CreateDefaultBuilder(args)
 .ConfigureWebHostDefaults(webBuilder =>
 {
 // Add the following line:
 webBuilder.UseSentry();
 });

<dependency>
 <groupId>io.sentry</groupId>
 <artifactId>sentry-spring-boot-starter</artifactId>
 <version><VERSION></version>
</dependency>

sentry.dsn=https://<key>@sentry.io/<project>
# Set traces_sample_rate to 1.0 to capture 100%
# of transactions for performance monitoring.
# We recommend adjusting this value in production.
sentry.traces-sample-rate=1.0

npm install @sentry/vue

import { createApp } from "vue";
import * as Sentry from "@sentry/vue";

const app = createApp({
 // ...
});

Sentry.init({
 app,
 dsn: "https://<key>@sentry.io/<project>"",
 // This enables automatic instrumentation (highly recommended),
 // but is not necessary for purely manual usage
 // If you only want to use custom instrumentation:
 // * Remove the BrowserTracing integration
 // * add Sentry.addTracingExtensions() above your Sentry.init() call
 integrations: [Sentry.browserTracingIntegration()],

 // We recommend adjusting this value in production, or using tracesSampler
 // for finer control
 tracesSampleRate: 1.0,
 // Set tracePropagationTargets to control for which URLs distributed tracing should be enabled
 tracePropagationTargets: ['localhost', /^https://yourserver.io/api/],
});

app.mount("#app");

// index.jsx / index.tsx

import * as Sentry from "@sentry/solid";
import { useBeforeLeave, useLocation } from "@solidjs/router";
import { render } from "solid-js/web";
import App from "./app";

// Initialize the Sentry SDK here 
Sentry.init({
 dsn: "__DSN__",
 integrations: [Sentry.browserTracingIntegration()],

 // Performance Monitoring
 tracesSampleRate: 1.0, // Capture 100% of the transactions
 // Set 'tracePropagationTargets' to control for which URLs trace propagation should be enabled
 tracePropagationTargets: ["localhost", /^https:\/\/yourserver\.io\/api/],
});

const app = document.getElementById("app");

if (!app) throw new Error("No #app element found in the DOM.");

render(() => <App />, app)

// main.js / main.ts

import App from "./App.svelte";

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

// Initialize the Sentry SDK here
Sentry.init({
 dsn: "__DSN__",
 release: "my-project-name@2.3.12",
 integrations: [new BrowserTracing()],

 // This enables automatic instrumentation (highly recommended),
 // but is not necessary for purely manual usage
 // If you only want to use custom instrumentation:
 // * Remove the BrowserTracing integration
 // * add Sentry.addTracingExtensions() above your Sentry.init() call
 integrations: [Sentry.browserTracingIntegration()],

 // We recommend adjusting this value in production, or using tracesSampler
 // for finer control
 tracesSampleRate: 1.0,

 // Set tracePropagationTargets to control for which URLs distributed tracing should be enabled
 tracePropagationTargets: ['localhost', /^https://yourserver.io/api/],
});

// Then bootstrap your Svelte app
const app = new App({
 target: document.getElementById("app"),
});

export default app;

npx astro add @sentry/astro

import { defineConfig } from "astro/config";
import sentry from "@sentry/astro";

export default defineConfig({
 integrations: [
 sentry({
 dsn: "__DSN__",
 sourceMapsUploadOptions: {
 project: "your-project-slug",
 authToken: process.env.SENTRY_AUTH_TOKEN,
 },
 tracesSampleRate: 1.0,
 }),
 ],
});

<script src="https://browser.sentry-cdn.com/<VERSION>/bundle.min.js"></script>

Sentry.init({ dsn: 'https://<key>@sentry.io/<project>',
 // This enables automatic instrumentation (highly recommended),
 // but is not necessary for purely manual usage
 // If you only want to use custom instrumentation:
 // * Remove the BrowserTracing integration
 // * add Sentry.addTracingExtensions() above your Sentry.init() call
 integrations: [Sentry.browserTracingIntegration()],

 // We recommend adjusting this value in production, or using tracesSampler
 // for finer control
 tracesSampleRate: 1.0,

 // Set tracePropagationTargets to control for which URLs distributed tracing should be enabled
 tracePropagationTargets: ['localhost', /^https://yourserver.io/api/],
});