plain_apm 0.2.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ef383306da20d00a0bc5c8b2072b1dfbb3d49eb7c5d1f0710cee6d6749b726d2
+  data.tar.gz: b5c174eb5869f5909695af612182f2e9e6fe960230ce4ecd2d94b4701c5856fc
+SHA512:
+  metadata.gz: 86dc64bd65c57fc77f4713f10bf08beeff9f32c7f9e80e3fc454b4462ff14a4cfc0613bd24879d2ec08e2692e9e35eb3ccad49b015cbfc3e331e9bcbdf4e45b9
+  data.tar.gz: 6f79c406f73217c44c06a46359722fb1ecb8d8c72e1c6de8ed5846992cab12ba56dc4c36fac18919896ab1f002a98129301d28cefde8502ccd32d7f6319f82c6

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in plainapm.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 PlainAPM
+
+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 OR COPYRIGHT HOLDERS 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,37 @@
+# PlainApm for Ruby
+
+[PlainAPM][plainapm] monitors your Rails application and helps you
+understand changes in its performance.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'plain_apm'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install plain_apm
+
+## Usage
+
+To be able to use the gem, collect, and view your app's performance
+metrics, request an APP key on [plainapm web site][plainapm] and follow
+the installation instructions.
+
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub][github-issues].
+
+Alternatively, feel free to send questions, suggestions, and feedback
+to [PlainAPM support][support-email].
+
+[plainapm]: https://plainapm.com
+[support-email]: mailto:support@plainapm.com
+[github-issues]: https://github.com/plainapm/plainapm-ruby/issues

data/Rakefile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "appraisal"
+require "standard/rake"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+namespace :test do
+  task all: "appraisal:all"
+end
+
+task default: :test

data/lib/plain_apm/agent.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "singleton"
+require "json"
+
+module PlainApm
+  class Agent
+    include Singleton
+
+    def self.collect(event)
+      instance.collect(event)
+    end
+
+    def self.start
+      instance.start
+    end
+
+    def collect(event)
+      return unless @config.enabled
+
+      @events << event.merge(
+        "collected_at" => Time.now.utc.to_f,
+        "pid" => Process.pid,
+        "thread_id" => Thread.current.object_id.to_s
+      )
+    end
+
+    def start
+      return unless @publisher.nil?
+      return unless @config.enabled
+
+      # TODO: sized queue w/ a timeout.
+      @events = Thread::Queue.new
+
+      # TODO: Multiple threads
+      @publisher = Thread.new { publisher_loop }
+
+      install_hooks
+
+      # TODO: add a cleaner shutdown.
+      at_exit { shutdown }
+    end
+
+    private
+
+    def initialize
+      # TODO: validate config
+      @config = Config.new
+
+      super
+    end
+
+    def install_hooks
+      [
+        Hooks::Deploy,
+        Hooks::ActionMailer,
+        Hooks::ActionPack,
+        Hooks::ActionView,
+        Hooks::ActiveJob,
+        Hooks::ActiveRecord,
+        Hooks::ErrorReporter
+      ].map(&:new).each(&:install)
+    end
+
+    def shutdown
+      return if @publisher.nil?
+
+      @events << nil
+      @publisher.join
+    end
+
+    ##
+    # Run a background thread that pops events from the queue and posts them to
+    # the target server.
+    def publisher_loop
+      # Have the thread keep it's own connection.
+      transport = Transport.new(
+        endpoint: @config.endpoint,
+        app_key: @config.app_key
+      )
+
+      loop do
+        event = @events.pop
+
+        break if event.nil?
+
+        # TODO: event serialization
+        _response, _error, _retriable = transport.deliver(JSON.generate(event))
+
+        # TODO: retries / drops
+      end
+    end
+  end
+end

data/lib/plain_apm/backoff.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module PlainApm
+  class Backoff
+    ##
+    # Exponential backoff with jitter.
+
+    DEFAULT_BASE_SECONDS = 1.5
+    DEFAULT_MAX_RETRIES = 10 # sum_0^10 1.5 ** k ~ 170s
+    DEFAULT_JITTER_MULTIPLIER = 0.2 # % of the current retry interval
+
+    ##
+    # @param base_seconds [Integer] base of the exponential retry.
+    # @param max_retries [Integer] maximum retries to perform.
+    # @param jitter_multiplier [Float] % of the current retry interval to use for jitter.
+    def initialize(base_seconds: nil, max_retries: nil, jitter_multiplier: nil)
+      @base_seconds = base_seconds || DEFAULT_BASE_SECONDS
+      @max_retries = max_retries || DEFAULT_MAX_RETRIES
+      @jitter_multiplier = jitter_multiplier || DEFAULT_JITTER_MULTIPLIER
+    end
+
+    ##
+    # @param retries [Integer] Number of current retry attempts.
+    #
+    # @return [Integer|nil] Amount of time slept, or nil if out of retries.
+    def delay_time(retries:)
+      return if retries >= max_retries
+
+      base_interval = (base_seconds**retries)
+      jitter_interval = base_interval * jitter_multiplier
+
+      # The random factor is never -1, but that shouldn't be an issue.
+      base_interval + jitter_interval * (1.0 - 2.0 * rand)
+    end
+
+    private
+
+    attr_reader :base_seconds, :max_retries, :jitter_multiplier
+  end
+end

data/lib/plain_apm/config.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module PlainApm
+  class Config
+    DEFAULT_EVENT_ENDPOINT = "https://ingest.plainapm.com/"
+
+    attr_accessor :endpoint, :app_key, :enabled
+
+    def initialize
+      @enabled = enabled?
+      @endpoint = ENV["PLAIN_APM_ENDPOINT"] || DEFAULT_EVENT_ENDPOINT
+      @app_key = ENV["PLAIN_APM_APP_KEY"] || warn("Missing PLAIN_APM_APP_KEY environment variable, plain_apm agent won't start.")
+    end
+
+    private
+
+    def enabled?
+      force = ENV["PLAIN_APM_ENABLED"] == "1"
+      key_present = ENV["PLAIN_APM_APP_KEY"] != ""
+      production = (ENV["RAILS_ENV"] || ENV["RACK_ENV"]) == "production"
+
+      key_present && (production || force)
+    end
+  end
+end

data/lib/plain_apm/extensions/exceptions/active_job.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module PlainApm
+  module Extensions
+    module TraceId
+      module ActiveJob
+        attr_accessor :trace_id
+
+        def initialize(*arguments)
+          super(*arguments)
+
+          # Either from request headers / a previous job, or a new trace.
+          @trace_id = PlainApm::Extensions::TraceId.current || SecureRandom.uuid
+        end
+
+        def serialize
+          super.update("trace_id" => trace_id)
+        end
+
+        def deserialize(job)
+          PlainApm::Extensions::TraceId.current = job["trace_id"]
+
+          super(job)
+        end
+      end
+
+      ##
+      # Allow tracing request ID through jobs
+      ActiveSupport.on_load(:active_job) do |klass|
+        klass.prepend(ActiveJob)
+      end
+    end
+  end
+end

data/lib/plain_apm/extensions/exceptions/rack.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module PlainApm
+  module Extensions
+    module Exceptions
+      class Rack
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          response = @app.call(env)
+
+          e = env["action_dispatch.exception"]
+          report_exception(e, env) unless e.nil?
+
+          response
+        rescue Exception => e # standard:disable Lint/RescueException
+          report_exception(e, env)
+          raise
+        end
+
+        private
+
+        def report_exception(e, env)
+          event = {
+            "source" => "rack_exceptions",
+            "name" => "exception",
+            "class" => e.class.name,
+            "message" => e.message,
+            "backtrace" => e.backtrace,
+            "params" => env["action_dispatch.request.parameters"],
+            "trace_id" => PlainApm::Extensions::TraceId.current
+          }
+
+          PlainApm::Agent.collect(event)
+        end
+      end
+    end
+  end
+end

data/lib/plain_apm/extensions/exceptions/railtie.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PlainApm
+  module Extensions
+    module Exceptions
+      class Railtie < Rails::Railtie
+        initializer "plain_apm.insert_exceptions_middleware" do |app|
+          app.config.middleware.insert(0, PlainApm::Extensions::Exceptions::Rack)
+        end
+      end
+    end
+  end
+end

data/lib/plain_apm/extensions/trace_id/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Steve Klabnik
+
+MIT License
+
+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 OR COPYRIGHT HOLDERS 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/lib/plain_apm/extensions/trace_id/active_job.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module PlainApm
+  module Extensions
+    module TraceId
+      module ActiveJob
+        def serialize
+          trace_id = PlainApm::Extensions::TraceId.current || SecureRandom.uuid
+          super.update("trace_id" => trace_id)
+        end
+
+        def deserialize(job)
+          PlainApm::Extensions::TraceId.current = job["trace_id"]
+
+          super(job)
+        end
+      end
+
+      ##
+      # Allow tracing request ID through jobs
+      ActiveSupport.on_load(:active_job) do |klass|
+        klass.prepend(ActiveJob)
+      end
+    end
+  end
+end

data/lib/plain_apm/extensions/trace_id/middleware.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+##
+# This code is inspired by request_store gem by Steve Klabnik:
+#
+# https://github.com/steveklabnik/request_store/
+#
+# See LICENSE.txt in the current directory for the license.
+module PlainApm
+  module Extensions
+    module TraceId
+      class Middleware
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          TraceId.current = trace_id(env)
+
+          status, headers, body = @app.call(env)
+
+          body = Rack::BodyProxy.new(body) do
+            TraceId.current = nil
+          end
+
+          processed = true
+
+          [status, headers, body]
+        ensure
+          TraceId.current = nil if !processed
+        end
+
+        private
+
+        def trace_id(env)
+          request_id(env) || SecureRandom.uuid
+        end
+
+        def request_id(env)
+          env["action_dispatch.request_id"] || env["HTTP_X_REQUEST_ID"]
+        end
+      end
+    end
+  end
+end

data/lib/plain_apm/extensions/trace_id/railtie.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+##
+# This code is inspired by request_store gem by Steve Klabnik:
+#
+# https://github.com/steveklabnik/request_store/
+#
+# See LICENSE.txt in the current directory for the license.
+module PlainApm
+  module Extensions
+    module TraceId
+      class Railtie < Rails::Railtie
+        initializer "plain_apm.insert_trace_id_middleware" do |app|
+          if defined?(ActionDispatch::RequestId)
+            app.config.middleware.insert_after ActionDispatch::RequestId, PlainApm::Extensions::TraceId::Middleware
+          else
+            app.config.middleware.insert_after Rack::MethodOverride, PlainApm::Extensions::TraceId::Middleware
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plain_apm/extensions/trace_id.rb

@@ -0,0 +1,15 @@
+module PlainApm
+  module Extensions
+    module TraceId
+      TRACE_KEY = :plain_apm_extensions_trace_id
+
+      def self.current
+        Thread.current[TRACE_KEY]
+      end
+
+      def self.current=(id)
+        Thread.current[TRACE_KEY] = id
+      end
+    end
+  end
+end

data/lib/plain_apm/hooks/action_mailer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module PlainApm
+  module Hooks
+    class ActionMailer < ActiveSupportSubscriber
+      NOTIFICATION_PATTERN = /\A[^!]\w+\.action_mailer\Z/.freeze
+
+      private
+
+      def notification_pattern
+        NOTIFICATION_PATTERN
+      end
+
+      def payload(event)
+        name, source = *event.name.split(".")
+        payload = event.payload
+
+        base = {
+          "source" => source,
+          "name" => name,
+          "backtrace" => filtered_backtrace,
+          "allocations" => event.allocations,
+          "started_at" => event.time,
+          "finished_at" => event.end,
+          "trace_id" => trace_id
+        }
+
+        case name
+        when "deliver"
+          base.merge({
+            "message_id" => payload[:message_id],
+            "mailer" => payload[:mailer],
+            "perform_deliveries" => payload[:perform_deliveries]
+          })
+        when "process"
+          base.merge({
+            "mailer" => payload[:mailer],
+            "action" => payload[:action]
+          })
+        end
+      end
+    end
+  end
+end

data/lib/plain_apm/hooks/action_pack.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module PlainApm
+  module Hooks
+    class ActionPack < ActiveSupportSubscriber
+      NOTIFICATION_PATTERN = /\A[^!]\w+\.action_controller\Z/.freeze
+
+      private
+
+      def notification_pattern
+        NOTIFICATION_PATTERN
+      end
+
+      def payload(event)
+        name, source = *event.name.split(".")
+        payload = event.payload
+
+        base = {
+          "source" => source,
+          "name" => name,
+          "backtrace" => filtered_backtrace,
+          "allocations" => event.allocations,
+          "started_at" => event.time,
+          "finished_at" => event.end,
+          "trace_id" => trace_id
+        }
+
+        case name
+        when "process_action"
+          base.merge({
+            "controller" => payload[:controller],
+            "action" => payload[:action],
+            "params" => payload[:params],
+            "format" => payload[:format],
+            "method" => payload[:method],
+            "path" => payload[:path],
+            "status" => payload[:status]
+          })
+        when "redirect_to", "start_processing", "halted_callback", "send_file", "send_data"
+          nil
+        when "read_fragment", "write_fragment", "exist_fragment?", "expire_fragment"
+          # controller, action, key
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/plain_apm/hooks/action_view.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module PlainApm
+  module Hooks
+    class ActionView < ActiveSupportSubscriber
+      NOTIFICATION_PATTERN = /\A[^!]\w+\.action_view\Z/.freeze
+
+      private
+
+      def notification_pattern
+        NOTIFICATION_PATTERN
+      end
+
+      def payload(event)
+        name, source = *event.name.split(".")
+        payload = event.payload
+
+        base = {
+          "source" => source,
+          "name" => name,
+          "backtrace" => filtered_backtrace,
+          "started_at" => event.time,
+          "finished_at" => event.end,
+          "allocations" => event.allocations,
+          "trace_id" => trace_id
+        }
+
+        case name
+        when "render_collection"
+          base.merge({
+            "identifier" => identifier(payload[:identifier]),
+            "layout" => payload[:layout],
+            "count" => payload[:count],
+            "cache_hits" => payload[:cache_hits]
+          })
+        when "render_layout"
+          base.merge({
+            "identifier" => identifier(payload[:identifier])
+          })
+        when "render_template"
+          base.merge({
+            "identifier" => identifier(payload[:identifier]),
+            "layout" => payload[:layout]
+          })
+        when "render_partial"
+          base.merge({
+            "identifier" => identifier(payload[:identifier]),
+            "layout" => payload[:layout],
+            "cache_hit" => payload[:cache_hit]
+          })
+        end
+      end
+
+      # strip rails root
+      def identifier(id)
+        return id unless defined?(Rails) && Rails.root
+
+        root = Rails.root.to_s
+
+        id.start_with?(root) ? id[root.size + 1..-1] : id # standard:disable Style/SlicingWithRange
+      end
+    end
+  end
+end

data/lib/plain_apm/hooks/active_job.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module PlainApm
+  module Hooks
+    class ActiveJob < ActiveSupportSubscriber
+      NOTIFICATION_PATTERN = /\A[^!]\w+\.active_job\Z/.freeze
+
+      private
+
+      def notification_pattern
+        NOTIFICATION_PATTERN
+      end
+
+      def payload(event)
+        name, source = *event.name.split(".")
+        payload = event.payload
+        job = payload[:job]
+
+        base = {
+          "source" => source,
+          "name" => name,
+          "backtrace" => filtered_backtrace,
+          "started_at" => event.time,
+          "finished_at" => event.end,
+          "trace_id" => trace_id,
+          "allocations" => event.allocations,
+          "queue_name" => job.queue_name,
+          "job_id" => job.job_id,
+          "job_class" => job.class.name,
+          "job_arguments" => job.arguments,
+          "executions" => job.executions,
+          "scheduled_at" => job.scheduled_at,
+          "adapter" => payload[:adapter].class.name,
+          "aborted" => payload[:aborted]
+        }
+
+        case name
+        when "enqueue", "enqueue_at", "perform"
+          base
+        when "enqueue_retry"
+          base.merge({
+            "error" => payload[:error],
+            "wait" => payload[:wait]
+          })
+        when "retry_stopped", "discard"
+          base.merge({
+            "error" => payload[:error]
+          })
+        when "perform_start"
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/plain_apm/hooks/active_record.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "active_support_subscriber"
+
+module PlainApm
+  module Hooks
+    class ActiveRecord < ActiveSupportSubscriber
+      NOTIFICATION_PATTERN = /\A[^!]\w+\.active_record\Z/.freeze
+
+      private
+
+      def notification_pattern
+        NOTIFICATION_PATTERN
+      end
+
+      def payload(event)
+        name, source = *event.name.split(".")
+        payload = event.payload
+
+        base = {
+          "source" => source,
+          "name" => name,
+          "backtrace" => filtered_backtrace,
+          "started_at" => event.time,
+          "finished_at" => event.end,
+          "allocations" => event.allocations,
+          "trace_id" => trace_id
+        }
+
+        case name
+        when "sql"
+          base.merge({
+            "sql_name" => payload[:name],
+            "sql" => payload[:sql]
+          })
+        end
+      end
+    end
+  end
+end

data/lib/plain_apm/hooks/active_support_subscriber.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module PlainApm
+  module Hooks
+    class ActiveSupportSubscriber
+      def install
+        begin
+          require "active_support/notifications"
+        rescue LoadError
+          return
+        end
+
+        asn = ActiveSupport::Notifications
+
+        # Rails >= 6.1
+        if asn.respond_to?(:monotonic_subscribe)
+          asn.monotonic_subscribe(notification_pattern, method(:collect))
+        else
+          asn.subscribe(notification_pattern, method(:collect))
+        end
+      end
+
+      def collect(event)
+        # id / transaction_id is by instrumenter and thread
+        payload = payload(event)
+
+        return if payload.nil?
+
+        Agent.instance.collect(payload)
+      end
+
+      private
+
+      def pattern
+        raise "Not implemented"
+      end
+
+      def payload(event)
+        raise "Not implemented"
+      end
+
+      def filtered_backtrace
+        if defined?(Rails) && defined?(Rails::BacktraceCleaner)
+          @cleaner ||= Rails::BacktraceCleaner.new
+          @cleaner.clean(caller)
+        end
+      end
+
+      ##
+      # The trace ID (comes from either HTTP_X_REQUEST_ID header, or is
+      # generated by the trace_id middleware)
+      def trace_id
+        PlainApm::Extensions::TraceId.current
+      end
+    end
+  end
+end

data/lib/plain_apm/hooks/deploy.rb

@@ -0,0 +1,47 @@
+module PlainApm
+  ##
+  # Tracks current revision of the app.
+  #
+  # This enables per-deploy metrics segmentation and checking
+  # for performance regressions.
+  module Hooks
+    class Deploy
+      ##
+      # Collect once, immediately on install.
+      def install
+        collect
+      end
+
+      def collect
+        result = git_revision || hg_revision || return
+
+        tool, revision = *result
+
+        Agent.instance.collect(
+          {"source" => tool, "revision" => revision, "name" => "deploy"}
+        )
+      end
+
+      private
+
+      # TODO: other deploy mechanisms
+      #
+      # Also, we might not be in the app root.
+      def git_revision
+        return nil unless File.exist?(".git")
+
+        ["git", `git rev-parse --short HEAD`.strip]
+      rescue Error::ENOENT # No git installed
+        nil
+      end
+
+      def hg_revision
+        return nil unless File.exist?(".hg")
+
+        ["hg", `hg log -l 1 -r . -T '{node}'`]
+      rescue Error::ENOENT # No mercurial installed
+        nil
+      end
+    end
+  end
+end

data/lib/plain_apm/hooks/error_reporter.rb

@@ -0,0 +1,53 @@
+module PlainApm
+  module Hooks
+    # Rails 7 error notification mechanism
+    class ErrorReporter
+      IGNORED_EXCEPTIONS = [
+        "Sidekiq::JobRetry::Skip" # Sidekiq uses exceptions for control flow.
+      ].freeze
+
+      def install
+        begin
+          require "active_support/error_reporter"
+          require "active_support/lazy_load_hooks"
+        rescue LoadError
+          return
+        end
+
+        # Install the hook when the app is up. This might miss errors that
+        # happen before that, but that's OK.
+        ActiveSupport.on_load(:after_initialize, yield: self, run_once: true) do
+          ::Rails.error.subscribe(self)
+        end
+      end
+
+      def collect(e, handled:, severity:, context: {})
+        return if IGNORED_EXCEPTIONS.include?(e.class.name)
+
+        event = {
+          "source" => "error_subscriber",
+          "name" => "exception",
+          "class" => e.class.name,
+          "message" => e.message,
+          "backtrace" => e.backtrace,
+          "handled" => handled,
+          "severity" => severity,
+          "context" => context,
+          "trace_id" => PlainApm::Extensions::TraceId.current
+        }
+
+        if e.cause
+          event.merge!({
+            "cause_class" => e.cause.class.name,
+            "cause_message" => e.cause.message,
+            "cause_backtrace" => e.cause.backtrace
+          })
+        end
+
+        PlainApm::Agent.collect(event)
+      end
+
+      alias_method :report, :collect
+    end
+  end
+end

data/lib/plain_apm/transport.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+
+module PlainApm
+  class Transport
+    ##
+    # HTTP transport class, mostly a wrapper for errors and timeout-handling.
+
+    # TODO: tune these.
+    HTTP_READ_TIMEOUT_SECONDS = 8 # default is 60
+    HTTP_WRITE_TIMEOUT_SECONDS = 8 # default is 60
+    HTTP_OPEN_TIMEOUT_SECONDS = 8 # default is 60
+
+    HTTP_TIMEOUTS = [
+      Net::OpenTimeout,
+      Net::ReadTimeout,
+      RUBY_VERSION >= "2.6.0" ? Net::WriteTimeout : nil
+    ].compact.freeze
+
+    ERRNO_ERRORS = [
+      Errno::ECONNABORTED,
+      Errno::ECONNREFUSED,
+      Errno::ECONNRESET,
+      Errno::EHOSTDOWN,
+      Errno::EHOSTUNREACH,
+      Errno::EINVAL,
+      Errno::ENETUNREACH,
+      Errno::EPIPE
+    ].freeze
+
+    ##
+    # @param endpoint [String] http URL to send the event to
+    # @param app_key [String] api key / token identifying this app
+    # @param http_client [Net::HTTP] for dependency injection in tests
+    def initialize(endpoint:, app_key:, http_client: Net::HTTP)
+      @uri = URI.parse(endpoint)
+      @app_key = app_key
+      @http = http_client.new(uri.host, uri.port)
+
+      # Forgotten /, e.g. https://example.com:3000
+      uri.path = "/" if uri.path.nil? || uri.path.empty?
+
+      # TODO: our own CA bundle?
+      http.use_ssl = uri.scheme == "https"
+
+      http.open_timeout = HTTP_OPEN_TIMEOUT_SECONDS
+      http.read_timeout = HTTP_READ_TIMEOUT_SECONDS
+
+      if RUBY_VERSION >= "2.6.0"
+        http.write_timeout = HTTP_WRITE_TIMEOUT_SECONDS
+      end
+
+      at_exit { shutdown }
+    end
+
+    ##
+    # Performs the actual HTTP request.
+    #
+    # @param data [String] serialized payload to POST
+    # @return [Array] [response, error, retriable]
+    def deliver(data)
+      http_response do
+        http_request(http, uri.path, data)
+      end
+    end
+
+    private
+
+    attr_reader :http, :uri, :app_key
+
+    ##
+    # Opens the underlying TCP connection.
+    def start
+      http.start unless http.started?
+    end
+
+    ##
+    # Close the connection at exit.
+    def shutdown
+      http.finish if http.started?
+    end
+
+    def http_request(http, path, body)
+      request = Net::HTTP::Post.new(path, http_headers)
+      http.request(request, body)
+    end
+
+    def http_headers
+      {
+        "Content-Type" => "application/json, charset=UTF-8",
+        "X-PlainApm-Key" => app_key
+      }
+    end
+
+    def http_response
+      # Opening the connection here allows us to rescue socket and SSL errors.
+      # It'll be a NO-OP if already connected.
+      start
+
+      response = yield
+
+      case response
+      when Net::HTTPSuccess
+        [response, nil, false]
+      when Net::HTTPServerError, Net::HTTPTooManyRequests
+        [response, nil, true]
+      when Net::HTTPBadRequest, Net::HTTPUnauthorized, Net::HTTPRequestEntityTooLarge
+        [response, nil, false]
+      else
+        # Caveat: this includes redirects.
+        [response, nil, false]
+      end
+    rescue *HTTP_TIMEOUTS, *ERRNO_ERRORS, IOError => e
+      # Lowlevel libc6, connection errors.
+      [nil, e, true]
+    rescue Exception => e # standard:disable Lint/RescueException
+      # SSL errors, socket errors, http protocol errors from Net. To avoid the
+      # caller thread loop dying.
+      [nil, e, false]
+    end
+  end
+end

data/lib/plain_apm/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PlainApm
+  VERSION = "0.2.6"
+end

data/lib/plain_apm.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "plain_apm/version"
+require_relative "plain_apm/transport"
+require_relative "plain_apm/config"
+require_relative "plain_apm/agent"
+
+require_relative "plain_apm/hooks/deploy"
+
+# Rails extensions
+begin
+  require "rack/body_proxy"
+
+  require_relative "plain_apm/extensions/trace_id"
+  require_relative "plain_apm/extensions/trace_id/middleware"
+  require_relative "plain_apm/extensions/trace_id/active_job" if defined?(ActiveSupport)
+  require_relative "plain_apm/extensions/trace_id/railtie" if defined?(Rails::Railtie)
+rescue LoadError
+  nil
+end
+
+# Rack exceptions
+require_relative "plain_apm/extensions/exceptions/rack"
+require_relative "plain_apm/extensions/exceptions/railtie" if defined?(Rails::Railtie)
+
+# Rails instrumentation
+require_relative "plain_apm/hooks/active_support_subscriber"
+require_relative "plain_apm/hooks/action_mailer"
+require_relative "plain_apm/hooks/action_pack"
+require_relative "plain_apm/hooks/action_view"
+require_relative "plain_apm/hooks/active_job"
+require_relative "plain_apm/hooks/active_record"
+require_relative "plain_apm/hooks/error_reporter"
+
+module PlainApm
+  Agent.start
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: plain_apm
+version: !ruby/object:Gem::Version
+  version: 0.2.6
+platform: ruby
+authors:
+- PlainAPM Team
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2022-10-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Ruby gem to collect events/metrics and send them to PlainAPM.
+email:
+- support@plainapm.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/plain_apm.rb
+- lib/plain_apm/agent.rb
+- lib/plain_apm/backoff.rb
+- lib/plain_apm/config.rb
+- lib/plain_apm/extensions/exceptions/active_job.rb
+- lib/plain_apm/extensions/exceptions/rack.rb
+- lib/plain_apm/extensions/exceptions/railtie.rb
+- lib/plain_apm/extensions/trace_id.rb
+- lib/plain_apm/extensions/trace_id/LICENSE.txt
+- lib/plain_apm/extensions/trace_id/active_job.rb
+- lib/plain_apm/extensions/trace_id/middleware.rb
+- lib/plain_apm/extensions/trace_id/railtie.rb
+- lib/plain_apm/hooks/action_mailer.rb
+- lib/plain_apm/hooks/action_pack.rb
+- lib/plain_apm/hooks/action_view.rb
+- lib/plain_apm/hooks/active_job.rb
+- lib/plain_apm/hooks/active_record.rb
+- lib/plain_apm/hooks/active_support_subscriber.rb
+- lib/plain_apm/hooks/deploy.rb
+- lib/plain_apm/hooks/error_reporter.rb
+- lib/plain_apm/transport.rb
+- lib/plain_apm/version.rb
+homepage: https://plainapm.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://plainapm.com
+  source_code_uri: https://github.com/plainapm/plainapm-ruby
+  changelog_uri: https://github.com/plainapm/plainapm-ruby/blob/main/CHANGELOG.md
+  github_repo: git@github.com:plainapm/plainapm-ruby.git
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key: 
+specification_version: 4
+summary: PlainAPM agent
+test_files: []