event_tracer 0.2.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72b9ead92b130709f1d0a48bac3508af836e65467b8815aa733c4f7101308472
-  data.tar.gz: 47dce77a79c44aa0c012f06a79f3ec3180777f107658c95d1b88d623f33efeba
+  metadata.gz: 5f5987bb0a399ec5960ef763bfcd0dbfa5ccd6057706deb1a1916daa126208be
+  data.tar.gz: 4ccd9d11711d43ff6bb9facc9bed872f2023d09f1c1669469eb1583bce46783b
 SHA512:
-  metadata.gz: 2c421202ce3c265caa5db1c61d8138252b3bf4b8944de665569f3794b26ea1753e64023fda526577af4b36bb82e4c6724f89d5f823b9e2750a004830b206bafc
-  data.tar.gz: 005d7c0b9b652e5020bce39afa4619c2774db3a4101d0981dcf48ee0d2dc9568c053b66268d403ef6ab599f7d16a1c9d4053adea3f2e618767e356344e252cf2
+  metadata.gz: 0d741c12baacd00c430f8d312d364161ba5959ccbcbfc79093ca520908b1d0c1537d9c50d918b3cb1df3610e5384f2fe36416342b9154fcec7e0d3d07b4d5d9f
+  data.tar.gz: 5bfd26725b5048a49a94746015127385cf03ada9fa9cede00d8a329780d3524442d40e4157a75c66c820e4076baa1d531381e7fd92374dcf98d0880c419be935

data/lib/event_tracer/appsignal_logger.rb

@@ -2,62 +2,62 @@ require_relative '../event_tracer'
 require_relative './basic_decorator'
 
 # NOTES
-# Appsignal interface to send our usual actions 
+# Appsignal interface to send our usual actions
 # BasicDecorator adds a transparent interface on top of the appsignal interface
 #
-# Usage: EventTracer.register :appsignal, EventTracer::AppsignalLogger.new(Appsignal)
-#        appsignal_logger.info appsignal: { increment_counter: { counter_1: 1, counter_2: 2 }, set_gauge: { gauge_1: 1 } }
-#        appsignal_logger.info appsignal: { set_gauge: { gauge_1: { value: 1, tags: { region: 'eu' } } } }
+# Usage: EventTracer.register :appsignal,
+#          EventTracer::AppsignalLogger.new(Appsignal, allowed_tags: ['tag_1', 'tag_2'])
+#
+#        appsignal_logger.info metrics: [:counter_1, :counter_2]
+#        appsignal_logger.info metrics: { counter_1: { type: :counter, value: 1 }, gauce_2: { type: :gauce, value: 10 } }
 module EventTracer
   class AppsignalLogger < BasicDecorator
 
-    SUPPORTED_METRICS ||= %i(increment_counter add_distribution_value set_gauge)
+    SUPPORTED_METRIC_TYPES = {
+      counter: :increment_counter,
+      distribution: :add_distribution_value,
+      gauge: :set_gauge
+    }
+    DEFAULT_METRIC_TYPE = :increment_counter
+    DEFAULT_COUNTER = 1
+
+    def initialize(decoratee, allowed_tags: [])
+      super(decoratee)
+      @allowed_tags = allowed_tags
+    end
 
     LOG_TYPES.each do |log_type|
       define_method log_type do |**args|
-        return LogResult.new(false, "Invalid appsignal config") unless args[:appsignal] && args[:appsignal].is_a?(Hash)
+        metrics = args[:metrics]
+
+        return fail_result('Invalid appsignal config') unless valid_args?(metrics)
+        return success_result if metrics.empty?
 
-        applied_metrics(args[:appsignal]).each do |metric|
-          metric_args = args[:appsignal][metric]
-          return LogResult.new(false, "Appsignal metric #{metric} invalid") unless metric_args && metric_args.is_a?(Hash) 
+        tags = args.slice(*allowed_tags)
 
-          send_metric metric, metric_args
-        rescue InvalidTagError => e
-          return LogResult.new(false, e.message)
+        case metrics
+        when Array
+          metrics.each do |metric|
+            appsignal.public_send(DEFAULT_METRIC_TYPE, metric, DEFAULT_COUNTER, tags)
+          end
+        when Hash
+          metrics.each do |metric_name, metric_payload|
+            metric_type = SUPPORTED_METRIC_TYPES[metric_payload.fetch(:type).to_sym]
+            appsignal.public_send(metric_type, metric_name, metric_payload.fetch(:value), tags) if metric_type
+          end
         end
 
-        LogResult.new(true)
+        success_result
       end
     end
 
     private
 
-      attr_reader :appsignal, :decoratee
+      attr_reader :decoratee, :allowed_tags
       alias_method :appsignal, :decoratee
 
-      def applied_metrics(appsignal_args)
-        appsignal_args.keys.select { |metric| SUPPORTED_METRICS.include?(metric) }
-      end
-
-      def send_metric(metric, payload)
-        payload.each do |increment, attribute|
-          if attribute.is_a?(Hash)
-            begin
-              appsignal.send(
-                metric,
-                increment,
-                attribute.fetch(:value),
-                attribute.fetch(:tags)
-              )
-            rescue KeyError
-              raise InvalidTagError, "Appsignal payload { #{increment}: #{attribute} } invalid"
-            end
-          else
-            appsignal.send(metric, increment, attribute)
-          end
-        end
+      def valid_args?(metrics)
+        metrics && (metrics.is_a?(Hash) || metrics.is_a?(Array))
       end
   end
-
-  class InvalidTagError < StandardError; end
 end

data/lib/event_tracer/base_logger.rb

@@ -20,6 +20,7 @@ module EventTracer
 
       # EventTracer ensures action & message is always populated
       def send_message(log_method, action:, message:, **args)
+        args.delete(:metrics)
         data = args.merge(action: action, message: message)
         logger.public_send(log_method, data)
       end

data/lib/event_tracer/basic_decorator.rb

@@ -16,5 +16,13 @@ module EventTracer
       @delegate_sd_obj = obj
     end
 
+    def success_result
+      LogResult.new(true)
+    end
+
+    def fail_result(message)
+      LogResult.new(false, message)
+    end
+
   end
 end

data/lib/event_tracer/buffer.rb

@@ -0,0 +1,65 @@
+require 'concurrent'
+
+module EventTracer
+  # This is an implementation of buffer storage. We use Concurrent::Array underneath
+  # to ensure thread-safe behavior. Data is stored until certain size / interval
+  # before flushing.
+  #
+  # Caveats: We should only store non-important data like logs in this buffer
+  # because if a process is killed, the data in this buffer is lost.
+  class Buffer
+    # Buffer can store maximum 10 items.
+    # Bigger size requires more memory to store, so choose a reasonable number
+    DEFAULT_BUFFER_SIZE = 10
+    # An item can live in buffer for at least 10s between each `Buffer#add` if the buffer is not full
+    # If there are larger interval between the calls, it can live longer.
+    DEFAULT_FLUSH_INTERVAL = 10
+
+    def initialize(
+      buffer_size: DEFAULT_BUFFER_SIZE,
+      flush_interval: DEFAULT_FLUSH_INTERVAL
+    )
+      @buffer_size = buffer_size
+      @flush_interval = flush_interval
+      @buffer = Concurrent::Array.new
+    end
+
+    # Add an item to buffer
+    #
+    # @param item: data to be added to buffer
+    # @return true if the item can be added, otherwise false
+    def add(item)
+      if add_item?
+        buffer.push({ item: item, created_at: Time.now })
+        true
+      else
+        false
+      end
+    end
+
+    # Remove all existing items from buffer
+    #
+    # @return all items in buffer
+    def flush
+      data = []
+
+      data << buffer.shift[:item] until buffer.empty?
+
+      data
+    end
+
+    # This method is only used to facilitate testing
+    def size
+      buffer.size
+    end
+
+    private
+
+      attr_reader :buffer_size, :flush_interval, :buffer
+
+      def add_item?
+        buffer.size < buffer_size &&
+          (buffer.empty? || buffer.first[:created_at] > Time.now - flush_interval)
+      end
+  end
+end

data/lib/event_tracer/config.rb

@@ -0,0 +1,10 @@
+require 'dry-configurable'
+
+module EventTracer
+  class Config
+    extend Dry::Configurable
+
+    setting :app_name, default: 'app_name'
+    setting :dynamo_db_table_name, default: 'logs'
+  end
+end

data/lib/event_tracer/datadog_logger.rb

@@ -4,72 +4,68 @@ require_relative './basic_decorator'
 # Datadog interface to send our usual actions
 # BasicDecorator adds a transparent interface on top of the datadog interface
 #
-# Usage: EventTracer.register :datadog, EventTracer::DataDogLogger.new(DataDog)
-#        data_dog_logger.info datadog: { count: { counter_1: 1, counter_2: 2 }, set: { gauge_1: 1 } }
-#        data_dog_logger.info datadog: { count: { counter_1: { value: 1, tags: ['tag1, tag2']} } }
+# Usage: EventTracer.register :datadog,
+#          EventTracer::DataDogLogger.new(DataDog, allowed_tags: ['tag_1', 'tag_2'])
+#
+#        data_dog_logger.info metrics: [:counter_1, :counter_2]
+#        data_dog_logger.info metrics: { counter_1: { type: :counter, value: 1}, gauce_2: { type: :gauce, value: 10 } }
 
 module EventTracer
   class DatadogLogger < BasicDecorator
 
-    class InvalidTagError < StandardError; end
+    SUPPORTED_METRIC_TYPES = {
+      counter: :count,
+      distribution: :distribution,
+      gauge: :gauge,
+      set: :set,
+      histogram: :histogram
+    }
+    DEFAULT_METRIC_TYPE = :count
+    DEFAULT_COUNTER = 1
 
-    SUPPORTED_METRICS ||= %i[count set distribution gauge histogram].freeze
+    def initialize(decoratee, allowed_tags: [])
+      super(decoratee)
+      @allowed_tags = allowed_tags
+    end
 
     LOG_TYPES.each do |log_type|
       define_method log_type do |**args|
-        return LogResult.new(false, 'Invalid datadog config') unless args[:datadog]&.is_a?(Hash)
+        metrics = args[:metrics]
+
+        return fail_result('Invalid Datadog config') unless valid_args?(metrics)
+        return success_result if metrics.empty?
 
-        applied_metrics(args[:datadog]).each do |metric|
-          metric_args = args[:datadog][metric]
-          return LogResult.new(false, "Datadog metric #{metric} invalid") unless metric_args.is_a?(Hash)
+        tags = build_tags(args)
 
-          send_metric metric, metric_args
+        case metrics
+        when Array
+          metrics.each do |metric|
+            datadog.public_send(DEFAULT_METRIC_TYPE, metric, DEFAULT_COUNTER, tags: tags)
+          end
+        when Hash
+          metrics.each do |metric_name, metric_payload|
+            metric_type = SUPPORTED_METRIC_TYPES[metric_payload.fetch(:type).to_sym]
+            datadog.public_send(metric_type, metric_name, metric_payload.fetch(:value), tags: tags) if metric_type
+          end
         end
 
-        LogResult.new(true)
+        success_result
       end
     end
 
     private
 
-    attr_reader :datadog, :decoratee
+    attr_reader :decoratee, :allowed_tags
     alias_method :datadog, :decoratee
 
-    def applied_metrics(datadog_args)
-      datadog_args.keys.select { |metric| SUPPORTED_METRICS.include?(metric) }
+    def valid_args?(metrics)
+      metrics && (metrics.is_a?(Hash) || metrics.is_a?(Array))
     end
 
-    def send_metric(metric, payload)
-      payload.each do |increment, attribute|
-        if attribute.is_a?(Hash)
-          begin
-            datadog.public_send(
-              metric,
-              increment,
-              attribute.fetch(:value),
-              build_options(attribute[:tags])
-            )
-          rescue KeyError
-            raise InvalidTagError, "Datadog payload { #{increment}: #{attribute} } invalid"
-          end
-        else
-          datadog.public_send(metric, increment, attribute)
-        end
+    def build_tags(args)
+      args.slice(*allowed_tags).map do |tag, value|
+        "#{tag}:#{value}"
       end
     end
-
-    def build_options(tags)
-      return {} unless tags
-
-      formattted_tags =
-        if tags.is_a?(Array)
-          tags
-        else
-          tags.inject([]) do |acc, (tag, value)|
-            acc << "#{tag}:#{value}"
-          end
-        end
-      { tags: formattted_tags }
-    end
   end
 end

data/lib/event_tracer/dynamo_db/client.rb

@@ -0,0 +1,9 @@
+module EventTracer
+  module DynamoDB
+    class Client
+      def self.call
+        Aws::DynamoDB::Client.new
+      end
+    end
+  end
+end

data/lib/event_tracer/dynamo_db/default_processor.rb

@@ -0,0 +1,15 @@
+module EventTracer
+  module DynamoDB
+    class DefaultProcessor
+      def call(log_type, action:, message:, args:)
+        args.merge(
+          timestamp: Time.now.utc.iso8601(6),
+          action: action,
+          message: message,
+          log_type: log_type,
+          app: EventTracer::Config.config.app_name
+        )
+      end
+    end
+  end
+end

data/lib/event_tracer/dynamo_db/logger.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'time'
+require_relative 'client'
+require_relative 'worker'
+require_relative 'default_processor'
+
+module EventTracer
+  module DynamoDB
+    class Logger
+      def initialize(buffer: Buffer.new(buffer_size: 0), log_processor: DefaultProcessor.new)
+        @buffer = buffer
+        @log_processor = log_processor
+      end
+
+      EventTracer::LOG_TYPES.each do |log_type|
+        define_method log_type do |**args|
+          save_message log_type, **args
+        end
+      end
+
+      private
+
+        attr_reader :buffer, :log_processor
+
+        def save_message(log_type, action:, message:, **args)
+          payload = log_processor.call(log_type, action: action, message: message, args: args)
+
+          unless buffer.add(payload)
+            all_payloads = buffer.flush + [payload]
+            Worker.perform_async(all_payloads)
+          end
+
+          LogResult.new(true)
+        end
+
+    end
+  end
+end

data/lib/event_tracer/dynamo_db/worker.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'client'
+
+begin
+  require 'sidekiq'
+  require 'aws-sdk-dynamodb'
+rescue LoadError => e
+  puts "Please add the missing gem into your app Gemfile: #{e.message}"
+  raise
+end
+
+module EventTracer
+  module DynamoDB
+    class Worker
+      include ::Sidekiq::Worker
+
+      sidekiq_options retry: 1, queue: 'low'
+
+      # See https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#batch_write_item-instance_method
+      MAX_DYNAMO_DB_ITEM_PER_REQUEST = 25
+
+      def perform(items)
+        wrap(items).each_slice(MAX_DYNAMO_DB_ITEM_PER_REQUEST) do |batch|
+          data = batch.map do |item|
+            { put_request: { item: clean_empty_values(item) } }
+          end
+
+          Client.call.batch_write_item(
+            request_items: { EventTracer::Config.config.dynamo_db_table_name => data }
+          )
+
+        rescue Aws::DynamoDB::Errors::ServiceError => e
+          EventTracer.error(
+            loggers: %i(base),
+            action: 'DynamoDBWorker',
+            app: EventTracer::Config.config.app_name,
+            error: e.class.name,
+            message: e.message
+          )
+        end
+      end
+
+      private
+
+        def wrap(items)
+          # NOTE: This allows us to handle either buffered or unbuffered payloads
+          if items.is_a?(Hash)
+            [items]
+          else
+            Array(items)
+          end
+        end
+
+        # dynamo can't serialise empty strings/ non-zero numerics
+        def clean_empty_values(data)
+          data.delete_if do |_key, value|
+            case value
+            when Hash
+              clean_empty_values(value)
+              false
+            when String then value.empty?
+            else false
+            end
+          end
+        end
+
+    end
+  end
+end

data/lib/event_tracer/version.rb

@@ -1,3 +1,3 @@
 module EventTracer
-  VERSION = '0.2.2'.freeze
+  VERSION = '0.4.0'.freeze
 end

data/lib/event_tracer.rb

@@ -31,14 +31,10 @@ module EventTracer
       result = Result.new
 
       loggers.each do |code, logger|
-        begin
-          if args[:action] && args[:message]
-            result.record code, logger.send(log_type, **filtered_log_arguments(code, args))
-          else
-            result.record code, LogResult.new(false, 'Fields action & message need to be populated')
-          end
-        rescue Exception => e
-          result.record code, LogResult.new(false, e.message)
+        if args[:action] && args[:message]
+          result.record code, logger.send(log_type, **args)
+        else
+          result.record code, LogResult.new(false, 'Fields action & message need to be populated')
         end
       end
 
@@ -55,14 +51,6 @@ module EventTracer
       @loggers.select { |code, _logger| selected_codes.include?(code) }
     end
 
-    def self.filtered_log_arguments(logger_code, args)
-      blacklisted_logger_keys = registered_logger_codes - [logger_code]
-
-      args.reject do |key, _value|
-        blacklisted_logger_keys.include?(key)
-      end
-    end
-
     def self.registered_logger_codes
       @loggers.keys
     end
@@ -82,4 +70,4 @@ module EventTracer
 end
 
 project_root = File.dirname(File.absolute_path(__FILE__))
-Dir.glob("#{project_root}/event_tracer/*") {|file| require file}
+Dir.glob("#{project_root}/event_tracer/*.rb") {|file| require file}

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: event_tracer
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.4.0
 platform: ruby
 authors:
 - melvrickgoh
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-02-10 00:00:00.000000000 Z
+date: 2021-10-15 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-configurable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -53,7 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 description: 'Thin wrapper for formatted logging/ metric services to be used as a
-  single service. External service(s) supported: Appsignal'
+  single service. External service(s) supported: Appsignal, Datadog, DynamoDB'
 email:
 - melvrickgoh@hotmail.com
 executables: []
@@ -64,7 +92,13 @@ files:
 - lib/event_tracer/appsignal_logger.rb
 - lib/event_tracer/base_logger.rb
 - lib/event_tracer/basic_decorator.rb
+- lib/event_tracer/buffer.rb
+- lib/event_tracer/config.rb
 - lib/event_tracer/datadog_logger.rb
+- lib/event_tracer/dynamo_db/client.rb
+- lib/event_tracer/dynamo_db/default_processor.rb
+- lib/event_tracer/dynamo_db/logger.rb
+- lib/event_tracer/dynamo_db/worker.rb
 - lib/event_tracer/log_result.rb
 - lib/event_tracer/version.rb
 homepage: https://github.com/melvrickgoh/event_tracer