zuora_observability 0.1.0.pre.a → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7e3a6c154d518f30f5a95e1be272b96b1853b46df0300d4fa45ca8e17f04451
-  data.tar.gz: 0c510e0da92d8b7139586e60bd048bc91f18cc61a9cfe8165f4f44676c223180
+  metadata.gz: 2f179eca39cb93afe9e161797593b9b36e0b99cc4b2f002c98e549a0eac24b17
+  data.tar.gz: 041fdacdc8805507528d04bbc0e73c3de85f16d60e3d92b15c0a9715650c1015
 SHA512:
-  metadata.gz: 3948b6dacece27853e9df426c81d6f475c1b8b5417131c4318eeac8b88c8ffa4c4f625036f95cc5b73ed78ed53352f182c2f7efb16800e313b797a7416372b3b
-  data.tar.gz: f67b67d6bbbf2ff33c30433f32f321bf28109540bbf54250764509332de9caba0dbcf94917439882ea7a0f8d6e1bc437eae221134ceb4adfac00933dddadd1f6
+  metadata.gz: f0ef15e3d143be63cadc70a1249b18e4d10be281d1a7fe30523beae340d85e8dc2bc141f30a73e3dda0162e4bc3171848f87d11509ab26bfa9c6bae3d9737f0a
+  data.tar.gz: 35ae00955747c5da4e62e58f9634157618d07d5b8749230b86158f0ae9691b0e6306e49f96b34a9702e4f2c0d87ebb36d37e97b705127fb9a6e429f1d1a7d646

data/README.md

@@ -2,10 +2,13 @@
 
 A ruby gem to enable observability into rails applications
 
-## Usage
-How to use my plugin.
+## Prerequisites
+
+- Ruby 2.5+
+- Rails 5.0+
 
 ## Installation
+
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -13,14 +16,21 @@ gem 'zuora_observability'
 ```
 
 And then execute:
+
 ```bash
 $ bundle
 ```
 
 Or install it yourself as:
+
 ```bash
 $ gem install zuora_observability
 ```
 
+## Usage
+
+- [Logging](doc/logging.md)
+
 ## License
+
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/config/initializers/loggers.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+if defined?(Resque.logger)
+  Resque.logger = ZuoraObservability::Logger.custom_logger(name: 'Resque')
+  if defined?(Resque::Scheduler)
+    Resque::Scheduler.logger = ZuoraObservability::Logger.custom_logger(name: 'ResqueScheduler')
+  end
+end
+
+if defined?(Delayed::Worker.logger)
+  Delayed::Worker.logger = ZuoraObservability::Logger.custom_logger(name: 'DelayedJob', level: Logger::INFO)
+end
+
+if defined?(Makara)
+  Makara::Logging::Logger.logger = ZuoraObservability::Logger.custom_logger(name: 'Makara')
+end
+
+if defined?(ElasticAPM) && ElasticAPM.running?
+  ElasticAPM.agent.config.logger = ZuoraObservability::Logger.custom_logger(name: 'ElasticAPM', level: Logger::WARN)
+end
+
+if defined?(ActionMailer)
+  ActionMailer::Base.logger = ZuoraObservability::Logger.custom_logger(name: 'ActionMailer')
+end

data/config/initializers/tagged_logging.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module TaggedLogging
+    # Patch to apply structured tags to Tagged Logs
+    module Formatter
+      def call(severity, timestamp, progname, data)
+        super(severity, timestamp, progname, merged_tags.merge!(data))
+      end
+
+      private
+
+      def merged_tags
+        tags = {}
+
+        current_tags.each do |tag|
+          tags.merge!(tag) if tag.is_a?(Hash)
+        end
+
+        tags
+      end
+    end
+  end
+end
+
+module Rails
+  module Rack
+    # Patch to compute structured tags for Tagged Logging
+    class Logger
+      private
+
+      def compute_tags(request)
+        {
+          trace_id: request.uuid
+        }
+      end
+    end
+  end
+end

data/lib/zuora_observability/configuration.rb

@@ -3,14 +3,19 @@
 module ZuoraObservability
   # Global configuration that can be set in a Rails initializer
   class Configuration
-    attr_accessor :enable_metrics, :telegraf_endpoint, :telegraf_debug,
-                  :json_logging
+    attr_reader :custom_payload_hooks
+    attr_accessor :zecs_service_hook, :json_logging
 
     def initialize
-      @enable_metrics = false
-      @telegraf_endpoint = 'udp://telegraf-app-metrics.monitoring.svc.cluster.local:8094'
-      @telegraf_debug = false
-      @json_logging = false
+      @custom_payload_hooks = []
+      @zecs_service_hook = nil
+      # NOTE(hartley): this checks the var for presence rather than value to
+      # align with how Rails does RAILS_LOG_TO_STDOUT
+      @json_logging = ENV['ZUORA_JSON_LOGGING'].present? ? true : !(Rails.env.development? || Rails.env.test?)
+    end
+
+    def add_custom_payload_hook(&block)
+      custom_payload_hooks << block
     end
   end
 end

data/lib/zuora_observability/engine.rb

@@ -10,64 +10,35 @@ module ZuoraObservability
     end
 
     initializer(:rails_stdout_logging, before: :initialize_logger) do
-      require 'lograge'
+      Rails.application.configure do
+        config.logger = ZuoraObservability::Logger.custom_logger(name: 'Rails')
 
-      Rails.configuration.logger = ZuoraObservability::Logger.custom_logger(name: "Rails")
-      if !Rails.env.test? && !Rails.env.development?
-        Rails.configuration.lograge.enabled = true
-        Rails.configuration.colorize_logging = false
-      end
+        next unless ZuoraObservability.configuration.json_logging
 
-      if Rails.configuration.lograge.enabled
-        if Rails.configuration.logger.class.to_s == 'Ougai::Logger'
-          Rails.configuration.lograge.formatter = Class.new do |fmt|
-            def fmt.call(data)
-              { msg: 'Rails Request', request: data }
-            end
-          end
-        end
-        #Rails.configuration.lograge.formatter = Lograge::Formatters::Json.new
-        Rails.configuration.lograge.custom_options = lambda do |event|
-          exceptions = %w(controller action format)
-          items = {
-            #time: event.time.strftime('%FT%T.%6N'),
-            params: event.payload[:params].as_json(except: exceptions).to_json.to_s
-          }
-          items.merge!({exception_object: event.payload[:exception_object]}) if event.payload[:exception_object].present?
-          items.merge!({exception: event.payload[:exception]}) if event.payload[:exception].present?
+        config.logger = ActiveSupport::TaggedLogging.new(config.logger)
 
-          if event.payload[:headers].present?
-            # By convertion, headers usually do not have dots. Nginx even rejects headers with dots
-            # All Rails headers are namespaced, like 'rack.input'.
-            # Thus, we can obtain the client headers by rejecting dots
-            request_headers =
-              event.payload[:headers].env.
-                reject { |key| key.to_s.include?('.') || REQUEST_HEADERS_TO_IGNORE.include?(key.to_s) }
-            begin
-              if request_headers["HTTP_AUTHORIZATION"].present?
-                if request_headers["HTTP_AUTHORIZATION"].include?("Basic")
-                  user_password = request_headers["HTTP_AUTHORIZATION"].split("Basic").last.strip
-                  user, password = Base64.decode64(user_password).split(":")
-                  request_headers["HTTP_AUTHORIZATION"] = "Basic #{user}:ValueFiltered"
-                elsif
-                  request_headers["HTTP_AUTHORIZATION"] = "ValueFiltered"
-                end
-              end
-              request_headers["HTTP_API_TOKEN"] = "ValueFiltered" if request_headers["HTTP_API_TOKEN"].present?
-            rescue
-              request_headers.delete("HTTP_API_TOKEN")
-              request_headers.delete("HTTP_AUTHORIZATION")
-            end
-            items.merge!({ headers: request_headers.to_s })
-          end
+        require 'lograge'
+        require 'zuora_observability/logging/custom_options'
+
+        config.lograge.enabled = true
+        config.colorize_logging = false
 
-          if Thread.current[:appinstance].present?
-            items.merge!({connect_user: Thread.current[:appinstance].connect_user, new_session: Thread.current[:appinstance].new_session_message})
-            if Thread.current[:appinstance].logitems.present? && Thread.current[:appinstance].logitems.class == Hash
-              items.merge!(Thread.current[:appinstance].logitems)
-            end
+        config.lograge.formatter = Lograge::Formatters::Raw.new
+
+        config.lograge.custom_options = Logging::CustomOptions
+        config.lograge.custom_payload do |controller|
+          payload = {}
+
+          ZuoraObservability.configuration.custom_payload_hooks.each do |hook|
+            payload.merge!(hook.call(controller))
           end
-          return items
+
+          next payload unless ZuoraObservability.configuration.zecs_service_hook
+
+          payload[:zecs_service] =
+            ZuoraObservability.configuration.zecs_service_hook.call(controller)
+
+          payload
         end
       end
     end

data/lib/zuora_observability/env.rb

@@ -4,9 +4,20 @@ module ZuoraObservability
   # Methods to get information about the application environment
   class Env
     class << self
+      def name
+        ENV['Z_APPLICATION_NAME']
+      end
+
+      def version
+        ENV['Z_APPLICATION_VERSION']
+      end
+
+      def environment
+        ENV['Z_APPLICATION_ENVIRONMENT']
+      end
+
       def app_name
-        # parent_name is deprecated in Rails 6.0, removed in 6.1
-        ENV['DEIS_APP'].presence || Rails.application.class.parent_name
+        ENV['DEIS_APP'].presence || app_parent_name
       end
 
       def pod_name
@@ -28,6 +39,16 @@ module ZuoraObservability
         end
         return p_type
       end
+
+      private
+
+      def app_parent_name
+        if Rails::VERSION::MAJOR >= 6
+          Rails.application.class.module_parent_name
+        else
+          Rails.application.class.parent_name
+        end
+      end
     end
   end
 end

data/lib/zuora_observability/logger.rb

@@ -1,47 +1,69 @@
 # frozen_string_literal: true
 
+require 'ougai'
 require 'mono_logger'
+require 'zuora_observability/logging/formatter'
+require 'ougai/formatters/customizable'
 
 module ZuoraObservability
   # A configurable logger that can be used for Rails and additional libraries
-  module Logger
-    # NOTE(hartley): potentially change Logger module to delegate methods to
-    # value returned from custom_logger (so it ends up being a pure wrapper)
-    def self.custom_logger(name: "", level: Rails.logger.present? ? Rails.logger.level : MonoLogger::INFO, type: :ougai)
-      #puts name + ' - ' + {Logger::WARN => 'Logger::WARN', Logger::ERROR => 'Logger::ERROR', Logger::DEBUG => 'Logger::DEBUG', Logger::INFO => 'Logger::INFO' }[level] + ' - '
+  class Logger < Ougai::Logger
+    # TODO(hartley): enable silence method for Rails 5.2 asset requests
+    # https://github.com/tilfin/ougai/wiki/Use-as-Rails-logger
+    def initialize(logdev, **)
+      super
+
+      # NOTE(hartley): the purpose for the original split between Ougai and
+      # MonoLogger was that MonoLogger enables logging in a trap context
+      # https://github.com/tilfin/ougai/issues/74
+      # By using our own Logger class, we can override the LogDevice created
+      # by ruby with MonoLogger's, enabling logging in a trap context
+      @logdev = MonoLogger::LocklessLogDevice.new(logdev)
+    end
+
+    def create_formatter
+      return ZuoraObservability::Logging::Formatter.new if ZuoraObservability.configuration.json_logging
+
+      formatter = Ougai::Formatters::Customizable.new(
+        format_err: method(:custom_error_formatter),
+        format_data: method(:custom_data_formatter),
+        format_msg: method(:custom_message_formatter)
+      )
+      formatter.datetime_format = '%FT%T.%3NZ'
+      formatter
+    end
+
+    def custom_message_formatter(severity, datetime, _progname, data)
+      msg = data.delete(:msg)
+      "#{severity.ljust(6)} #{datetime}: #{msg}"
+    end
+
+    def custom_data_formatter(data)
+      data.delete_if do |k|
+        %i[app_instance_id tenant_ids organization environment].include? k
+      end
+
+      return nil if data.blank?
+
+      "#{'DATA'.ljust(6)} #{Time.current.strftime('%FT%T.%3NZ')}: #{data.to_json}"
+    end
+
+    def custom_error_formatter(data)
+      return nil unless data.key?(:err)
+
+      err = data.delete(:err)
+      "  #{err[:name]} (#{err[:message]})\n #{err[:stack]}"
+    end
+
+    def self.custom_logger(name: '', level: Rails.logger.present? ? Rails.logger.level : MonoLogger::INFO, type: :ougai)
       if type == :ougai
-        require 'ougai'
-        require "ougai/formatters/customizable"
-        #logger = Ougai::Logger.new(MonoLogger.new(STDOUT))
-        logger = Ougai::Logger.new(STDOUT)
-        logger.level = level
-        if ZuoraObservability.configuration.json_logging
-          require 'zuora_observability/logging/formatter'
-          logger.formatter = ZuoraObservability::Logging::Formatter.new(name)
-          logger.before_log = lambda do |data|
-            data[:trace_id] = ZuoraConnect::RequestIdMiddleware.request_id if ZuoraConnect::RequestIdMiddleware.request_id.present?
-            data[:zuora_trace_id] = ZuoraConnect::RequestIdMiddleware.zuora_request_id if ZuoraConnect::RequestIdMiddleware.zuora_request_id.present?
-            #data[:traces] = {amazon_id: data[:trace_id], zuora_id: data[:zuora_trace_id]}
-          end
-        else
-          logger.formatter = Ougai::Formatters::Customizable.new(
-            format_err: proc do |data|
-              next nil unless data.key?(:err)
-              err = data.delete(:err)
-              "  #{err[:name]} (#{err[:message]})\n #{err[:stack]}"
-            end,
-            format_data: proc do |data|
-              data.delete(:app_instance_id); data.delete(:tenant_ids); data.delete(:organization); data.delete(:environment)
-              format('%s %s: %s', 'DATA'.ljust(6), Time.now.strftime('%FT%T.%6NZ'), "#{data.to_json}") if data.present?
-            end,
-            format_msg: proc do |severity, datetime, _progname, data|
-              msg = data.delete(:msg)
-              format('%s %s: %s', severity.ljust(6), datetime, msg)
-            end
-          )
-          logger.formatter.datetime_format = '%FT%T.%6NZ'
-        end
+        logger = new($stdout, level: level, progname: name)
       else
+        ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          Creating a non-ougai custom_logger is deprecated and will be removed
+          in a future version of zuora_observability.
+        MSG
+
         require 'mono_logger'
         logger = MonoLogger.new(STDOUT)
         logger.level = level
@@ -65,7 +87,8 @@ module ZuoraObservability
           end
         end
       end
-      return logger
+
+      logger
     end
   end
 end

data/lib/zuora_observability/logging/custom_options.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module ZuoraObservability
+  module Logging
+    # Custom Options for lograge to add additional fields to logged data
+    module CustomOptions
+      IGNORE_HEADERS = %w[
+        RAW_POST_DATA
+        REQUEST_METHOD
+        REQUEST_URI
+        REQUEST_PATH
+        PATH_INFO
+        CONTENT_TYPE
+        ORIGINAL_FULLPATH
+        QUERY_STRING
+        HTTP_COOKIE
+        HTTP_X_ENVOY_PEER_METADATA
+        HTTP_X_ENVOY_DECORATOR_OPERATION
+        HTTP_ZSESSION
+        HTTP_SEC_CH_UA_MOBILE
+      ].freeze
+
+      IGNORE_PARAMS = %w[controller action format].freeze
+
+      FILTERED = '[FILTERED]'
+
+      class << self
+        def call(event)
+          items = {
+            msg: 'Rails Request',
+            params: event.payload[:params].as_json(except: IGNORE_PARAMS).to_s,
+            zuora_trace_id: event.payload[:headers]['HTTP_ZUORA_REQUEST_ID'],
+            error: event.payload[:exception_object]
+          }
+
+          if event.payload[:headers].present?
+            request_headers = filter_request_headers(event.payload[:headers])
+
+            filtered_headers = filter_sensitive_headers(request_headers)
+
+            items.merge!({ headers: filtered_headers })
+          end
+
+          items
+        end
+
+        private
+
+        def filter_request_headers(action_dispatch_headers)
+          action_dispatch_headers.env.select do |header|
+            next false if IGNORE_HEADERS.include? header
+
+            header =~ /^HTTP_/ || ActionDispatch::Http::Headers::CGI_VARIABLES.include?(header)
+          end
+        end
+
+        def filter_sensitive_headers(headers)
+          filtered = {}
+
+          auth = headers['HTTP_AUTHORIZATION']
+          filtered['HTTP_AUTHORIZATION'] = filter_auth_header(auth) if auth
+
+          filtered['HTTP_API_TOKEN'] = FILTERED if headers['HTTP_API_TOKEN']
+
+          headers.merge(filtered)
+        end
+
+        def filter_auth_header(authorization)
+          return FILTERED unless authorization.include? 'Basic'
+
+          encoded = authorization.split(' ', 2).second
+          user, _password = Base64.decode64(encoded).split(':')
+
+          "Basic #{user}:#{FILTERED}"
+        end
+      end
+    end
+  end
+end

data/lib/zuora_observability/logging/formatter.rb

@@ -1,45 +1,191 @@
 # frozen_string_literal: true
 
-require 'ougai/formatters/base'
-require 'ougai/formatters/for_json'
-
 module ZuoraObservability
   module Logging
-    # A JSON formatter compatible with node-bunyan
-    class Formatter < Ougai::Formatters::Base
-      include Ougai::Formatters::ForJson
-
-      # Intialize a formatter
-      # @param [String] app_name application name (execution program name if nil)
-      # @param [String] hostname hostname (hostname if nil)
-      # @param [Hash] opts the initial values of attributes
-      # @option opts [String] :trace_indent (2) the value of trace_indent attribute
-      # @option opts [String] :trace_max_lines (100) the value of trace_max_lines attribute
-      # @option opts [String] :serialize_backtrace (true) the value of serialize_backtrace attribute
-      # @option opts [String] :jsonize (true) the value of jsonize attribute
-      # @option opts [String] :with_newline (true) the value of with_newline attribute
-      def initialize(app_name = nil, hostname = nil, opts = {})
-        aname, hname, opts = Ougai::Formatters::Base.parse_new_params([app_name, hostname, opts])
-        super(aname, hname, opts)
-        init_opts_for_json(opts)
-      end
+    # Formats data into ZECS Logging Standard and dumps as JSON
+    # https://tag.pages.gitlab.zeta.tools/standards/logging
+    class Formatter < Ougai::Formatters::Bunyan
+      ECS_VERSION = '1.5.0'
+
+      ZECS_TOP_LEVEL_FIELDS = %i[
+        error event http organization process url user
+      ].freeze
+      ECS_HTTP_FIELDS = %i[request response].freeze
 
       def _call(severity, time, progname, data)
-        data.merge!({ message: data.delete(:msg) })
-        if data[:timestamp].present?
-          time = data[:timestamp]
-          data.delete(:timestamp)
-        end
-        dump({
-          name: progname || @app_name,
-          pid: $$,
-          level: severity,
-          timestamp: time.utc.strftime('%FT%T.%6NZ'),
-        }.merge(data))
+        output = base_fields(severity, time, progname, data)
+
+        other_fields = get_fields_for(ZECS_TOP_LEVEL_FIELDS, data)
+        output.merge!(other_fields)
+
+        zuora_fields = ZuoraFields.call(data)
+        output[:zuora] = zuora_fields unless zuora_fields.empty?
+
+        dump(output)
       end
 
+      # Note(hartley): Ougai::Formatters::ForJson requires this be present
       def convert_time(data)
-        # data[:timestamp] = format_datetime(data[:time])
+        data[:@timestamp] = data[:@timestamp].utc.iso8601(3)
+      end
+
+      private
+
+      def get_fields_for(list, data)
+        final_hash = {}
+
+        list.each do |field|
+          field_output = send("#{field}_fields", data)
+          final_hash[field] = field_output unless field_output.empty?
+        end
+
+        final_hash
+      end
+
+      # Fields required by ECS
+      def base_fields(severity, time, progname, data)
+        {
+          :@timestamp => time,
+          message: data[:msg],
+          ecs: { version: ECS_VERSION },
+          log: { level: severity, logger: progname || @app_name },
+          service: { name: Env.name, version: Env.version },
+          trace: { id: data[:trace_id] },
+          tags: ['zecs']
+        }
+      end
+
+      # errors
+      def error_fields(data)
+        return {} unless data[:error] || data[:err]
+
+        error = data[:err] || serialize_exc(data[:error])
+
+        {
+          message: error[:message],
+          stack_trace: error[:stack],
+          type: error[:name]
+        }.compact
+      end
+
+      # http
+      def http_fields(data)
+        get_fields_for(ECS_HTTP_FIELDS, data)
+      end
+
+      # http.request
+      def request_fields(data)
+        request = data.slice(:method, :params).merge(data.fetch(:request, {}))
+
+        {
+          method: request[:method],
+          body: ({ content: request[:params] } if request.key? :params)
+        }.compact
+      end
+
+      # http.response
+      def response_fields(data)
+        response = data.slice(:status).merge(data.fetch(:response, {}))
+
+        {
+          status_code: response[:status],
+          body: ({ content: response[:params] } if response.key? :params),
+        }.compact
+      end
+
+      # organization
+      def organization_fields(data)
+        {
+          name: data[:organization]
+        }.compact
+      end
+
+      # process
+      def process_fields(_data)
+        { id: Process.pid }
+      end
+
+      # url
+      def url_fields(data)
+        {
+          full: data.dig(:url, :full),
+          path: data[:path]
+        }.compact
+      end
+
+      # user
+      def user_fields(data)
+        {
+          id: data[:user_id],
+          email: data[:email]
+        }.compact
+      end
+
+      # event
+      def event_fields(data)
+        full_action = "#{data[:controller]}##{data[:action]}"
+
+        {
+          action: (full_action unless full_action == '#'),
+          duration: data[:duration]
+        }.compact
+      end
+    end
+
+    # The Zuora Extension to ECS defined by ZECS
+    module ZuoraFields
+      ZECS_VERSION = '1.1'
+
+      class << self
+        # zuora top level field
+        def call(data)
+          hash = base_fields(data)
+
+          z_http = http_fields(data)
+          hash[:http] = z_http unless z_http.empty?
+
+          z_service = service_fields(data)
+          hash[Env.name.to_sym] = z_service unless z_service.empty?
+
+          return {} if hash.empty?
+
+          hash.merge({ ecs: { version: ZECS_VERSION } })
+        end
+
+        def base_fields(data)
+          {
+            cp_id: data[:zuora_track_id],
+            entity_ids: data[:entity_ids],
+            environment: data[:environment],
+            tenant_id: data[:tenant_ids],
+            trace_id: data[:zuora_trace_id]
+          }.compact
+        end
+
+        # zuora.http
+        def http_fields(data)
+          z_http_request = {
+            headers: data[:headers] || data.dig(:request, :headers),
+            headers_blob: data.dig(:request, :headers_blob)
+          }.compact
+
+          z_http_response = {
+            headers: data.dig(:response, :headers),
+            headers_blob: data.dig(:response, :headers_blob)
+          }.compact
+
+          {
+            request: (z_http_request unless z_http_request.empty?),
+            response: (z_http_response unless z_http_response.empty?)
+          }.compact
+        end
+
+        # Service's Custom Fields
+        def service_fields(data)
+          {
+            app_instance_id: data[:app_instance_id]
+          }.merge(data.fetch(:zecs_service, {})).compact
+        end
       end
     end
   end

data/lib/zuora_observability/metrics.rb

@@ -3,18 +3,7 @@
 module ZuoraObservability
   # Methods to gather and format metrics
   module Metrics
-    @@telegraf_host = nil
-
     class << self
-      def write_to_telegraf(*args)
-        if ZuoraObservability.configuration.enable_metrics && !defined?(Prometheus)
-          @@telegraf_host = Metrics::Telegraf.new() if @@telegraf_host == nil
-          unicorn_stats = Metrics.unicorn_listener if defined?(Unicorn) && Unicorn.respond_to?(:listener_names)
-          @@telegraf_host.write(direction: 'Raindrops', tags: {}, values: unicorn_stats)  unless unicorn_stats.blank?
-          return @@telegraf_host.write(*args)
-        end
-      end
-
       def resque
         Resque.redis.ping
 

data/lib/zuora_observability/version.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
+# frozen_string_literal: truemf
 
 module ZuoraObservability
-  VERSION = '0.1.0-a'
+  VERSION = '0.3.5'
 end

data/lib/zuora_observability.rb

@@ -7,8 +7,6 @@ require 'zuora_observability/metrics'
 require 'zuora_observability/logger'
 
 require 'zuora_observability/logging/formatter'
-require 'zuora_observability/metrics/telegraf'
-require 'zuora_observability/metrics/point_value'
 
 # Provides Rails application with tools for observabilty
 module ZuoraObservability

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zuora_observability
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.a
+  version: 0.3.5
 platform: ruby
 authors:
 - Hartley McGuire
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-25 00:00:00.000000000 Z
+date: 2024-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lograge
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: mono_logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: ougai
   requirement: !ruby/object:Gem::Requirement
@@ -52,20 +66,6 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 1.0.0
-- !ruby/object:Gem::Dependency
-  name: mono_logger
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -140,16 +140,16 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop-rails
   requirement: !ruby/object:Gem::Requirement
@@ -168,16 +168,16 @@ dependencies:
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0.pre
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0.pre
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -244,15 +244,12 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
-- app/assets/config/zuora_observability_manifest.js
-- app/assets/stylesheets/zuora_observability/application.css
 - app/controllers/zuora_observability/application_controller.rb
 - app/controllers/zuora_observability/metrics_controller.rb
 - app/helpers/zuora_observability/application_helper.rb
-- app/jobs/zuora_observability/application_job.rb
-- app/mailers/zuora_observability/application_mailer.rb
-- app/models/zuora_observability/application_record.rb
 - app/views/layouts/zuora_observability/application.html.erb
+- config/initializers/loggers.rb
+- config/initializers/tagged_logging.rb
 - config/routes.rb
 - lib/tasks/zuora_observability_tasks.rake
 - lib/zuora_observability.rb
@@ -260,16 +257,15 @@ files:
 - lib/zuora_observability/engine.rb
 - lib/zuora_observability/env.rb
 - lib/zuora_observability/logger.rb
+- lib/zuora_observability/logging/custom_options.rb
 - lib/zuora_observability/logging/formatter.rb
 - lib/zuora_observability/metrics.rb
-- lib/zuora_observability/metrics/point_value.rb
-- lib/zuora_observability/metrics/telegraf.rb
 - lib/zuora_observability/version.rb
-homepage: 
+homepage:
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -277,15 +273,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: Summary of ZuoraObservability.
 test_files: []

data/app/assets/config/zuora_observability_manifest.js

@@ -1 +0,0 @@
-//= link_directory ../stylesheets/zuora_observability .css

data/app/assets/stylesheets/zuora_observability/application.css

@@ -1,15 +0,0 @@
-/*
- * This is a manifest file that'll be compiled into application.css, which will include all the files
- * listed below.
- *
- * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
- * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
- *
- * You're free to add application-wide styles to this file and they'll appear at the bottom of the
- * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
- * files in this directory. Styles in this file should be added after the last require_* statement.
- * It is generally better to create a new file per style scope.
- *
- *= require_tree .
- *= require_self
- */

data/app/jobs/zuora_observability/application_job.rb

@@ -1,4 +0,0 @@
-module ZuoraObservability
-  class ApplicationJob < ActiveJob::Base
-  end
-end

data/app/mailers/zuora_observability/application_mailer.rb

@@ -1,6 +0,0 @@
-module ZuoraObservability
-  class ApplicationMailer < ActionMailer::Base
-    default from: 'from@example.com'
-    layout 'mailer'
-  end
-end

data/app/models/zuora_observability/application_record.rb

@@ -1,5 +0,0 @@
-module ZuoraObservability
-  class ApplicationRecord < ActiveRecord::Base
-    self.abstract_class = true
-  end
-end

data/lib/zuora_observability/metrics/point_value.rb

@@ -1,84 +0,0 @@
-# this looks copied from https://github.com/influxdata/influxdb-ruby, it may be
-# worth just using the gem instead of vendoring the file
-# module InfluxDB
-module ZuoraObservability
-  module Metrics
-    # Convert data point to string using Line protocol
-    class PointValue
-      attr_reader :series, :values, :tags, :timestamp
-
-      def initialize(data)
-        @series    = escape data[:series], :measurement
-        @values    = escape_values data[:values]
-        @tags      = escape_tags data[:tags]
-        @timestamp = data[:timestamp]
-      end
-
-      def dump
-        dump =  @series.dup
-        dump << ",#{@tags}" if @tags
-        dump << " #{@values}"
-        dump << " #{@timestamp}" if @timestamp
-        dump
-      end
-
-      private
-
-      ESCAPES = {
-        measurement:  [' '.freeze, ','.freeze],
-        tag_key:      ['='.freeze, ' '.freeze, ','.freeze],
-        tag_value:    ['='.freeze, ' '.freeze, ','.freeze],
-        field_key:    ['='.freeze, ' '.freeze, ','.freeze, '"'.freeze],
-        field_value:  ["\\".freeze, '"'.freeze],
-      }.freeze
-
-      private_constant :ESCAPES
-
-      def escape(str, type)
-        # rubocop:disable Layout/AlignParameters
-        str = str.encode "UTF-8".freeze, "UTF-8".freeze,
-          invalid: :replace,
-          undef: :replace,
-          replace: "".freeze
-        # rubocop:enable Layout/AlignParameters
-
-        ESCAPES[type].each do |ch|
-          str = str.gsub(ch) { "\\#{ch}" }
-        end
-        str
-      end
-
-      def escape_values(values)
-        return if values.nil?
-        values.map do |k, v|
-          key = escape(k.to_s, :field_key)
-          val = escape_value(v)
-          "#{key}=#{val}"
-        end.join(",".freeze)
-      end
-
-      def escape_value(value)
-        if value.is_a?(String)
-          '"'.freeze + escape(value, :field_value) + '"'.freeze
-        elsif value.is_a?(Integer)
-          "#{value}i"
-        else
-          value.to_s
-        end
-      end
-
-      def escape_tags(tags)
-        return if tags.nil?
-
-        tags = tags.map do |k, v|
-          key = escape(k.to_s, :tag_key)
-          val = escape(v.to_s, :tag_value)
-
-          "#{key}=#{val}" unless key == "".freeze || val == "".freeze
-        end.compact
-
-        tags.join(",") unless tags.empty?
-      end
-    end
-  end
-end

data/lib/zuora_observability/metrics/telegraf.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-module ZuoraObservability
-  module Metrics
-    # Functionality for sending metrics to a Telegraf endpoint
-    #
-    # it looks like https://github.com/influxdata/influxdb-ruby may provide some
-    # more high level abstractions instead of using a UDPSocket directly
-    class Telegraf
-      attr_accessor :host
-
-      OUTBOUND_METRICS = true
-      OUTBOUND_METRICS_NAME = 'request-outbound'
-      INBOUND_METRICS = true
-      INBOUND_METRICS_NAME = 'request-inbound'
-
-      def initialize
-        connect
-      end
-
-      def connect
-        # TODO(hartley): this Rails logger was originally ZuoraConnect.logger
-        Rails.logger.debug(format_metric_log('Telegraf', 'Need new connection')) if ZuoraObservability.configuration.telegraf_debug
-        uri = URI.parse(ZuoraObservability.configuration.telegraf_endpoint)
-        self.host = UDPSocket.new.tap do |socket|
-          socket.connect uri.host, uri.port
-        end
-      rescue => ex
-        self.host = nil
-        # TODO(hartley): this Rails logger was originally ZuoraConnect.logger
-        Rails.logger.warn(self.format_metric_log('Telegraf', "Failed to connect: #{ex.class}")) if Rails.env.to_s != 'production'
-      end
-
-      def write(direction: 'Unknown', tags: {}, values: {})
-        time = Benchmark.measure do
-          # To avoid writing metrics from rspec tests
-          if Rails.env.to_sym != :test
-            app_instance = Thread.current[:appinstance].present? ? Thread.current[:appinstance].id : 0
-            tags = {
-              app_name: Env.app_name, process_type: Env.process_type,
-              app_instance: app_instance, pod_name: Env.pod_name
-            }.merge(tags)
-
-            if direction == :inbound
-              # This condition relies on a monkey patch in the connect gem that
-              # adds a to_bool method for Nil, True, and False that are not
-              # present by default
-              if INBOUND_METRICS && !Thread.current[:inbound_metric].to_bool
-                self.write_udp(series: INBOUND_METRICS_NAME, tags: tags, values: values)
-                Thread.current[:inbound_metric] = true
-              else
-                return
-              end
-            elsif direction == :outbound
-              write_udp(series: OUTBOUND_METRICS_NAME, tags: tags, values: values) if OUTBOUND_METRICS
-            else
-              write_udp(series: direction, tags: tags, values: values)
-            end
-          end
-        end
-
-        return unless ZuoraObservability.configuration.telegraf_debug
-
-        # TODO(hartley): these Rails loggers were originally ZuoraConnect.logger
-        Rails.logger.debug(format_metric_log('Telegraf', tags.to_s))
-        Rails.logger.debug(format_metric_log('Telegraf', values.to_s))
-        Rails.logger.debug(
-          format_metric_log(
-            'Telegraf',
-            "Writing '#{direction.capitalize}': #{time.real.round(5)} ms"
-          )
-        )
-      end
-
-      def write_udp(series: '', tags: {}, values: {})
-        return if values.blank?
-
-        host.write PointValue.new({ series: series, tags: tags, values: values }).dump
-      rescue => ex
-        self.connect
-        ZuoraConnect.logger.warn(self.format_metric_log('Telegraf', "Failed to write udp: #{ex.class}")) if Rails.env.to_s != 'production'
-      end
-
-      def format_metric_log(message, dump = nil)
-        message_color = '1;91'
-        dump_color = '0;1'
-        log_entry = "  \e[#{message_color}m#{message}\e[0m   #{
-          "\e[#{dump_color}m#{dump}\e[0m" if dump
-        }"
-        if Rails.env.development?
-          log_entry
-        else
-          [message, dump].compact.join(' - ')
-        end
-      end
-    end
-  end
-end