sentry-ruby 0.1.1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd48cd818d98c18e281aab8c37346fc7dc204b78396afe0ccaa64fa3cc8c0d2f
-  data.tar.gz: 2d4f7e657e9a3abc1d1063aa73e86ef7d9e09b0e5205f2a16b54d2242955316e
+  metadata.gz: 517bd830d9052aef4d3c9011f95e1d95f7740fae3bfdd746ece393766f637d84
+  data.tar.gz: 0b25ac7ffe3abf0c8b0a153681952bd36315fe406341add2e7e724632ca74d35
 SHA512:
-  metadata.gz: 612e9205c0d42c107a9a3a1d5b7bc759fd4daae5ede8ffd0efec1a0c3d1aa22860669f5f4d5a244397dcfe481f7784ae3f23c42c9e316338702cf372f8610e48
-  data.tar.gz: 45535f8367e8b37ba0f106b78ee2e9b7f40622ccb9b7207ba34ee49238600c6885a16125f15ff65957d713871f576b8579ecdbc88fbfb45cc6feecab0e64b1aa
+  metadata.gz: a717d3e5286400706e44f8bf1a17d6901e5fc7149efbff7f2f70758b1ac5c4f0f134f0d875a5543fa95777013aa1b0b0168f7c41fa149316bd9ced3a2f4ed48e
+  data.tar.gz: ad58cf9e97b482ff9b3107a677d1bc03d3429bba26052f908ce43b25635985f65525b3345afccd1488d5c94eabb0c6565b1ce16d003859da2e359f6ccbdd1eb9

data/.craft.yml

@@ -12,6 +12,7 @@ artifactProvider:
 targets:
     - name: gem
     - name: github
+      tagPrefix: sentry-ruby-v
     - name: registry
       type: sdk
       config:

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 4.0.0
+
+- Only documents update for the official release and no API/feature changes.
+
+## 0.3.0
+
+- Major API changes: [1123](https://github.com/getsentry/sentry-ruby/pull/1123)
+- Support event hint: [1122](https://github.com/getsentry/sentry-ruby/pull/1122)
+- Add request-id tag to events: [1120](https://github.com/getsentry/sentry-ruby/pull/1120) (by @tvec)
+
+## 0.2.0
+
+- Multiple fixes and refactorings
+- Tracing support
+
+## 0.1.3
+
+Fix require reference
+
+## 0.1.2
+
+- Fix: Fix async callback [1098](https://github.com/getsentry/sentry-ruby/pull/1098)
+- Refactor: Some code cleanup [1100](https://github.com/getsentry/sentry-ruby/pull/1100)
+- Refactor: Remove Event options [1101](https://github.com/getsentry/sentry-ruby/pull/1101)
+
 ## 0.1.1
 
 - Feature: Allow passing custom scope to Hub#capture* helpers [1086](https://github.com/getsentry/sentry-ruby/pull/1086)

data/Gemfile

@@ -9,3 +9,8 @@ gem "codecov"
 
 gem "pry"
 gem "rack"
+
+gem "benchmark-ips"
+gem "benchmark_driver"
+gem "benchmark-ipsa"
+gem "benchmark-memory"

data/README.md

@@ -1,44 +1,220 @@
-# Sentry::Ruby
+<p align="center">
+  <a href="https://sentry.io" target="_blank" align="center">
+    <img src="https://sentry-brand.storage.googleapis.com/sentry-logo-black.png" width="280">
+  </a>
+  <br>
+</p>
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/sentry/ruby`. To experiment with that code, run `bin/console` for an interactive prompt.
+# sentry-ruby, the Ruby Client for Sentry
 
-TODO: Delete this and the text above, and describe your gem
+**The old `sentry-raven` client has entered maintenance mode and was moved to [here](https://github.com/getsentry/sentry-ruby/tree/master/sentry-raven).**
 
-## Installation
+---
 
-Add this line to your application's Gemfile:
+
+[![Gem Version](https://img.shields.io/gem/v/sentry-ruby.svg)](https://rubygems.org/gems/sentry-ruby)
+![Build Status](https://github.com/getsentry/sentry-ruby/workflows/sentry-ruby%20Test/badge.svg)
+[![Coverage Status](https://img.shields.io/codecov/c/github/getsentry/sentry-ruby/master?logo=codecov)](https://codecov.io/gh/getsentry/sentry-ruby/branch/master)
+[![Gem](https://img.shields.io/gem/dt/sentry-ruby.svg)](https://rubygems.org/gems/sentry-ruby/)
+[![SemVer](https://api.dependabot.com/badges/compatibility_score?dependency-name=sentry-ruby&package-manager=bundler&version-scheme=semver)](https://dependabot.com/compatibility-score.html?dependency-name=sentry-ruby&package-manager=bundler&version-scheme=semver)
+
+
+[Documentation](https://docs.sentry.io/platforms/ruby/) | [Bug Tracker](https://github.com/getsentry/sentry-ruby/issues) | [Forum](https://forum.sentry.io/) | IRC: irc.freenode.net, #sentry
+
+The official Ruby-language client and integration layer for the [Sentry](https://github.com/getsentry/sentry) error reporting API.
+
+
+## Requirements
+
+We test on Ruby 2.4, 2.5, 2.6 and 2.7 at the latest patchlevel/teeny version. We also support JRuby 9.0.
+
+## Getting Started
+
+### Install
+
+```ruby
+gem "sentry-ruby"
+```
+
+and depends on the integrations you want to have, you might also want to install these:
+
+```ruby
+gem "sentry-rails"
+gem "sentry-sidekiq"
+# and mores to come in the future!
+```
+
+### Sentry only runs when Sentry DSN is set
+
+Sentry will capture and send exceptions to the Sentry server whenever its DSN is set. This makes environment-based configuration easy - if you don't want to send errors in a certain environment, just don't set the DSN in that environment!
+
+```bash
+# Set your SENTRY_DSN environment variable.
+export SENTRY_DSN=http://public@example.com/project-id
+```
+```ruby
+# Or you can configure the client in the code.
+Sentry.init do |config|
+  config.dsn = 'http://public@example.com/project-id'
+end
+```
+
+### Sentry doesn't report some kinds of data by default
+
+**Sentry ignores some exceptions by default** - most of these are related to 404s parameter parsing errors. [For a complete list, see the `IGNORE_DEFAULT` constant](https://github.com/getsentry/sentry-ruby/blob/master/sentry-ruby/lib/sentry/configuration.rb#L118) and the integration gems' `IGNORE_DEFAULT`, like [`sentry-rails`'s](https://github.com/getsentry/sentry-ruby/blob/update-readme/sentry-rails/lib/sentry/rails/configuration.rb#L12)
+
+Sentry doesn't send personally identifiable information (pii) by default, such as request body, user ip or cookies. If you want those information to be sent, you can use the `send_default_pii` config option:
+
+```ruby
+Sentry.init do |config|
+  # other configs
+  config.send_default_pii = true
+end
+```
+
+### Performance Monitoring
+
+You can activate performance monitoring by enabling traces sampling:
+
+```ruby
+Sentry.init do |config|
+  # set a uniform sample rate between 0.0 and 1.0
+  config.traces_sample_rate = 0.2
+
+  # or control sampling dynamically
+  config.traces_sampler = lambda do |sampling_context|
+    # sampling_context[:transaction_context] contains the information about the transaction
+    # sampling_context[:parent_sampled] contains the transaction's parent's sample decision
+    true # return value can be a boolean or a float between 0.0 and 1.0
+  end
+end
+```
+
+To lean more about performance monitoring, please visit the [official documentation](https://docs.sentry.io/platforms/ruby/performance).
+
+### Usage
+
+`sentry-ruby` has a default integration with `Rack`, so you only need to use the middleware in your application like:
+
+```ruby
+require 'sentry-ruby'
+
+Sentry.init do |config|
+  config.dsn = 'https://examplePublicKey@o0.ingest.sentry.io/0'
+
+  # To activate performance monitoring, set one of these options.
+  # We recommend adjusting the value in production:
+  config.traces_sample_rate = 0.5
+  # or
+  config.traces_sampler = lambda do |context|
+    true
+  end
+end
+
+use Sentry::Rack::Tracing # this needs to be placed first
+use Sentry::Rack::CaptureException
+```
+
+Otherwise, Sentry you can always use the capture helpers manually
+
+```ruby
+Sentry.capture_message("hello world!")
+
+begin
+  1 / 0
+rescue ZeroDivisionError => exception
+  Sentry.capture_exception(exception)
+end
+```
+
+We also provide integrations with popular frameworks/libraries with the related extensions:
+
+- [sentry-rails](https://github.com/getsentry/sentry-ruby/tree/master/sentry-rails)
+- [sentry-sidekiq](https://github.com/getsentry/sentry-ruby/tree/master/sentry-sidekiq)
+
+### More configuration
+
+You're all set - but there's a few more settings you may want to know about too!
+
+#### async
+
+When an error or message occurs, the notification is immediately sent to Sentry. Sentry can be configured to send asynchronously:
+
+```ruby
+config.async = lambda { |event|
+  Thread.new { Sentry.send_event(event) }
+}
+```
+
+Using a thread to send events will be adequate for truly parallel Ruby platforms such as JRuby, though the benefit on MRI/CRuby will be limited. If the async callback raises an exception, Sentry will attempt to send synchronously.
+
+Note that the naive example implementation has a major drawback - it can create an infinite number of threads. We recommend creating a background job, using your background job processor, that will send Sentry notifications in the background.
 
 ```ruby
-gem 'sentry-ruby'
+config.async = lambda { |event| SentryJob.perform_later(event) }
+
+class SentryJob < ActiveJob::Base
+  queue_as :default
+
+  def perform(event)
+    Sentry.send_event(event)
+  end
+end
 ```
 
-And then execute:
+#### Contexts
 
-    $ bundle install
+In sentry-ruby, every event will inherit their contextual data from the current scope. So you can enrich the event's data by configuring the current scope like:
 
-Or install it yourself as:
+```ruby
+Sentry.configure_scope do |scope|
+  scope.set_user(id: 1, email: "test@example.com")
 
-    $ gem install sentry-ruby
+  scope.set_tag(:tag, "foo")
+  scope.set_tags(tag_1: "foo", tag_2: "bar")
 
-## Usage
+  scope.set_extra(:order_number, 1234)
+  scope.set_extras(order_number: 1234, tickets_count: 4)
+end
 
-TODO: Write usage instructions here
+Sentry.capture_exception(exception) # the event will carry all those information now
+```
 
-## Development
+Or use top-level setters
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+```ruby
+Sentry.set_user(id: 1, email: "test@example.com")
+Sentry.set_tags(tag_1: "foo", tag_2: "bar")
+Sentry.set_extras(order_number: 1234, tickets_count: 4)
 
-## Contributing
+```
+
+Or build up a temporary scope for local information:
+
+```ruby
+Sentry.configure_scope do |scope|
+  scope.set_tags(tag_1: "foo")
+end
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/sentry-ruby. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/sentry-ruby/blob/master/CODE_OF_CONDUCT.md).
+Sentry.with_scope do |scope|
+  scope.set_tags(tag_1: "bar", tag_2: "baz")
 
+  Sentry.capture_message("message") # this event will have 2 tags: tag_1 => "bar" and tag_2 => "baz"
+end
 
-## License
+Sentry.capture_message("another message") # this event will have 1 tag: tag_1 => "foo"
+```
+
+Of course, you can always assign the information on a per-event basis:
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+```ruby
+Sentry.capture_exception(exception, tags: {foo: "bar"})
+```
 
-## Code of Conduct
+## More Information
 
-Everyone interacting in the Sentry::Ruby project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/sentry-ruby/blob/master/CODE_OF_CONDUCT.md).
+* [Documentation](https://docs.sentry.io/platforms/ruby/)
+* [Bug Tracker](https://github.com/getsentry/sentry-ruby/issues)
+* [Forum](https://forum.sentry.io/)
+- [Discord](https://discord.gg/ez5KZN7)

data/Rakefile

@@ -1,6 +1,8 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
-RSpec::Core::RakeTask.new(:spec)
+RSpec::Core::RakeTask.new(:spec).tap do |task|
+  task.rspec_opts = "--order rand"
+end
 
 task :default => :spec

data/lib/{sentry.rb → sentry-ruby.rb}

@@ -1,8 +1,13 @@
+require "forwardable"
+
 require "sentry/version"
 require "sentry/core_ext/object/deep_dup"
 require "sentry/configuration"
 require "sentry/logger"
 require "sentry/event"
+require "sentry/transaction_event"
+require "sentry/span"
+require "sentry/transaction"
 require "sentry/hub"
 require "sentry/rack"
 
@@ -20,7 +25,15 @@ module Sentry
     META
   end
 
+  def self.utc_now
+    Time.now.utc
+  end
+
   class << self
+    extend Forwardable
+
+    def_delegators :get_current_scope, :set_tags, :set_extras, :set_user
+
     def init(&block)
       config = Configuration.new
       yield(config)
@@ -39,8 +52,8 @@ module Sentry
       configuration.logger
     end
 
-    def breadcrumbs
-      get_current_scope.breadcrumbs
+    def add_breadcrumb(breadcrumb, &block)
+      get_current_scope.breadcrumbs.record(breadcrumb, &block)
     end
 
     def configuration
@@ -52,7 +65,12 @@ module Sentry
     end
 
     def get_current_hub
-      Thread.current[THREAD_LOCAL]
+      # we need to assign a hub to the current thread if it doesn't have one yet
+      #
+      # ideally, we should do this proactively whenever a new thread is created
+      # but it's impossible for the SDK to keep track every new thread
+      # so we need to use this rather passive way to make sure the app doesn't crash
+      Thread.current[THREAD_LOCAL] || clone_hub_to_current_thread
     end
 
     def clone_hub_to_current_thread
@@ -71,6 +89,10 @@ module Sentry
       get_current_hub.configure_scope(&block)
     end
 
+    def send_event(event)
+      get_current_client.send_event(event)
+    end
+
     def capture_event(event)
       get_current_hub.capture_event(event)
     end
@@ -83,6 +105,10 @@ module Sentry
       get_current_hub.capture_message(message, **options, &block)
     end
 
+    def start_transaction(**options)
+      get_current_hub.start_transaction(**options)
+    end
+
     def last_event_id
       get_current_hub.last_event_id
     end

data/lib/sentry/benchmarks/benchmark_transport.rb

@@ -0,0 +1,14 @@
+module Sentry
+  class BenchmarkTransport < Transport
+    attr_accessor :events
+
+    def initialize(*)
+      super
+      @events = []
+    end
+
+    def send_event(event)
+      @events << encode(event.to_hash)
+    end
+  end
+end

data/lib/sentry/breadcrumb.rb

@@ -2,13 +2,13 @@ module Sentry
   class Breadcrumb
     attr_accessor :category, :data, :message, :level, :timestamp, :type
 
-    def initialize
-      @category = nil
-      @data = {}
-      @level = nil
-      @message = nil
-      @timestamp = Time.now.to_i
-      @type = nil
+    def initialize(category: nil, data: nil, message: nil, timestamp: nil, level: nil, type: nil)
+      @category = category
+      @data = data || {}
+      @level = level
+      @message = message
+      @timestamp = timestamp || Sentry.utc_now.to_i
+      @type = type
     end
 
     def to_hash

data/lib/sentry/breadcrumb/sentry_logger.rb

@@ -58,17 +58,15 @@ module Sentry
         last_crumb = current_breadcrumbs.peek
         # try to avoid dupes from logger broadcasts
         if last_crumb.nil? || last_crumb.message != message
-          current_breadcrumbs.record do |crumb|
-            crumb.level = Sentry::Breadcrumb::SentryLogger::LEVELS.fetch(severity, nil)
-            crumb.category = category
-            crumb.message = message
-            crumb.type =
-              if severity >= 3
-                "error"
-              else
-                crumb.level
-              end
-          end
+          level = Sentry::Breadcrumb::SentryLogger::LEVELS.fetch(severity, nil)
+          crumb = Sentry::Breadcrumb.new(
+            level: level,
+            category: category,
+            message: message,
+            type: severity >= 3 ? "error" : level
+          )
+
+          Sentry.add_breadcrumb(crumb)
         end
       end
 
@@ -80,21 +78,7 @@ module Sentry
       end
 
       def current_breadcrumbs
-        Sentry.breadcrumbs
-      end
-    end
-    module OldBreadcrumbsSentryLogger
-      def self.included(base)
-        base.class_eval do
-          include Sentry::Breadcrumbs::SentryLogger
-          alias_method :add_without_sentry, :add
-          alias_method :add, :add_with_sentry
-        end
-      end
-
-      def add_with_sentry(*args)
-        add_breadcrumb(*args)
-        add_without_sentry(*args)
+        Sentry.get_current_scope.breadcrumbs
       end
     end
   end