treblle 1.0.3 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33af7f59af8142ab9221eeae5e96157831ebd85f103d282bbfe94527f3430a50
-  data.tar.gz: 46a242aba5acb59cc02eb83b7ddfecbdcafdaccf6b096a1d3130d1f5176b0898
+  metadata.gz: f42bc2d08d4eb451f07f8924e5ba73719b4c2e92c5b10de40ee7b28565750167
+  data.tar.gz: 16576e8b2c202f02c6d484ace4aa8fce5e1125b7feddd5f203953fc2238d5850
 SHA512:
-  metadata.gz: c4c40f9be2cdf09ef85ba0c2a9b8fc5ff8da22fd96356c8154602d1d48003ccb47a126f35cd27abf44b865d0299d6c6b8a25f7507d836fa38422156d7034f70a
-  data.tar.gz: 2546afe677f060122e034453992bf565d6008dd62fff234bf48aef93ac6c6251e34e4879baf1464a8e9669aeeba5f04eba77ceeeb4aeb4e28c1f26e04526795d
+  metadata.gz: 4807e68c43c329e0c770a30194724de8f49a231d171301ec6463d2894ccfeb4bc659ec72cc7ce077ac74e2a334c37def9a0fcbc70a6e91266d9b61e119236ae8
+  data.tar.gz: 6044a7c79673530ca87a84a5367e5dc102c2011e5ada7fd66e5aa7f4f6811e3c12606ee86e0dc15fc56df184655d9843993ebacbeb51a354eba1e87f8d277269

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (C) 2024 Treblle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,168 @@
+<div align="center">
+  <img src="https://treblle-github.s3.us-east-1.amazonaws.com/github-header.jpg"/>
+</div>
+<div align="center">
+
+# Treblle
+
+<a href="https://docs.treblle.com/en/integrations" target="_blank">Integrations</a>
+<span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+<a href="http://treblle.com/" target="_blank">Website</a>
+<span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+<a href="https://docs.treblle.com" target="_blank">Docs</a>
+<span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+<a href="https://blog.treblle.com" target="_blank">Blog</a>
+<span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+<a href="https://twitter.com/treblleapi" target="_blank">Twitter</a>
+<span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+<a href="https://treblle.com/chat" target="_blank">Discord</a>
+<br />
+
+  <hr />
+</div>
+
+Treblle is a lightweight SDK that helps Engineering and Product teams build, ship & maintain REST based APIs faster.
+
+## Features
+
+<div align="center">
+  <br />
+  <img src="https://treblle-github.s3.amazonaws.com/features.png"/>
+  <br />
+  <br />
+</div>
+
+- [API Monitoring & Observability](https://www.treblle.com/features/api-monitoring-observability)
+- [Auto-generated API Docs](https://www.treblle.com/features/auto-generated-api-docs)
+- [API analytics](https://www.treblle.com/features/api-analytics)
+- [Treblle API Score](https://www.treblle.com/features/api-quality-score)
+- [API Lifecycle Collaboration](https://www.treblle.com/features/api-lifecycle)
+- [Native Treblle Apps](https://www.treblle.com/features/native-apps)
+
+
+## How Treblle Works
+Once you’ve integrated a Treblle SDK in your codebase, this SDK will send requests and response data to your Treblle Dashboard.
+
+In your Treblle Dashboard you get to see real-time requests to your API, auto-generated API docs, API analytics like how fast the response was for an endpoint, the load size of the response, etc.
+
+Treblle also uses the requests sent to your Dashboard to calculate your API score which is a quality score that’s calculated based on the performance, quality, and security best practices for your API.
+
+> Visit [https://docs.treblle.com](http://docs.treblle.com) for the complete documentation.
+
+## Security
+
+### Masking fields
+Masking fields ensure certain sensitive data are removed before being sent to Treblle.
+
+To make sure masking is done before any data leaves your server [we built it into all our SDKs](https://docs.treblle.com/en/security/masked-fields#fields-masked-by-default).
+
+This means data masking is super fast and happens on a programming level before the API request is sent to Treblle. You can [customize](https://docs.treblle.com/en/security/masked-fields#custom-masked-fields) exactly which fields are masked when you’re integrating the SDK.
+
+> Visit the [Masked fields](https://docs.treblle.com/en/security/masked-fields) section of the [docs](https://docs.sailscasts.com) for the complete documentation.
+
+
+## Get Started
+
+1. Sign in to [Treblle](https://app.treblle.com).
+2. [Create a Treblle project](https://docs.treblle.com/en/dashboard/projects#creating-a-project).
+3. [Setup the SDK](#install-the-SDK) for your platform.
+
+#### SDK Requirements
+
+```ruby
+gem "rails", ">= 6.1"
+```
+
+### Install the SDK
+
+Add the gem to your Gemfile:
+
+```ruby
+# Gemfile
+gem "treblle", "~> 2.0"
+```
+Configure Treblle:
+
+```ruby
+# config/initializers/treblle.rb
+
+Treblle.configure do |config|
+  config.api_key               = ENV.fetch('TREBLLE_API_KEY')
+  config.project_id            = ENV.fetch('TREBLLE_PROJECT_ID')
+  config.enabled_environments  = %w[staging development]
+  config.sensitive_attrs       = %w[top_secret_custom_attribute password_digest]
+  config.restricted_endpoints  = %w[/api/users /api/v2/*]
+  config.whitelisted_endpoints = %w[/api/]
+end
+```
+
+- `config.api_key` (required)
+- `config.project_id` (required)
+- `config.enabled_environments` (required) - enables monitoring on specified environments
+- `config.sensitive_attrs` (optional) - mask additional attributes
+- `config.restricted_endpoints` (optional) - routes that you don't want to monitor
+- `config.whitelisted_endpoints` (optional) - routes that you want to monitor, by default `/api/`
+
+> See the [docs](https://docs.treblle.com/en/integrations/ruby) for this SDK to learn more.
+
+## Available SDKs
+
+Treblle provides [open-source SDKs](https://docs.treblle.com/en/integrations) that let you seamlessly integrate Treblle with your REST-based APIs.
+
+- [`treblle-laravel`](https://github.com/Treblle/treblle-laravel): SDK for Laravel
+- [`treblle-php`](https://github.com/Treblle/treblle-php): SDK for PHP
+- [`treblle-symfony`](https://github.com/Treblle/treblle-symfony): SDK for Symfony
+- [`treblle-lumen`](https://github.com/Treblle/treblle-lumen): SDK for Lumen
+- [`treblle-sails`](https://github.com/Treblle/treblle-sails): SDK for Sails
+- [`treblle-adonisjs`](https://github.com/Treblle/treblle-adonisjs): SDK for AdonisJS
+- [`treblle-fastify`](https://github.com/Treblle/treblle-fastify): SDK for Fastify
+- [`treblle-directus`](https://github.com/Treblle/treblle-directus): SDK for Directus
+- [`treblle-strapi`](https://github.com/Treblle/treblle-strapi): SDK for Strapi
+- [`treblle-express`](https://github.com/Treblle/treblle-express): SDK for Express
+- [`treblle-koa`](https://github.com/Treblle/treblle-koa): SDK for Koa
+- [`treblle-go`](https://github.com/Treblle/treblle-go): SDK for Go
+- [`treblle-ruby`](https://github.com/Treblle/treblle-ruby): SDK for Ruby on Rails
+- [`treblle-python`](https://github.com/Treblle/treblle-python): SDK for Python/Django
+
+> See the [docs](https://docs.treblle.com/en/integrations) for more on SDKs and Integrations.
+
+## Other Packages
+
+Besides the SDKs, we also provide helpers and configuration used for SDK
+development. If you're thinking about contributing to or creating a SDK, have a look at the resources
+below:
+
+- [`treblle-utils`](https://github.com/Treblle/treblle-utils):  A set of helpers and
+  utility functions useful for the JavaScript SDKs.
+- [`php-utils`](https://github.com/Treblle/php-utils):   A set of helpers and
+  utility functions useful for the PHP SDKs.
+
+## Community 💙
+
+First and foremost: **Star and watch this repository** to stay up-to-date.
+
+Also, follow our [Blog](https://blog.treblle.com), and on [Twitter](https://twitter.com/treblleapi).
+
+You can chat with the team and other members on [Discord](https://treblle.com/chat) and follow our tutorials and other video material at [YouTube](https://youtube.com/@treblle).
+
+[![Treblle Discord](https://img.shields.io/badge/Treblle%20Discord-Join%20our%20Discord-F3F5FC?labelColor=7289DA&style=for-the-badge&logo=discord&logoColor=F3F5FC&link=https://treblle.com/chat)](https://treblle.com/chat)
+
+[![Treblle YouTube](https://img.shields.io/badge/Treblle%20YouTube-Subscribe%20on%20YouTube-F3F5FC?labelColor=c4302b&style=for-the-badge&logo=YouTube&logoColor=F3F5FC&link=https://youtube.com/@treblle)](https://youtube.com/@treblle)
+
+[![Treblle on Twitter](https://img.shields.io/badge/Treblle%20on%20Twitter-Follow%20Us-F3F5FC?labelColor=1DA1F2&style=for-the-badge&logo=Twitter&logoColor=F3F5FC&link=https://twitter.com/treblleapi)](https://twitter.com/treblleapi)
+
+### How to contribute
+
+Here are some ways of contributing to making Treblle better:
+
+- **[Try out Treblle](https://docs.treblle.com/en/introduction#getting-started)**, and let us know ways to make Treblle better for you. Let us know here on [Discord](https://treblle.com/chat).
+- Join our [Discord](https://treblle.com/chat) and connect with other members to share and learn from.
+- Send a pull request to any of our [open source repositories](https://github.com/Treblle) on Github. Check the contribution guide on the repo you want to contribute to for more details about how to contribute. We're looking forward to your contribution!
+
+### Contributors
+<!-- Replace link with the link of the SDK contributors-->
+<a href="https://github.com/Treblle/treblle-ruby/graphs/contributors">
+  <p align="center">
+    <img  src="https://contrib.rocks/image?repo=Treblle/treblle-ruby" alt="A table of avatars from the project's contributors" />
+  </p>
+</a>

data/SECURITY.md

@@ -0,0 +1,12 @@
+# Security Policy
+
+## Supported versions
+
+The current release series and the next most recent one (by major-minor version) will receive patches and new versions in case of a security issue.
+
+### Unsupported Release Series
+
+When a release series is no longer supported, it’s your own responsibility to deal with bugs and security issues. If you are not comfortable maintaining your own versions, you should upgrade to a supported version.
+
+## Reporting a security issue
+Contact the Treblle support at treblle.com.

data/lib/treblle/configuration.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative 'errors/configuration_errors'
+
+module Treblle
+  class Configuration
+    DEFAULT_SENSITIVE_ATTRS = %w[
+      card_number
+      cardNumber
+      cc
+      ccv
+      credit_score
+      creditScore
+      password
+      password_confirmation
+      passwordConfirmation
+      pwd
+      secretn
+      ssn
+    ].freeze
+
+    attr_accessor :restricted_endpoints, :whitelisted_endpoints,
+      :api_key, :project_id, :app_version
+    attr_reader :sensitive_attrs, :enabled_environments
+
+    def initialize
+      @restricted_endpoints = []
+      @whitelisted_endpoints = '/api/'
+      @app_version = nil
+      @sensitive_attrs = DEFAULT_SENSITIVE_ATTRS
+    end
+
+    def monitoring_enabled?(request_url)
+      whitelisted_endpoint?(request_url) && !restricted_endpoint?(request_url)
+    end
+
+    def sensitive_attrs=(attributes)
+      @sensitive_attrs = attributes ? DEFAULT_SENSITIVE_ATTRS + attributes : DEFAULT_SENSITIVE_ATTRS
+    end
+
+    def enabled_environments=(value)
+      @enabled_environments = Array(value)
+    end
+
+    def enabled_environment?
+      return false if enabled_environments.empty?
+
+      enabled_environments.include?(environment)
+    end
+
+    def validate_credentials!
+      raise Errors::MissingApiKeyError if api_key.to_s.empty?
+      raise Errors::MissingProjectIdError if project_id.to_s.empty?
+    end
+
+    private
+
+    def environment
+      @environment || ::Rails.env
+    end
+
+    def whitelisted_endpoint?(request_url)
+      Array(whitelisted_endpoints).any? do |endpoint|
+        request_url.start_with?(endpoint)
+      end
+    end
+
+    def restricted_endpoint?(request_url)
+      restricted_endpoints.any? do |endpoint|
+        pattern = Regexp.escape(endpoint).gsub('\*', '.*')
+        Regexp.new("^#{pattern}$") =~ request_url
+      end
+    end
+  end
+end

data/lib/treblle/dispatcher.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/http'
+require 'securerandom'
+require 'treblle/logging'
+
+module Treblle
+  class Dispatcher
+    include Logging
+
+    TREBLLE_URIS = %w[
+      https://rocknrolla.treblle.com
+      https://punisher.treblle.com
+      https://sicario.treblle.com
+    ].freeze
+
+    def initialize(payload:, configuration: Treblle.configuration)
+      @payload = payload
+      @uri = get_uri
+      @configuration = configuration
+    end
+
+    def call
+      send_payload_to_treblle
+    end
+
+    private
+
+    attr_reader :payload, :uri, :configuration
+
+    def get_uri
+      URI(TREBLLE_URIS.sample)
+    end
+
+    def send_payload_to_treblle
+      Thread.new do
+        response = make_http_request
+
+        if response.code.to_i >= 400
+          log_error(response.body)
+        else
+          log_success(response.body)
+        end
+      rescue StandardError => e
+        log_error(e.message)
+      end
+    end
+
+    def make_http_request
+      http = Net::HTTP.new(uri.hostname, uri.port)
+      http.use_ssl = true
+      http.read_timeout = 2
+      http.open_timeout = 2
+
+      http.start do |http_instance|
+        http_instance.request(build_request)
+      end
+    end
+
+    def build_request
+      req = Net::HTTP::Post.new(uri)
+      req['Content-Type'] = 'application/json'
+      req['x-api-key'] = configuration.api_key
+      req['x-treblle-trace-id'] = SecureRandom.uuid
+      req.body = payload
+      req
+    end
+  end
+end

data/lib/treblle/errors/configuration_errors.rb

@@ -0,0 +1,21 @@
+module Treblle
+  module Errors
+    class ConfigurationError < StandardError
+      def initialize(msg = "Configuration error")
+        super(msg)
+      end
+    end
+
+    class MissingApiKeyError < ConfigurationError
+      def initialize(msg = "API key is missing")
+        super(msg)
+      end
+    end
+
+    class MissingProjectIdError < ConfigurationError
+      def initialize(msg = "Project ID is missing")
+        super(msg)
+      end
+    end
+  end
+end

data/lib/treblle/generate_payload.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'treblle/version'
+require 'treblle/utils/hash_sanitizer'
+
+module Treblle
+  class GeneratePayload
+    SDK_LANG = 'ruby'
+    TIME_FORMAT = '%Y-%m-%d %H:%M:%S'
+
+    def initialize(request:, response:, started_at:, configuration: Treblle.configuration)
+      @request = request
+      @response = response
+      @started_at = started_at
+      @configuration = configuration
+    end
+
+    def call
+      payload.to_json
+    end
+
+    private
+
+    attr_reader :request, :response, :started_at, :configuration
+
+    def sanitize(body)
+      Utils::HashSanitizer.sanitize(body, configuration.sensitive_attrs)
+    end
+
+    def timestamp
+      started_at.strftime(TIME_FORMAT)
+    end
+
+    def load_time
+      Time.now - started_at
+    end
+
+    def payload
+      {
+        api_key: configuration.api_key,
+        project_id: configuration.project_id,
+        version: Treblle::API_VERSION,
+        sdk: SDK_LANG,
+        data: {
+          server: {
+            ip: request.server.remote_addr,
+            timezone: request.server.timezone,
+            software: request.server.software,
+            signature: '',
+            protocol: request.server.protocol,
+            os: {
+              name: request.server.os_name,
+              release: '',
+              architecture: request.server.os_architecture
+            }
+          },
+          language: {
+            name: SDK_LANG,
+            version: RUBY_VERSION
+          },
+          request: {
+            timestamp: timestamp,
+            ip: request.client.ip,
+            url: request.client.url,
+            user_agent: request.client.user_agent,
+            method: request.method,
+            headers: request.headers,
+            body: sanitize(request.body)
+          },
+          response: {
+            headers: response.headers,
+            code: response.status,
+            size: response.size,
+            load_time: load_time,
+            body: response.body,
+            errors: errors
+          }
+        }
+      }
+    end
+
+    def errors
+      return [] if response.exception.nil?
+
+      [{
+        source: 'onError',
+        type: response.exception.type,
+        message: response.exception.message,
+        file: response.exception.file_path,
+        line: response.exception.line_number
+      }]
+    end
+  end
+end

data/lib/treblle/logging.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Treblle
+  module Logging
+    def logger
+      @logger ||= Logger.new($stdout)
+    end
+
+    def log_error(message)
+      logger.error("Treblle monitoring failed: #{message}")
+    end
+
+    def log_success(message)
+      logger.info("Successfully sent to Treblle: #{message}")
+    end
+  end
+end

data/lib/treblle/middleware.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'treblle/dispatcher'
+require 'treblle/request_builder'
+require 'treblle/response_builder'
+require 'treblle/generate_payload'
+require 'treblle/logging'
+require 'treblle'
+
+module Treblle
+  class Middleware
+    include Logging
+
+    def initialize(app, configuration: Treblle.configuration)
+      @app = app
+      @configuration = configuration
+    end
+
+    def call(env)
+      if should_monitor?(env)
+        call_with_treblle_monitoring(env)
+      else
+        @app.call(env)
+      end
+    end
+
+    private
+
+    attr_reader :configuration
+
+    def call_with_treblle_monitoring(env)
+      started_at = Time.now
+
+      response = @app.call(env)
+      handle_monitoring(env, response, started_at)
+
+      response
+    end
+
+    def handle_monitoring(env, rack_response, started_at)
+      request = RequestBuilder.new(env).build
+      response = ResponseBuilder.new(rack_response).build
+      payload = GeneratePayload.new(request: request, response: response, started_at: started_at).call
+
+      Dispatcher.new(payload: payload).call
+    rescue StandardError => e
+      log_error(e.message)
+    end
+
+    def should_monitor?(env)
+      configuration.enabled_environment? && configuration.monitoring_enabled?(env['PATH_INFO'])
+    end
+  end
+end

data/lib/treblle/models/request/client.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Treblle
+  module Models
+    class Request
+      class Client
+        def initialize(request)
+          @ip = request.ip
+          @url = request.original_url
+          @user_agent = request.user_agent
+        end
+
+        attr_reader :ip, :url, :user_agent
+      end
+    end
+  end
+end

data/lib/treblle/models/request/server.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module Treblle
+  module Models
+    class Request
+      class Server
+        def initialize(request)
+          @request = request
+          @software = get_server_software
+          @protocol = get_server_protocol
+          @os_architecture = get_platform
+          @os_name = get_host_os
+          @timezone = get_timezone
+          @remote_addr = get_remote_addr
+        end
+
+        attr_reader :software, :protocol, :os_name, :os_architecture, :remote_addr, :timezone
+
+        private
+
+        attr_reader :request
+
+        def get_host_os
+          RbConfig::CONFIG.fetch('host_os', 'unknown')
+        end
+
+        def get_platform
+          Gem::Platform.local.os
+        end
+
+        def get_remote_addr
+          request.env.fetch('REMOTE_ADDR', '')
+        end
+
+        def get_server_software
+          request.env.fetch('SERVER_SOFTWARE', '')
+        end
+
+        def get_server_protocol
+          request.env.fetch('SERVER_PROTOCOL', '')
+        end
+
+        def get_timezone
+          Time.now.zone
+        end
+      end
+    end
+  end
+end

data/lib/treblle/models/request.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Treblle
+  module Models
+    class Request
+      attr_accessor :server, :client, :method, :headers, :body
+    end
+  end
+end

data/lib/treblle/models/response/exception.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Treblle
+  module Models
+    class Response
+      class Exception
+        def initialize(response)
+          @response = response
+          @trace = fetch_trace
+          @type = fetch_type
+          @message = fetch_message
+          @file_path, @line_number = get_exception_path_and_line
+        end
+
+        attr_reader :file_path, :line_number, :message, :type, :trace
+
+        private
+
+        attr_reader :response
+
+        def fetch_trace
+          response.body.dig("traces", "Application Trace")&.first&.[]("trace")
+        end
+
+        def fetch_type
+          response.body["error"] || response.body["errors"] || 'Unhandled error'
+        end
+
+        def fetch_message
+          response.body["exception"] || response.body["error"] || response.body["errors"]
+        end
+
+        def get_exception_path_and_line
+          return [nil, nil] if trace.nil?
+
+          match_data = trace.match(/^(.*):(\d+):in `.*'$/)
+          return [nil, nil] if match_data.nil?
+
+          file_path = match_data[1]
+          line_number = match_data[2]
+
+          [file_path, line_number]
+        end
+      end
+    end
+  end
+end

data/lib/treblle/models/response.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Treblle
+  module Models
+    class Response
+      attr_accessor :status, :headers, :body, :size, :exception
+    end
+  end
+end

data/lib/treblle/rails/railtie.rb

@@ -0,0 +1,12 @@
+require 'treblle/middleware'
+require 'rails'
+
+module Treblle
+  module Rails
+    class Railtie < ::Rails::Railtie
+      initializer 'treblle.install_middleware' do |app|
+        app.config.middleware.insert_after ActionDispatch::ShowExceptions, Treblle::Middleware
+      end
+    end
+  end
+end

data/lib/treblle/request_builder.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'treblle/models/request'
+require 'treblle/models/request/server'
+require 'treblle/models/request/client'
+require 'action_dispatch'
+
+module Treblle
+  class RequestBuilder
+    MAX_BODY_LENGTH = 2048
+
+    HEADER_PREFIXES = %w[
+      HTTP AUTHORIZATION QUERY CONTENT REMOTE
+      REQUEST SERVER ACCEPT USER HOST X PATH
+      VARY REFERRER
+    ].freeze
+
+    def initialize(rack_env)
+      @rack_env = rack_env
+    end
+
+    def build
+      Models::Request.new.tap do |request|
+        apply_to_request(request)
+      end
+    end
+
+    private
+
+    attr_reader :rack_env
+
+    def apply_to_request(request)
+      request_metadata = ActionDispatch::Request.new(rack_env)
+
+      request.server = Models::Request::Server.new(request_metadata)
+      request.client = Models::Request::Client.new(request_metadata)
+      request.method = request_metadata.method
+      request.headers = get_headers(request_metadata)
+      request.body = get_body(request_metadata)
+
+      request
+    end
+
+    def get_headers(request_metadata)
+      request_metadata.headers.select { |header, _value| header_to_include?(header) }.to_h
+                      .transform_keys { |header| normalize_header(header) }
+    end
+
+    def normalize_header(header)
+      header.delete_prefix('HTTP_').tr('_', '-')
+    end
+
+    def header_to_include?(header)
+      return false if header.start_with?('rack', 'puma')
+
+      HEADER_PREFIXES.any? do |prefix|
+        header.to_s.start_with?(prefix)
+      end
+    end
+
+    def get_body(request_metadata)
+      case request_metadata.media_type
+      when 'application/x-www-form-urlencoded', 'multipart/form-data'
+        request_metadata.POST.dup
+      else
+        body = request_metadata.body.read
+        request_metadata.body.rewind
+        body.byteslice(0, MAX_BODY_LENGTH).force_encoding('utf-8').scrub
+
+        request_metadata.media_type == 'application/json' ? JSON.parse(body) : body
+      end
+    end
+  end
+end

data/lib/treblle/response_builder.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'treblle/models/response'
+require 'treblle/models/response/exception'
+require 'active_support'
+require 'json'
+
+module Treblle
+  class ResponseBuilder
+    def initialize(rack_response)
+      @rack_response = rack_response
+    end
+
+    def build
+      Models::Response.new.tap do |response|
+        apply_to_response(response)
+      end
+    end
+
+    private
+
+    attr_reader :rack_response, :handle_errors
+
+    def apply_to_response(response)
+      status, headers, response_data = rack_response || [500, [], nil]
+
+      response.status = status
+      response.headers = headers
+      response.body = parse_body(response_data) || parse_error_body(response_data)
+      response.size = calculate_size(response.body, response.headers)
+      response.exception = Models::Response::Exception.new(response) if status >= 400
+
+      response
+    end
+
+    def calculate_size(body, headers)
+      return 0 if body.nil?
+
+      headers.fetch('content-length', nil) || ActiveSupport::JSON.encode(body).size
+    end
+
+    def parse_body(response_data)
+      return nil unless response_data.respond_to?(:body)
+
+      JSON.parse(response_data.body)
+    rescue JSON::ParserError
+      response_data.body
+    end
+
+    def parse_error_body(response_data)
+      return nil unless response_data.is_a?(Array) && !response_data.empty?
+
+      JSON.parse(response_data.first)
+    rescue JSON::ParserError
+      response_data.body
+    end
+  end
+end

data/lib/treblle/utils/hash_sanitizer.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Treblle
+  module Utils
+    class HashSanitizer
+      class << self
+        def sanitize(body, sensitive_attrs)
+          return {} if body.nil? || body.empty?
+          return hash unless body.is_a?(Hash) || body.is_a?(Array)
+
+          if body.is_a?(Hash)
+            sanitize_hash(body, sensitive_attrs)
+          elsif body.is_a?(Array)
+            sanitize_array(body, sensitive_attrs)
+          end
+        end
+
+        private
+
+        def sanitize_hash(hash, sensitive_attrs)
+          hash.each_with_object({}) do |(key, value), result|
+            result[key] = if value.is_a?(Hash) || value.is_a?(Array)
+                            sanitize(value, sensitive_attrs)
+                          else
+                            sanitize_value(key, value, sensitive_attrs)
+                          end
+          end
+        end
+
+        def sanitize_array(array, sensitive_attrs)
+          array.map { |item| sanitize(item, sensitive_attrs) }
+        end
+
+        def sanitize_value(key, value, sensitive_attrs)
+          sensitive_attrs.include?(key.to_s) ? '*' * value.to_s.length : value
+        end
+      end
+    end
+  end
+end

data/lib/treblle/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Treblle
+  VERSION = '2.0.2'
+  API_VERSION = '0.6'
+end

data/lib/treblle.rb

@@ -1,93 +1,20 @@
 # frozen_string_literal: true
 
-require 'uri'
-require 'net/http'
-require 'treblle/data_builder'
+require 'treblle/middleware'
+require 'treblle/configuration'
+require 'treblle/rails/railtie'
 
 # 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
+module Treblle
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
     end
 
-    [status, headers, response]
-  end
+    def configure
+      yield(configuration)
 
-  # 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
-    res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
-      http.request(req)
+      configuration.validate_credentials! if configuration.enabled_environment?
     end
-    puts 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

@@ -1,23 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: treblle
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 2.0.2
 platform: ruby
 authors:
-- Hrvoje Grdic
+- Borna Kapusta
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-01 00:00:00.000000000 Z
-dependencies: []
-description: TreblleSDK for ruby
-email: hrvoje.grdic@bitlab.hr
+date: 2024-03-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.1.0
+description: |
+  Treblle is a lightweight SDK that helps Engineering and Product teams
+   build, ship & maintain REST based APIs faster.
+email: borna.kapusta@cactus-code.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- MIT-LICENSE
+- README.md
+- SECURITY.md
 - lib/treblle.rb
-- lib/treblle/data_builder.rb
+- lib/treblle/configuration.rb
+- lib/treblle/dispatcher.rb
+- lib/treblle/errors/configuration_errors.rb
+- lib/treblle/generate_payload.rb
+- lib/treblle/logging.rb
+- lib/treblle/middleware.rb
+- lib/treblle/models/request.rb
+- lib/treblle/models/request/client.rb
+- lib/treblle/models/request/server.rb
+- lib/treblle/models/response.rb
+- lib/treblle/models/response/exception.rb
+- lib/treblle/rails/railtie.rb
+- lib/treblle/request_builder.rb
+- lib/treblle/response_builder.rb
+- lib/treblle/utils/hash_sanitizer.rb
+- lib/treblle/version.rb
 homepage: https://rubygems.org/gems/treblle
 licenses:
 - MIT
@@ -37,8 +71,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.5.6
 signing_key:
 specification_version: 4
-summary: TreblleSDK
+summary: Middleware for monitoring your API endpoints
 test_files: []

data/lib/treblle/data_builder.rb

@@ -1,142 +0,0 @@
-# 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)
-        }
-      }
-    }
-
-    begin
-      data.to_json
-    rescue Exception
-      JSON.dump(data)
-    end
-  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