application_insights 0.5.3 → 0.5.4

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    YmYzZWY1NTZhMmUyZGE5MmFiMWU0N2YwZjVmMjEzMmUyNDQwMGIwZg==
-  data.tar.gz: !binary |-
-    YTU5M2NlN2NhMjJmZDVkNGVjYjE5NzIxODEzZTU4NGIwNzNmNThmMQ==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    Y2RlNzYxZjJiNDdkNjRkOGEyYmE4Yjc3NjA4NWQ1YmMyYzFmZWQ4M2Q4ODRk
-    NDQ4Mzk3ZTVmOTZlMzljMjA3ZDJhODAwMmMyNTdlNDJkYjU3NTFkMjI0ZTA4
-    ZDQ0NWQ0Nzk5ODVmOWE0NTg1Yzc1MGYwMzRhM2JmNjg5MmE2N2E=
-  data.tar.gz: !binary |-
-    NGFhYzM5ZmE3YjBjYmViMWIzZDhmN2ZiMjFmZjMyYmE3MDRiNjQ5YjlmNDk2
-    MmZiZmVmODdiMDljNWUwMzVmYjhmN2RiMWRhYmZlZjRhNDNlODFiOGY0Y2U5
-    YTFhMTQ2NDEzMGE0MTFmYmRiZmQwMTYzMjM2YWExZTJiY2RmZmM=
+SHA1:
+  metadata.gz: eec95e24b4930002c21840002367106145b2752a
+  data.tar.gz: e38cde81727c4a511aaf4b4626c32cd9c3fb5826
+SHA512:
+  metadata.gz: 9c55af8a02ca69adefe4396d6b01f4e4ceeddb68e401b9e903db49054f179ab2dd45f171c81cc80b01c2c45b46d80d0eaa4e719d006e2cb6662976f8eabf48e7
+  data.tar.gz: 0452d3daa3574d705c26576ea93ca8086ef105559e4ae0f094567ec58be6daee28e5a202cd090bdf7ed51197435a3fad97d5e28039dcc09cbb39eeabfad00042

data/.travis.yml

@@ -1,9 +1,21 @@
-language: ruby
-rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.0
-  - 2.2.0
-
-install:
-  - bundle install
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.2.0
+  - 2.3.3
+  - 2.4.0
+  - ruby-head
+
+cache: bundler
+
+before_install:
+  - gem install bundler
+
+matrix:
+  allow_failures:
+  - rvm: ruby-head
+
+install:
+  - bundle install

data/CONTRIBUTING.md

@@ -0,0 +1,30 @@
+# How to Contribute
+
+If you're interested in contributing, take a look at the general [contributer's guide](https://github.com/Microsoft/ApplicationInsights-Home/blob/master/CONTRIBUTING.md) first.
+
+## Build Gem
+
+Run ```gem build application_insights.gemspec``` to generate the gem file.
+
+And you can install the gem to test it locally by running ```gem install application_insights-[version].gem```.
+
+## Run Test
+
+Make sure you have bundler installed, you can install it by ```sudo gem install bundler```. And run ```bundler install``` once to install all dependencies.
+
+Run ```rake test```.
+
+## Contributing
+
+This project welcomes contributions and suggestions. Most contributions require you to
+agree to a Contributor License Agreement (CLA) declaring that you have the right to,
+and actually do, grant us the rights to use your contribution. For details, visit
+https://cla.microsoft.com.
+
+When you submit a pull request, a CLA-bot will automatically determine whether you need
+to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the
+instructions provided by the bot. You will only need to do this once across all repositories using our CLA.
+
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
+For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/)
+or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.

data/Gemfile

@@ -1,4 +1,4 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in application_insights.gemspec
-gemspec
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in application_insights.gemspec
+gemspec

data/LICENSE.txt

@@ -1,11 +1,11 @@
-AppInsights-Ruby
-Copyright (c) Microsoft Corporation
-All rights reserved. 
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ""Software""), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+AppInsights-Ruby
+Copyright (c) Microsoft Corporation
+All rights reserved. 
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ""Software""), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,7 +1,7 @@
 # Application Insights SDK for Ruby #
 
 [![Gem Version](https://badge.fury.io/rb/application_insights.svg)](http://badge.fury.io/rb/application_insights)
-[![Build Status](https://travis-ci.org/Microsoft/AppInsights-Ruby.svg)](https://travis-ci.org/Microsoft/ApplicationInsights-Ruby)
+[![Build Status](https://travis-ci.org/Microsoft/ApplicationInsights-Ruby.svg)](https://travis-ci.org/Microsoft/ApplicationInsights-Ruby)
 
 >Ruby is a dynamic, open source programming language with a focus on simplicity and productivity. It has an elegant syntax that is natural to read and easy to write.
 > -- <cite>[Ruby - Official Site](https://www.ruby-lang.org/en/)</cite>
@@ -28,7 +28,7 @@ Once installed, you can send telemetry to Application Insights. Here are a few s
 >**Note**: before you can send data to you will need an instrumentation key. Please see the [Getting an Application Insights Instrumentation Key](https://github.com/Microsoft/AppInsights-Home/wiki#getting-an-application-insights-instrumentation-key) section for more information.
 
 
-###Sending a simple event telemetry item###
+### Sending a simple event telemetry item ###
 ```ruby
 require 'application_insights'
 tc = ApplicationInsights::TelemetryClient.new '<YOUR INSTRUMENTATION KEY GOES HERE>'
@@ -36,7 +36,7 @@ tc.track_event 'My event'
 tc.flush
 ```
 
-###Sending an event telemetry item with custom properties and measurements###
+### Sending an event telemetry item with custom properties and measurements ###
 ```ruby
 require 'application_insights'
 tc = ApplicationInsights::TelemetryClient.new '<YOUR INSTRUMENTATION KEY GOES HERE>'
@@ -44,15 +44,15 @@ tc.track_event 'My event', :properties => { 'custom property' => 'some value' },
 tc.flush
 ```
 
-###Sending a trace telemetry item with custom properties###
+### Sending a trace telemetry item with custom properties ###
 ```ruby
 require 'application_insights'
 tc = ApplicationInsights::TelemetryClient.new '<YOUR INSTRUMENTATION KEY GOES HERE>'
-tc.track_trace 'My trace statement', :properties => { 'custom property' => 'some value' }
+tc.track_trace 'My trace statement', ApplicationInsights::Channel::Contracts::SeverityLevel::INFORMATION, :properties => { 'custom property' => 'some value' }
 tc.flush
 ```
 
-###Sending a metric telemetry item (without and with optional values)###
+### Sending a metric telemetry item (without and with optional values) ###
 ```ruby
 require 'application_insights'
 tc = ApplicationInsights::TelemetryClient.new '<YOUR INSTRUMENTATION KEY GOES HERE>'
@@ -62,7 +62,7 @@ tc.track_metric 'My metric', 42, :kind => ApplicationInsights::Channel::Contract
 tc.flush
 ```
 
-###Sending an exception telemetry item with custom properties and measurements###
+### Sending an exception telemetry item with custom properties and measurements ###
 ```ruby
 require 'application_insights'
 tc = ApplicationInsights::TelemetryClient.new '<YOUR INSTRUMENTATION KEY GOES HERE>'
@@ -74,11 +74,10 @@ end
 tc.flush
 ```
 
-###Configuring context for a telemetry client instance###
+### Configuring context for a telemetry client instance ###
 ```ruby
 require 'application_insights'
 tc = ApplicationInsights::TelemetryClient.new '<YOUR INSTRUMENTATION KEY GOES HERE>'
-tc.context.application.id = 'My application'
 tc.context.application.ver = '1.2.3'
 tc.context.device.id = 'My current device'
 tc.context.device.oem_name = 'Asus'
@@ -89,7 +88,7 @@ tc.track_trace 'My trace with context'
 tc.flush
 ```
 
-###Configuring synchronous (default) channel properties###
+### Configuring synchronous (default) channel properties ###
 ```ruby
 require 'application_insights'
 tc = ApplicationInsights::TelemetryClient.new
@@ -99,7 +98,7 @@ tc.channel.queue.max_queue_length = 10
 tc.channel.sender.send_buffer_size = 5
 ```
 
-###Configuring an asynchronous channel instead of the synchronous default###
+### Configuring an asynchronous channel instead of the synchronous default ###
 ```ruby
 require 'application_insights'
 sender = ApplicationInsights::Channel::AsynchronousSender.new
@@ -111,7 +110,7 @@ tc = ApplicationInsights::TelemetryClient.new '<YOUR INSTRUMENTATION KEY GOES HE
 tc.track_event 'My event'
 ```
 
-###Configuring asynchronous channel properties###
+### Configuring asynchronous channel properties ###
 ```ruby
 require 'application_insights'
 sender = ApplicationInsights::Channel::AsynchronousSender.new
@@ -129,7 +128,7 @@ tc.channel.sender.send_time = 5
 tc.channel.sender.send_interval = 0.5
 ```
 
-###Collecting unhandled exceptions###
+### Collecting unhandled exceptions ###
 ```ruby
 require 'application_insights'
 # setup unhandled exception handler
@@ -138,7 +137,7 @@ ApplicationInsights::UnhandledException.collect('<YOUR INSTRUMENTATION KEY GOES
 raise Exception, 'Boom!'
 ```
 
-###Collecting requests for rack applications###
+### Collecting requests for rack applications ###
 ```ruby
 # set up the TrackRequest middleware in the rackup (config.ru) file
 require 'application_insights'

data/Rakefile

@@ -1,15 +1,15 @@
-require "bundler/gem_tasks"
-require 'rake/testtask'
-require 'yard'
-
-Rake::TestTask.new do |test|
-  test.libs << 'test'
-  test.test_files = FileList['test/application_insights.rb']
-  test.verbose = true
-end
-
-YARD::Rake::YardocTask.new do |task|
-  task.files   = ['lib/**/*.rb', '-', 'LICENSE.txt', 'README.md']
-end
-
+require "bundler/gem_tasks"
+require 'rake/testtask'
+require 'yard'
+
+Rake::TestTask.new do |test|
+  test.libs << 'test'
+  test.test_files = FileList['test/application_insights.rb']
+  test.verbose = true
+end
+
+YARD::Rake::YardocTask.new do |task|
+  task.files   = ['lib/**/*.rb', '-', 'LICENSE.txt', 'README.md']
+end
+
 task :default => [ :test, :build, :yard ]

data/application_insights.gemspec

@@ -1,29 +1,28 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'application_insights/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'application_insights'
-  spec.version       = ApplicationInsights::VERSION
-  spec.authors       = ['Microsoft']
-  spec.email         = ['aiengdisc@microsoft.com']
-  spec.summary       = %q{Application Insights SDK for Ruby}
-  spec.description   = %q{This project extends the Application Insights API surface to support Ruby.}
-  spec.homepage      = 'https://github.com/Microsoft/AppInsights-Ruby'
-  spec.license       = 'MIT'
-
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ['lib']
-
-  spec.required_ruby_version = '>= 1.9.3'
-
-  spec.add_development_dependency 'bundler', '~> 1.7'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'yard', '~> 0.8.7.6'
-  spec.add_development_dependency 'redcarpet', '~> 3.2.2'
-  spec.add_development_dependency 'rack', '>= 1.0.0'
-  spec.add_development_dependency 'test-unit', '~> 3.0.8'
-end
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'application_insights/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'application_insights'
+  spec.version       = ApplicationInsights::VERSION
+  spec.authors       = ['Microsoft']
+  spec.email         = ['aiengdisc@microsoft.com']
+  spec.summary       = %q{Application Insights SDK for Ruby}
+  spec.description   = %q{This project extends the Application Insights API surface to support Ruby.}
+  spec.homepage      = 'https://github.com/Microsoft/AppInsights-Ruby'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 1.9.3'
+
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'yard', '~> 0.9.11'
+  spec.add_development_dependency 'redcarpet', '~> 3.2.2'
+  spec.add_development_dependency 'rack', '>= 1.0.0'
+  spec.add_development_dependency 'test-unit', '~> 3.0.8'
+end

data/lib/application_insights.rb

@@ -1,9 +1,9 @@
-require_relative 'application_insights/telemetry_client'
-require_relative 'application_insights/unhandled_exception'
-require_relative 'application_insights/version'
-
-module ApplicationInsights
-  module Rack
-    autoload :TrackRequest,               "application_insights/rack/track_request"
-  end
-end
+require_relative 'application_insights/telemetry_client'
+require_relative 'application_insights/unhandled_exception'
+require_relative 'application_insights/version'
+
+module ApplicationInsights
+  module Rack
+    autoload :TrackRequest, "application_insights/rack/track_request"
+  end
+end

data/lib/application_insights/channel/asynchronous_queue.rb

@@ -1,51 +1,58 @@
-require_relative 'event'
-require_relative 'queue_base'
-
-module ApplicationInsights
-  module Channel
-    # An asynchronous queue for use in conjunction with the {AsynchronousSender}. The queue
-    # will notify the sender that it needs to pick up items when it reaches {#max_queue_length}, or when the consumer
-    # calls {#flush} via the {#flush_notification} event.
-    # @example
-    #   require 'application_insights'
-    #   require 'thread'
-    #   queue = ApplicationInsights::Channel::AsynchronousQueue.new nil
-    #   Thread.new do
-    #     sleep 1
-    #     queue.push 1
-    #     queue.flush
-    #   end
-    #   queue.flush_notification.wait
-    #   queue.flush_notification.clear
-    #   result = queue.pop
-    class AsynchronousQueue < QueueBase
-      # Initializes a new instance of the class.
-      # @param [SenderBase] sender the sender object that will be used in conjunction with this queue. In addition to
-      #   the sender object must support a {AsynchronousSender#start} method which is invoked
-      #   each time an item is pushed to the queue as well as use the {#flush_notification} event.
-      def initialize(sender)
-        @flush_notification = Event.new
-        super sender
-      end
-
-      # The flush notification {ApplicationInsights::Channel::Event} that the {#sender} will use to get notified
-      # that a flush is needed.
-      # @return [Event] object that the {#sender} can wait on.
-      attr_reader :flush_notification
-
-      # Adds the passed in item object to the queue and notifies the {#sender} to start an asynchronous send operation
-      # by calling {AsynchronousSender#start}.
-      # @param [Contracts::Envelope] item the telemetry envelope object to send to the service.
-      def push(item)
-        super item
-        @sender.start if @sender
-      end
-
-      # Flushes the current queue by notifying the {#sender} via the {#flush_notification} event.
-      def flush
-        @flush_notification.set
-        @sender.start if @sender
-      end
-    end
-  end
-end
+require_relative 'event'
+require_relative 'queue_base'
+
+module ApplicationInsights
+  module Channel
+    # An asynchronous queue for use in conjunction with the {AsynchronousSender}.
+    # The queue will notify the sender that it needs to pick up items when it
+    # reaches {#max_queue_length}, or when the consumer calls {#flush} via the
+    # {#flush_notification} event.
+    #
+    # @example
+    #   require 'application_insights'
+    #   require 'thread'
+    #   queue = ApplicationInsights::Channel::AsynchronousQueue.new nil
+    #   Thread.new do
+    #     sleep 1
+    #     queue.push 1
+    #     queue.flush
+    #   end
+    #   queue.flush_notification.wait
+    #   queue.flush_notification.clear
+    #   result = queue.pop
+    class AsynchronousQueue < QueueBase
+      # Initializes a new instance of the class.
+      # @param [SenderBase] sender the sender object that will be used in
+      #   conjunction with this queue. In addition to the sender object must
+      #   support a {AsynchronousSender#start} method which is invoked each time
+      #   an item is pushed to the queue as well as use the {#flush_notification}
+      #   event.
+      def initialize(sender)
+        @flush_notification = Event.new
+        super sender
+      end
+
+      # The flush notification {ApplicationInsights::Channel::Event} that the {#sender}
+      # will use to get notified that a flush is needed.
+      # @return [Event] object that the {#sender} can wait on.
+      attr_reader :flush_notification
+
+      # Adds the passed in item object to the queue and notifies the {#sender}
+      # to start an asynchronous send operation
+      # by calling {AsynchronousSender#start}.
+      # @param [Contracts::Envelope] item the telemetry envelope object to send
+      #   to the service.
+      def push(item)
+        super item
+        @sender.start if @sender
+      end
+
+      # Flushes the current queue by notifying the {#sender} via the
+      # {#flush_notification} event.
+      def flush
+        @flush_notification.set
+        @sender.start if @sender
+      end
+    end
+  end
+end

data/lib/application_insights/channel/asynchronous_sender.rb

@@ -1,123 +1,132 @@
-require_relative 'sender_base'
-require 'thread'
-
-module ApplicationInsights
-  module Channel
-    # An asynchronous sender that works in conjunction with the {AsynchronousQueue}. The sender object will start a
-    # worker thread that will pull items from the {#queue}. The thread will be created when the client calls {#start} and
-    # will check for queue items every {#send_interval} seconds. The worker thread can also be forced to check the queue
-    # by setting the {AsynchronousQueue#flush_notification} event.
-    #
-    # - If no items are found, the thread will go back to sleep.
-    # - If items are found, the worker thread will send items to the specified service in batches of {#send_buffer_size}.
-    #
-    # If no queue items are found for {#send_time} seconds,  the worker thread will shut down (and {#start} will
-    # need  to be called again).
-    class AsynchronousSender < SenderBase
-      # Initializes a new instance of the class.
-      # @param [String] service_endpoint_uri the address of the service to send telemetry data to.
-      def initialize(service_endpoint_uri='https://dc.services.visualstudio.com/v2/track')
-        @send_interval = 1.0
-        @send_remaining_time = 0
-        @send_time = 3.0
-        @lock_work_thread = Mutex.new
-        @work_thread = nil
-        @start_notification_processed = true
-        super service_endpoint_uri
-      end
-
-      # The time span in seconds at which the the worker thread will check the {#queue} for items (defaults to: 1.0).
-      # @return [Fixnum] the interval in seconds.
-      attr_accessor :send_interval
-
-      # The time span in seconds for which the worker thread will stay alive if no items are found in the {#queue} (defaults to 3.0).
-      # @return [Fixnum] the interval in seconds.
-      attr_accessor :send_time
-
-      # The worker thread which checks queue items and send data every (#send_interval) seconds or upon flush.
-      # @return [Thread] the work thread
-      attr_reader :work_thread
-
-      # Calling this method will create a worker thread that checks the {#queue} every {#send_interval} seconds for
-      # a total duration of {#send_time} seconds for new items. If a worker thread has already been created, calling
-      # this method does nothing.
-      def start
-        @start_notification_processed = false
-        # Maintain one working thread at one time
-        if !@work_thread
-          @lock_work_thread.synchronize do
-            if !@work_thread
-              local_send_interval = (@send_interval < 0.1) ? 0.1 : @send_interval
-              @send_remaining_time = (@send_time < local_send_interval) ? local_send_interval : @send_time
-              @work_thread = Thread.new do
-                run
-              end
-              @work_thread.abort_on_exception = false
-            end
-          end
-        end
-      end
-
-      private
-
-      def run
-        # save the queue locally
-        local_queue = @queue
-        if local_queue == nil
-          @work_thread = nil
-          return
-        end
-
-        begin
-        # fix up the send interval (can't be lower than 100ms)
-        local_send_interval = (@send_interval < 0.1) ? 0.1 : @send_interval
-        while TRUE
-          @start_notification_processed = true
-          while TRUE
-            # get at most @send_buffer_size items from the queue
-            counter = @send_buffer_size
-            data = []
-            while counter > 0
-              item = local_queue.pop
-              break if not item
-              data.push item
-              counter -= 1
-            end
-
-            # if we didn't get any items from the queue, we're done here
-            break if data.length == 0
-
-            # reset the send time
-            @send_remaining_time = @send_time
-
-            # finally send the data
-            send data
-          end
-
-          # wait at most @send_interval ms (or until we get signalled)
-          result = local_queue.flush_notification.wait local_send_interval
-          if result
-            local_queue.flush_notification.clear
-            next
-          end
-
-          # decrement the remaining time
-          @send_remaining_time -= local_send_interval
-          # If remaining time <=0 and there is no start notification unprocessed, then stop the working thread
-          if @send_remaining_time <= 0 && @start_notification_processed
-            # Note: there is still a chance some start notification could be missed, e.g., the start method
-            # got triggered between the above and following line. However the data is not lost as it would be processed
-            # later when next start notification comes after the worker thread stops.  The cost to ensure no
-            # notification miss is high where a lock is required each time the start method calls.
-            @work_thread = nil
-            break
-          end
-        end
-        rescue
-          # Make sure work_thread sets to nil when it terminates abnormally
-          @work_thread = nil
-        end
-      end
-    end
-  end
-end
+require_relative 'sender_base'
+require 'thread'
+
+module ApplicationInsights
+  module Channel
+    # An asynchronous sender that works in conjunction with the {AsynchronousQueue}.
+    # The sender object will start a worker thread that will pull items from the
+    # {#queue}. The thread will be created when the client calls {#start} and
+    # will check for queue items every {#send_interval} seconds. The worker thread
+    # can also be forced to check the queue by setting the
+    # {AsynchronousQueue#flush_notification} event.
+    #
+    # - If no items are found, the thread will go back to sleep.
+    # - If items are found, the worker thread will send items to the specified
+    #   service in batches of {#send_buffer_size}.
+    #
+    # If no queue items are found for {#send_time} seconds,  the worker thread
+    # will shut down (and {#start} will need  to be called again).
+    class AsynchronousSender < SenderBase
+      SERVICE_ENDPOINT_URI = 'https://dc.services.visualstudio.com/v2/track'
+      # Initializes a new instance of the class.
+      # @param [String] service_endpoint_uri the address of the service to send
+      #   telemetry data to.
+      def initialize(service_endpoint_uri = SERVICE_ENDPOINT_URI)
+        @send_interval = 1.0
+        @send_remaining_time = 0
+        @send_time = 3.0
+        @lock_work_thread = Mutex.new
+        @work_thread = nil
+        @start_notification_processed = true
+        super service_endpoint_uri
+      end
+
+      # The time span in seconds at which the the worker thread will check the
+      # {#queue} for items (defaults to: 1.0).
+      # @return [Fixnum] the interval in seconds.
+      attr_accessor :send_interval
+
+      # The time span in seconds for which the worker thread will stay alive if
+      # no items are found in the {#queue} (defaults to 3.0).
+      # @return [Fixnum] the interval in seconds.
+      attr_accessor :send_time
+
+      # The worker thread which checks queue items and send data every
+      # (#send_interval) seconds or upon flush.
+      # @return [Thread] the work thread
+      attr_reader :work_thread
+
+      # Calling this method will create a worker thread that checks the {#queue}
+      # every {#send_interval} seconds for a total duration of {#send_time}
+      # seconds for new items. If a worker thread has already been created,
+      # calling this method does nothing.
+      def start
+        @start_notification_processed = false
+        # Maintain one working thread at one time
+        unless @work_thread
+          @lock_work_thread.synchronize do
+            unless @work_thread
+              local_send_interval = [@send_interval, 0.1].max
+              @send_remaining_time = [@send_time, local_send_interval].max
+              @work_thread = Thread.new { run }
+              @work_thread.abort_on_exception = false
+            end
+          end
+        end
+      end
+
+      private
+
+      def run
+        # save the queue locally
+        local_queue = @queue
+        if local_queue.nil?
+          @work_thread = nil
+          return
+        end
+
+        begin
+          # fix up the send interval (can't be lower than 100ms)
+          local_send_interval = [@send_interval, 0.1].max
+
+          while true
+            @start_notification_processed = true
+            while true
+              # get at most @send_buffer_size items from the queue
+              data = []
+              @send_buffer_size.downto(1) do
+                item = local_queue.pop
+                break if not item
+                data.push item
+              end
+
+              # if we didn't get any items from the queue, we're done here
+              break if data.length == 0
+
+              # reset the send time
+              @send_remaining_time = @send_time
+
+              # finally send the data
+              send data
+            end
+
+            # wait at most @send_interval ms (or until we get signalled)
+            result = local_queue.flush_notification.wait local_send_interval
+            if result
+              local_queue.flush_notification.clear
+              next
+            end
+
+            # decrement the remaining time
+            @send_remaining_time -= local_send_interval
+            # If remaining time <=0 and there is no start notification unprocessed,
+            # then stop the working thread
+            if @send_remaining_time <= 0 && @start_notification_processed
+              # Note: there is still a chance some start notification could be
+              # missed, e.g., the start method got triggered between the above and
+              # following line. However the data is not lost as it would be
+              # processed later when next start notification comes after the worker
+              # thread stops. The cost to ensure no notification miss is high where
+              # a lock is required each time the start method calls.
+              @work_thread = nil
+              break
+            end
+          end
+        rescue
+          # Make sure work_thread sets to nil when it terminates abnormally
+          @work_thread = nil
+        end
+      end
+    end
+  end
+end