transaction_logger 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9dcfe3a7f8cbdde324e95e0a246a411907faf9f5
-  data.tar.gz: c7747c2a99b7705e3689b317276969e41e902b3f
+  metadata.gz: 9b596362707ab73c1c50f5acbabccf71f550bdeb
+  data.tar.gz: 8ae2171ebd12b0af053aa4c0c71cd06a25e7537d
 SHA512:
-  metadata.gz: 81fb304e54412d6ed784684b14b64145ee3796b0fe841fb4b41485cd8790068c9b703cc07fe89da23b629f935f3b6cf1d75797544b3bd81a73f9cef49c79f64f
-  data.tar.gz: 47e00a81952e0633aa9974bea50b7cf9c79f6c72d8899baa315be4330615a43c9d9210409ebedf31d7d89838b46bdb1ff058cc73d8387b0415d0c5935c068ca1
+  metadata.gz: 9b61478fed4c1980b615c49ea2f1d4b8678bc3b9942878ab68b0895fd502dd4fddbcb819026512fa0ce3596ef0baea25a3088d4d03b5997fdb97d7c15d975a47
+  data.tar.gz: 7a51811366be8ad002c624130fe68de5e759edf9a8bbb696e5ca605be857be692602a6f7f5c1e0e1c084c5121c404d023f90c5f9cf312236c67551f9ad34eef7

data/.gitignore

@@ -7,6 +7,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+test.rb
 *.bundle
 *.so
 *.o

data/.rubocop.yml

@@ -0,0 +1,63 @@
+Lint/ParenthesesAsGroupedExpression:
+  Enabled: true
+  Exclude:
+    - 'spec/**/*'
+
+Style/BlockDelimiters:
+  Enabled: true
+  Exclude:
+    - 'spec/**/*'
+
+Style/Documentation:
+  Enabled: false
+
+Style/ClassVars:
+  Enabled: false
+
+Style/EmptyLinesAroundClassBody:
+  Enabled: false
+
+Style/EmptyLinesAroundModuleBody:
+  Enabled: false
+
+Style/GuardClause:
+  Enabled: false
+
+Style/PredicateName:
+  Enabled: false
+
+Style/SignalException:
+  Enabled: false
+
+Style/SpaceAroundEqualsInParameterDefault:
+  Enabled: false
+
+Style/StringLiterals:
+  Enabled: false
+
+# Offense count: 9
+Metrics/AbcSize:
+  Enabled: false
+
+# Offense count: 1
+# Configuration parameters: CountComments.
+Metrics/ClassLength:
+  Enabled: false
+
+# Offense count: 2
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+# Offense count: 79
+# Configuration parameters: AllowURI, URISchemes.
+Metrics/LineLength:
+  Enabled: false
+
+# Offense count: 10
+# Configuration parameters: CountComments.
+Metrics/MethodLength:
+  Enabled: false
+
+# Offense count: 2
+Metrics/PerceivedComplexity:
+  Enabled: false

data/README.md

@@ -1,8 +1,17 @@
 # Blinkist TransactionLogger
-[ ![Codeship Status for blinkist/transaction_logger](https://codeship.com/projects/fb9745c0-edc7-0132-b6b1-1efd3f886df2/status?branch=master)](https://codeship.com/projects/84119) [![Code Climate](https://codeclimate.com/github/blinkist/transaction_logger/badges/gpa.svg)](https://codeclimate.com/github/blinkist/transaction_logger) [![Dependency Status](https://www.versioneye.com/ruby/transaction_logger/badge.svg)](https://www.versioneye.com/ruby/transaction_logger/)
+[ ![Codeship Status for blinkist/transaction_logger](https://codeship.com/projects/fb9745c0-edc7-0132-b6b1-1efd3f886df2/status?branch=master)](https://codeship.com/projects/84119) [![Gem Version](https://badge.fury.io/rb/transaction_logger.svg)](http://badge.fury.io/rb/transaction_logger) [![Code Climate](https://codeclimate.com/github/blinkist/transaction_logger/badges/gpa.svg)](https://codeclimate.com/github/blinkist/transaction_logger) [![Dependency Status](https://www.versioneye.com/ruby/transaction_logger/badge.svg)](https://www.versioneye.com/ruby/transaction_logger/)
 
 Business Transactions Logger for Ruby that compiles contextual logging information and can send it to a configured logging service such as Logger or Loggly in a nested hash.
 
+## Table of Contents
+
+1. [Installation](#installation)
+2. [Output](#output)
+3. [Configuration](#configuration)
+4. [Usage](#usage)
+5. [Version History](#version-history)
+6. [Contributing](#contributing)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -21,11 +30,13 @@ Or install it yourself as:
 
 ## Output
 
-Given a root transaction, the TransactionLogger is expected to print out every log that occurred under this root transaction, and each sub-transaction's local information.
+By registering a method with TransactionLogger, the TransactionLogger is expected to print out every log that occurred under this method, and each nested method's local information as well.
 
 When a transaction raises an error, it will log the *error message*, *error class*, and *10 lines* of the backtrace by default. This will be logged at the level of the transaction that raised the error.
 
-## Usage
+Additionally, if no errors are raised, but an *error* or *fatal* log is made, then the TransactionLogger will send it's log hash to the configured logger.
+
+## Configuration
 
 Configure the logger by calling TransactionLogger.logger, such as with Ruby's Logger:
 
@@ -36,10 +47,13 @@ TransactionLogger.logger = logger
 
 Calling Transaction_Logger.logger with no parameter sets the logger to a new instance of Logger as shown above.
 
+### Configuring the Prefix
+
 You can add a prefix to every hash key in the log by using the class method log_prefix:
 
 ```ruby
 TransactionLogger.log_prefix = "transaction_logger_"
+# output hash:
 # {
 #   "transaction_logger_name" => "some name"
 #   "transaction_logger_context" => { "user_id" => 1 }
@@ -47,22 +61,35 @@ TransactionLogger.log_prefix = "transaction_logger_"
 # }
 ```
 
-Wrap a business transaction method with a TransactionLogger lambda:
+### Configuring the Log Level Threshold
+
+You may also choose at which log level the TransactionLogger sends it's log hash. By default, *error* is the threshold, so that if an *error* or *fatal* log is made, then the TransactionLogger will send a JSON hash to it's configured logger. If you wish to set the threshold to *warn*, you can configure the TransactionLogger to do so:
 
 ```ruby
-def some_method
-  TransactionLogger.start -> (t) do
-    # your code.
+TransactionLogger.level_threshold = :warn
+```
+
+## Usage
+
+To register a method as a transaction, include the TransactionLogger and use *add_transaction_log* after the method definition:
+
+```ruby
+class YourClass
+  include TransactionLogger
+
+  def some_method
+    logger.info "logged message"
+    # method code
   end
+
+  add_transaction_log :some_method
 end
 ```
 
-From within this lambda, you may call upon t to add a custom name, context and log your messages, like so:
+By default, the transaction will be named *YourClass:some_method*, and have no context. You can easily change this by adding the following symbols to an additional options parameter:
 
 ```ruby
-t.name = "YourClass.some_method"
-t.context = { specific: "context: #{value}" }
-t.log "A message you want logged"
+add_transaction_log :some_method, {name: "Custom Name", context: {}}
 ```
 
 ### Example
@@ -70,30 +97,27 @@ t.log "A message you want logged"
 Initial setup, in a config file:
 
 ```ruby
-# Sets output to new instance of Logger
-TransactionLogger.logger
+logger = Logger.new STDOUT
 
-# Sets the prefix of each hash key in the log to "transaction_"
-#   eg. An error message has key: "transaction_error_message"
-TransactionLogger.log_prefix = "transaction_"
+# Sets output to the new Logger
+TransactionLogger.logger = logger
 ```
 
 Here is a transaction that raises an error:
 
 ```ruby
 class ExampleClass
-  def some_method
-    TransactionLogger.start -> (t) do
-      t.name = "ExampleClass.some_method"
-      t.context = { some_id: 12 }
+  def some_method(result)
+    include TransactionLogger
 
-      t.log "Trying something complex"
-      raise RuntimeError, "Error"
+    logger.info "Trying something complex"
+    raise RuntimeError, "Error"
 
-      result
-      t.log "Success"
-    end
+    result
+    logger.info "Success"
   end
+
+  add_transaction_log :some_method, {context: {some_id: 12}}
 end
 ```
 
@@ -101,7 +125,7 @@ The expected output is:
 
 ```json
 {
-  "name": "ExampleClass.some_method",
+  "name": "ExampleClass:some_method",
   "context": {
     "some_id": 12
   },
@@ -112,17 +136,36 @@ The expected output is:
       "error_message": "Error",
       "error_class": "RuntimeError",
       "error_backtrace": [
-        "example.rb:84:in `block in nested_method'",
-        ".../TransactionLogger_Example/transaction_logger.rb:26:in `call'",
-        ".../TransactionLogger_Example/transaction_logger.rb:26:in `run'",
-        ".../TransactionLogger_Example/transaction_logger.rb:111:in `start'",
-        "example.rb:79:in `nested_method'"
+        "example_class.rb:6:in `some_method'",
+        ".../transaction_logger.rb:86:in `call'",
+        ".../transaction_logger.rb:86:in `block (2 levels) in add_transaction_log'",
+        ".../transaction_logger/transaction.rb:37:in `call'",
+        ".../transaction_logger/transaction.rb:37:in `run'",
+        ".../transaction_logger/transaction_manager.rb:41:in `start'",
+        ".../transaction_logger.rb:78:in `block in add_transaction_log'",
+        "test.rb:4:in `<main>'"
       ]
 
   }]
 }
 ```
 
+## Version History
+
+### v1.0.0
+
+- AOP approach that provides a much cleaner, easier implementation of the TransactionLogger
+- Added default transaction name
+- Added support for log level threshold
+
+### v0.1.0
+
+- Added support for log prefixes
+
+### v0.0.1
+
+- initial version
+
 ## Contributing
 
 1. Fork it ( https://github.com/blinkist/transaction_logger/fork )

data/Rakefile

@@ -1,2 +1,8 @@
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
 
+RuboCop::RakeTask.new
+RSpec::Core::RakeTask.new :spec
+
+task default: [:rubocop, :spec]

data/lib/transaction_logger/transaction.rb

@@ -1,131 +1,166 @@
+require "json"
+require "logger"
+
+module TransactionLogger
+  class Transaction
+    attr_reader :parent
+
+    attr_accessor :name
+    attr_accessor :context
+    attr_accessor :level_threshold
+    attr_accessor :level_threshold_broken
+
+    # @param parent [TransactionLogger::Transaction] Parent of transaction
+    # @param lmbda [Proc] The surrounded block
+    #
+    def initialize(options, lmbda)
+      @parent = options[:parent]
+      @parent.log self if @parent
+
+      @lmbda = lmbda
+
+      @log_prefix = options[:prefix]
+      @name = "undefined"
+      @context = {}
+      @level_threshold = options[:level_threshold] || :error
+      @log_queue = []
+      @start = Time.now
+      @error_printed = nil
+      @level_threshold_broken = false
+
+      @logger = options[:logger]
+    end
 
-class TransactionLogger::Transaction
-  attr_reader :parent
+    # @private
+    # Runs the lines of code from within the lambda. FOR INTERNAL USE ONLY.
+    #
+    def run
+      begin
+        result = @lmbda.call self
+      rescue => error
 
-  attr_accessor :name
-  attr_accessor :context
+        e_message_key = "#{@log_prefix}error_message"
+        e_class_key = "#{@log_prefix}error_class"
+        e_backtrace_key = "#{@log_prefix}error_backtrace"
 
-  # @param parent [TransactionLogger::Transaction] Parent of transaction
-  # @param lmbda [Proc] The surrounded block
-  #
-  def initialize(parent=nil, lmbda)
-    @parent = parent
-    @parent.log self if @parent
+        log(e_message_key => error.message,
+            e_class_key => error.class.name,
+            e_backtrace_key => error.backtrace.take(10))
 
-    @lmbda = lmbda
+        failure error, self
+      else
+        success
+      end
 
-    @name = "undefined"
-    @context = {}
-    @log_queue = Array.new
-    @start = Time.now
-    @error_printed = nil
-  end
+      result
+    end
 
-  # @private
-  # Runs the lines of code from within the lambda. FOR INTERNAL USE ONLY.
-  #
-  def run
-    begin
-      result = @lmbda.call self
-    rescue => error
-
-      e_message_key = "#{TransactionLogger.log_prefix}error_message"
-      e_class_key = "#{TransactionLogger.log_prefix}error_class"
-      e_backtrace_key = "#{TransactionLogger.log_prefix}error_backtrace"
-
-      log({
-        e_message_key => error.message,
-        e_class_key => error.class.name,
-        e_backtrace_key => error.backtrace.take(5)
-      })
-
-      failure error, self
-    else
-      success
+    # Pushes a message into the log queue. Logs are stored in order
+    #   of time logged. Note that this method will not output a log, but just
+    #   stores it in the queue to be outputted if an error is raised in a
+    #   transaction.
+    #
+    # @param message [#to_s] Any String or Object that responds to to_s
+    #   that you want to be stored in the log queue.
+    #
+    def log(message, level=:info)
+      check_level(level)
+      if message.is_a? String
+        message_key = "#{@log_prefix}#{level}"
+        message = { message_key => message }
+        @log_queue.push message
+      else
+        @log_queue.push message
+      end
     end
 
-    result
-  end
+    # @private
+    # Logs the error and raises error to the parent process
+    def failure(error, transaction)
+      calc_duration
+
+      if @parent
+        @parent.failure error, transaction
+      else
+        unless @error_printed
+          print_transactions
+          @error_printed = true
+        end
 
-  # Pushes a message into the log queue. Logs are stored in order
-  #   of time logged. Note that this method will not output a log, but just
-  #   stores it in the queue to be outputted if an error is raised in a
-  #   transaction.
-  #
-  # @param message [#to_s] Any String or Object that responds to to_s
-  #   that you want to be stored in the log queue.
-  #
-  def log(message)
-    if message.is_a? String
-      message_key = "#{TransactionLogger.log_prefix}info"
-      message = { message_key => message }
-      @log_queue.push message
-    else
-      @log_queue.push message
+        raise error
+      end
     end
-  end
 
-  # @private
-  # Logs the error and raises error to the parent process
-  def failure(error, transaction)
-    calc_duration
-
-    if @parent
-      @parent.failure error, transaction
-    else
-      unless @error_printed
-        print_transactions
-        @error_printed = true
+    # @private
+    # Converts a Transaction and it's children into a single nested hash
+    def to_hash
+      name_key = "#{@log_prefix}name"
+      context_key = "#{@log_prefix}context"
+      duration_key = "#{@log_prefix}duration"
+      history_key = "#{@log_prefix}history"
+
+      output = {
+        name_key => @name,
+        context_key => @context,
+        duration_key => @duration,
+        history_key => []
+      }
+
+      @log_queue.each do|entry|
+        if entry.is_a? self.class
+          output[history_key] << entry.to_hash
+        elsif entry.is_a? Hash
+          output[history_key] << entry
+        else
+          output[history_key] << entry
+        end
       end
 
-      raise error
+      output
     end
-  end
 
-  # @private
-  # Converts a Transaction and it's children into a single nested hash
-  def to_hash
-    name_key = "#{TransactionLogger.log_prefix}name"
-    context_key = "#{TransactionLogger.log_prefix}context"
-    duration_key = "#{TransactionLogger.log_prefix}duration"
-    history_key = "#{TransactionLogger.log_prefix}history"
-
-    output = {
-      name_key => @name,
-      context_key => @context,
-      duration_key => @duration,
-      history_key => []
-    }
-
-    @log_queue.each {|entry|
-      if entry.is_a? TransactionLogger::Transaction
-        output[history_key] << entry.to_hash
-      elsif entry.is_a? Hash
-        output[history_key] << entry
+    # @private
+    #
+    def check_level(level)
+      levels = { debug: 0, info: 1, warn: 2, error: 3, fatal: 4 }
+      input_level_id = levels[level]
+      level_threshold_id = levels[@level_threshold]
+      if level_threshold_id
+        @level_threshold_broken = true if input_level_id >= level_threshold_id
       else
-        output[history_key] << entry
+        @level_threshold_broken = true if input_level_id >= 3
       end
-    }
+    end
 
-    output
-  end
+    private
 
+    # Calculates the duration upon the success of a transaction
+    def success
+      calc_duration
 
-  private
+      unless @error_printed || !@level_threshold_broken
+        if @parent
+          @parent.instance_variable_set :@level_threshold_broken, true
+        else
+          print_transactions
+          @error_printed = true
+        end
+      end
 
-  # Calculates the duration upon the success of a transaction
-  def success
-    calc_duration
-  end
+      # unless @parent || @error_printed || !@level_threshold_broken
+      # end
+    end
 
-  # Calculates the number of milliseconds that the Transaction has taken
-  def calc_duration
-    @duration = (Time.now - @start) * 1000.0
-  end
+    # Calculates the number of milliseconds that the Transaction has taken
+    def calc_duration
+      @duration = (Time.now - @start) * 1000.0
+    end
 
-  # Sends the transaction context and log to an instance of logger
-  def print_transactions(transaction=nil)
-    TransactionLogger.logger.error to_hash
-  end
+    # Sends the transaction context and log to an instance of logger
+    def print_transactions
+      @logger ||= Logger.new(STDOUT)
+      @logger.error to_hash
+    end
 
+  end
 end

data/lib/transaction_logger/transaction_manager.rb

@@ -0,0 +1,64 @@
+require "logger"
+require "transaction_logger/version"
+require "transaction_logger/transaction"
+
+module TransactionLogger
+  class TransactionManager
+
+    @@prefix = ""
+    @@current_transactions = {}
+
+    # Marks the beginning of a "Transaction lambda," which will log an error if the
+    #   containing code raises an error. A lambda instance variable let's you call
+    #   the .log method and access the ".name" and ".context" variables. The start
+    #   method must take a lambda as an argument.
+    #
+    #   Whatever the outer method is, if a value is returned within the Transaction
+    #   lambda it will be returned to the outer method as well.
+    #
+    #   The start method does not catch errors, so if an error is raised, it will simply
+    #   envoke a logging message to be outputted and then raise the error.
+    #
+    #   This also checks which thread is envoking the method in order to make sure the
+    #   logs are thread-safe.
+    #
+    # @param prefix [String]
+    # @param logger [Logger]
+    # @param level_threshold [Symbol]
+    # @param lmbda [Proc]
+    #
+    def self.start(options={}, lmbda)
+      options[:parent] = active_transaction
+
+      transaction = TransactionLogger::Transaction.new options, lmbda
+      self.active_transaction = transaction
+
+      begin
+        transaction.run
+      rescue StandardError => e
+        raise e
+      ensure
+        self.active_transaction = transaction.parent
+      end
+    end
+
+    # @private
+    # Returns the current parent of a thread of Transactions.
+    #
+    # @return [TransactionLogger::Transaction] The current parent given a Thread
+    #
+    def self.active_transaction
+      if @@current_transactions.key?(Thread.current.object_id)
+        @@current_transactions[Thread.current.object_id]
+      end
+    end
+
+    # @private
+    # Sets the current parent of a thread of Transactions.
+    #
+    def self.active_transaction=(transaction)
+      @@current_transactions[Thread.current.object_id] = transaction
+    end
+
+  end
+end

data/lib/transaction_logger/version.rb

@@ -1,3 +1,3 @@
-class TransactionLogger
-  VERSION = "0.1.0"
+module TransactionLogger
+  VERSION = "1.0.0"
 end

data/lib/transaction_logger.rb

@@ -1,95 +1,133 @@
 require "transaction_logger/version"
 require "transaction_logger/transaction"
+require "transaction_logger/transaction_manager"
 
-class TransactionLogger
+module TransactionLogger
 
-  @@prefix = ""
-  @@current_transactions = {}
+  # @private
+  # Extends ClassMethods of including class to the TransactionLogger
+  #
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
 
-  # Marks the beginning of a "Transaction lambda," which will log an error if the
-  #   containing code raises an error. A lambda instance variable let's you call
-  #   the .log method and access the ".name" and ".context" variables. The start
-  #   method must take a lambda as an argument.
+  # Sets the hash keys on the TransactionLogger's log to have a prefix.
   #
-  #   Whatever the outer method is, if a value is returned within the Transaction
-  #   lambda it will be returned to the outer method as well.
+  # Using .log_prefix "str_", the output of the log hash will contain keys
+  # prefixed with "str_", such as { "str_name" => "Class.method" }.
   #
-  #   The start method does not catch errors, so if an error is raised, it will simply
-  #   envoke a logging message to be outputted and then raise the error.
+  # @param prefix [#to_s] Any String or Object that responds to to_s
   #
-  #   This also checks which thread is envoking the method in order to make sure the
-  #   logs are thread-safe.
+  def self.log_prefix=(prefix)
+    @prefix = "#{prefix}"
+  end
+
+  # @private
+  # Returns the log_prefix
   #
-  # @param lmbda [Proc]
+  # @return [String] The currently stored prefix.
   #
-  def self.start(lmbda)
-
-    active_transaction = get_active_transaction
-
-    transaction = TransactionLogger::Transaction.new active_transaction, lmbda
-    active_transaction = transaction
-
-    set_active_transaction active_transaction
-
-    begin
-      transaction.run
-    rescue Exception => e
-      raise e
-    ensure
-      set_active_transaction transaction.parent
-    end
+  def self.log_prefix
+    @prefix
   end
 
   # Sets the TransactionLogger's output to a specific instance of Logger.
   #
   # @param logger [Logger] Any instace of ruby Logger
   #
-  def self.logger=(logger)
-    @@logger = logger
+  class << self
+    attr_writer :logger
   end
 
   # Sets the TransactionLogger's output to a new instance of Logger
   #
   def self.logger
-    @@logger ||= Logger.new(STDOUT)
+    @logger ||= Logger.new(STDOUT)
   end
 
-  # Sets the hash keys on the TransactionLogger's log to have a prefix.
-  #
-  # Using .log_prefix "str_", the output of the log hash will contain keys prefixed
-  # with "str_", such as { "str_name" => "Class.method" }.
+  # Sets the TransactionLogger's logger level threshold.
   #
-  # @param prefix [#to_s] Any String or Object that responds to to_s
+  # @param level [Symbol] A symbol recognized by logger, such as :warn
   #
-  def self.log_prefix=(prefix)
-    @@prefix = "#{prefix}"
+  class << self
+    attr_writer :level_threshold
   end
 
-  # @private
-  # Returns the log_prefix
-  #
-  # @return [String] The currently stored prefix.
-  #
-  def self.log_prefix
-    @@prefix
-  end
+  module ClassMethods
 
-  # @private
-  # Returns the current parent of a thread of Transactions.
-  #
-  # @return [TransactionLogger::Transaction] The current parent given a Thread
-  #
-  def self.get_active_transaction
-    if @@current_transactions.has_key?(Thread.current.object_id)
-      @@current_transactions[Thread.current.object_id]
+    # Registers a method with the TransactionLogger, which will begin tracking the
+    #   logging within the method and it's nested methods. These logs are collected
+    #   under one transaction, and if the level threshold is broken or when an error
+    #   is raised, the collected logs are pushed to the configured logger as a JSON
+    #   hash.
+    #
+    #   By registering multiple methods as transactions, each method becomes it's
+    #   own transaction.
+    #
+    # @param method [Symbol] The method you want to register with TransactionLogger
+    # @param options [Hash] Additional options, such as custom transaction name and context
+    #
+    def add_transaction_log(method, options={})
+      old_method = instance_method method
+
+      prefix = Module.nesting.last.instance_variable_get :@prefix
+      logger = Module.nesting.last.instance_variable_get :@logger
+      level_threshold = Module.nesting.last.instance_variable_get :@level_threshold
+
+      options = { prefix: prefix, logger: logger, level_threshold: level_threshold }
+
+      define_method method do
+        TransactionManager.start options, lambda  { |transaction|
+          transaction.name = options[:name]
+          transaction.name ||= "#{old_method.bind(self).owner}#{method.inspect}"
+          transaction.context = options[:context]
+          transaction.context ||= {}
+
+          self.class.trap_logger method, transaction
+          old_method.bind(self).call
+        }
+      end
     end
-  end
 
-  # @private
-  # Sets the current parent of a thread of Transactions.
-  #
-  def self.set_active_transaction(transaction)
-    @@current_transactions[Thread.current.object_id] = transaction
+    # @private
+    # Traps the original logger inside the TransactionLogger
+    #
+    # @param method [Symbol]
+    # @param transaction [Transaction]
+    #
+    def trap_logger(_method, transaction)
+      logger_method = instance_method :logger
+
+      define_method :logger do
+        @original_logger ||= logger_method.bind(self).call
+        calling_method = caller_locations(1, 1)[0].label
+
+        @trapped_logger ||= {}
+        @trapped_logger[calling_method] ||= LoggerProxy.new @original_logger, transaction
+      end
+    end
   end
 
+  class LoggerProxy
+
+    # @private
+    def initialize(original_logger, transaction)
+      @original_logger = original_logger
+      @transaction = transaction
+    end
+
+    levels = %i( debug info warn error fatal )
+
+    levels.each do |level|
+      define_method level do |*args|
+        @original_logger.send level, *args
+        @transaction.log(*args, level)
+      end
+    end
+
+    # @private
+    def method_missing(method, *args)
+      @original_logger.send method, *args
+    end
+  end
 end

data/spec/transaction_logger_spec.rb

@@ -2,13 +2,15 @@ require "spec_helper"
 require "logger"
 
 describe TransactionLogger do
-
   let (:test_lmbda) {
-    -> (t) do
+    lambda  do |_t|
     end
   }
 
-  subject { TransactionLogger::Transaction.new nil, test_lmbda }
+  subject {
+    TransactionLogger::Transaction.new(
+      { prefix: nil, logger: Logger.new(STDOUT), level_threshold: nil }, test_lmbda)
+  }
 
   it "initializes with a nil parent" do
     expect(subject.parent).to be_nil
@@ -16,79 +18,35 @@ describe TransactionLogger do
 
   it "responds to .start" do
     expect(described_class).to receive(:start)
-    described_class.start -> (t) do end
+    described_class.start -> (_t) do end
   end
 
   context "when there is a parent" do
-
     let (:test_parent) { subject }
-    let (:child) { child = TransactionLogger::Transaction.new test_parent, test_lmbda }
+    let (:child) {
+      TransactionLogger::Transaction.new(
+        { parent: test_parent, prefix: nil, logger: Logger.new(STDOUT), level_threshold: nil }, test_lmbda)
+    }
     let (:test_parent_log_queue) { test_parent.instance_variable_get(:@log_queue) }
 
     it "has a parent" do
-      expect(child).to have_attributes(:parent => test_parent)
+      expect(child).to have_attributes(parent: test_parent)
     end
 
     it "places itself into the log of the parent" do
       expect(test_parent_log_queue).to include(child)
     end
-
-    context "when there is an error" do
-
-      it "raises the error to the parent" do
-
-      end
-
-    end
-
-  end
-
-  context "when in 3-level nested transactions" do
-    it "raises an error" do
-      expect {
-        described_class.start -> (t) do
-          t.context = {user_id: 01, information: "contextual info"}
-          t.log "First Message"
-
-          described_class.start -> (t2) do
-            t2.context = {user_id: 01, information: "contextual info"}
-            t2.log "Second Message"
-            t2.log "Third Message"
-
-          end
-
-          t.log "Fourth Message"
-
-          described_class.start -> (t3) do
-            t3.context = {user_id: 01, information: "contextual info"}
-            t3.log "Fifth Message"
-
-            described_class.start -> (t4) do
-              t4.context = {user_id: 01, information: "contextual info"}
-              t4.log "Sixth Message"
-              t4.log "Seventh Message"
-
-              fail RuntimeError, "test error"
-            end
-
-            t3.log "Eighth Message"
-          end
-
-        end
-      }.to raise_error RuntimeError
-    end
   end
 
   describe ".start" do
     let (:test_lmbda) {
-      described_class.start -> (t) do
+      described_class.start lambda (t) do
         t.log ""
       end
     }
   end
 
   describe ".log_prefix" do
-
     context "when there is no prefix" do
       it "does not change the output" do
         expect(subject.to_hash).to include("name" => "undefined")
@@ -102,6 +60,11 @@ describe TransactionLogger do
         described_class.log_prefix = prefix
       end
 
+      subject {
+        TransactionLogger::Transaction.new(
+          { prefix: described_class.log_prefix, logger: Logger.new(STDOUT), level_threshold: nil }, test_lmbda)
+      }
+
       after :example do
         described_class.log_prefix = ""
       end
@@ -110,15 +73,12 @@ describe TransactionLogger do
         expect(subject.to_hash).to include("bta_name" => "undefined")
       end
     end
-
   end
 
   describe "#run" do
-
     context "when no exception is raised" do
-
       let (:test_lmbda) {
-        -> (t) do
+        lambda  do |_t|
           "result"
         end
       }
@@ -128,121 +88,30 @@ describe TransactionLogger do
       it "returns lmda" do
         expect(result).to eq "result"
       end
-
     end
 
     context "when an exception is raised" do
-
       let (:test_lmbda) {
-        -> (t) do
-          fail RuntimeError, "test error"
+        lambda  do |_t|
+          fail "test error"
         end
       }
 
+      let (:child) {
+        TransactionLogger::Transaction.new(
+          { prefix: nil, logger: Logger.new(STDOUT), level_threshold: nil }, test_lmbda)
+      }
+
       let (:result) { subject.run }
 
       it "raises an exception" do
-        expect{result}.to raise_error "test error"
+        expect { result }.to raise_error "test error"
       end
 
       it "calls failure" do
         expect(subject).to receive(:failure)
         result
       end
-
     end
-
   end
-
-  # Try to think of ways to refactor this
-  #   given that I can test certain specific behaviors
-  #   first, and then use those tests to know the bigger
-  #   picture is working...
-  describe "Logger" do
-
-    subject {
-      Logger.new STDOUT
-    }
-
-    before :each do
-      described_class.logger = subject
-    end
-
-    context "when there is one transaction" do
-
-      it "recieves nothing" do
-        expect(subject).to_not receive(:error)
-
-        described_class.start -> (t) do
-          t.context = {user_id: 01, information: "contextual info"}
-          t.log "First Message"
-        end
-      end
-
-      it "recieves error if an exception occurs" do
-        expect(subject).to receive(:error)
-        expect {
-          described_class.start -> (t) do
-            t.context = {user_id: 01, information: "contextual info"}
-            t.log "First Message"
-            fail RuntimeError, "test error"
-          end
-        }.to raise_error(RuntimeError)
-      end
-
-    end
-
-    context "when there is a nested transaction with two levels" do
-
-      it "recieves error if an exception occurs" do
-        expect(subject).to receive(:error) do |options|
-          expect(options["history"]).to include( {"info" => "First Message"} )
-          expect(options["history"].last["history"]).to include({"info" => "Second Message"})
-          expect(options["history"].last["history"].last["error_message"]).to eq("test error")
-          expect(options["history"].last["history"].last["error_class"]).to eq("RuntimeError")
-        end
-
-        expect {
-          described_class.start -> (t) do
-            t.context = {user_id: 01, information: "contextual info"}
-            t.log "First Message"
-            described_class.start -> (t2) do
-              t2.log "Second Message"
-              fail RuntimeError, "test error"
-            end
-          end
-        }.to raise_error RuntimeError
-      end
-
-    end
-
-    context "when there are two nested transactions, two-levels deep" do
-
-      it "recieves error if an exception occurs" do
-
-        expect(subject).to receive("error") do |options|
-          expect(options["history"].first["history"]).to include({"info" => "First Message"})
-          expect(options["history"].last["history"]).to include({"info" => "Second Message"})
-          expect(options["history"].last["history"].last["error_message"]).to eq("test error")
-          expect(options["history"].last["history"].last["error_class"]).to eq("RuntimeError")
-        end
-
-        expect {
-          described_class.start -> (t) do
-            t.context = {user_id: 01, information: "contextual info"}
-            described_class.start -> (t2) do
-              t2.log "First Message"
-            end
-            described_class.start -> (t2) do
-              t2.log "Second Message"
-              fail RuntimeError, "test error"
-            end
-          end
-        }.to raise_error RuntimeError
-      end
-
-    end
-
-  end
-
 end

data/transaction_logger.gemspec

@@ -8,13 +8,13 @@ Gem::Specification.new do |spec|
   spec.version       = TransactionLogger::VERSION
   spec.authors       = ["John Donner", "Sebastian Schleicher"]
   spec.email         = ["johnbdonner@gmail.com", "sebastian.julius@gmail.com"]
-  spec.summary       = %q{Contextual Business Transaction Logger for Ruby}
-  spec.description   = %q{A logger that silently collects information in the
+  spec.summary       = 'Contextual Business Transaction Logger for Ruby'
+  spec.description   = 'A logger that silently collects information in the
                           background and when an error is raised, logs a hash either
                           out to the System or pushes the log to a service such as
                           Loggly. The log hash contains information such as the
-                          backtrace, any logs from calling classes and methods, 
-                          and configurable contextual information.}
+                          backtrace, any logs from calling classes and methods,
+                          and configurable contextual information.'
   spec.homepage      = "https://github.com/blinkist/transaction_logger"
   spec.license       = "MIT"
 
@@ -31,4 +31,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "yard"
   spec.add_development_dependency "redcarpet"
   spec.add_development_dependency "github-markdown"
+  spec.add_development_dependency "rubocop"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: transaction_logger
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - John Donner
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-10 00:00:00.000000000 Z
+date: 2015-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -109,12 +109,27 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: "A logger that silently collects information in the\n                          background
-  and when an error is raised, logs a hash either\n                          out to
-  the System or pushes the log to a service such as\n                          Loggly.
-  The log hash contains information such as the\n                          backtrace,
-  any logs from calling classes and methods, \n                          and configurable
-  contextual information."
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  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'
+description: |-
+  A logger that silently collects information in the
+                            background and when an error is raised, logs a hash either
+                            out to the System or pushes the log to a service such as
+                            Loggly. The log hash contains information such as the
+                            backtrace, any logs from calling classes and methods,
+                            and configurable contextual information.
 email:
 - johnbdonner@gmail.com
 - sebastian.julius@gmail.com
@@ -123,6 +138,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rubocop.yml"
 - ".yardopts"
 - Gemfile
 - LICENSE
@@ -131,6 +147,7 @@ files:
 - Rakefile
 - lib/transaction_logger.rb
 - lib/transaction_logger/transaction.rb
+- lib/transaction_logger/transaction_manager.rb
 - lib/transaction_logger/version.rb
 - spec/spec_helper.rb
 - spec/support/debugging.rb