mirror of
https://github.com/getsentry/sentry-agent-skills.git
synced 2026-09-20 14:23:25 +08:00
main
48 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
 Daniel Griesser
|
9f54eb0219 |
chore: add sunset notice — skills moved to sentry-for-ai (#20)
All skills have been ported to getsentry/sentry-for-ai, which is now the single source of truth for Sentry agent skills, MCP config, slash commands, and plugin metadata. The full legacy README is preserved in a collapsed details block for reference until the repo is archived. Co-Authored-By: Claude (Anthropic)latest |
||
|
Daniel Griesser
|
4d235fa92c |
refactor(sdk-skill-creator): move philosophy doc into skill references
Move docs/sdk-skill-philosophy.md into skills/sentry-sdk-skill-creator/references/philosophy.md so the SDK skill authoring guide lives alongside the skill that implements it, rather than in a separate top-level docs directory. Updated all references across AGENTS.md, README.md, SKILL.md, and .pi/context.md to point to the new location. Removed the now-empty docs/ directory. Fixed a commit-strategy list numbering gap in SKILL.md caused by removing the obsolete philosophy-doc commit step. |
||
|
Paul Jaffre
|
01b71b5d7e |
feat: Add sentry-otel-exporter-setup skill (#1)
* feat: Add sentry-otel-exporter skill for OTel Collector setup Add skill for configuring OpenTelemetry Collector with the Sentry Exporter. Covers multi-project routing, auto-provisioning, and self-hosted setups. Co-Authored-By: Claude <noreply@anthropic.com> Co-authored-by: Cursor <cursoragent@cursor.com> * ref: Rename to sentry-otel-exporter-setup and update README Follow naming convention matching sentry-python-setup pattern. Add skill to README tables. Co-Authored-By: Claude <noreply@anthropic.com> Co-authored-by: Cursor <cursoragent@cursor.com> * docs(otel-exporter): Align skill with exporter spec and improve language support - Remove Team:Read permission requirement (team info comes from project API) - Add missing config options: http, sending_queue - Add "Using with Sentry SDKs" section for trace connectedness - Lead with environment variables (works for all languages) - Add link to OpenTelemetry docs for any language - Add cache guardrails to limitations (max 1000 projects/queue) - Update troubleshooting to remove Team:Read references - Add 403 cache eviction behavior to troubleshooting Co-Authored-By: Claude <noreply@anthropic.com> * fix(otel-exporter): Search for existing .env files before creating new one Prevents creating a duplicate .env at root when the project already has one elsewhere (e.g., in /api). Now prompts user to choose which .env file to add credentials to. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * docs(otel-exporter): Check for existing config and fetch docs from repo - Add Step 1 to search for existing collector configs before creating - Prefer editing existing config to avoid duplicates - Replace hardcoded YAML with links to upstream docs: - example-config.yaml for scaffolding template - spec.md for advanced options - Update step numbering and cross-references Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix(otel-exporter): Clarify that Step 5 adds placeholders, not credentials Rename "Set Up Credentials" to "Add Environment Variable Placeholders" to avoid language that sounds like we're handling real secrets. The agent now clearly adds placeholder values that users fill in manually. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix(otel-exporter): Add explicit DO/DON'T language constraints for env vars Add concrete examples of what to say and what not to say when adding placeholder environment variables. Constraints placed directly in Step 5 where the action happens. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix(otel-exporter): Correct org slug location instructions Point to Settings → Organization Settings → Organization Slug and note it matches the subdomain. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * refactor(otel-exporter): Improve skill per skill-creator standards - Simplify Step 1 to imperative voice, remove bash code block - Make Step 2 Binary section more concise - Add Step 7: Verify Setup with success criteria - Add Troubleshooting table for common errors Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * feat(otel-exporter): Add version check and use latest release - Check for existing collector before downloading - Skip download if version >= 0.145.0 (compatible) - Fetch latest release from GitHub API instead of hardcoding 0.145.0 - Prevents downgrading users who have newer versions Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix(otel-exporter): Validate config only after credentials are set - Add confirmation prompt before validation - Wait for user to confirm .env has real credentials - Run validation after confirmation, before starting collector - Update troubleshooting for env var errors Prevents confusing validation failures when placeholders aren't replaced. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * refactor(otel-exporter): Apply synthesis improvements to skill Based on research of Agent Skills spec and Anthropic's official skills: - Add master progress checklist for tracking 7-step workflow - Simplify question formats from structured to natural language bullets - Improve validation loop with explicit "validate → fix → repeat" pattern - Use concrete example paths instead of placeholder syntax - Remove unnecessary terminology note (Claude knows capitalization) These changes align the skill with Anthropic patterns while maintaining the sophisticated credential handling and validation gates that make this skill effective. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix(otel-exporter): Restore terminology note for Sentry Exporter The terminology instruction was removed during synthesis improvements, but testing showed Claude doesn't consistently capitalize "Sentry Exporter" during interactive skill execution without this explicit guidance. Real-world testing trumps theoretical best practices - keeping this instruction to ensure consistent capitalization. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix(otel-exporter): Add explicit flow control to prevent skipping steps User reported that Claude was jumping between steps without waiting for answers to questions - asking about auto-create (Step 3) before getting an answer about modify vs create config (Step 1), then proceeding to create a new config without the user's decision. Changes: - Step 1: Add "Wait for the user's answer and record their choice" - Step 3: Add "Wait for the user's answer before proceeding to Step 4" - Step 4: Add "Use the decision from Step 1" reminder at the top - Step 5: Add "Wait for the user's answer" for .env file selection - Convert Step 1 options to bullet format for consistency This enforces proper sequential flow and prevents Claude from making assumptions about unanswered questions. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix(otel-exporter): Add user confirmation gate before running collector After validation passes, Claude was automatically proceeding to run the collector without explicit user consent. This could be unexpected if the user wants to review the config or prepare their environment first. Changes: - Add confirmation question after validation passes - Explicit "Wait for the user's confirmation before proceeding to Step 6" - Clarify that Step 6 should PROVIDE the command, not execute it - Tell user to run the command themselves when ready This gives users full control over when the collector starts. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix(otel-exporter): Address review bot feedback on paths and versions - Fix version placeholders: GitHub tag_name includes 'v' prefix but OTel downloads and Docker tags use numeric versions without prefix - Add Docker validation command: Users who chose Docker installation now get a validation command that runs inside the container - Use dynamic paths throughout: Validation and run commands now reference the config file, env file, and collector path chosen in earlier steps instead of hardcoding collector-config.yaml, .env, and ./otelcol-contrib - Record chosen paths: Steps now explicitly note to record paths (collector path, config file, env file) for use in later steps Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix(otel-exporter): Clarify version prefix usage in download URLs The URL path requires the v prefix (e.g., /download/v0.145.0/) while only the filename portion uses the numeric version without prefix. Previous wording incorrectly said to strip the prefix from URLs entirely. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix(otel-exporter): Add env var loading for binary installation path Binary users need to load the .env file into their shell before running the collector, since there's no --env-file flag like Docker has. Added export command to both validation and run steps for the binary path. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix(otel-exporter): Handle absolute paths in Docker volume mounts Docker volume mounts require absolute paths. Added note clarifying that relative paths should be prefixed with $(pwd)/ while absolute paths should be used directly. Changed placeholder from $(pwd)/<config_file> to <absolute_config_path> to make this explicit. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix(otel-exporter): Add license and fix env loading security issue - Add missing license: Apache-2.0 field for consistency with other skills - Replace `export $(grep ... | xargs)` with `set -a && source ... && set +a` to prevent command injection via malicious .env file content Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix(otel-exporter): Add instructions for handling existing Docker container Running docker run with --name otel-collector fails if a container with that name already exists. Added cleanup command before the run command and added the error to the troubleshooting table. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix(otel-exporter): Clarify Sentry references in instructions - Change "automatic project creation" to "automatic Sentry project creation" - Change "Org slug" to "Sentry org slug" - Add "In Sentry," prefix to navigation instructions - Makes it clearer that Settings paths refer to the Sentry UI Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix(otel-exporter): Prompt user before deleting downloaded tarball Instead of silently deleting or leaving the tarball, ask the user if they want to clean it up to save ~50MB disk space. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix(otel-exporter): Quote file path placeholders in shell commands Shell commands using placeholders like <env_file> and <config_file> will fail if paths contain spaces. Add double quotes around all path placeholders to ensure proper handling. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix(otel-exporter): Require explicit user selection for env file and tarball cleanup - Env file: Explicitly state not to infer from context or guess based on open files - Tarball: Add explicit wait for user response before deleting Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> --------- Co-authored-by: Claude <noreply@anthropic.com> Co-authored-by: Cursor <cursoragent@cursor.com> Co-authored-by: Daniel Griesser <daniel.griesser.86@gmail.com> |
||
|
Daniel Griesser
|
e12b0145b4 |
feat(dotnet-sdk): add sentry-dotnet-sdk skill bundle (#19)
* feat(sentry-dotnet-sdk): add main SKILL.md wizard
Four-phase wizard covering the full .NET SDK setup journey:
Phase 1 (Detect): bash commands to scan for .csproj, framework type
(ASP.NET Core, WPF, WinForms, MAUI, Blazor WASM, Azure Functions,
classic ASP.NET), existing Sentry packages, and companion frontends.
Phase 2 (Recommend): opinionated feature matrix — Error Monitoring and
Tracing always, Logging when ILogger/Serilog/NLog detected, Profiling
and Crons as optional extras.
Phase 3 (Guide): Option 1 wizard (npx @sentry/wizard@latest -i dotnet),
Option 2 manual setup with complete working code for every major
framework (ASP.NET Core, WPF, WinForms, MAUI, Blazor WASM, Azure
Functions isolated worker, AWS Lambda, classic ASP.NET). Includes
MSBuild symbol upload setup for readable production stack traces.
Reference dispatch table points to references/*.md for each feature.
Phase 4 (Cross-Link): detects companion Next.js/React/Vue/Nuxt frontends
and suggests the matching SDK skill to enable distributed tracing.
Also includes:
- Full SentryOptions config reference table (all options, types, defaults, env vars)
- ASP.NET Core and MAUI extended options tables
- Environment variables table with double-underscore convention note
- MSBuild symbol upload properties table
- Troubleshooting table covering 10 common failure modes
* feat(sentry-dotnet-sdk): add error-monitoring.md deep-dive reference
Adds a comprehensive error monitoring reference for the .NET SDK at
skills/sentry-dotnet-sdk/references/error-monitoring.md, following the
same structure and depth as the Next.js exemplar.
Coverage:
- Automatic vs manual capture table with the core rule ('if you catch
and don't re-throw, Sentry never sees it')
- Full CaptureException / CaptureMessage / CaptureEvent API with all
overloads and inline scope callback semantics
- ASP.NET Core setup (Program.cs, appsettings.json, env vars), what is
auto-captured, manual capture in controllers, custom ISentryUserFactory
- Scope management: ConfigureScope, PushScope/using pattern, inline
configureScope callbacks, scope decision guide table
- Context enrichment: tags (with constraints), SentryUser fields,
breadcrumbs (manual + auto sources), custom Contexts, tags vs
contexts vs extra comparison table
- BeforeSend / BeforeSendTransaction / BeforeBreadcrumb / BeforeSendLog
hooks with full signatures and practical examples
- Fingerprinting and custom grouping: collapse, split with {{ default }},
template variable reference table
- Exception filters: AddExceptionFilterForType, IExceptionFilter,
DeduplicateMode flags
- Unhandled exception capture for WPF (constructor requirement, global
mode), MAUI (platform coverage table), WinForms (SetUnhandledExceptionMode
requirement), Console (flush-on-exit note)
- Event processors: ISentryEventProcessor, ISentryEventExceptionProcessor,
execution order, inline FuncEventProcessor
- User feedback: CaptureFeedback API, SentryFeedback object, crash-report
modal (JS dialog) with ASP.NET Core integration
- Scenario coverage table, API quick reference, full SentryOptions
reference table, 10-entry troubleshooting table
* feat(sentry-dotnet-sdk): add tracing.md deep-dive reference
Adds skills/sentry-dotnet-sdk/references/tracing.md — a comprehensive
reference covering all aspects of performance monitoring in the Sentry
.NET SDK, loaded on demand when the SKILL.md wizard reaches the tracing
phase.
Key topics covered:
- Activation model: TracesSampleRate / TracesSampler, both disabled by
default; includes the TransactionSamplingContext shape and how to pass
custom sampling hints at transaction start-time.
- ASP.NET Core middleware: UseSentry() placement requirement, what the
SentryMiddleware does automatically (one transaction per request, route
naming, error linking, ContinueTrace, IHttpClientFactory spans, EF Core
spans), and how to drop/rename transactions via BeforeSendTransaction.
- Auto-instrumentation table: all integrations (ASP.NET Core, EF Core,
SQLClient, Azure Functions Worker, Hangfire, Extensions.AI) with the
three EF Core span types (db.query_compiler, db.connection, db.query)
and the SentryHttpMessageHandler pattern for manual HttpClient usage.
- Custom instrumentation: minimal example, real-world checkout flow,
attaching to an active transaction via GetSpan(), nested spans with
SetData, IHub DI-friendly pattern, exception-aware Finish() mapping.
- Distributed tracing: sentry-trace + baggage header semantics, CORS
warning, TracePropagationTargets, manual outgoing header injection,
ContinueTrace() for incoming headers, and a full producer/consumer
queue example showing trace linkage across service boundaries.
- OpenTelemetry: version requirements, SentrySpanProcessor mapping
(first span → Transaction, children → child Spans), full dual-setup
(AddSentry() in OTel builder + UseOpenTelemetry() in SentryOptions),
and the critical warning against activity.RecordException() / AddException().
- Dynamic sampling: how DSC is propagated in baggage, why
TransactionNameSource matters for grouping, table of all name source
values with cardinality guidance.
- Operation types and Origin field naming conventions table.
- Custom measurements: SetMeasurement API, full MeasurementUnit
reference table, unit consistency warning.
- SpanStatus reference with automatic exception and HTTP status mapping.
- Complete configuration reference with all key options in a table
(TracesSampleRate, TracesSampler, TracePropagationTargets,
SendDefaultPii, MaxSpans, ProfilesSampleRate, UseOpenTelemetry,
DisableDiagnosticSourceIntegration).
- Quick reference cheat sheet for common one-liners.
- Troubleshooting table with 9 entries covering no-transaction,
missing child spans, missing HTTP/EF Core spans, broken distributed
traces, CORS issues, OTel misconfiguration, and high-cardinality names.
* feat(sentry-dotnet-sdk): add profiling.md deep-dive reference
Adds skills/sentry-dotnet-sdk/references/profiling.md — a comprehensive
reference for CPU profiling with the Sentry .NET SDK.
Covers:
- Minimum SDK version (Sentry.Profiling ≥ 4.0.0, .NET 8+ required)
- Installation via NuGet (and why iOS/Mac Catalyst don't need the package)
- How profiling attaches to transactions via ProfilesSampleRate ×
TracesSampleRate compounding — one profiler per process at a time
- Three-step AddProfilingIntegration setup with ASP.NET Core and
console/worker service examples
- Synchronous startup pattern (AddProfilingIntegration(TimeSpan)) to
avoid missing early-startup transactions
- Platform matrix: Windows/Linux/macOS (EventPipe), iOS/Mac Catalyst
(native Mono AOT), and unsupported platforms (.NET Framework, Android,
Blazor WASM, Native AOT)
- Linux known issue (#4815, ReflectionTypeLoadException) with try/catch
mitigation
- OTel + profiling conflict (#4820) and how to diagnose it
- All known limitations: 30-second cap, one-at-a-time constraint,
unknown JIT frames, .NET 8+ requirement
- Config options table with types, defaults, and descriptions
- Production vs development recommended rates
- Troubleshooting table with 9 entries covering every common failure mode
* docs(sentry-dotnet-sdk): add logging.md deep-dive reference
Adds a comprehensive logging reference for the Sentry .NET SDK covering:
- Native SentrySdk.Logger API with all six severity levels (Trace through
Fatal), attribute overloads, and supported attribute value types
- EnableLogs configuration requirement — clarifies the silent no-op behaviour
without it and documents SetBeforeSendLog filtering with the full SentryLog
object shape
- Automatically attached attributes table (trace/span IDs, user context,
environment, release, message template parameters)
- Four third-party integrations with full working examples:
• Microsoft.Extensions.Logging (ILogger) — ASP.NET Core, Generic Host,
and direct ILoggerFactory setups; breadcrumb cascade behaviour; all
config options
• Serilog (Sentry.Serilog) — basic sink, separate SDK init, and
ASP.NET Core UseSerilog patterns; config options table
• NLog (Sentry.NLog) — code-based and XML (nlog.config) configs;
prominent warning about minlevel needing to be lower than
MinimumBreadcrumbLevel; all config options
• log4net (Sentry.Log4Net) — XML appender and programmatic SDK init
patterns; key appender options
- Log-to-trace correlation explanation (automatic via TraceId/SpanId on
every log entry, no extra config needed)
- Log level mapping table across all four integrations
- SDK version matrix (native logger requires 5.14.0; integration packages
4.x; native logs forwarded via integrations requires 6.1.0)
- Troubleshooting table with 9 entries covering the most common failure
modes (missing EnableLogs, NLog minlevel pitfall, double SDK init,
sensitive data, high volume filtering)
* docs(sentry-dotnet-sdk): add crons.md reference
Comprehensive deep-dive covering all cron monitoring capabilities in the
Sentry .NET SDK (≥ 4.2.0):
- CaptureCheckIn() API signature with all parameters
- CheckInStatus enum values (InProgress, Ok, Error)
- Two-signal check-in pattern (recommended) vs heartbeat pattern with
optional duration reporting
- Programmatic monitor upsert via configureMonitorOptions: crontab and
interval schedules, CheckInMargin, MaxRuntime, TimeZone,
FailureIssueThreshold, RecoveryThreshold
- SentryMonitorInterval enum values
- Full monitor configuration reference table
- ASP.NET Core BackgroundService integration with complete production
example (NightlyReportJob) and a minimal IHostedService/Timer pattern
- Hangfire integration via Sentry.Hangfire package
- Quartz.NET manual pattern (no official package)
- Long-running heartbeat loop pattern for continuously running processors
- Rate limit documentation (6 check-ins/min per monitor/environment)
- Alerting setup instructions
- SDK version matrix
- 8-entry troubleshooting table covering common failure modes
* docs(readme): add sentry-dotnet-sdk to available skills table
Add the sentry-dotnet-sdk skill entry to the SDK Skills table in README.md,
listing its supported frameworks (ASP.NET Core, MAUI, WPF, WinForms, Azure
Functions, Blazor, gRPC) and linking to the official .NET guide.
Also add four trigger phrases to the Quick Start section so users and AI
assistants can discover the skill when asking about .NET, ASP.NET Core,
MAUI/WPF/WinForms, or Azure Functions integration.
* fix(dotnet-sdk): correct API defaults and property casing from review
Address P1/P2 findings from code review, verified against sentry-dotnet
source code (github.com/getsentry/sentry-dotnet):
- CaptureFailedRequests default: false → true (error-monitoring.md)
- AttachStacktrace default: false → true (error-monitoring.md)
- MaxRequestBodySize thresholds: Small <4 KB, Medium <10 KB (error-monitoring.md)
- AttachStackTrace → AttachStacktrace casing in appsettings.json examples
(both SKILL.md and error-monitoring.md)
|
||
|
Daniel Griesser
|
77d210f0ad |
feat: add sentry-nextjs-sdk skill bundle (#18)
* feat(sentry-nextjs-sdk): add main SKILL.md wizard Implements the four-phase wizard for the sentry-nextjs-sdk skill bundle, covering all three Next.js runtimes (browser, Node.js server, Edge). Phase 1 detects the project's router type (App Router vs Pages Router), existing Sentry config, Next.js version, and companion backends. Phase 2 recommends Error Monitoring + Tracing + Session Replay as the opinionated baseline, with Logging and Profiling as optional extras. Phase 3 guides setup with: - Option 1: Wizard (Recommended) — `npx @sentry/wizard@latest -i nextjs` with auth flow + source map benefits described (PR #17 pattern) - Option 2: Manual Setup — complete instructions for all three init files (`instrumentation-client.ts`, `sentry.server.config.ts`, `sentry.edge.config.ts`) plus `instrumentation.ts` registration hook, App Router `global-error.tsx`, Pages Router `_error.tsx`, and `withSentryConfig()` wrapper - Source maps coverage in the main file (not a reference), with env var setup, .gitignore note, and `authToken` wiring - Reference dispatch table for Error Monitoring, Tracing, Session Replay, Logging, and Profiling reference files Phase 4 cross-links companion backend SDKs (Go, Python, Ruby, Java, Node) with distributed tracing context. Also includes: init options reference table, env vars table, verification checklist, and 8-entry troubleshooting table covering common issues (minified stack traces, missing edge errors, tunnel 404s, Turbopack tree-shaking conflicts). * feat(nextjs-sdk): add error-monitoring.md reference Adds a comprehensive error monitoring reference for the sentry-nextjs-sdk skill covering all three Next.js runtimes (browser, Node.js, Edge). Key sections: - Three-runtime architecture overview with init file mapping table - Automatic vs manual capture decision table with the core rule explained - Client-side: captureException, captureMessage, unhandled rejections - Error boundaries: app/error.tsx, app/global-error.tsx (App Router), pages/_error.tsx + _app.tsx (Pages Router), Sentry.ErrorBoundary for React 18 and earlier, reactErrorHandler() for React 19+ - Server-side: onRequestError hook (SDK ≥8.28.0 + Next.js 15+), API routes for both routers, Server Actions (manual and withServerActionInstrumentation) - Edge runtime: sentry.edge.config.ts, middleware pattern, tunnel route exclusion - Scope management: global/isolation/current scopes with decision guide - Event enrichment: setTag/setTags, setContext, setUser, setExtra with searchability/indexing comparison table - Breadcrumbs: automatic capture table, manual addBreadcrumb with full property reference, beforeBreadcrumb filter/mutate pattern - beforeSend / beforeSendTransaction / ignoreErrors / allowUrls / denyUrls - Fingerprinting: per-event, withScope, beforeSend patterns with template vars - Event processors (multiple allowed, unlike beforeSend) - Scenario coverage table (which errors are auto vs manual) - API quick reference cheat sheet - Troubleshooting table with 10 common issues * docs(sentry-nextjs-sdk): add tracing.md and profiling.md references Add two deep-dive reference files for the sentry-nextjs-sdk skill: **tracing.md** (616 lines) covers: - SDK activation: all three runtime configs must have tracesSampleRate/tracesSampler - tracesSampleRate uniform sampling with environment-aware patterns - tracesSampler with SamplingContext shape, route-based examples, inheritOrSampleWith - Auto-instrumented operations: browser (pageload, navigation, fetch, INP, LoAF) and server (API routes, RSC, getServerSideProps, Edge middleware) - browserTracingIntegration full options table - Custom spans: startSpan, startSpanManual, startInactiveSpan, setActiveSpanInBrowser - Span options reference with common op values table - Span enrichment: setAttribute, setStatus, updateSpanName, beforeSendSpan - Server Actions: withServerActionInstrumentation() with full options table - Distributed tracing: sentry-trace/baggage headers, tracePropagationTargets, automatic SSR→client trace continuation, manual propagation for non-HTTP channels - Advanced APIs: continueTrace, startNewTrace, suppressTracing, withActiveSpan, forceTransaction, onlyIfParent, browser flat span hierarchy - Complete three-runtime config example - Troubleshooting table with 11 common issues **profiling.md** (385 lines) covers: - Browser vs Node.js profiling runtimes and what each captures - How profiling attaches to traces (compound sampling formula) - Browser: Chromium-only limitation, Document-Policy header requirement with platform-specific setup (Next.js headers, Vercel, Netlify, Nginx) - Browser SDK config: trace mode and manual mode with uiProfiler - Node.js: @sentry/profiling-node install, version pinning requirement, nodeProfilingIntegration, trace mode and manual mode with profiler - Supported platforms table (OS × arch × Node version) - Environment variables for binary path and logging mode - Configuration parameters reference table - profileSessionSampleRate session-level semantics - profileLifecycle modes comparison table - Production vs development recommendations with performance impact notes - Chrome DevTools conflict warning - Complete four-file setup example (client, server, edge, next.config.ts) - Troubleshooting table with 12 common issues * feat(sentry-nextjs-sdk): add logging, session-replay, ai-monitoring, and crons references Four deep-dive reference files for the sentry-nextjs-sdk skill: **logging.md** (~280 lines) - Three-runtime configuration requirement (client, server, edge) - Full Sentry.logger API (trace/debug/info/warn/error/fatal) with attribute types - Parameterized messages via logger.fmt tagged template literal - consoleLoggingIntegration with console→Sentry level mapping - beforeSendLog filtering hook with log object shape - Scope-based attributes (getGlobalScope vs getIsolationScope) with Next.js-specific warning about cross-request isolation on the server - Third-party integrations: Pino, Consola, Winston - Auto-generated attributes table, wide events best practice - Version matrix and troubleshooting table **session-replay.md** (~330 lines) - instrumentation-client.ts placement with explicit "where NOT to add" table - Sample rate semantics and recommended values by traffic tier - Session lifecycle (5min inactivity, 60min max) - Full replayIntegration() options reference (general + network capture) - Privacy masking: mask/block/ignore mechanisms with HTML attribute/class table - v8 breaking change note for unblock/unmask defaults - Network capture with limits (150k chars, text-only bodies) - Tree-shaking via withSentryConfig (webpack only, Turbopack unsupported) - Canvas recording with WebGL/3D manual snapshot mode - Lazy loading, programmatic control, custom compression worker - CSP requirements with Next.js headers() example - Performance impact notes and troubleshooting table **ai-monitoring.md** (~290 lines) - Supported libraries table: OpenAI, Vercel AI SDK, Anthropic with auto-enable status - OpenAI: server-side openAIIntegration() vs manual instrumentOpenAiClient() with critical streaming note (stream_options: { include_usage: true }) - Vercel AI SDK: force: true requirement for Vercel production deployments, per-call experimental_telemetry opt-in requirement - Anthropic: server auto-enable and manual instrumentAnthropicAiClient() - Token usage attributes following OpenTelemetry GenAI semantic conventions - PII controls (recordInputs/recordOutputs with sendDefaultPii interaction) - Complete three-integration setup example with Route Handler examples - AI Agents dashboard overview (Overview/Models/Tools/Traces tabs) - Version matrix and troubleshooting table **crons.md** (~250 lines) - Four approaches: Vercel auto-monitors, cron library instrumentation, withMonitor() wrapper, manual captureCheckIn() - Critical note: automaticVercelMonitors only works with Pages Router, NOT App Router route handlers - Auto-instrumentation for cron, node-cron, node-schedule packages - Full MonitorConfig interface (crontab/interval schedule, checkinMargin, maxRuntime, timezone, failureIssueThreshold, recoveryThreshold) - App Router Route Handler and Edge runtime examples - Rate limit (6 check-ins/min/environment) and alerting notes - Version matrix and troubleshooting table * docs(readme): add sentry-nextjs-sdk to Available Skills Register the new Next.js SDK skill bundle in the README's SDK Skills table and the 'When to Use Which Skill' quick-reference section. Table entry covers the full feature set: error monitoring, tracing, profiling, logging, session replay, AI monitoring, and crons — with App Router + Pages Router support noted and a link to the official Next.js guide. Three trigger phrases added to the quick-reference: general Next.js setup, App Router-specific setup, and AI/OpenAI monitoring in Next.js. * fix(sentry-nextjs-sdk): address P1/P2 review findings across skill and references Fix six issues identified in code review: P1 fixes: - Add AI Monitoring and Crons to Phase 2 recommendation list (optional enhanced observability), with matching rows in the Phase 3 reference dispatch table and updated frontmatter description to include the two new features - Replace NEXT_PUBLIC_SENTRY_DSN with SENTRY_DSN in all sentry.server.config.ts and sentry.edge.config.ts code blocks in ai-monitoring.md (6 occurrences) and logging.md (server + edge blocks in the three-runtime example); client-side instrumentation-client.ts blocks correctly retain NEXT_PUBLIC_SENTRY_DSN - Replace deprecated sentry.client.config.ts file name with instrumentation-client.ts in logging.md (combined header comment at line ~16 and the three-runtime section at line ~266) P2 fixes: - Add Metrics to Phase 2 optional list with description and recommendation logic row - Remove cross-link to non-existent sentry-java-sdk skill; replace with a direct link to docs.sentry.io/platforms/java/ - Update session-replay.md opening warning to drop the legacy sentry.client.config.ts mention, keeping only instrumentation-client.ts as the correct client config file * fix(nextjs-sdk): correct DSN variable in server-side logging examples Replace NEXT_PUBLIC_SENTRY_DSN with SENTRY_DSN in the two remaining server-side code blocks in logging.md: - The 'Enabling Logs' combined example now annotates per-runtime DSN usage and defaults to SENTRY_DSN with a comment for client config - The Pino integration example now correctly uses SENTRY_DSN and notes it belongs in sentry.server.config.ts (Node.js server-side only) These were the last two DSN inconsistencies flagged by the reviewer. |
||
|
Daniel Griesser
|
2a54c46058 |
Wizard-first setup guidance for frontend/mobile SDK skills (#17)
* docs: wizard-first setup guidance for frontend/mobile SDK skills Add systematic guidance for recommending the Sentry wizard CLI as the primary setup path when a wizard integration exists for the target framework. The wizard handles the full auth flow (browser login, org/project selection, auth token creation/download) and source map upload configuration automatically — the two things most commonly misconfigured in manual frontend setups. Changes: - docs/sdk-skill-philosophy.md: Add 'Wizard-First for Framework SDKs' section with pattern template, known wizard integrations table, and 'Source Maps: The Non-Negotiable for Frontend' checklist. Update the scaffold to show wizard option in Phase 3. - skills/sentry-sdk-skill-creator/SKILL.md: Add wizard research step in Phase 2, wizard-first + source maps as key principles (#2, #3), wizard/source-map structure in the SKILL.md template, source map note for frontend reference files, and two new checklist items. - skills/sentry-svelte-sdk/SKILL.md: Upgrade wizard description from 'Easiest' to 'Recommended', add auth flow details. - skills/sentry-react-native-sdk/SKILL.md: Add auth flow details to wizard description. - skills/sentry-cocoa-sdk/SKILL.md: Expand wizard description with interactive auth flow and dSYM upload details. * docs(sdk-skill-creator): replace hard 500-line limit with qualitative focus guidance The arbitrary 500-line cap on main SKILL.md files could force bad tradeoffs — splitting content that belongs together or omitting useful context to stay under a number. Replace it with qualitative guidance: keep the main file focused on the wizard flow, quick start, and reference dispatch; deep-dive content goes in references/. Be thorough but not redundant. Updated in SKILL.md (Phase 3 intro, review pass, checklist) and in references/quality-checklist.md (spec compliance table, final verification script). |
||
|
Johannes Daxböck
|
2e56a58130 |
fix(sentry-ruby-sdk): Correct inaccuracies, add OTLP path, expand migrations (#15)
* fix(sentry-ruby-sdk): Correct inaccuracies, add OTLP path, expand migrations
Critical fixes:
- Replace fabricated `Sentry.init_otel_provider` with actual OTLP
integration using `config.otlp.enabled = true` (v6.4.0+)
- Fix logging minimum SDK version from v5.24.0 to v5.27.0
- Fix Gemfile grep patterns to use word boundaries instead of
double-quote matching (single-quoted gems were missed)
OTLP integration path:
- Add granular OTel detection (tracing vs logging separately)
- When OTel tracing detected, recommend OTLP instead of native tracing
- When OTel logging NOT detected (common), keep Sentry native logging
- Add OTLP config options and troubleshooting entries
Migration expansion:
- Add Bugsnag, Rollbar, and Airbrake migration sections with full
API mapping tables, call-site grep patterns, and env var mappings
- Update detection to cover all five competitor tools
Structural improvements per sdk-skill-philosophy.md review:
- Add framework integration table to SKILL.md
- Add `${SKILL_ROOT}/` prefix to all reference dispatch paths
- Add "walk through features one at a time" instruction block
- Expand troubleshooting from 7 to 12 entries (forking servers,
Process.exit! flush, DSN validation, OTLP-specific)
- Add Log object schema table to logging.md
- Add config options table to logging.md
- Expand profiling.md with GVL explanation and overhead notes
- Rename misleading "heartbeat pattern" to "completion-only check-in"
- Add production warning to metrics.md Thread.new polling pattern
- Replace `rescue nil` with logged rescue in migration dual-capture shim
- Add scheduled job detection for Crons recommendation
Co-Authored-By: Claude <noreply@anthropic.com>
* feat(sentry-ruby-sdk): Add Puma request queue time documentation
Sentry v6.4.0+ automatically captures request queue time from the
X-Request-Start header, subtracting Puma's body wait time to isolate
actual queue delay. This is on by default but requires proxy config.
- Add `capture_queue_time` to SKILL.md config table
- Add Puma detection to Phase 1 with routing guidance
- Add "Request Queue Time" section to tracing.md with Nginx/HAProxy
proxy configuration examples and explanation of why it matters
- Update tracing.md TOC and config table
Co-Authored-By: Claude <noreply@anthropic.com>
* fix(sentry-ruby-sdk): Rename "Log object" heading to Ruby-idiomatic name
Co-Authored-By: Claude <noreply@anthropic.com>
* fix(sentry-ruby-sdk): Use Sentry.logger instead of Rails.logger in universal shim
The dual-capture shim is in the "Universal Migration Checklist" section
which claims to work for any Ruby app, but Rails.logger would raise
NameError in Sinatra/Rack/plain Ruby. Use Sentry.logger which is
available in any context where Sentry.init has been called.
Co-Authored-By: Claude <noreply@anthropic.com>
* fix(sentry-ruby-sdk): Correct Bugsnag and Rollbar migration mappings
The Bugsnag discard_classes mapping accessed e.exception on a Sentry
Event, which returns the serialized ExceptionInterface — not the
original Ruby exception. Use h[:exception] from the hint parameter
instead, matching the pattern used throughout error-monitoring.md.
The Rollbar.log(level, e) mapping used level.to_sym, which produces
:critical for Rollbar's 'critical' level — not a valid Sentry level.
Add an explicit lookup that maps "critical" to :fatal.
Co-Authored-By: Claude <noreply@anthropic.com>
* fix(sentry-ruby-sdk): Return event from before_send when not filtering
The before_send lambdas in the Bugsnag and Airbrake migration tables
used `nil if condition` which returns nil in both branches — silently
dropping all events, not just the filtered ones. Use ternary to
explicitly return the event when the filter condition is false.
Co-Authored-By: Claude <noreply@anthropic.com>
---------
Co-authored-by: Claude <noreply@anthropic.com>
|
||
|
Daniel Griesser
|
98a20d1ea9 |
feat: add sentry-react-sdk skill bundle — comprehensive React Browser SDK wizard (#16)
* feat(react-sdk): add sentry-react-sdk main SKILL.md wizard
Four-phase setup wizard for the Sentry React Browser SDK skill bundle.
Follows the same structural pattern as sentry-go-sdk and sentry-svelte-sdk.
Phase 1 detects React version, router (React Router v5/v6/v7, TanStack),
state management (Redux), build tool (Vite, CRA, webpack), existing Sentry
installation, and companion backend directories.
Phase 2 recommends features based on detection: Error Monitoring always,
Tracing always for SPAs, Session Replay for user-facing apps, Logging and
Profiling as optional extras. Surfaces React-specific extras: React 19
error hooks, router integration, Redux enhancer, Vite source map plugin.
Phase 3 guides installation of @sentry/react with:
- instrument.ts sidecar pattern (must be first import)
- DSN env var table by build tool (Vite / CRA / webpack)
- React 19+ reactErrorHandler() vs React <19 Sentry.ErrorBoundary
- Router integration mapping table (v5, v6/v7, TanStack, custom)
- Redux createReduxEnhancer() setup
- Source maps via sentryVitePlugin (Vite) and sentryWebpackPlugin (CRA)
- Reference dispatch table for Error Monitoring, Tracing, Session Replay,
Logging, and Profiling deep dives
Phase 4 cross-links to backend SDK skills when a companion Go, Python,
Ruby, Java, or Node.js backend is detected without Sentry coverage.
Includes full Sentry.init() options reference, React version compatibility
matrix, and 12-entry troubleshooting table. 435 lines — under 500 limit.
* feat(react-sdk): add error monitoring deep-dive reference
Adds skills/sentry-react-sdk/references/error-monitoring.md — a
comprehensive, 1500-line reference covering every error monitoring
surface in @sentry/react ≥8.0.0.
Sections:
- Automatic capture: what's caught by GlobalHandlers, BrowserApiErrors,
and what requires manual instrumentation (event handlers, swallowed
try/catch, React Router boundaries)
- React Error Boundaries (React 19+): full reactErrorHandler() API for
createRoot/hydrateRoot onUncaughtError/onCaughtError/onRecoverableError
hooks, including the dual-use pattern with <ErrorBoundary> for fallback
UIs alongside the global net
- React Error Boundaries (React ≤18): complete <Sentry.ErrorBoundary>
props reference (fallback render fn, onError, beforeCapture, onReset,
showDialog/dialogOptions, onMount/onUnmount), withErrorBoundary HOC,
nested boundary isolation strategy, and captureReactException for
custom class boundaries with componentStack linkage (≥9.8.0)
- Manual capture: captureException with all captureContext fields,
captureMessage with all levels, captureEvent for raw events, and
React-specific patterns (useEffect wrapper, event handlers, async
effects, promise chains)
- Context enrichment: setUser/setUser(null), setContext, setTag/setTags
with key constraints, setExtra/setExtras, and inline context on
capture calls
- Breadcrumbs: full automatic breadcrumb table, addBreadcrumb with
complete type/category/level reference, and beforeBreadcrumb filtering
- Scopes: three-scope hierarchy (global/isolation/current), merge
priority diagram, withScope for per-event isolation, scope decision
guide, and explicit deprecation of configureScope
- Event filtering: beforeSend with originalException from hint,
ignoreErrors patterns, allowUrls/denyUrls, sampleRate, fingerprinting
with {{ default }} placeholder and beforeSend-based patterns
- User feedback: feedbackIntegration complete config table (all labels,
theme overrides, callbacks, programmatic openDialog/attachTo),
captureFeedback with attachments, showReportDialog with full options
table; side-by-side comparison of widget vs crash-report modal
- React Router: custom errorElement pattern with captureException to
prevent React Router's default boundary silently swallowing errors
- Quick reference card for all APIs and troubleshooting table with 13
common issues
* feat(react-sdk): add tracing deep-dive reference
Comprehensive tracing reference for the Sentry React SDK covering every
aspect of performance monitoring in React applications.
Key sections:
**browserTracingIntegration options** — exhaustive table of all options
with types, defaults, and plain-English descriptions: span lifecycle
(idleTimeout, finalTimeout, childSpanTimeout, markBackgroundSpan), HTTP
span controls (traceFetch, traceXHR, enableHTTPTimings,
shouldCreateSpanForRequest, onRequestSpanStart), performance observations
(enableLongTask, enableLongAnimationFrame, enableInp,
interactionsSampleRate), span naming (beforeStartSpan), trace linking
(linkPreviousTrace), and span filtering (ignoreResourceSpans,
ignorePerformanceApiSpans).
**React Router integrations** — full, working examples for every
supported version and API surface:
- v7 (react-router): createBrowserRouter + wrapCreateBrowserRouterV7,
<Routes> + withSentryReactRouterV7Routing, useRoutes +
wrapUseRoutesV7, and a SentryRouteErrorBoundary pattern for capturing
errors that React Router v7 would otherwise swallow
- v6 (react-router-dom): all three methods (createBrowserRouter,
<Routes>, useRoutes); wrapCreateMemoryRouterV6 noted for SDK ≥8.50.0
- v4/v5: withSentryRouting HOC with route ordering guidance, plus static
route config approach with matchPath
- TanStack Router: tanstackRouterBrowserTracingIntegration with router
instance; explains why no hook wiring is needed vs React Router
Each router section includes: complete init config, router setup,
app wiring, and a note on how URLs become parameterized transaction names.
**Custom spans** — all three span APIs (startSpan, startSpanManual,
startInactiveSpan) with async/sync examples, span options reference,
all span methods (setAttribute, setAttributes, setStatus, setHttpStatus,
updateName, end), nesting patterns with Promise.all, forceTransaction for
standalone root spans, and the browser flat hierarchy explanation.
**Distributed tracing** — sentry-trace + baggage headers, CORS
requirements, SSR meta tag approach with server-side getTraceData()
example, manual propagation over WebSockets, W3C traceparent support
(SDK ≥10.10.0).
**Sampling** — tracesSampleRate table by traffic level, full
tracesSampler with complete samplingContext interface, inheritOrSampleWith
explanation (why it beats checking parentSampled directly), boolean vs
number return values.
**Filtering** — beforeSendTransaction, ignoreTransactions, beforeSendSpan
(with the 'cannot return null' gotcha), ignoreSpans (SDK ≥10.2.0) with
all matching patterns (string, regex, op object, name+op object).
**Custom routing** — startBrowserTracingPageLoadSpan +
startBrowserTracingNavigationSpan for unsupported routers with
SEMANTIC_ATTRIBUTE_SENTRY_SOURCE upgrade pattern.
**Full import reference** and **decision tree** (ASCII) for choosing the
right integration. Closes with 13-entry troubleshooting table covering
the most common real-world issues.
* feat(react-sdk): add session replay deep-dive reference
Adds skills/sentry-react-sdk/references/session-replay.md, a
comprehensive 1,125-line reference covering every aspect of Session
Replay for the React SDK.
Sections covered:
- Setup and when NOT to add replay (SSR, workers, Next.js server)
- Sample rates (replaysSessionSampleRate / replaysOnErrorSampleRate),
interaction model, and all three recommended strategies (errors-only,
balanced, full)
- Complete replayIntegration() constructor option table with types,
defaults, and notes
- Privacy & masking in depth: default behavior, maskAllText/maskAllInputs,
mask/unmask/block/unblock/ignore selectors, HTML attribute API
(data-sentry-mask etc.) with JSX examples, maskFn, three privacy
modes, how React component trees interact with masking, and
beforeAddRecordingEvent scrubbing
- Network request recording: default captured fields, networkDetailAllowUrls,
networkDetailDenyUrls, networkCaptureBodies, request/response headers,
body format support, 150 KB truncation limit, GraphQL operation name
capture, and the Apollo AbortController body capture bug with workaround
- Canvas recording: replayCanvasIntegration() for 2D, WebGL manual
snapshotting, WebGPU skipRequestAnimationFrame, cross-origin canvas CORS fix
- Lazy loading via lazyLoadIntegration() with trade-off discussion
- Advanced config: beforeErrorSampling, mutation limits, slowClickIgnoreSelectors,
workerUrl / self-hosted worker, manual session control API (start /
startBuffering / stop / flush / getReplayId), deferred init from feature
flags, route-based recording
- Session lifecycle: session vs segment, session vs buffer mode comparison
table, buffer flush flow on error
- Performance: bundle size table, runtime overhead table
- CSP requirements with complete header examples for blob: and self-hosted
worker cases
- Troubleshooting table with 16 entries covering all common failure modes
* feat(react-sdk): add profiling and logging deep-dive references
Add two comprehensive reference files for the sentry-react-sdk skill bundle:
**profiling.md** — Complete guide to browser profiling via the JS Self-Profiling API:
- Beta status, Chromium-only support (Chrome/Edge; Firefox/Safari silently no-op)
- Required Document-Policy: js-profiling header with setup examples for Vercel,
Netlify, Express, Nginx, Apache, CloudFront, and ASP.NET Core
- Both profiling modes: Trace (auto-attach to all spans) and Manual
(uiProfiler.startProfiler/stopProfiler for specific flows)
- Configuration table: tracesSampleRate, profileSessionSampleRate, profileLifecycle
- How compound sampling works (profiles only attach when transaction is also sampled)
- Sentry vs Chrome DevTools comparison (100Hz vs 1000Hz, production vs local)
- Why source maps are critical for readable flame graphs, with Vite plugin config
- Limitations table and 7-entry troubleshooting section
**logging.md** — Complete guide to structured logging via Sentry.logger:
- Minimum SDK versions for each feature (9.41.0 base, 10.13.0 console integration,
10.32.0 scope attributes)
- All six log levels with intent and recommended production volume guidance
- logger.fmt tagged template literals — how parameterized messages become searchable
message.parameter.N attributes in Sentry
- consoleLoggingIntegration setup, capturable console methods, and level mapping
- beforeSendLog hook with full log object shape and filtering examples
- Scope-based automatic attributes: getGlobalScope, getIsolationScope, withScope
- Auto-generated attributes table (trace correlation, replay correlation, user context)
- Log-to-trace-to-replay correlation with working startSpan example
- React-specific best practice: wide events over fragmented logs
- Decision guide: logger.* vs captureException vs captureMessage
- 10-entry troubleshooting section covering common pitfalls
* feat(react-sdk): add react-features deep-dive reference
Adds `skills/sentry-react-sdk/references/react-features.md`, a 1200-line
catch-all reference covering everything React-specific that does not belong
in the feature-pillar files (error monitoring, tracing, replay, profiling,
logging).
Topics covered:
**Redux integration**
- Complete `createReduxEnhancer()` setup for Redux Toolkit and legacy
`createStore` (with and without middleware)
- All four options: `actionTransformer`, `stateTransformer`,
`configureScopeWithState`, `attachReduxState`
- PII filtering examples: scrubbing passwords, tokens, credit card
numbers, and entire sensitive subtrees from actions and state
- `normalizeDepth` placement (init, not enhancer)
- Full working TypeScript example with `@reduxjs/toolkit`
- Performance guidance for large state trees
**Component tracking**
- Build-time React component name annotation via `sentryVitePlugin` and
the standalone `@sentry/babel-plugin-component-annotate`
- Bundler support matrix (Vite/Webpack/Rollup ✅, esbuild ❌)
- `Sentry.withProfiler()` HOC: all options, what gets tracked, when to
use it, performance overhead warning
**Source maps (thorough)**
- Debug ID system: how modern matching works without release-based naming
- Sentry Wizard quickstart (`npx @sentry/wizard@latest -i sourcemaps`)
- Vite: full `vite.config.ts` with `sourcemap: "hidden"` and
`filesToDeleteAfterUpload`
- Webpack: `hidden-source-map` devtool + `sentryWebpackPlugin`
- Create React App: CRACO approach (no eject) + post-eject approach
- Manual upload with `sentry-cli sourcemaps upload` and CI/CD pattern
- Environment variables: `SENTRY_AUTH_TOKEN`, `SENTRY_ORG`,
`SENTRY_PROJECT`, `.env.sentry-build-plugin`, security guidance
- Troubleshooting table (7 common failure modes)
**Default integrations**
- Full table of all 9 auto-enabled integrations with descriptions
- How to customize options of a default integration (pass it explicitly)
- How to remove a default integration (function-form filter)
- How to disable ALL defaults (`defaultIntegrations: false`)
**Optional integrations**
- Grouped by category: performance, replay, logging, user feedback,
error enhancement, stack frame rewriting
- Full `httpClientIntegration` config example
- `addIntegration()` post-init pattern
- Lazy loading with `lazyLoadIntegration()` and dynamic import
**Build tool detection & environment variables**
- Detection commands and decision table (Vite / CRA / CRACO / Webpack)
- DSN variable patterns per bundler with complete examples
- Conditional init: production vs development
- Kitchen-sink `instrument.ts` combining all features
* docs(readme): add sentry-react-sdk to SDK Skills table and usage section
Add the new sentry-react-sdk skill bundle to the README:
- SDK Skills table: new row for sentry-react-sdk covering error monitoring,
tracing, session replay, profiling, and logging for React 16+ with support
for React Router v5-v7, TanStack Router, Redux, Vite, and webpack
- Usage section (SDK Skills): three new trigger phrases routing to
sentry-react-sdk (React app setup, error boundaries, session replay)
- Setup section: note that sentry-react-setup is superseded by sentry-react-sdk
while keeping the entry for backwards compatibility
* fix(react-sdk): correct API errors and accuracy issues in SKILL.md
P0 fixes:
- tanstackRouterBrowserTracingIntegration() now receives required router
instance argument (was called with no args, which is invalid)
- React Router hook imports moved from @sentry/react to react-router-dom /
react-router — they were never exported from the Sentry package
- wrapCreateBrowserRouter replaced with versioned variants:
wrapCreateBrowserRouterV6 for v6.4+ and wrapCreateBrowserRouterV7 for v7
(unversioned function does not exist in the SDK)
P1 fixes:
- Router table split into separate v6 and v7 rows, each referencing the
correct integration name and import source package
- Vite sourcemap config changed from true to "hidden" to avoid publicly
exposing source maps while still uploading them to Sentry
- Profiling requirement corrected from COOP/COEP headers to
Document-Policy: js-profiling (which is what the JS Self-Profiling API
actually requires); updated both recommendation table and troubleshooting
- react-features.md added to the reference dispatch table so agents know
to load it for Redux, component tracking, and integrations catalog
P2 fixes:
- TanStack Router description changed from "Zero-config" to "Pass router
instance — no hooks required" (it is not zero-config; a router arg is
required)
* refactor: remove sentry-react-setup, replace with sentry-react-sdk references
Remove the old sentry-react-setup skill (149 lines) which is fully
superseded by the new sentry-react-sdk bundle (6,343 lines across 7
files with deep-dive references for every feature pillar).
Update all cross-link tables in sentry-go-sdk, sentry-python-sdk,
sentry-ruby-sdk, sentry-react-native-sdk, README.md, and the SDK
skill philosophy doc to point to sentry-react-sdk instead.
|
||
|
Daniel Griesser
|
7d7fb4fcc8 |
chore: remove deprecated setup skills superseded by SDK bundles (#14)
* chore: remove deprecated setup skills superseded by SDK bundles Remove sentry-ios-swift-setup, sentry-react-native-setup, sentry-setup-tracing, sentry-setup-logging, and sentry-setup-metrics skills. These are now covered by the full SDK bundle skills (sentry-cocoa-sdk, sentry-react-native-sdk, etc.) which provide comprehensive platform-specific guidance. Update README.md to remove all references: table rows, usage examples, and directory structure examples (replaced sentry-setup-tracing with sentry-fix-issues). * chore(release): generate skill list dynamically from SKILL.md frontmatter Replace the hardcoded (and stale) skill list in the release workflow with a script that reads name and description from each skills/*/SKILL.md frontmatter. This ensures the release notes stay current as skills are added or removed. Adds scripts/generate-skill-list.sh which extracts the first sentence of each skill's description and formats it as a markdown list. |
||
|
Daniel Griesser
|
76e5021158 |
feat: add sentry-cocoa-sdk skill bundle for Apple platforms (#12)
* feat(cocoa-sdk): add sentry-cocoa-sdk main SKILL.md wizard
Introduces the main four-phase wizard for the Sentry Cocoa SDK skill bundle,
covering all Apple platforms: iOS, macOS, tvOS, watchOS, and visionOS.
The wizard follows the established SDK skill philosophy (docs/sdk-skill-philosophy.md)
and mirrors the structural quality of the Go SDK skill. Key sections:
- Phase 1: Detect — scans Package.swift/Podfile for existing Sentry, identifies
SwiftUI vs UIKit entry points, detects deployment platforms, logging libraries,
and companion backends for distributed tracing setup.
- Phase 2: Recommend — opinionated recommendation table covering Error Monitoring
(always), Tracing (always for apps), Profiling (production), Session Replay
(iOS/tvOS with iOS 26+ Liquid Glass caveat), Logging, and User Feedback. Clearly
marks features not available on Cocoa (Metrics, Crons, AI Monitoring).
- Phase 3: Guide — three installation paths (Sentry Wizard, SPM, CocoaPods),
SPM product selection table, and full recommended SentrySDK.start configs for
both SwiftUI (@main App) and UIKit (AppDelegate). Uses SDK 9.0.0+ APIs throughout
including configureProfiling closure (replaces removed profilesSampleRate),
enableAppHangTrackingV2, and experimental.enableLogs. Dispatches to reference
files for deep dives on each feature pillar.
- Phase 4: Cross-Link — detects companion backends (Go, Python, Ruby, Node) and
suggests matching SDK skills for distributed tracing end-to-end coverage.
Also includes a Configuration Reference table of key SentryOptions fields, a
platform feature support matrix (iOS/tvOS/macOS/watchOS/visionOS), environment
variable mapping, production sample-rate recommendations, verification snippet,
and a 13-entry troubleshooting table covering common SDK 9.0.0 migration issues
(removed profilesSampleRate, removed inAppExclude, etc.).
Skill is 379 lines — within the 500-line budget specified in the task.
Also adds sentry-cocoa-sdk to the SDK Skills table in README.md.
* feat(cocoa-sdk): add 6 deep-dive reference files for Cocoa SDK skill bundle
Add reference files covering all major Sentry Cocoa SDK feature areas:
- error-monitoring.md — SentrySDK.capture(error/message/event), Swift Error
protocol and CustomNSError integration, automatic crash reporting (signal
handlers, Mach exceptions, C++), app hang detection with V2 types, watchdog
termination, HTTP client error capture, scope management (global and per-event),
breadcrumbs, beforeSend hook, screenshot/view hierarchy attachments,
fingerprinting with {{ default }} variable, and onCrashedLastRun callback
- tracing.md — tracesSampleRate / tracesSampler with context-aware sampling,
all auto-instrumented features (app start with span hierarchy, URLSession network,
UIViewController lifecycle with TTID/TTFD, SwiftUI with SentryTracedView,
user interaction, file I/O with manual extension API, Core Data, slow/frozen
frames), custom spans and bindToScope pattern, distributed tracing with
tracePropagationTargets, and full platform support matrix
- profiling.md — configureProfiling closure API (v8.49.0+/v9.0.0+),
SentryProfileLifecycle (.trace vs .manual), startProfiler/stopProfiler for
manual mode, app launch profiling, compound sampling maths, dSYM upload
requirement, and migration table from all legacy APIs (profilesSampleRate,
enableAppLaunchProfiling, continuous beta) removed in v9.0.0
- session-replay.md — sessionSampleRate/onErrorSampleRate with sampling logic
explanation, privacy masking defaults, SwiftUI .sentryReplayMask() /
.sentryReplayUnmask() modifiers, UIKit instance and class-level masking,
iOS 26/Liquid Glass caveat with auto-disable in v8.57.0 and the experimental
enableSessionReplayInUnreliableEnvironment override, performance benchmarks
- logging.md — options.enableLogs (v9.0.0+ stable) and
options.experimental.enableLogs (v8.55.0-8.x), SentrySDK.logger API with all
six log levels, structured attributes dictionary, Swift string interpolation
extraction as sentry.message.parameter.* attributes, beforeSendLog hook,
automatic default attributes, and os.log coexistence pattern
- user-feedback.md — SentrySDK.showUserFeedbackForm() and
SentrySDK.feedback.showWidget(), configureUserFeedback configuration,
programmatic SentryFeedback capture with source: .custom, linking feedback to
error events via associatedEventId, screenshot attachment, SwiftUI and UIKit
presentation patterns, full widget/form/theme configuration reference tables,
session replay integration
Each file follows the standard reference format: configuration table, working
Swift code examples, best practices, and 5+ troubleshooting entries.
* docs(readme): add sentry-cocoa-sdk entries, deprecate sentry-ios-swift-setup
Add the new sentry-cocoa-sdk SDK bundle skill to the README:
- Add trigger phrases for iOS, macOS, and Swift/SwiftUI in the SDK Skills
usage table, pointing to sentry-cocoa-sdk
- Update the iOS/Swift row in the Setup usage table to reference
sentry-cocoa-sdk instead of sentry-ios-swift-setup
- Mark sentry-ios-swift-setup in the Setup Skills table as superseded by
sentry-cocoa-sdk, preserving the row for discoverability
The sentry-cocoa-sdk bundle is a full-featured wizard covering error
monitoring, tracing, profiling, session replay, logging, and user feedback
across all Apple platforms (iOS, macOS, tvOS, watchOS, visionOS).
sentry-ios-swift-setup remains in the table with a deprecation note so
existing users can find the migration path.
* fix(cocoa-sdk): correct fabricated APIs, type errors, and platform inconsistencies
P0 — Remove fabricated SentrySDK.showUserFeedbackForm() from user-feedback.md.
This method does not exist in the SDK. All references replaced with the correct
APIs: SentrySDK.feedback.showWidget() / hideWidget() for programmatic control, and
a clear note that SentryFeedbackAPI is the correct type. Also fixed the SentryFeedback
initializer: the 'screenshot: Data' parameter does not exist — replaced with the
actual 'attachments: [Attachment]?' parameter throughout examples and troubleshooting.
P1 — Replace options.experimental.enableLogs with options.enableLogs in Quick Start
snippets (both SwiftUI and UIKit blocks). The skill targets sentry-cocoa 9.5.1+; in
9.0.0 enableLogs was promoted to a stable top-level property and removed from
SentryExperimentalOptions. A comment notes the 8.x experimental path for context.
P1 — Mark Session Replay as iOS only in the Phase 2 recommendation table. The platform
feature matrix already showed ❌ for tvOS/macOS/watchOS/visionOS; the recommendation
logic row now matches with an explicit 'iOS only' note.
P1 — Fix tracesSampleRate type in Configuration Reference table from Float/0.0 to
NSNumber?/nil (the actual ObjC type), and document that Swift auto-boxes Double
literals to NSNumber. nil default is important: tracing is fully disabled until
this is set.
P2 — Add V1/V2 version caveat to the beforeSend app hang filter example in
error-monitoring.md. The exception type 'App Hanging' applies to V1
(enableAppHangTracking); V2 (enableAppHangTrackingV2, default in 9.0+) may
differ — agents are instructed to inspect at runtime.
P2 — Fix Node.js backend cross-link in Phase 4. Node.js is a backend runtime; the
previous suggestion of sentry-react-setup / sentry-svelte-sdk was wrong. Now maps
to sentry-node-sdk / sentry-express-sdk.
P2 — Clarify enablePropagateTraceparent version requirement in tracing.md. The inline
comment already noted v9.0.0+; added an explicit blockquote callout below the code
example making it unambiguous that this option does not exist in 8.x.
* chore: remove .pi artifacts from branch
* chore: remove review.md artifact
|
||
|
Daniel Griesser
|
449a983729 |
feat: add sentry-react-native-sdk skill bundle (#13)
* feat(react-native-sdk): add sentry-react-native-sdk full wizard skill
Introduces the `sentry-react-native-sdk` skill bundle — a comprehensive,
four-phase setup wizard for integrating Sentry into React Native and Expo
projects. Replaces the minimal `sentry-react-native-setup` skill with a
deep, opinionated guide covering every Sentry feature mobile apps need.
## What's included
**Phase 1 — Detect**
Bash commands to identify project type (Expo managed vs bare vs vanilla RN),
Expo SDK version, navigation library (React Navigation vs Wix RNN), existing
Sentry config, Hermes usage, and backend/web sibling directories for
cross-linking.
**Phase 2 — Recommend**
Opinionated feature proposals rather than open-ended questions. Error
monitoring and tracing are always recommended; session replay, profiling,
logging, and user feedback are surfaced based on project context.
**Phase 3 — Guide**
Three setup paths with full, copy-paste-ready code:
- Path A: Wizard CLI (`npx @sentry/wizard@latest -i reactNative`) with a
table of every file it creates/modifies
- Path B: Manual Expo managed (config plugin, metro config, Expo Router and
standard Expo init variants with nav integration)
- Path C: Manual bare React Native (iOS Xcode build phase, Android
`sentry.gradle`, metro config)
Includes the full-featured recommended `Sentry.init()` config, both React
Navigation and Wix RNN integration patterns, and production-safe sample
rate guidance.
**Phase 4 — Cross-Link**
Detects backend languages (Go, Python, Ruby, Node) and web frontends in
adjacent directories and suggests the matching SDK skill. Documents how to
configure `tracePropagationTargets` for distributed tracing between mobile
and backend.
## Reference dispatch table
Points to six feature reference files (to be created in follow-up todos):
error-monitoring, tracing, profiling, session-replay, logging, user-feedback.
## Additional sections
- Complete `Sentry.init()` option reference (core, tracing, native/mobile,
session health, replay, logging, hooks)
- Environment variables table (DSN, AUTH_TOKEN, ORG, PROJECT, etc.)
- Source map and dSYM upload explanation for iOS and Android
- Default integrations catalogue (auto-enabled) + opt-in integrations
- Expo config plugin reference (`app.json` and `app.config.js` variants)
- Production settings with dynamic sample rates and release/dist config
- Verification steps with test buttons and dashboard checklist
- Expo Go limitation callout (native features require a real build)
- 20-row troubleshooting table covering iOS build failures, Android Gradle
issues, Hermes source maps, session replay, TTID/TTFD, Expo secrets, EAS
builds, and more
* docs(react-native-sdk): add error-monitoring.md reference
Comprehensive deep dive into error monitoring for @sentry/react-native,
covering all three error layers unique to React Native: JavaScript runtime,
native iOS (sentry-cocoa), and native Android (sentry-android + NDK).
Coverage includes:
- Core capture APIs: captureException, captureMessage, captureEvent with full
options including scope callbacks, inline context, and isolated scopes
- Native crash handling: how crashes are written to disk and sent on next
launch, offline caching behavior per platform, linked error chains via .cause
- ANR/app hang detection: Android watchdog via sentry-android (always-on),
iOS hang tracking with configurable threshold, OOM/watchdog termination
- Unhandled promise rejections: automatic capture via UnhandledRejection
integration with disable instructions
- Sentry.wrap(App): what it does (error boundary, touch breadcrumbs, feedback
widget support, session replay buffering) and correct placement in index.js
- ErrorBoundary component: all props documented, fallback-as-function pattern,
HOC withErrorBoundary, nested boundaries with contextual tags, showDialog
- Scope management: all three scope types (global/isolation/current), data
precedence rules, withScope for temporary isolation, convenience methods
- Context enrichment: tags with constraints, user identity (set/clear), custom
structured contexts with setContext, inline context on capture calls
- Breadcrumbs: manual API with all properties, automatic sources table,
beforeBreadcrumb hook with scrubbing examples, capacity configuration
- beforeSend / beforeSendTransaction: PII scrubbing, event dropping, dynamic
fingerprinting from hint, ignoreErrors/ignoreTransactions pre-filtering
- Fingerprinting: SDK-level static and dynamic fingerprints, all template
variables, server-side fingerprint rules, priority order
- Event processors: global vs scoped, async support, execution order vs beforeSend
- Attachments: attachScreenshot (v4.11.0+), attachViewHierarchy, manual file
attachments, scope.addAttachment, size limits and PII considerations
- Redux integration: createReduxEnhancer with actionTransformer and
stateTransformer, Redux Toolkit configureStore example
- Device & app context: automatic fields per platform, release/dist/environment
- Release health: session lifecycle, crash-free rate metrics, autoSessionTracking
- Offline caching: per-platform cache behavior, maxCacheItems configuration
- Default and opt-in integrations: all built-in integrations documented,
customization examples including httpClientIntegration
- Full init() options reference with all 30+ options grouped by category
- Quick reference cheatsheet and 20-row troubleshooting table
* docs(react-native-sdk): add tracing.md reference
Comprehensive 970-line reference covering the full surface of React Native
performance monitoring — all the mobile-specific capabilities that have no
web equivalent alongside the cross-platform tracing APIs.
Coverage:
- Basic tracing setup (tracesSampleRate vs tracesSampler)
- reactNativeTracingIntegration and the required Sentry.wrap(App) wrapping
- App Start tracing: cold vs warm start, why wrap matters, optimization tips
- React Navigation integration with registerNavigationContainer in onReady
- React Native Navigation (Wix/RNN) integration
- Time to Initial Display (TTID) and Time to Full Display (TTFD) — automatic
and manual, including tab-screen edge cases using explicit components
- Slow & frozen frames as Mobile Vitals with Android AndroidX note
- JS event loop stall tracking (longest stall, total stall time, stall count)
- Network request tracing with span filtering and idle/final timeouts
- Distributed tracing: sentry-trace/baggage headers, tracePropagationTargets,
CORS requirements, and an end-to-end RN → backend example
- User interaction tracing with sentry-label, experimental span attributes,
and RNGH v2 gesture tracing via sentryTraceGesture()
- Custom spans: startSpan, startSpanManual, startInactiveSpan — all patterns
with sync/async examples, nesting, attributes, and span utilities
- React Component Profiler (withProfiler) with production bundle warning
- Profiling (Hermes + native platform profilers, UI profiling experimental)
- Dynamic sampling with tracesSampler showing critical-path and parent-based
sampling patterns
- Full configuration reference tables for all integrations
- Mobile vs web feature matrix showing what RN adds over the web SDK
- 17-row troubleshooting table covering the most common setup mistakes
* docs(react-native-sdk): add profiling.md reference
Adds a dedicated profiling reference for the React Native SDK skill bundle,
covering the full picture of how profiling works in a RN context.
Key topics covered:
- How profilesSampleRate relates to tracesSampleRate (multiplicative, not independent)
- Two-layer profiling architecture: Hermes (JS) + native platform profilers (iOS/Android)
- hermesProfilingIntegration and the platformProfilers option for JS-only mode
- UI Profiling (experimental) via _experiments.profilingOptions, including the
deprecated androidProfilingOptions migration note
- What data is captured in profiles and how profiles link to transaction spans
- Performance overhead guidance and production sample rate recommendations
- Expo compatibility table (Expo Go not supported; Development Build / EAS Build required)
- iOS-specific notes: dSYM upload, Simulator caveats, cold start profiling
- Android-specific notes: Hermes requirement, ProGuard mapping upload, low-end device overhead
- Full configuration reference for all profiling-related options
- Version requirements table (5.32.0 / 5.33.0 / 7.9.0 / 7.12.0)
- Known limitations (JSC not supported, minified names, profile size limits, etc.)
- Troubleshooting table with 11 common issues and solutions
* docs(react-native-sdk): add session-replay.md reference
Adds a comprehensive mobile Session Replay reference for the React Native
SDK skill, covering the full surface area of mobileReplayIntegration().
Key areas covered:
- **Mobile vs web fundamentals**: Screenshot-based capture at ~1 fps
(not DOM recording), native-layer pixel masking, offline limitations,
and the absence of selectable text or CSS inspection in replays.
- **mobileReplayIntegration() options**: Full config table with types,
defaults, and minimum SDK versions for every option including
maskAllText/Images/Vectors, screenshotStrategy (Android 7.5.0+),
includedViewClasses/excludedViewClasses (iOS 7.9.0+), and
beforeErrorSampling.
- **Privacy masking**: Default all-masked behavior, disabling global
masks, Sentry.Mask / Sentry.Unmask components (6.4.0-beta.1+),
masking rules (Mask wins, Unmask only affects direct children),
and the React Native View Flattening gotcha that can silently
remove Mask/Unmask wrappers and expose PII.
- **Platform-specific considerations**: Android pixelCopy vs canvas
screenshot strategies, iOS view hierarchy traversal with class
allowlists/blocklists, and the iOS 26.0 Liquid Glass rendering
bug that can leak masked content through the glass effect.
- **Performance benchmarks**: Real measured overhead on iPhone 14 Pro
and Pixel 2XL across FPS, memory, CPU, startup time, and bandwidth.
Includes guidance on replaysSessionQuality to reduce impact.
- **Expo compatibility**: Expo Go is unsupported (native modules
required); expo-dev-client and EAS Build are the supported paths.
- **Known limitations vs web replay**: Side-by-side table of missing
capabilities (network bodies, rage clicks, nested Unmask, offline
session mode, canvas strategy restrictions).
- **Complete production example**: Full Sentry.init() with all options,
PaymentScreen masking pattern, and metro.config.js for component name
annotations.
- **Troubleshooting table**: 14 entries covering the most common issues
including View Flattening, Expo Go, Android canvas strategy, iOS
traversal crashes, Liquid Glass, and beforeErrorSampling not firing.
* feat(react-native-sdk): add logging.md reference
Comprehensive logging reference for the sentry-react-native-sdk skill,
covering all structured logging APIs available in @sentry/react-native ≥7.0.0.
Contents:
- enableLogs opt-in configuration with placement guidance (index.js, _layout.tsx)
- Full Sentry.logger API: trace/debug/info/warn/error/fatal with level-selection guide
- logger.fmt tagged template literals for parameterized, searchable messages
- Structured attribute patterns with practical examples (screens, API calls, Redux)
- Scope-based automatic attributes via getGlobalScope/withScope (≥10.32.0)
- consoleLoggingIntegration for capturing console.* calls (≥10.13.0)
- beforeSendLog hook for filtering by level, scrubbing PII, dropping noise
- Auto-generated attributes table and React Native vs web differences
(no browser.*, no replay_id, no server.address)
- Trace + log correlation: logs inside startSpan() are linked in the Sentry UI
- Performance impact notes: async batching, no sampling, 1 MB cap, crash buffer loss
- Known limitations: crash buffer loss, no per-log sampling, missing browser attrs
- Troubleshooting table covering 10 common issues with targeted solutions
- Practical code patterns: screen lifecycle, API calls, Redux middleware logging
* feat(react-native-sdk): add user-feedback.md reference
Adds a comprehensive reference for collecting user feedback in React Native
with Sentry, covering all three collection approaches and their trade-offs.
Coverage includes:
- Built-in feedback widget (showFeedbackWidget, showFeedbackButton,
hideFeedbackButton) with feedbackIntegration configuration options
(labels, placeholders, required fields, styles, useSentryUser pre-fill)
- FeedbackWidget component for inline embedding within custom screens
- captureFeedback() programmatic API with full type reference, captureContext
tags, and file attachments
- Crash report modal pattern: how to use lastEventId() to detect a prior
crash on launch and present a post-crash feedback form
- ErrorBoundary integration via showDialog prop and onError callback for
linking render-error eventIds to custom feedback forms
- Screenshots in feedback via react-native-view-shot + attachments, and the
attachScreenshot: true Sentry.init alternative
- Session Replay auto-attachment (30-second buffer) when mobileReplayIntegration
is enabled alongside feedbackIntegration
- Offline caching: feedback queued on-device and replayed on reconnect
- Complete custom feedback form example with validation, loading state, and
error handling
- Expo considerations: widget requires native build; captureFeedback() works
in Expo Go; isRunningInExpoGo() guard pattern
- Migration guide from deprecated captureUserFeedback() to captureFeedback()
- Architecture compatibility table (Legacy vs New Architecture / Fabric)
- Version requirements table and troubleshooting guide
* fix(sentry-react-native-sdk): correct version numbers, deprecations, and web-only APIs
Fix all P0, P1, and P2 review findings across the React Native SDK skill bundle.
**P0 — Version accuracy (logging.md, user-feedback.md):**
- Replace fabricated `@sentry/core` versions (≥10.13.0, ≥10.32.0) with correct
`@sentry/react-native` versions: ≥7.0.0 for `consoleLoggingIntegration()` and
≥7.8.0 for scope attribute setters (`getGlobalScope().setAttributes()`)
- Fix user-feedback version table: replace blanket ≥5.0.0 with accurate per-feature
minimums (captureFeedback ≥6.5.0, showFeedbackWidget/feedbackIntegration ≥6.9.0,
showFeedbackButton/hideFeedbackButton ≥6.15.0); add missing button API row
**P1 — Correctness fixes:**
- tracing.md: replace deprecated `{ transactionContext }` destructuring in
`tracesSampler` examples with modern `{ name, attributes, parentSampled }` signature
- user-feedback.md: fix replay buffer duration from "30 seconds" → "60 seconds" (2 occurrences)
- logging.md: reword misleading "Session Replay is not available in React Native" —
mobile replay IS available; replay_id just isn't attached to log events
(linked via trace context instead)
- error-monitoring.md: remove web-only `dom: true` and `history: true` from
`breadcrumbsIntegration` example; add clarifying comment
**P2 — Minor polish:**
- error-monitoring.md: comment out `denyUrls`/`allowUrls` in the full init reference
with a note that they match stack frame URLs and are primarily useful for web
- error-monitoring.md: make `enableTombstone` consistent — both occurrences now show
`true` with a note that the default is `false`
- SKILL.md: add `// SDK ≥7.0.0` comment next to `enableLogs: true` in the main init example
* fix(react-native-sdk): fix code example bugs in tracing and logging references
Remove duplicate animation.start() call in the startSpanManual example that
would restart the animation and leak an unclosed span. Add missing async
keyword to the withScope callback in the logging reference so the await
inside it is valid syntax.
|
||
|
Daniel Griesser
|
411275373a |
chore: remove legacy setup skills and size-restricting guidelines (#11)
Remove sentry-python-setup and sentry-ruby-setup skills — these are superseded by the comprehensive sentry-python-sdk and sentry-ruby-sdk bundles which cover all Sentry features with deep-dive references. Update cross-references in sentry-svelte-sdk to point to the full SDK bundle skills instead of the deleted setup skills. Remove size-restricting language (100-200 line targets, <500 line caps, token optimization warnings) from AGENTS.md, README.md, and sdk-skill-philosophy.md. The new direction favors comprehensive, all-encompassing skills that use references/ directories for deep-dive content loaded on demand. |
||
|
Daniel Griesser
|
aeece801b5 |
feat: SDK skill bundles — opinionated, full-platform Sentry setup wizards (#8)
* docs: add SDK skill bundle philosophy guide Introduces docs/sdk-skill-philosophy.md — the canonical authoring guide for SDK skill bundles, a new pattern that goes beyond single-feature skills to provide full, opinionated Sentry setup wizards for each SDK. The document covers: - Bundle architecture: a lean main SKILL.md wizard (<500 lines) paired with a references/ directory of deep-dive files, one per feature pillar - Feature pillars matrix showing which pillars each SDK type supports (error monitoring, tracing, profiling, logging, metrics, crons, session replay, AI monitoring) - The four-phase wizard flow: Detect → Recommend → Guide → Cross-Link, with concrete implementation patterns and example markdown - Opinionated recommendation logic — e.g. always recommend error monitoring, recommend tracing when HTTP handlers are detected, etc. - The 'non-negotiable baseline' rule: error monitoring is never opt-in - Reference file format requirements and style rules - Naming conventions for skill directories, SKILL.md fields, and reference files - A minimal SKILL.md scaffold authors can copy to start a new bundle - A 'Staying Current' section covering version requirements and the docs-verification disclaimer pattern Also adds an 'SDK Skill Bundles' section to AGENTS.md pointing to the new guide, so skill authors discover it alongside the existing Setup and Workflow categories. * feat(go-sdk): add sentry-go-sdk main SKILL.md wizard Introduces the primary wizard file for the sentry-go-sdk bundle, a four-phase opinionated setup guide for integrating Sentry into Go applications. Phase 1 (Detect) scans go.mod for the existing sentry-go dependency, the active web framework (Gin, Echo, Fiber, FastHTTP, Iris, Negroni, net/http), logging libraries (logrus, zap, zerolog, slog), cron scheduler patterns, OpenTelemetry usage, and companion frontend directories — giving the agent a complete picture before making any recommendations. Phase 2 (Recommend) presents a concrete, opinionated proposal rather than an open-ended question. Error monitoring is always recommended; tracing is triggered by HTTP/gRPC/DB patterns; logging fires when a known logging library is detected; profiling, metrics, and crons are flagged as optional enhancements. Phase 3 (Guide) covers installation of the core SDK and the correct framework sub-package, a full-featured recommended sentry.Init() call with build-time release injection, a framework middleware table documenting the correct Repanic/WaitForDelivery settings per framework (critical for Fiber/FastHTTP which use fasthttp with no built-in recovery), and a reference dispatch table that tells the agent which references/<feature>.md to load for each agreed feature pillar. Phase 4 (Cross-Link) detects companion frontend directories and maps them to the appropriate Sentry frontend skill (sentry-react-setup, sentry-svelte-sdk, etc.). Also includes a full ClientOptions reference table, environment variable mapping, a verification code snippet, and a troubleshooting table covering the most common Go-specific gotchas (os.Exit bypassing defer flush, goroutine hub cloning, SampleRate 0.0 behaviour, fasthttp middleware options). 285 lines — well within the 500-line Agent Skills spec limit. * feat(go-sdk): add reference deep-dives for all six feature pillars Create six reference files in skills/sentry-go-sdk/references/ that serve as the deep-dive documentation loaded on demand by the main SKILL.md wizard. Each file covers one Sentry feature pillar with working code examples, configuration tables, and troubleshooting guides sourced from the sentry-go v0.43.0 API. error-monitoring.md — CaptureException/Message/Event, panic recovery (Recover/RecoverWithContext), hub cloning for goroutines, scope enrichment (tags, user, context, breadcrumbs), error chain unwrapping (%w / errors.Join / pkg/errors), BeforeSend filtering, event processors, and custom fingerprinting. tracing.md — EnableTracing configuration, TracesSampler vs TracesSampleRate, StartTransaction/StartSpan/StartChild patterns, span status and data, all five framework middleware integrations (sentryhttp, sentrygin, sentryecho, sentryfiber, sentryiris), distributed tracing header propagation (sentry-trace + baggage), and the OTel bridge via sentryotel. profiling.md — Accurately documents that profiling was removed in v0.31.0 (ProfilesSampleRate does not exist). Includes a compile-error example showing the broken field, explains the history, and points to Go-native alternatives (pprof, Pyroscope, etc.). logging.md — Native sentry.NewLogger(ctx) API with full Logger and LogEntry interfaces, EnableLogs requirement, BeforeSendLog filtering, auto-attached attributes, and all four library integrations: logrus (NewLogHook vs NewEventHook with correct level mapping and special field names), slog (Option struct, LevelFatal constant, level-to- severity mapping), zerolog (sends Events not Logs — explicitly documented), and zap (sentryzap.NewSentryCore, Context() helper, added in v0.43.0). metrics.md — Open-beta Meter interface (Count/Gauge/Distribution only — Sets are not implemented in Go), MeterOption functions, all unit constants, BeforeSendMetric hook, trace-linked metrics via meter.WithCtx(), timing via time.Since()+Distribution (no built-in timer), and cardinality best practices. crons.md — CheckIn/MonitorConfig structs, CrontabSchedule and IntervalSchedule constructors (int64 types noted), the check-in vs heartbeat patterns with complete before/after examples, manual robfig/cron integration wrapper, error-to-monitor linking via scope context, rate limit guidance (6/min), and nil-safety note for CaptureCheckIn return value. * feat(svelte-sdk): add sentry-svelte-sdk main SKILL.md wizard Introduces the main wizard skill for the Sentry Svelte/SvelteKit SDK bundle, following the four-phase wizard architecture established in docs/sdk-skill-philosophy.md. The skill handles both Svelte (standalone/Vite) and SvelteKit projects, with three distinct setup paths: - Path A: SvelteKit modern (≥2.31.0) — wizard or manual; covers instrumentation.server.ts, hooks.client.ts, hooks.server.ts, svelte.config.js, and vite.config.ts for source map upload - Path B: SvelteKit legacy (<2.31.0) — Sentry.init() in hooks.server.ts without the instrumentation file - Path C: Plain Svelte — single entry point setup with optional component tracking via svelte.config.js preprocessor Phase 1 detects the framework type (SvelteKit vs. plain Svelte), version, existing Sentry presence, logging libraries, and companion backend directories. Phase 2 gives an opinionated feature recommendation matrix covering Error Monitoring, Tracing, Session Replay, and Logging. Phase 3 walks through each path with complete, production-ready Quick Start configs. Phase 4 cross-links to backend SDK skills (Go, Python, Ruby, Node) when a companion backend is detected. Also includes: SvelteKit file summary table, adapter compatibility table, full Sentry.init() config reference, verification steps, and a troubleshooting table covering the most common SvelteKit-specific pitfalls (legacy wrapLoadWithSentry, cloudflare adapter, ad-blocker tunneling). 436 lines — well within the 500-line budget. Reference deep-dives for each feature pillar (error-monitoring.md, tracing.md, session-replay.md, logging.md) will be added in subsequent tasks. * feat(svelte-sdk): add reference deep-dives for all four feature pillars Adds four reference files to skills/sentry-svelte-sdk/references/ covering the complete Sentry feature surface for Svelte and SvelteKit: - error-monitoring.md — automatic capture via handleErrorWithSentry() and sentryHandle(), manual captureException/captureMessage, context enrichment (user, tags, breadcrumbs, extra, initialScope), beforeSend filtering, Svelte component tracking with withSentryConfig(), +error.svelte integration, and withScope vs configureScope semantics - tracing.md — browserTracingIntegration() for client-side page loads and navigations, sentryHandle() for server-side request instrumentation, custom spans (startSpan/startSpanManual/startInactiveSpan), sampling including dynamic tracesSampler, tracePropagationTargets for distributed tracing, SSR→client trace stitching via injected <meta> tags, load function tracing, Web Vitals capture, span filtering, and legacy wrapLoadWithSentry notes - session-replay.md — replayIntegration() setup for both SvelteKit and standalone Svelte, sample rate guidance by traffic volume including errors-only strategy, privacy-first masking defaults with selector-based unmask/unblock and data-sentry-* HTML attributes, network capture with networkDetailAllowUrls, canvas recording, lazy loading, event filtering via beforeAddRecordingEvent, CSP requirements, and SvelteKit-specific notes - logging.md — enableLogs configuration in both hook files, all six Sentry.logger levels, logger.fmt parameterized messages for searchable attributes, consoleLoggingIntegration and Consola reporter, scope-based automatic attributes (getGlobalScope/getIsolationScope for SDK ≥10.32.0), beforeSendLog filtering, auto-generated attribute table, trace+log correlation, and SvelteKit server-side logging patterns Each reference file covers both Svelte and SvelteKit where they differ, uses tables over prose, and includes minimum SDK version requirements at the top for features that have a higher version floor. * docs(readme): add sentry-go-sdk and sentry-svelte-sdk SDK bundle entries Introduces a new top-level 'SDK Skills (Full Platform Bundles)' section in the Available Skills table, placed above the existing Setup Skills section to reflect their broader scope. Adds the two new skills: - sentry-go-sdk: full wizard for Go (net/http, Gin, Echo, Fiber), covering error monitoring, tracing, profiling, logging, metrics, and crons - sentry-svelte-sdk: full wizard for Svelte/SvelteKit, covering error monitoring, tracing, session replay, and logging Also updates: - Usage section: adds a parallel 'SDK Skills' subsection with trigger phrases for Go and SvelteKit so users know what to say to activate each skill - Skill Format section: documents the references/ directory pattern used by SDK bundles to keep deep-dive content out of the main wizard prompt - Contributing section: links to docs/sdk-skill-philosophy.md for authors who want to create additional full-platform SDK skill bundles All changes are additive; no existing content was restructured. * fix(skills): correct P0+P1 review findings across go and svelte skills Three correctness fixes identified during code review: **P0 — Remove profiling from sentry-go-sdk advertising** Profiling was removed from the sentry-go SDK in v0.31.0. While references/profiling.md correctly documents this removal, the skill was still actively advertising and recommending profiling in: - README.md SDK skills table description - SKILL.md frontmatter description field - SKILL.md 'Invoke This Skill When' trigger list - Phase 2 optional features list and recommendation table - Phase 2 proposal sentence Profiling is now marked with a ⚠️ warning in the recommendation table ('Removed in v0.31.0 — do not recommend') and removed from all advertising copy. The references/profiling.md reference file is retained as-is since it correctly documents the removal and offers OpenTelemetry alternatives. **P1 — Replace deprecated configureScope with modern scope APIs** The error-monitoring.md reference for sentry-svelte-sdk was using Sentry.configureScope(), deprecated since SDK v8. Replaced with the modern Sentry.getIsolationScope() / Sentry.getGlobalScope() APIs, which match the pattern already used in the logging reference for the same skill. Added minimum SDK version notes (≥8.0.0 for isolation scopes, ≥10.32.0 for getGlobalScope/getIsolationScope). Also updated the Best Practices bullet that recommended configureScope. **P1 — Add <svelte:boundary> error boundary coverage** Svelte 5 introduced <svelte:boundary> for catching component-level errors before they crash the full page. Added a dedicated 'Error Boundaries (Svelte 5+)' section showing: basic onerror integration with captureException, the failed snippet fallback UI pattern, and a second example combining reset() with lastEventId() + showReportDialog() for user feedback. Includes requirements note (Svelte 5 + @sveltejs/kit ≥2.x) and practical tips on nesting boundaries for widget isolation. * feat(sdk-skill-creator): add meta-skill for creating SDK skill bundles Add sentry-sdk-skill-creator — a process skill that codifies the full workflow for producing research-backed SDK skill bundles for any Sentry platform. Captures the exact methodology used to build the Go and Svelte SDK skills. The main SKILL.md (290 lines) walks through six phases: 1. Identify the SDK and its feature matrix 2. Research all feature pillars via parallel claude tasks with outputFile 3. Create the main wizard SKILL.md following the philosophy doc 4. Create reference deep-dive files for each feature pillar 5. Verify APIs against actual SDK source code, run reviewer 6. Register the skill in README.md and commit Two reference files support the process: - research-playbook.md: prompt templates for each research batch, execution pattern, file naming conventions, failure recovery - quality-checklist.md: spec compliance, wizard flow requirements, code example quality rubric, accuracy red flags, cross-cutting consistency checks, and final verification commands Also adds an 'Authoring Skills' section to README.md. * feat(ruby-sdk): add sentry-ruby-sdk skill bundle Full Sentry setup wizard for Ruby covering error monitoring, tracing, logging, custom metrics (Sidekiq), and migration from AppSignal/Honeybadger. Includes five reference deep-dives and README entries. Co-Authored-By: Claude <noreply@anthropic.com> * test(ruby-sdk): add three-app validation harness for sentry-ruby-sdk Includes Rails, Sinatra, and Honeybadger migration test apps plus a three-mode validation script (mock/spotlight/real) and a pure-Ruby mock server for zero-dependency local testing. Co-Authored-By: Claude <noreply@anthropic.com> * ref(ruby-sdk): remove dashboard creation from metrics reference Dashboard creation is better done manually via the Sentry UI. The curl snippet was overly complex and error-prone (wrong region, API quirks). Co-Authored-By: Claude <noreply@anthropic.com> * ref(ruby-sdk): store pre-skill baseline in test apps Commit pre-Sentry state so reset.sh can use git restore and git diff shows exactly what the skill generates. rails-app and honeybadger_app Gemfiles have no Sentry gems; sinatra_app.rb has no Sentry setup; honeybadger_app uses Honeybadger.notify throughout. Co-Authored-By: Claude <noreply@anthropic.com> * fix(ruby-sdk): add competitor initializer deletion to migration docs The migration guide and skill wizard omitted deleting the competitor's initializer file (config/initializers/honeybadger.rb, appsignal.rb). Leaving it in place causes startup failures because the competitor gem is no longer installed but its initializer still runs. Co-Authored-By: Claude <noreply@anthropic.com> * fix(ruby-sdk): address P1/P2/P3 quality-checklist findings - logging.md: add required `enabled_patches << :logger` prerequisite for std_lib_logger_filter — without it the filter proc is never called (P1) - tracing.md: add config options table (traces_sample_rate, traces_sampler, trace_propagation_targets, propagate_traces) matching reference file spec (P2) - metrics.md: tighten minimum SDK version from vague v6.x+ to v6.3.0+, which is when the count/gauge/distribution API replaced the beta increment (P2) - migration.md: add missing minimum SDK version header present on all other reference files (P2) - SKILL.md: add "Invoke This Skill When" section and update version note to v6.4.0; add Configuration Reference table with all key init options and env vars; add Profiling and Crons rows to Phase 2 recommend table and Phase 3 feature reference dispatch table (P2/P3) Co-Authored-By: Claude <noreply@anthropic.com> * feat(ruby-sdk): add profiling and crons reference deep-dives profiling.md: covers StackProf (sentry-ruby ≥5.9.0) and Vernier (≥5.21.0, Ruby 3.2.1+) setup, profiles_sample_rate config, beta disclaimer, and troubleshooting. Vernier preferred for Ruby 3.2.1+ due to lower overhead. crons.md: covers manual capture_check_in pattern, ActiveJob mixin (Sentry::Cron::MonitorCheckIns), Sidekiq-Cron auto-capture via enabled_patches, MonitorConfig upsert with crontab and interval schedules, heartbeat pattern, and troubleshooting. Both pillars were missing from the skill bundle; SKILL.md already updated to route to these files. Co-Authored-By: Claude <noreply@anthropic.com> * fix(sdk-skill-creator): correct relative path to philosophy doc The ${SKILL_ROOT} variable resolves to skills/sentry-sdk-skill-creator/, so two parent traversals (../../) reach the repo root where docs/ lives. The previous path had three (../../../), which would resolve above the repository root and fail to load the philosophy document. * feat(python-sdk): add sentry-python-sdk main SKILL.md wizard Introduces the four-phase setup wizard for the Sentry Python SDK skill bundle. The wizard follows the same structural pattern as sentry-go-sdk and sentry-svelte-sdk but is tailored to Python's broader ecosystem. Key design decisions: - Phase 1 scans both requirements.txt and pyproject.toml (Python has no single canonical dependency file like go.mod), plus detects frameworks, task queues, logging libs, AI libraries, and cron patterns. - Phase 2 recommendation matrix covers all seven feature pillars: Error Monitoring (always), Tracing (HTTP framework detected), Profiling (production), Logging (always — stdlib auto-captured), Metrics, Crons (Celery Beat / APScheduler), and AI Monitoring (OpenAI/Anthropic/etc. are zero-config auto-instrumented). - Phase 3 init placement table covers 11 frameworks including the special cases: Sanic (must init inside before_server_start listener), Celery (dual-process init via celeryd_init signal), and RQ (settings file loaded by worker process). Full Quick Start init enables tracing, continuous profiling, and structured logs with sensible defaults. - Auto-enabled vs explicit integration table saves the agent from unnecessarily adding integrations=[] for frameworks that wire up automatically. - Verification, configuration reference, env var table, and 14-entry troubleshooting table cover the most common Python gotchas (uWSGI threading flags, cross-request scope leaks, Sanic lifecycle init, RQ --sentry-dsn flag conflict). - Phase 4 cross-links to sentry-react-setup and sentry-svelte-sdk for companion frontend directories. 317 lines — well under the 500-line limit. * feat(python-sdk): add reference deep-dive files for all 7 feature pillars Add seven reference files under skills/sentry-python-sdk/references/ covering every major Sentry feature pillar for Python: - error-monitoring.md — capture APIs, scope management (global/isolation/current scopes, new_scope()), context enrichment (tags, user, context, breadcrumbs), before_send hook, fingerprinting, EventScrubber PII scrubbing, Exception Groups - tracing.md — traces_sample_rate, traces_sampler, @sentry_sdk.trace decorator, start_transaction/start_span, distributed tracing headers, auto-instrumented databases (SQLAlchemy, Redis, PyMongo), OTel bridge - profiling.md — both APIs: transaction-based (profiles_sample_rate, SDK 1.18+) and continuous (profile_session_sample_rate + profile_lifecycle, SDK 2.24.1+), manual start/stop profiler - logging.md — distinguishes Sentry Structured Logs (enable_logs, sentry_sdk.logger, SDK 2.35+) from classic LoggingIntegration breadcrumbs/events; covers Loguru, before_send_log, and the decision table for which system to use - metrics.md — count/distribution/gauge/set/timing APIs, unit strings, attribute cardinality guidance, before_send_metric hook (SDK 2.44+, open beta) - crons.md — @monitor decorator, capture_checkin() manual API, MonitorConfig upsert, MonitorStatus constants, heartbeat pattern, Celery Beat auto-discovery - ai-monitoring.md — all 10 integrations with auto-enabled vs explicit matrix, PII two-layer control, gen_ai.* manual span ops, token attribute accounting, agent workflow hierarchy, streaming support, unsupported provider workarounds All files follow the reference format: tables over prose, working Python code examples, version requirements at top, troubleshooting tables. * docs(readme): add sentry-python-sdk to SDK skills table and usage section Registers the new sentry-python-sdk skill bundle in the Available Skills table and the Usage quick-reference section. - Added sentry-python-sdk row to the SDK Skills (Full Platform Bundles) table with description covering error monitoring, tracing, profiling, logging, metrics, crons, and AI monitoring across Django, Flask, FastAPI, Celery, Starlette, and AIOHTTP - Added three trigger-phrase rows to the SDK Skills usage table so users know which natural-language prompts activate the skill (generic Python app, framework-specific setup, and OpenAI/LangChain AI monitoring) * fix(python-sdk): correct P1 review findings in metrics and AI monitoring references Remove fabricated metrics APIs (Set and Timing) that were removed in sentry-sdk v2.41.0 — only count(), gauge(), and distribution() exist in the current API. Update overview text to match. Fix AI monitoring integration matrix auto-enabled status: - Google GenAI: ⚠️ Use explicit → ✅ Yes (it is auto-enabled) - MCP: ❌ No → ✅ Yes (auto-enabled since v2.43.0) - Pydantic AI: ❌ No → ✅ Yes (auto-enabled since v2.43.0) Update bold warning to reflect that only LiteLLM requires explicit registration. Remove MCPIntegration, PydanticAIIntegration, and GoogleGenAIIntegration from the explicit-registration code example. Replace the misleading single-version header '2.41.0+' with a more accurate range: '2.1.0+ (core AI spans); 2.45.0+ for auto-enabling all integrations'. Add '> Requires SDK ≥ 2.51.0' note to the conversation tracking (set_conversation_id) section. Fix the LiteLLM/MCP troubleshooting row — MCP is now auto-enabled so the row now mentions only LiteLLM. Fix SKILL.md enable_logs troubleshooting entry to distinguish between direct structured logging via sentry_sdk.logger and stdlib bridging via LoggingIntegration(sentry_logs_level=...). * chore(ruby-sdk): remove test-apps directory from skill bundle Skills ship as agent context, not as runnable projects. The test-apps directory (Rails app, Sinatra app, Honeybadger migration app, mock server, and validation scripts) adds 27 files of application code that doesn't belong in a skill bundle. No skill or reference file references these files — they were used during development only. --------- Co-authored-by: Johannes Daxböck <johannes.daxboeck@sentry.io> Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Cody De Arkland
|
895e3e10cc |
Merge pull request #7 from getsentry/fix/deep-content-review-accuracy
fix: deep content review — correct inaccuracies across all 12 skills |
||
|
Cody De Arkland
|
681f114f40 |
fix: deep content review — correct inaccuracies across all 12 skills
Verified every skill against official Sentry docs, the getsentry/sentry-mcp repo, the Agent Skills specification, and Sentry API documentation. Critical fixes: - sentry-fix-issues: replace all 7 wrong MCP tool names with correct ones from getsentry/sentry-mcp (search_issues, get_issue_details, etc.), add analyze_issue_with_seer, fix search parameter to naturalLanguageQuery - sentry-create-alert: fix all filter condition comparison formats (polymorphic shapes per type), fix frequency unit from seconds to minutes, add beta warning, add 5 action types and 4 condition types - sentry-ios-swift-setup: add enableLogs version gate (9.0.0+ vs 8.x experimental), add Session Replay iOS 26/Liquid Glass caveat, add SPM product variants - sentry-ruby-setup: fix environment default from 'Auto-detected' to 'development', add Vernier profiler_class config requirement Medium fixes: - sentry-setup-ai-monitoring: fix instrumentOpenAiClient scope (browser/Next.js, not Node.js), add 6 missing Python integrations, remove duplicate PII section - sentry-python-setup: add min SDK versions (2.24.1+ profiling, 2.35.0+ logs), collapse 3 identical framework blocks into compact table - sentry-setup-tracing: add min SDK version column, fix Python sampler type hints - sentry-pr-code-review: fix bot name from sentry[bot] to seer-by-sentry[bot], add --paginate, expand from 70 to 105 lines with prerequisites and troubleshooting Polish: - Add license: Apache-2.0 to all 12 skills - Add Ruby metrics support (SDK 6.3.0+) to sentry-setup-metrics - Fix React Router v4/v5 shared integration, add TanStack Router - Remove unverified Pino/Winston claims from logging skill - Add Verification sections to 4 feature setup skills - Enrich descriptions with additional trigger keywords |
||
|
Cody De Arkland
|
d40fae2c7a |
Merge pull request #6 from getsentry/fix/docs-accuracy-audit
fix: correct factual inaccuracies across 9 skills based on Sentry docs audit |
||
|
Cody De Arkland
|
d35c05bcae |
fix: add missing iOS skill to README, fix AGENTS.md spec accuracy
- Add sentry-ios-swift-setup to Available Skills table and Usage section - Fix AI Monitoring docs link (was Next.js-specific, now general) - Replace non-existent 'model' field with 'metadata' in AGENTS.md - Update name field constraints to match Agent Skills spec (no consecutive hyphens, must not start/end with hyphen) |
||
|
Cody De Arkland
|
45339762ef |
fix: correct iOS minimum version to 15.0+ per SDK Package.swift
The sentry-cocoa Package.swift specifies .iOS(.v15) as the platform minimum. The docs manual setup page says 11.0 but is outdated — the Package.swift is the source of truth that Xcode enforces at build time. |
||
|
Cody De Arkland
|
65fa649d55 |
fix: add docs verification disclaimer to all setup skills
Adds a note to each skill reminding the agent that code samples and SDK versions are examples and must be verified against docs.sentry.io before implementing. Covers all 9 skills that provide language-specific SDK configuration. |
||
|
Cody De Arkland
|
0b9ba0d1e6 |
fix: correct factual inaccuracies across 9 skills based on Sentry docs audit
Cross-referenced all skills against official Sentry documentation and fixed: - sentry-react-setup: duplicate integrations key (runtime bug), wrong file path, missing router v4 integration, misleading env var prefix - sentry-setup-tracing: wrong Ruby span API, outdated sampler patterns, Next.js oversimplification, non-standard op value - sentry-setup-logging: wrong Ruby patch operator, incorrect Python log level examples, flagged unverifiable Winston integration - sentry-setup-ai-monitoring: 6 wrong JS min SDK versions (all 10.28.0), wrong Python install commands (no extras needed), wrong Vercel AI platform scope, LangChain incorrectly marked explicit - sentry-python-setup: defaults None not 0/False, environment default is production, separated SDK vs CLI env vars - sentry-ruby-setup: defaults nil not 0, added Vernier profiler option, added missing redis_logger - sentry-ios-swift-setup: iOS min 11.0 not 13.0, SPM version 9.5.0 not 9.0.0, CocoaPods syntax, removed undocumented SentrySDK.crash(), replay min SDK 8.31.1, fixed auto-instrumentation list, fastlane install command - sentry-react-native-setup: .env.local -> env.local (no leading dot) - sentry-create-alert: removed fabricated Critical=100 priority, fixed Slack and PagerDuty field names, added issue_resolved_trigger, added PUT endpoint |
||
|
Cody De Arkland
|
f9ccd0fe85 |
Merge pull request #5 from getsentry/fix/metrics-cardinality-review
fix: correct inaccurate cardinality references and Ruby support in metrics skill |
||
|
Cody De Arkland
|
6852091980 |
fix: direct to Sentry docs for SDK support instead of enumerating platforms
Replace platform-specific notes with a link to the official getting started page. Keep JS and Python as examples only. |
||
|
Cody De Arkland
|
2c6e7edae6 |
fix: correct inaccurate cardinality references and Ruby support claim in metrics skill
Replace outdated cardinality limits (from old DDM system) with current 2KB per-metric size limit. Remove incorrect claim that Ruby lacks metrics support. |
||
|
Cody De Arkland
|
e6072ed092 |
Merge pull request #4 from getsentry/fix/security-audit-remediations
fix: address security audit findings in fix-issues and ai-monitoring skills |
||
|
Cody De Arkland
|
3674136ac5 |
fix: address security audit findings in fix-issues and ai-monitoring skills
Add prompt injection guardrails and PII handling rules to sentry-fix-issues. Change prompt/output capture from default-on to opt-in in sentry-setup-ai-monitoring. |
||
|
Nico Hinderling
|
2b39e26a70 |
Merge pull request #3 from NicoHinderling/feat/sentry-create-alert
feat: Add sentry-create-alert skill for workflow engine alerts |
||
|
Nico Hinderling
|
6faed64aae |
feat: Add sentry-create-alert skill for workflow engine alerts
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> |
||
|
Cody De Arkland
|
5ff9def7dd |
Merge pull request #2 from jaffrepaul/docs/add-npx-install-instructions
docs: Add npx skills CLI installation instructions |
||
|
paulj
|
baa3a928fa |
docs: Add npx skills CLI installation instructions
Add the recommended quick install method using the skills CLI: - npx skills add for all skills - npx skills add --skill for individual skills - Link to skills.sh browser Move existing client-specific instructions under "Manual Installation". Co-Authored-By: Claude <noreply@anthropic.com> |
||
|
Cody De Arkland
|
d263acf6bc | feat: Add Size Analysis section to iOS Swift skill | ||
|
Cody De Arkland
|
827202ee7d | feat: Add sentry-ios-swift-setup skill for iOS/Swift apps | ||
|
Cody De Arkland
|
8a3cad2d86 |
feat: Remove sentry-nextjs-setup skill from main
The nextjs-setup skill relies on unreleased features. Moved to develop-nextjs-headless branch for future release. |
||
|
Cody De Arkland
|
116eda354f | perf: Optimize sentry-fix-issues skill token usage (57% reduction) | ||
|
Cody De Arkland
|
0f1dbb1023 | docs: Update skill descriptions to match frontmatter and clarify Seer Bug Prediction | ||
|
Cody De Arkland
|
49dd7087d1 | fix: Update release workflow with renamed skills | ||
|
Cody De Arkland
|
3e0337583a | refactor: Rename wizard skills to setup | ||
|
Cody De Arkland
|
3b4f20114b | feat: Add setup skills for React, Python, Ruby, and React Native | ||
|
Cody De Arkland
|
d1bef7ec55 | refactor: Rename sentry-code-review to sentry-pr-code-review | ||
|
Cody De Arkland
|
d8f8cbdb24 |
fix: Delete and recreate release for fresh timestamps
The previous approach updated assets but kept original creation date. Now deletes existing release/tag before creating new one. |
||
|
Cody De Arkland
|
1365d4b0fc | docs: Add Sentry docs links for each skill in README | ||
|
Cody De Arkland
|
7d52660e63 | docs: Remove MCP setup steps from README | ||
|
Cody De Arkland
|
eab3e49429 |
feat(nextjs-wizard): Add MCP project creation check post-setup
- Check for Sentry MCP create_project capability after wizard completes - If available, auto-create project and configure DSN - If not, advise user on re-auth or manual creation options - List all files requiring DSN/project configuration |
||
|
Cody De Arkland
|
f96292df15 |
docs: Add AGENTS.md with skill authoring guidelines
- Token optimization patterns (tables over prose, ~100-200 lines target) - Skill structure template with phases and verification - Self-challenging verification for workflow skills - Version requirements and troubleshooting table patterns - Technical accuracy checklist (verify against Sentry docs) Also update release.yml to include sentry-fix-issues in release notes |
||
|
Cody De Arkland
|
a8f3e48f47 |
docs: Update README with new skills and improved organization
- Add sentry-fix-issues to Available Skills (with MCP requirement) - Split skills into Setup and Workflow categories - Add Platforms/Requirements columns to skill tables - Add Prerequisites section for MCP and GitHub CLI setup - Expand Usage section with 'What to Say' trigger examples - Add Style Guidelines for contributors (token optimization) |
||
|
Cody De Arkland
|
daac793b81 |
feat: Simplify skills ~76% and add sentry-fix-issues skill
- Simplify 6 existing skills to reduce token usage: - sentry-code-review: 185 -> 70 lines (62%) - sentry-nextjs-wizard: 520 -> 99 lines (81%) - sentry-setup-logging: 581 -> 139 lines (76%) - sentry-setup-tracing: 725 -> 149 lines (79%) - sentry-setup-metrics: 752 -> 157 lines (79%) - sentry-setup-ai-monitoring: 856 -> 164 lines (81%) - Fix accuracy issues from docs review: - AI monitoring: LangChain is auto-enabled (was incorrectly No) - AI monitoring: Add Next.js OpenAI instrumentOpenAiClient wrapper - Logging: Add SDK version requirements for Pino/Winston/Consola - Add new sentry-fix-issues skill: - Uses Sentry MCP to discover and analyze issues - 7-phase methodology with self-challenging verification - Leverages full Sentry context: traces, breadcrumbs, replays |
||
|
Cody De Arkland
|
44f3953a00 |
feat: Add GitHub Action to auto-release skills tarball
This workflow automatically creates a tarball of the skills directory and uploads it to a 'latest' release on every push to main. The tarball can be downloaded at: https://github.com/getsentry/sentry-agent-skills/releases/download/latest/sentry-agent-skills.tar.gz This enables sentry-wizard to easily fetch and install skills without requiring git on the user's machine. |
||
|
Cody De Arkland
|
195bf2434c | Add sentry-nextjs-wizard to README skills table | ||
|
Cody De Arkland
|
908044f4e1 |
Add Sentry agent skills and installation instructions
- Add 6 skills: sentry-code-review, sentry-setup-ai-monitoring, sentry-setup-logging, sentry-setup-metrics, sentry-setup-tracing, sentry-nextjs-wizard - Add comprehensive README with installation instructions for Claude Code, Codex, Copilot, Cursor, OpenCode, and AmpCode - Skills follow Agent Skills specification (agentskills.io) |