sentry-ruby 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd48cd818d98c18e281aab8c37346fc7dc204b78396afe0ccaa64fa3cc8c0d2f
-  data.tar.gz: 2d4f7e657e9a3abc1d1063aa73e86ef7d9e09b0e5205f2a16b54d2242955316e
+  metadata.gz: 4cd10cdc1a28f396af641980c7440ab8fc74648a2ebe1364e81d137af7a8d832
+  data.tar.gz: d96bebca93ed6d16fc4bc1a7c6f14a53f33ebf84f4d6197ce79ee344bd2a0056
 SHA512:
-  metadata.gz: 612e9205c0d42c107a9a3a1d5b7bc759fd4daae5ede8ffd0efec1a0c3d1aa22860669f5f4d5a244397dcfe481f7784ae3f23c42c9e316338702cf372f8610e48
-  data.tar.gz: 45535f8367e8b37ba0f106b78ee2e9b7f40622ccb9b7207ba34ee49238600c6885a16125f15ff65957d713871f576b8579ecdbc88fbfb45cc6feecab0e64b1aa
+  metadata.gz: bacf5d66a156684b3dcf3048806ffab6b53f3172a146626a4b28e4a80d1c933a729ee813a933052a425d86d3c58ce04b8409a55ba0b3fe76c45cce3defc8a6f0
+  data.tar.gz: 756550d44dd6765e478ae2922f69c2098121c3ae290dd99345805d5690281021683146b54e999b77ed82b82330f40b5ec7e57b172a39741e4023c911c9867cb0

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,11 @@
 # Changelog
 
+## 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/README.md

@@ -1,44 +1,178 @@
-# 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
+---
 
-## 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/clients/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'
+gem "sentry-ruby"
 ```
 
-And then execute:
+and depends on the integrations you want to have, you might also want to install these:
 
-    $ bundle install
+```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!
 
-Or install it yourself as:
+```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
+```
 
-    $ gem install sentry-ruby
+### Sentry doesn't report some kinds of data by default
 
-## Usage
+**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)
 
-TODO: Write usage instructions here
+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:
 
-## Development
+```ruby
+Sentry.init do |config|
+  # other configs
+  config.send_default_pii = true
+end
+```
+
+### Usage
+
+`sentry-ruby` has a default integration with `Rack`, so you only need to use the middleware in your application like:
+
+```
+require 'rack'
+require 'sentry'
+
+use Sentry::Rack::CaptureException
+
+run theapp
+```
+
+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
+```
 
-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.
+We also provide integrations with popular frameworks/libraries with the related extensions:
 
-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).
+- [sentry-rails](https://github.com/getsentry/sentry-ruby/tree/master/sentry-rails)
+- [sentry-sidekiq](https://github.com/getsentry/sentry-ruby/tree/master/sentry-sidekiq)
 
-## Contributing
+### More configuration
 
-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).
+You're all set - but there's a few more settings you may want to know about too!
 
+#### async
 
-## License
+When an error or message occurs, the notification is immediately sent to Sentry. Sentry can be configured to send asynchronously:
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+```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
+config.async = lambda { |event| SentryJob.perform_later(event) }
+
+class SentryJob < ActiveJob::Base
+  queue_as :default
+
+  def perform(event)
+    Sentry.send_event(event)
+  end
+end
+```
+
+#### Contexts
+
+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:
+
+```ruby
+Sentry.configure_scope do |scope|
+  scope.set_user(id: 1, email: "test@example.com")
+
+  scope.set_tag(:tag, "foo")
+  scope.set_tags(tag_1: "foo", tag_2: "bar")
+
+  scope.set_extra(:order_number, 1234)
+  scope.set_extras(order_number: 1234, tickets_count: 4)
+end
+
+Sentry.capture_exception(exception) # the event will carry all those information now
+```
+
+Or build up a temporary scope for local information:
+
+```ruby
+Sentry.configure_scope do |scope|
+  scope.set_tags(tag_1: "foo")
+end
+
+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
+
+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:
+
+```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/clients/ruby/)
+* [Bug Tracker](https://github.com/getsentry/sentry-ruby/issues)
+* [Forum](https://forum.sentry.io/)
+- [Discord](https://discord.gg/ez5KZN7)

data/lib/sentry.rb

@@ -52,7 +52,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 +76,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

data/lib/sentry/client.rb

@@ -1,5 +1,4 @@
 require "sentry/transport"
-require 'sentry/utils/deep_merge'
 
 module Sentry
   class Client
@@ -21,51 +20,35 @@ module Sentry
       end
     end
 
-    def capture_exception(exception, scope:, **options, &block)
-      event = event_from_exception(exception, **options)
-      return unless event
-
-      block.call(event) if block
-      capture_event(event, scope)
-    end
-
-    def capture_message(message, scope:, **options, &block)
-      event = event_from_message(message, **options)
-      block.call(event) if block
-      capture_event(event, scope)
-    end
-
     def capture_event(event, scope)
       scope.apply_to_event(event)
-      send_event(event)
-      event
-    end
 
-    def event_from_exception(exception, **options)
-      exception_context =
-        if exception.instance_variable_defined?(:@__sentry_context)
-          exception.instance_variable_get(:@__sentry_context)
-        elsif exception.respond_to?(:sentry_context)
-          exception.sentry_context
-        else
-          {}
+      if configuration.async?
+        begin
+          # We have to convert to a JSON-like hash, because background job
+          # processors (esp ActiveJob) may not like weird types in the event hash
+          configuration.async.call(event.to_json_compatible)
+        rescue => e
+          configuration.logger.error(LOGGER_PROGNAME) { "async event sending failed: #{e.message}" }
+          send_event(event)
         end
+      else
+        send_event(event)
+      end
 
-      options = Utils::DeepMergeHash.deep_merge(exception_context, options)
+      event
+    end
 
+    def event_from_exception(exception)
       return unless @configuration.exception_class_allowed?(exception)
 
-      options = Event::Options.new(**options)
-
-      Event.new(configuration: configuration, options: options).tap do |event|
+      Event.new(configuration: configuration).tap do |event|
         event.add_exception_interface(exception)
       end
     end
 
-    def event_from_message(message, **options)
-      options.merge!(message: message)
-      options = Event::Options.new(options)
-      Event.new(configuration: configuration, options: options)
+    def event_from_message(message)
+      Event.new(configuration: configuration, message: message)
     end
 
     def send_event(event, hint = nil)

data/lib/sentry/configuration.rb

@@ -93,9 +93,6 @@ module Sentry
     # Silences ready message when true.
     attr_accessor :silence_ready
 
-    # Default tags for events. Hash.
-    attr_accessor :tags
-
     attr_reader :transport
 
     # Optional Proc, called before sending an event to the server/
@@ -157,7 +154,7 @@ module Sentry
       self.dsn = ENV['SENTRY_DSN']
       self.server_name = server_name_from_env
       self.should_capture = false
-      self.tags = {}
+
       @transport = Transport::Configuration.new
       self.before_send = false
       self.rack_env_whitelist = RACK_ENV_WHITELIST_DEFAULT

data/lib/sentry/event.rb

@@ -2,10 +2,8 @@
 
 require 'socket'
 require 'securerandom'
-require 'sentry/event/options'
 require 'sentry/interface'
 require 'sentry/backtrace'
-require 'sentry/utils/deep_merge'
 require 'sentry/utils/real_ip'
 
 module Sentry
@@ -23,7 +21,7 @@ module Sentry
 
     alias event_id id
 
-    def initialize(options:, configuration:)
+    def initialize(configuration:, message: nil)
       # this needs to go first because some setters rely on configuration
       @configuration = configuration
 
@@ -33,27 +31,21 @@ module Sentry
       @platform      = :ruby
       @sdk           = Sentry.sdk_meta
 
-      @user          = options.user
-      @extra         = options.extra
-      @contexts      = options.contexts
-      @tags          = configuration.tags.merge(options.tags)
+      @user          = {}
+      @extra         = {}
+      @contexts      = {}
+      @tags          = {}
 
-      @fingerprint = options.fingerprint
+      @fingerprint = []
 
-      @server_name = options.server_name || configuration.server_name
-      @environment = options.environment || configuration.current_environment
-      @release = options.release || configuration.release
+      @server_name = configuration.server_name
+      @environment = configuration.current_environment
+      @release = configuration.release
       @modules = list_gem_specs if configuration.send_modules
 
-      @message = options.message if options.message
+      @message = message || ""
 
-      self.level = options.level
-
-      if !options.backtrace.empty?
-        @stacktrace = Sentry::StacktraceInterface.new.tap do |int|
-          int.frames = stacktrace_interface_from(options.backtrace)
-        end
-      end
+      self.level = :error
     end
 
     class << self
@@ -113,6 +105,10 @@ module Sentry
     end
 
     def add_exception_interface(exc)
+      if exc.respond_to?(:sentry_context)
+        @extra.merge!(exc.sentry_context)
+      end
+
       @exception = Sentry::ExceptionInterface.new.tap do |exc_int|
         exceptions = Sentry::Utils::ExceptionCauseChain.exception_to_array(exc).reverse
         backtraces = Set.new

data/lib/sentry/transport.rb

@@ -26,27 +26,12 @@ module Sentry
 
       return nil unless encoded_data
 
-      begin
-        if configuration.async?
-          begin
-            # We have to convert to a JSON-like hash, because background job
-            # processors (esp ActiveJob) may not like weird types in the event hash
-            configuration.async.call(event.to_json_compatible)
-          rescue => e
-            configuration.logger.error(LOGGER_PROGNAME) { "async event sending failed: #{e.message}" }
-            send_data(encoded_data, content_type: content_type)
-          end
-        else
-          send_data(encoded_data, content_type: content_type)
-        end
-
-        state.success
-      rescue => e
-        failed_for_exception(e, event)
-        return
-      end
+      send_data(encoded_data, content_type: content_type)
 
+      state.success
       event
+    rescue => e
+      failed_for_exception(e, event)
     end
 
     def generate_auth_header

data/lib/sentry/version.rb

@@ -1,3 +1,3 @@
 module Sentry
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-11-06 00:00:00.000000000 Z
+date: 2020-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -55,7 +55,6 @@ files:
 - lib/sentry/core_ext/object/duplicable.rb
 - lib/sentry/dsn.rb
 - lib/sentry/event.rb
-- lib/sentry/event/options.rb
 - lib/sentry/hub.rb
 - lib/sentry/interface.rb
 - lib/sentry/interfaces/exception.rb
@@ -73,7 +72,6 @@ files:
 - lib/sentry/transport/dummy_transport.rb
 - lib/sentry/transport/http_transport.rb
 - lib/sentry/transport/state.rb
-- lib/sentry/utils/deep_merge.rb
 - lib/sentry/utils/exception_cause_chain.rb
 - lib/sentry/utils/real_ip.rb
 - lib/sentry/version.rb

data/lib/sentry/event/options.rb

@@ -1,31 +0,0 @@
-module Sentry
-  class Event
-    class Options
-      attr_reader :message,
-        :user, :extra, :tags, :contexts,
-        :backtrace, :level, :fingerprint,
-        :server_name, :release, :environment
-
-      def initialize(
-        message: "",
-        user: {}, extra: {}, tags: {}, contexts: {},
-        backtrace: [], level: :error, fingerprint: [],
-        # nilable attributes because we'll fallback to the configuration's values
-        server_name: nil, release: nil, environment: nil
-      )
-        @message = message || ""
-        @user = user || {}
-        @extra = extra || {}
-        @tags = tags || {}
-        @contexts = contexts || {}
-        @backtrace = backtrace || []
-        @fingerprint = fingerprint || []
-        @level = level || :error
-        @server_name = server_name
-        @environment = environment
-        @release = release
-      end
-    end
-  end
-end
-

data/lib/sentry/utils/deep_merge.rb

@@ -1,22 +0,0 @@
-module Sentry
-  module Utils
-    # ported from ActiveSupport
-    module DeepMergeHash
-      def self.deep_merge(hash, other_hash, &block)
-        deep_merge!(hash, other_hash, &block)
-      end
-
-      def self.deep_merge!(hash, other_hash, &block)
-        hash.merge!(other_hash) do |key, this_val, other_val|
-          if this_val.is_a?(Hash) && other_val.is_a?(Hash)
-            deep_merge(this_val, other_val, &block)
-          elsif block_given?
-            block.call(key, this_val, other_val)
-          else
-            other_val
-          end
-        end
-      end
-    end
-  end
-end