treblle 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ec91ab95442d3471d51d7b7c23baf9c3129e89baa265af101b95db188e1c323b
+  data.tar.gz: 44076ace1dc079742312999cfe5e3b73eaee7a2960beb6211dbf6b1e73789445
+SHA512:
+  metadata.gz: bab469e6487bab98fa3e3a92af832e22c58aff4dd8c6ddf02f3d0b55d6c7c51959933426fa84b97f05200f8d2cfc673d3fe868fbb12aad49243914fb9da9c266
+  data.tar.gz: d6caa192c3a881d974f993c7e492e63f5c87b6f7966d8ba99b2a737cbb7d2f58c7798c366b6d920bff06d1d2255da9cc602b267d3072744644128a39b6707a48

data/lib/treblle/data_builder.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+# Gathers and builds body payload to be sent to Treblle in json format.
+# Hides sensitive data based on default values and additional ones provided via env variable.
+class DataBuilder
+  DEFAULT_SENSITIVE_FIELDS = Set[
+    'card_number',
+    'cardNumber',
+    'cc',
+    'ccv',
+    'credit_score',
+    'creditScore',
+    'password',
+    'password_confirmation',
+    'passwordConfirmation',
+    'pwd',
+    'secret',
+    'ssn'
+  ].freeze
+
+  attr_accessor :env, :status, :started_at, :ended_at, :request, :headers, :json_response, :exception
+
+  def initialize(params)
+    @ended_at = params[:ended_at]
+    @env = params[:env]
+    @exception = params[:exception]
+    @headers = params[:headers]
+    @json_response = params[:json_response]
+    @request = params[:request]
+    @started_at = params[:started_at]
+    @status = params[:status]
+  end
+
+  def call
+    time_spent = ended_at - started_at
+    user_agent = env['HTTP_USER_AGENT']
+    ip = env['action_dispatch.remote_ip'].calculate_ip
+    request_method = env['REQUEST_METHOD']
+    project_id = ENV.fetch('TREBLLE_PROJECT_ID') { '' }
+    request_body = request_method.downcase == 'get' ? request.query_parameters : safe_to_json(request.raw_post)
+
+    data = {
+      api_key: ENV.fetch('TREBLLE_API_KEY') { '' },
+      project_id: project_id,
+      version: Treblle::TREBLLE_VERSION,
+      sdk: 'ruby',
+      data: {
+        server: {
+          ip: server_ip,
+          timezone: Time.zone.name,
+          software: request_headers.try(:[], 'SERVER_SOFTWARE'),
+          signature: '',
+          protocol: request_headers.try(:[], 'SERVER_PROTOCOL'),
+          os: {}
+        },
+        language: {
+          name: 'ruby',
+          version: RUBY_VERSION
+        },
+        request: {
+          timestamp: started_at.to_formatted_s(:db),
+          ip: ip,
+          url: request.original_url,
+          user_agent: user_agent,
+          method: request_method,
+          headers: request_headers,
+          body: without_sensitive_attrs(request_body)
+        },
+        response: {
+          headers: headers || {},
+          code: status,
+          size: json_response&.to_json&.bytesize || 0,
+          load_time: time_spent,
+          body: without_sensitive_attrs(json_response),
+          errors: build_error_object(exception)
+        }
+      }
+    }
+
+    data.to_json
+  end
+
+  private
+
+  def without_sensitive_attrs(obj)
+    return {} unless obj.present?
+
+    obj.each do |k, v|
+      value = v || k
+      if value.is_a?(Hash) || value.is_a?(Array)
+        without_sensitive_attrs(value)
+      elsif sensitive_attrs.include?(k.to_s)
+        obj[k] = '*' * v.to_s.length
+      end
+    end
+    obj
+  rescue StandardError => e
+    Rails.logger.error e.message
+  end
+
+  def sensitive_attrs
+    @sensitive_attrs ||= user_sensitive_fields.merge(DEFAULT_SENSITIVE_FIELDS)
+  end
+
+  def user_sensitive_fields
+    fields = ENV.fetch('TREBLLE_SENSITIVE_FIELDS') { '' }.gsub(/\s+/, '')
+    fields.split(',').to_set
+  end
+
+  def build_error_object(exception)
+    return [] unless exception.present?
+
+    [
+      {
+        source: 'onError',
+        type: exception.class.to_s || 'Unhandled error',
+        message: exception.message,
+        file: exception.backtrace.try(:first) || ''
+      }
+    ]
+  end
+
+  def server_ip
+    Socket.ip_address_list.find { |ai| ai.ipv4? && !ai.ipv4_loopback? }.ip_address
+  end
+
+  def request_headers
+    @request_headers ||= request.headers.env.reject { |key| key.to_s.include?('.') }
+  end
+
+  def safe_to_json(obj)
+    JSON.parse(obj)
+  rescue StandardError => e
+    {}
+  end
+end

data/lib/treblle.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/http'
+require 'treblle/data_builder'
+
+# Treblle middleware for request interception and gathering.
+class Treblle
+  TREBLLE_URI = 'https://rocknrolla.treblle.com'
+  TREBLLE_VERSION = '0.6'
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    request = ActionDispatch::Request.new(env)
+    started_at = Time.now
+
+    begin
+      status, headers, response = @app.call(env)
+      to_parse = response.clone
+      to_parse = to_parse.try(:body) if to_parse.respond_to?(:body)
+
+      begin
+        json_response = JSON.parse(to_parse)
+      rescue JSON::ParserError, TypeError
+        # continue with original values when unable to parse reponse to json
+        return [status, headers, response]
+      end
+
+      params = {
+        ended_at: Time.now,
+        env: env,
+        headers: headers,
+        json_response: json_response,
+        request: request,
+        started_at: started_at,
+        status: status
+      }
+      capture(params)
+    rescue Exception => e
+      status = status_code_for_exception(e)
+      params = {
+        ended_at: Time.now,
+        env: env,
+        exception: e,
+        headers: headers,
+        request: request,
+        started_at: started_at,
+        status: status
+      }
+      # send error payload to treblle, but raise exception as well
+      capture(params)
+      raise e
+    end
+
+    [status, headers, response]
+  end
+
+  # Creates data to send in a format that Treblle expects and does the sending in a new thread
+  # for perfomance reasons.
+  # @param [Object] params
+  def capture(params)
+    data = DataBuilder.new(params).call
+    return if data&.bytesize.to_i > 2.megabytes # ignore the capture for unnaturally large requests
+
+    Thread.new do
+      send_to_treblle(data)
+    end
+  rescue Exception => e
+    Rails.logger.error(e.message)
+  end
+
+  def send_to_treblle(data)
+    uri = URI(TREBLLE_URI)
+    req = Net::HTTP::Post.new(uri)
+    req['Content-Type'] = 'application/json'
+    req['x-api-key'] = ENV.fetch('TREBLLE_API_KEY') { '' }
+    req.body = data
+    puts data
+    res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+      http.request(req)
+    end
+    res.try(:body)
+  end
+
+  def status_code_for_exception(exception)
+    exception_wrapper = ActionDispatch::ExceptionWrapper.new(nil, exception)
+    exception_wrapper.status_code
+  rescue
+    500
+  end
+end

metadata

@@ -0,0 +1,44 @@
+--- !ruby/object:Gem::Specification
+name: treblle
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Hrvoje Grdic
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-09-02 00:00:00.000000000 Z
+dependencies: []
+description: TreblleSDK for ruby
+email: hrvoje.grdic@bitlab.hr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/treblle.rb
+- lib/treblle/data_builder.rb
+homepage: https://rubygems.org/gems/treblle
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: TreblleSDK
+test_files: []