Tracer now has a config API at the class level because things like
runner, its override option and sink need to be set just once
* changed initialize API to take opts with trace_id, parent_span_id only
* return from intiialize/start/stop unless allowed to run
Changed span annotation API to include: key, message, ignore_if_blank.
* internally, it calls its own API
Tracer's config should be reset before each test so
it starts with a clean slate each time
Switch runner off if no error log device is supplied
* expose error_logger through Telemetry::Config
* invalidates need for Telemetry::Logger
Aliased find_or_create on tracer as fetch
Tracer delegates relevant methods to its current span
only if its allowed to run otherwise it returns a nil. Everything else
goes to super's method_missing
Tracer cleanup:
* raise an exception if with_override is called before the
  config is applied. This is because override is the secondary
  circuit breaker as is meant to be applied on top of the config
* a trace is enabled or disabled at init time so that it finishes
  all the way through.
* privatize the flush method as there's no need to expose it at the
  trace level
* reset a trace only if its not in progress i.e. hasn't started and
  if the override flag is switched (or the trace completes)
If there is an error when the trace is sunk, log the trace
bits in json along with the error backtrace
Switch runner off if no sink information is supplied or
no error log is supplied
Tracer now has a apply_with_annotation helper to its API
so it can annotate a trace at the start itself
Cleanup of Tracer API:
* no need to expose current_span, spans to the client. Doing this forces
  the tracer to apply conditionals such as:
    if run? then do x on the current_span else noop
* exposing spans on the tracer allows the client to add a new span to the
  tracer at any point. Providing yet another option to add a span to the
  currently executing trace is another piece of functinality to defend
  against in terms of enabled/disabled logic
* exposing current_span allows the client to call methods on it. If its
  nil as in the case when the tracer is not allowed to run, then this
  opens a new set of problems, e.g. should we send back a span "proxy"
  object which responds to all of the span methods but performs a noop.
  This starts to get more and more complicated for sub-object the tracer
  interacts with. Therefore best to turn off exposure to sub-objects. If
  the client side wants to test them, they can always call
  to_hash on the tracer which will show its state at any given time.
* start/stop are now private. There's no need to expose them since the
  apply method that takes a block should be sufficient.
* start_new_span is also private - apply_new_span is exposed and uses
  it. The client should never have to call current_span. The client
  simply passes on annotations/post_process_blocks to the current trace
  and the trace figures out how to delegate to the current span. The more
  objects we expose (like current_span), the more protection mechanisms we
  have to build in if they are nil etc. so the underlying app does not
  throw NoMethodErrors if the Tracer is switched off
* no need to expose dirty? - a tainted trace is clear enough with the
  reason being listed in the hash
* for the above listed reasons, no need to expose annotations/post_process_blocks
  for the current span
* run is now enabled for each trace instance
Abstracting post processing functionality into its own class.
* Span class is simpler now. Removed ignore_if_blank option
  when annotating.
* Added a test for timer helper
* a tracer can now be applied with multiple annotations
Fixed broken tests
Added an in memory sink for testing
Tests for zephyr
Removed current API on tracer as it only causes confusion
Added zephyr dependency for development
Updated version
TracerProcessedException now spits out the trace/current_span ids
Tracer's apply API now starts a newly nested span if the the
currently running one is already in progress:
* a span no longer executes its post_process_block when stopped
* The trace's flush method is triggered when all spans are stopped
* calling flush on the tracer triggers the post_process_block
  for each span
* removed the apply_new_span API call on trace as its functionality
  is now handled by the apply API itself