sentry-ruby 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b16bf44cdc5e7689122b6727e08f680c7cfb98be5bebba286fdfc8a9e9f2cb81
-  data.tar.gz: 55a4793366f3e1a1dba8db0bec236d5c7bed5b2f1cb838244faaf629f4a1edb4
+  metadata.gz: f8f89cd1b0354cede1b5aab23b0b8652fed01bcebc3af7f0cb45a13d0f1d99ba
+  data.tar.gz: 38fa765f4acb958b8170a31017028a45cce342667bd8dee7dbff07c4e097ffc5
 SHA512:
-  metadata.gz: 99da84ece5e4ee5c459fa93284edfa2154c4bb0409278bb763ff98c2ceeddb57821f173c8fe3d1cf3a1cfa48d9d168e676f8cc666117604d7b367c5f8f352f4c
-  data.tar.gz: aed7ff1ecf47362e8f8be166cc173b0b5ef62dacd17dc21d7d10e6c8240193024b934d1b510cbb72ccd39837c24b79421b568577ad3e3921adbb4b050395a976
+  metadata.gz: be0a56af7629bf528be987f62bcb0a4fd12430d75b7541acc6d946314306ab4968c214eb7a533695dcd8aa3b3f434225f8dffceecee4bc39a8b5bd45e168e3d1
+  data.tar.gz: 383d6e88932c6ff3f6e79ca3c35c05d7a23151dd85db057e45dc8577f88673e8195659df3a0c01d71b1e67a61e7f1008eb36ab294047fdeea5cedf2a7d02f92c

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.2.0
+
+- Multiple fixes and refactorings
+- Tracing support
+
 ## 0.1.3
 
 Fix require reference

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/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-ruby.rb

@@ -3,6 +3,9 @@ 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,6 +23,10 @@ module Sentry
     META
   end
 
+  def self.utc_now
+    Time.now.utc
+  end
+
   class << self
     def init(&block)
       config = Configuration.new
@@ -92,6 +99,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

@@ -7,7 +7,7 @@ module Sentry
       @data = {}
       @level = nil
       @message = nil
-      @timestamp = Time.now.to_i
+      @timestamp = Sentry.utc_now.to_i
       @type = nil
     end
 

data/lib/sentry/breadcrumb/sentry_logger.rb

@@ -83,20 +83,6 @@ module Sentry
         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)
-      end
-    end
   end
 end
 

data/lib/sentry/client.rb

@@ -51,6 +51,18 @@ module Sentry
       Event.new(configuration: configuration, message: message)
     end
 
+    def event_from_transaction(transaction)
+      TransactionEvent.new(configuration: configuration).tap do |event|
+        event.transaction = transaction.name
+        event.contexts.merge!(trace: transaction.get_trace_context)
+        event.timestamp = transaction.timestamp
+        event.start_timestamp = transaction.start_timestamp
+
+        finished_spans = transaction.span_recorder.spans.select { |span| span.timestamp && span != transaction }
+        event.spans = finished_spans.map(&:to_hash)
+      end
+    end
+
     def send_event(event)
       return false unless configuration.sending_allowed?(event)
 

data/lib/sentry/configuration.rb

@@ -15,6 +15,28 @@ module Sentry
     attr_reader :async
     alias async? async
 
+    # a proc/lambda that takes an array of stack traces
+    # it'll be used to silence (reduce) backtrace of the exception
+    #
+    # for example:
+    #
+    # ```ruby
+    # Sentry.configuration.backtrace_cleanup_callback = lambda do |backtrace|
+    #   Rails.backtrace_cleaner.clean(backtrace)
+    # end
+    # ```
+    #
+    attr_accessor :backtrace_cleanup_callback
+
+    # Optional Proc, called before sending an event to the server/
+    # E.g.: lambda { |event| event }
+    # E.g.: lambda { |event| nil }
+    # E.g.: lambda { |event|
+    #   event[:message] = 'a'
+    #   event
+    # }
+    attr_reader :before_send
+
     # An array of breadcrumbs loggers to be used. Available options are:
     # - :sentry_logger
     # - :active_support_logger
@@ -26,6 +48,9 @@ module Sentry
     # RACK_ENV by default.
     attr_reader :current_environment
 
+    # the dsn value, whether it's set via `config.dsn=` or `ENV["SENTRY_DSN"]`
+    attr_reader :dsn
+
     # Whitelist of environments that will send notifications to Sentry. Array of Strings.
     attr_accessor :environments
 
@@ -64,22 +89,14 @@ module Sentry
     # any events, and a value of 1.0 will send 100% of events.
     attr_accessor :sample_rate
 
-    # a proc/lambda that takes an array of stack traces
-    # it'll be used to silence (reduce) backtrace of the exception
-    #
-    # for example:
-    #
-    # ```ruby
-    # Sentry.configuration.backtrace_cleanup_callback = lambda do |backtrace|
-    #   Rails.backtrace_cleaner.clean(backtrace)
-    # end
-    # ```
-    #
-    attr_accessor :backtrace_cleanup_callback
-
     # Include module versions in reports - boolean.
     attr_accessor :send_modules
 
+    # When send_default_pii's value is false (default), sensitive information like
+    # - user ip
+    # - user cookie
+    # - request body
+    # will not be sent to Sentry.
     attr_accessor :send_default_pii
 
     attr_accessor :server_name
@@ -90,25 +107,24 @@ module Sentry
     # e.g. lambda { |exc_or_msg| exc_or_msg.some_attr == false }
     attr_reader :should_capture
 
-    # Silences ready message when true.
-    attr_accessor :silence_ready
-
+    # Return a Transport::Configuration object for transport-related configurations.
     attr_reader :transport
 
-    # Optional Proc, called before sending an event to the server/
-    # E.g.: lambda { |event| event }
-    # E.g.: lambda { |event| nil }
-    # E.g.: lambda { |event|
-    #   event[:message] = 'a'
-    #   event
-    # }
-    attr_reader :before_send
+    # Take a float between 0.0 and 1.0 as the sample rate for tracing events (transactions).
+    attr_accessor :traces_sample_rate
 
-    # Errors object - an Array that contains error messages. See #
-    attr_reader :errors
+    # Take a Proc that controls the sample rate for every tracing event, e.g.
+    # ```
+    # lambda do |tracing_context|
+    #   # tracing_context[:transaction_context] contains the information about the transaction
+    #   # tracing_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
+    # ```
+    attr_accessor :traces_sampler
 
-    # the dsn value, whether it's set via `config.dsn=` or `ENV["SENTRY_DSN"]`
-    attr_reader :dsn
+    # these are not config options
+    attr_reader :errors, :gem_specs
 
     # Most of these errors generate 4XX responses. In general, Sentry clients
     # only automatically report 5xx responses.
@@ -155,9 +171,11 @@ module Sentry
       self.server_name = server_name_from_env
       self.should_capture = false
 
-      @transport = Transport::Configuration.new
       self.before_send = false
       self.rack_env_whitelist = RACK_ENV_WHITELIST_DEFAULT
+
+      @transport = Transport::Configuration.new
+      @gem_specs = Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
       post_initialization_callback
     end
 
@@ -211,13 +229,6 @@ module Sentry
       @before_send = value
     end
 
-    # Allows config options to be read like a hash
-    #
-    # @param [Symbol] option Key for a given attribute
-    def [](option)
-      public_send(option)
-    end
-
     def current_environment=(environment)
       @current_environment = environment.to_s
     end
@@ -234,8 +245,8 @@ module Sentry
     alias sending_allowed? capture_allowed?
 
     def error_messages
-      @errors = [errors[0]] + errors[1..-1].map(&:downcase) # fix case of all but first
-      errors.join(", ")
+      @errors = [@errors[0]] + @errors[1..-1].map(&:downcase) # fix case of all but first
+      @errors.join(", ")
     end
 
     def project_root=(root_dir)
@@ -259,6 +270,10 @@ module Sentry
       environments.empty? || environments.include?(current_environment)
     end
 
+    def tracing_enabled?
+      !!((@traces_sample_rate && @traces_sample_rate > 0.0) || @traces_sampler)
+    end
+
     private
 
     def detect_project_root
@@ -279,13 +294,17 @@ module Sentry
     end
 
     def excluded_exception?(incoming_exception)
-      excluded_exceptions.any? do |excluded_exception|
-        matches_exception?(get_exception_class(excluded_exception), incoming_exception)
+      excluded_exception_classes.any? do |excluded_exception|
+        matches_exception?(excluded_exception, incoming_exception)
       end
     end
 
+    def excluded_exception_classes
+      @excluded_exception_classes ||= excluded_exceptions.map { |e| get_exception_class(e) }
+    end
+
     def get_exception_class(x)
-      x.is_a?(Module) ? x : qualified_const_get(x)
+      x.is_a?(Module) ? x : safe_const_get(x)
     end
 
     def matches_exception?(excluded_exception_class, incoming_exception)
@@ -296,14 +315,9 @@ module Sentry
       end
     end
 
-    # In Ruby <2.0 const_get can't lookup "SomeModule::SomeClass" in one go
-    def qualified_const_get(x)
-      x = x.to_s
-      if !x.match(/::/)
-        Object.const_get(x)
-      else
-        x.split(MODULE_SEPARATOR).reject(&:empty?).inject(Object) { |a, e| a.const_get(e) }
-      end
+    def safe_const_get(x)
+      x = x.to_s unless x.is_a?(String)
+      Object.const_get(x)
     rescue NameError # There's no way to safely ask if a constant exist for an unknown string
       nil
     end

data/lib/sentry/dsn.rb

@@ -2,7 +2,10 @@ require "uri"
 
 module Sentry
   class DSN
-    attr_reader :scheme, :project_id, :public_key, :secret_key, :host, :port, :path
+    PORT_MAP = { 'http' => 80, 'https' => 443 }.freeze
+    REQUIRED_ATTRIBUTES = %w(host path public_key project_id).freeze
+
+    attr_reader :scheme, :secret_key, :port, *REQUIRED_ATTRIBUTES
 
     def initialize(dsn_string)
       @raw_value = dsn_string
@@ -24,7 +27,7 @@ module Sentry
     end
 
     def valid?
-      %w(host path public_key project_id).all? { |k| public_send(k) }
+      REQUIRED_ATTRIBUTES.all? { |k| public_send(k) }
     end
 
     def to_s
@@ -33,7 +36,7 @@ module Sentry
 
     def server
       server = "#{scheme}://#{host}"
-      server += ":#{port}" unless port == { 'http' => 80, 'https' => 443 }[scheme]
+      server += ":#{port}" unless port == PORT_MAP[scheme]
       server += path
       server
     end

data/lib/sentry/event.rb

@@ -13,21 +13,19 @@ module Sentry
       release environment server_name modules
       message user tags contexts extra
       fingerprint breadcrumbs backtrace transaction
-      platform sdk
+      platform sdk type
     )
 
     attr_accessor(*ATTRIBUTES)
-    attr_reader :id, :configuration
-
-    alias event_id id
+    attr_reader :configuration
 
     def initialize(configuration:, message: nil)
       # this needs to go first because some setters rely on configuration
       @configuration = configuration
 
       # Set some simple default values
-      @id            = SecureRandom.uuid.delete("-")
-      @timestamp     = Time.now.utc
+      @event_id      = SecureRandom.uuid.delete("-")
+      @timestamp     = Sentry.utc_now.iso8601
       @platform      = :ruby
       @sdk           = Sentry.sdk_meta
 
@@ -41,7 +39,7 @@ module Sentry
       @server_name = configuration.server_name
       @environment = configuration.current_environment
       @release = configuration.release
-      @modules = list_gem_specs if configuration.send_modules
+      @modules = configuration.gem_specs if configuration.send_modules
 
       @message = message || ""
 
@@ -51,8 +49,8 @@ module Sentry
     class << self
       def get_log_message(event_hash)
         message = event_hash[:message] || event_hash['message']
-        message = get_message_from_exception(event_hash) if message.empty?
-        message = '<no message value>' if message.empty?
+        message = get_message_from_exception(event_hash) if message.nil? || message.empty?
+        message = '<no message value>' if message.nil? || message.empty?
         message
       end
 
@@ -68,7 +66,7 @@ module Sentry
     end
 
     def timestamp=(time)
-      @timestamp = time.is_a?(Time) ? time.strftime('%Y-%m-%dT%H:%M:%S') : time
+      @timestamp = time.is_a?(Time) ? time.to_f : time
     end
 
     def level=(new_level) # needed to meet the Sentry spec
@@ -87,11 +85,12 @@ module Sentry
       end
     end
 
-    def to_hash
-      data = ATTRIBUTES.each_with_object({}) do |att, memo|
-        memo[att] = public_send(att) if public_send(att)
-      end
+    def type
+      "event"
+    end
 
+    def to_hash
+      data = serialize_attributes
       data[:breadcrumbs] = breadcrumbs.to_hash if breadcrumbs
       data[:stacktrace] = @stacktrace.to_hash if @stacktrace
       data[:request] = @request.to_hash if @request
@@ -141,9 +140,9 @@ module Sentry
         frame.in_app = line.in_app
         frame.module = line.module_name if line.module_name
 
-        if configuration[:context_lines] && frame.abs_path
+        if configuration.context_lines && frame.abs_path
           frame.pre_context, frame.context_line, frame.post_context = \
-            configuration.linecache.get_file_context(frame.abs_path, frame.lineno, configuration[:context_lines])
+            configuration.linecache.get_file_context(frame.abs_path, frame.lineno, configuration.context_lines)
         end
 
         memo << frame if frame.filename
@@ -152,6 +151,14 @@ module Sentry
 
     private
 
+    def serialize_attributes
+      self.class::ATTRIBUTES.each_with_object({}) do |att, memo|
+        if value = public_send(att)
+          memo[att] = value
+        end
+      end
+    end
+
     # When behind a proxy (or if the user is using a proxy), we can't use
     # REMOTE_ADDR to determine the Event IP, and must use other headers instead.
     def calculate_real_ip_from_rack(env)
@@ -162,10 +169,5 @@ module Sentry
         :forwarded_for => env["HTTP_X_FORWARDED_FOR"]
       ).calculate_ip
     end
-
-    def list_gem_specs
-      # Older versions of Rubygems don't support iterating over all specs
-      Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
-    end
   end
 end

data/lib/sentry/hub.rb

@@ -67,6 +67,12 @@ module Sentry
       @stack.pop
     end
 
+    def start_transaction(transaction: nil, **options)
+      transaction ||= Transaction.new(**options)
+      transaction.set_initial_sample_desicion
+      transaction
+    end
+
     def capture_exception(exception, **options, &block)
       return unless current_client
 
@@ -99,7 +105,7 @@ module Sentry
 
       event = current_client.capture_event(event, scope)
 
-      @last_event_id = event.id
+      @last_event_id = event.event_id
       event
     end
 

data/lib/sentry/rack.rb

@@ -2,3 +2,4 @@ require 'time'
 require 'rack'
 
 require 'sentry/rack/capture_exception'
+require 'sentry/rack/tracing'

data/lib/sentry/rack/tracing.rb

@@ -0,0 +1,39 @@
+module Sentry
+  module Rack
+    class Tracing
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        Sentry.clone_hub_to_current_thread unless Sentry.get_current_hub
+
+        if Sentry.configuration.traces_sample_rate.to_f == 0.0
+          return @app.call(env)
+        end
+
+        Sentry.with_scope do |scope|
+          scope.clear_breadcrumbs
+          scope.set_transaction_name(env["PATH_INFO"]) if env["PATH_INFO"]
+          span = Sentry.start_transaction(name: scope.transaction_name, op: "rack.request")
+          scope.set_span(span)
+
+          begin
+            response = @app.call(env)
+          rescue
+            finish_span(span, 500)
+            raise
+          end
+
+          finish_span(span, response[0])
+          response
+        end
+      end
+
+      def finish_span(span, status_code)
+        span.set_http_status(status_code)
+        span.finish
+      end
+    end
+  end
+end

data/lib/sentry/scope.rb

@@ -3,7 +3,7 @@ require "etc"
 
 module Sentry
   class Scope
-    ATTRIBUTES = [:transaction_names, :contexts, :extra, :tags, :user, :level, :breadcrumbs, :fingerprint, :event_processors, :rack_env]
+    ATTRIBUTES = [:transaction_names, :contexts, :extra, :tags, :user, :level, :breadcrumbs, :fingerprint, :event_processors, :rack_env, :span]
 
     attr_reader(*ATTRIBUTES)
 
@@ -20,6 +20,11 @@ module Sentry
       event.user = user.merge(event.user)
       event.extra = extra.merge(event.extra)
       event.contexts = contexts.merge(event.contexts)
+
+      if span
+        event.contexts[:trace] = span.get_trace_context
+      end
+
       event.fingerprint = fingerprint
       event.level ||= level
       event.transaction = transaction_names.last
@@ -52,6 +57,7 @@ module Sentry
       copy.user = user.deep_dup
       copy.transaction_names = transaction_names.deep_dup
       copy.fingerprint = fingerprint.deep_dup
+      copy.span = span
       copy
     end
 
@@ -63,6 +69,7 @@ module Sentry
       self.user = scope.user
       self.transaction_names = scope.transaction_names
       self.fingerprint = scope.fingerprint
+      self.span = scope.span
     end
 
     def update_from_options(
@@ -86,6 +93,11 @@ module Sentry
       @rack_env = env
     end
 
+    def set_span(span)
+      check_argument_type!(span, Span)
+      @span = span
+    end
+
     def set_user(user_hash)
       check_argument_type!(user_hash, Hash)
       @user = user_hash
@@ -130,6 +142,15 @@ module Sentry
       @transaction_names.last
     end
 
+    def get_transaction
+      # transaction will always be the first in the span_recorder
+      span.span_recorder.spans.first if span
+    end
+
+    def get_span
+      span
+    end
+
     def set_fingerprint(fingerprint)
       check_argument_type!(fingerprint, Array)
 
@@ -164,6 +185,7 @@ module Sentry
       @transaction_names = []
       @event_processors = []
       @rack_env = {}
+      @span = nil
     end
 
     class << self

data/lib/sentry/span.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+require "securerandom"
+
+module Sentry
+  class Span
+    STATUS_MAP = {
+      400 => "invalid_argument",
+      401 => "unauthenticated",
+      403 => "permission_denied",
+      404 => "not_found",
+      409 => "already_exists",
+      429 => "resource_exhausted",
+      499 => "cancelled",
+      500 => "internal_error",
+      501 => "unimplemented",
+      503 => "unavailable",
+      504 => "deadline_exceeded"
+    }
+
+
+    attr_reader :trace_id, :span_id, :parent_span_id, :sampled, :start_timestamp, :timestamp, :description, :op, :status, :tags, :data
+    attr_accessor :span_recorder
+
+    def initialize(description: nil, op: nil, status: nil, trace_id: nil, parent_span_id: nil, sampled: nil, start_timestamp: nil, timestamp: nil)
+      @trace_id = trace_id || SecureRandom.uuid.delete("-")
+      @span_id = SecureRandom.hex(8)
+      @parent_span_id = parent_span_id
+      @sampled = sampled
+      @start_timestamp = start_timestamp || Sentry.utc_now.to_f
+      @timestamp = timestamp
+      @description = description
+      @op = op
+      @status = status
+      @data = {}
+      @tags = {}
+    end
+
+    def set_span_recorder
+      @span_recorder = SpanRecorder.new(1000)
+      @span_recorder.add(self)
+    end
+
+    def finish
+      # already finished
+      return if @timestamp
+
+      @timestamp = Sentry.utc_now.to_f
+    end
+
+    def to_sentry_trace
+      sampled_flag = ""
+      sampled_flag = @sampled ? 1 : 0 unless @sampled.nil?
+
+      "#{@trace_id}-#{@span_id}-#{sampled_flag}"
+    end
+
+    def to_hash
+      {
+        trace_id: @trace_id,
+        span_id: @span_id,
+        parent_span_id: @parent_span_id,
+        start_timestamp: @start_timestamp,
+        timestamp: @timestamp,
+        description: @description,
+        op: @op,
+        status: @status,
+        tags: @tags,
+        data: @data
+      }
+    end
+
+    def get_trace_context
+      {
+        trace_id: @trace_id,
+        span_id: @span_id,
+        description: @description,
+        op: @op,
+        status: @status
+      }
+    end
+
+    def start_child(**options)
+      options = options.dup.merge(trace_id: @trace_id, parent_span_id: @span_id, sampled: @sampled)
+      child_span = Span.new(options)
+      child_span.span_recorder = @span_recorder
+
+      if @span_recorder && @sampled
+        @span_recorder.add(child_span)
+      end
+
+      child_span
+    end
+
+    def set_op(op)
+      @op = op
+    end
+
+    def set_description(description)
+      @description = description
+    end
+
+    def set_status(status)
+      @status = status
+    end
+
+    def set_timestamp(timestamp)
+      @timestamp = timestamp
+    end
+
+    def set_http_status(status_code)
+      status_code = status_code.to_i
+      set_data("status_code", status_code)
+
+      status =
+        if status_code >= 200 && status_code < 299
+          "ok"
+        else
+          STATUS_MAP[status_code]
+        end
+      set_status(status)
+    end
+
+    def set_data(key, value)
+      @data[key] = value
+    end
+
+    def set_tag(key, value)
+      @tags[key] = value
+    end
+
+    class SpanRecorder
+      attr_reader :max_length, :spans
+
+      def initialize(max_length)
+        @max_length = max_length
+        @spans = []
+      end
+
+      def add(span)
+        if @spans.count < @max_length
+          @spans << span
+        end
+      end
+    end
+  end
+end

data/lib/sentry/transaction.rb

@@ -0,0 +1,113 @@
+module Sentry
+  class Transaction < Span
+    SENTRY_TRACE_REGEXP = Regexp.new(
+      "^[ \t]*" +  # whitespace
+      "([0-9a-f]{32})?" +  # trace_id
+      "-?([0-9a-f]{16})?" +  # span_id
+      "-?([01])?" +  # sampled
+      "[ \t]*$"  # whitespace
+    )
+    UNLABELD_NAME = "<unlabeled transaction>".freeze
+    MESSAGE_PREFIX = "[Tracing]"
+
+    attr_reader :name, :parent_sampled
+
+    def initialize(name: nil, parent_sampled: nil, **options)
+      super(**options)
+
+      @name = name
+      @parent_sampled = parent_sampled
+      set_span_recorder
+    end
+
+    def self.from_sentry_trace(sentry_trace, **options)
+      return unless sentry_trace
+
+      match = SENTRY_TRACE_REGEXP.match(sentry_trace)
+      trace_id, parent_span_id, sampled_flag = match[1..3]
+
+      sampled = sampled_flag != "0"
+
+      new(trace_id: trace_id, parent_span_id: parent_span_id, parent_sampled: sampled, **options)
+    end
+
+    def to_hash
+      hash = super
+      hash.merge!(name: @name, sampled: @sampled, parent_sampled: @parent_sampled)
+      hash
+    end
+
+    def set_initial_sample_desicion(sampling_context = {})
+      unless Sentry.configuration.tracing_enabled?
+        @sampled = false
+        return
+      end
+
+      return unless @sampled.nil?
+
+      transaction_description = generate_transaction_description
+
+      logger = Sentry.configuration.logger
+      sample_rate = Sentry.configuration.traces_sample_rate
+      traces_sampler = Sentry.configuration.traces_sampler
+
+      if traces_sampler.is_a?(Proc)
+        sampling_context = sampling_context.merge(
+          parent_sampled: @parent_sampled,
+          transaction_context: self.to_hash
+        )
+
+        sample_rate = traces_sampler.call(sampling_context)
+      end
+
+      unless [true, false].include?(sample_rate) || (sample_rate.is_a?(Float) && sample_rate >= 0.0 && sample_rate <= 1.0)
+        @sampled = false
+        logger.warn("#{MESSAGE_PREFIX} Discarding #{transaction_description} because of invalid sample_rate: #{sample_rate}")
+        return
+      end
+
+      if sample_rate == 0.0 || sample_rate == false
+        @sampled = false
+        logger.debug("#{MESSAGE_PREFIX} Discarding #{transaction_description} because traces_sampler returned 0 or false")
+        return
+      end
+
+      if sample_rate == true
+        @sampled = true
+      else
+        @sampled = Random.rand < sample_rate
+      end
+
+      if @sampled
+        logger.debug("#{MESSAGE_PREFIX} Starting #{transaction_description}")
+      else
+        logger.debug(
+          "#{MESSAGE_PREFIX} Discarding #{transaction_description} because it's not included in the random sample (sampling rate = #{sample_rate})"
+        )
+      end
+    end
+
+    def finish(hub: nil)
+      super() # Span#finish doesn't take arguments
+
+      if @name.nil?
+        @name = UNLABELD_NAME
+      end
+
+      return unless @sampled
+
+      hub ||= Sentry.get_current_hub
+      event = hub.current_client.event_from_transaction(self)
+      hub.capture_event(event)
+    end
+
+    private
+
+    def generate_transaction_description
+      result = op.nil? ? "" : "<#{@op}> "
+      result += "transaction"
+      result += " <#{@name}>" if @name
+      result
+    end
+  end
+end

data/lib/sentry/transaction_event.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Sentry
+  class TransactionEvent < Event
+    ATTRIBUTES = %i(
+      event_id level timestamp start_timestamp
+      release environment server_name modules
+      user tags contexts extra
+      transaction platform sdk type
+    )
+
+    attr_accessor(*ATTRIBUTES)
+    attr_accessor :spans
+
+    def start_timestamp=(time)
+      @start_timestamp = time.is_a?(Time) ? time.to_f : time
+    end
+
+    def type
+      "transaction"
+    end
+
+    def to_hash
+      data = super
+      data[:spans] = @spans.map(&:to_hash) if @spans
+      data
+    end
+  end
+end

data/lib/sentry/transport.rb

@@ -32,10 +32,11 @@ module Sentry
       event
     rescue => e
       failed_for_exception(e, event)
+      nil
     end
 
     def generate_auth_header
-      now = Time.now.to_i.to_s
+      now = Sentry.utc_now.to_i
       fields = {
         'sentry_version' => PROTOCOL_VERSION,
         'sentry_client' => USER_AGENT,
@@ -48,11 +49,12 @@ module Sentry
 
     def encode(event_hash)
       event_id = event_hash[:event_id] || event_hash['event_id']
+      event_type = event_hash[:type] || event_hash['type']
 
       envelope = <<~ENVELOPE
-        {"event_id":"#{event_id}","dsn":"#{configuration.dsn.to_s}","sdk":#{Sentry.sdk_meta.to_json},"sent_at":"#{DateTime.now.rfc3339}"}
-        {"type":"event","content_type":"application/json"}
-        #{event_hash.to_json}
+        {"event_id":"#{event_id}","dsn":"#{configuration.dsn.to_s}","sdk":#{Sentry.sdk_meta.to_json},"sent_at":"#{Sentry.utc_now.iso8601}"}
+        {"type":"#{event_type}","content_type":"application/json"}
+        #{JSON.generate(event_hash)}
       ENVELOPE
 
       [CONTENT_TYPE, envelope]
@@ -86,7 +88,7 @@ module Sentry
     end
 
     def log_not_sending(event)
-      configuration.logger.warn(LOGGER_PROGNAME) { "Failed to submit event: #{Event.get_log_message(event.to_hash)}" }
+      configuration.logger.warn(LOGGER_PROGNAME) { "Failed to submit event. Unreported Event: #{Event.get_log_message(event.to_hash)}" }
     end
   end
 end

data/lib/sentry/transport/http_transport.rb

@@ -23,9 +23,12 @@ module Sentry
       end
     rescue Faraday::Error => e
       error_info = e.message
-      if e.response && e.response[:headers]['x-sentry-error']
-        error_info += " Error in headers is: #{e.response[:headers]['x-sentry-error']}"
+
+      if e.response
+        error_info += "\nbody: #{e.response[:body]}"
+        error_info += " Error in headers is: #{e.response[:headers]['x-sentry-error']}" if e.response[:headers]['x-sentry-error']
       end
+
       raise Sentry::Error, error_info
     end
 

data/lib/sentry/transport/state.rb

@@ -9,7 +9,7 @@ module Sentry
         return true if @status == :online
 
         interval = @retry_after || [@retry_number, 6].min**2
-        return true if Time.now - @last_check >= interval
+        return true if Sentry.utc_now - @last_check >= interval
 
         false
       end
@@ -17,7 +17,7 @@ module Sentry
       def failure(retry_after = nil)
         @status = :error
         @retry_number += 1
-        @last_check = Time.now
+        @last_check = Sentry.utc_now
         @retry_after = retry_after
       end
 

data/lib/sentry/version.rb

@@ -1,3 +1,3 @@
 module Sentry
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-11-13 00:00:00.000000000 Z
+date: 2020-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -46,6 +46,7 @@ files:
 - bin/setup
 - lib/sentry-ruby.rb
 - lib/sentry/backtrace.rb
+- lib/sentry/benchmarks/benchmark_transport.rb
 - lib/sentry/breadcrumb.rb
 - lib/sentry/breadcrumb/sentry_logger.rb
 - lib/sentry/breadcrumb_buffer.rb
@@ -65,7 +66,11 @@ files:
 - lib/sentry/logger.rb
 - lib/sentry/rack.rb
 - lib/sentry/rack/capture_exception.rb
+- lib/sentry/rack/tracing.rb
 - lib/sentry/scope.rb
+- lib/sentry/span.rb
+- lib/sentry/transaction.rb
+- lib/sentry/transaction_event.rb
 - lib/sentry/transport.rb
 - lib/sentry/transport/configuration.rb
 - lib/sentry/transport/dummy_transport.rb