application_insights 0.3.0 → 0.5.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NWFiNjNiNjljMTc2ODI1NzQ4M2VhNTlmODU2MTcxZTFlZjliMTA2Yw==
+    ODhmYmI4Y2ExYTdmNTAyOGY3MDAyNGM3NDI0N2ViMmM0NmMzYTkzNg==
   data.tar.gz: !binary |-
-    NGM3NzEwNDZkYzI1MWEwNjRiNTMwNWMyOGJlYTkwODA5MjM2MmI2Yw==
+    NjY2MmVkYzcwYzFmZjYzYzMyZjYzZmIwMTBjOTliZjBlNzc2NGUyZA==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    MTU5OTgzY2QzMWMwOTJmYTM3YTZiZWNlYTg4NmQ0NWM4ODkzYjk2ZTI4MTQ4
-    NzJmMDJiNTQxNTA0YzkwNjBmYTEwYTc3ZjBhNmU5YjQxZTRmODA2ZTU4Zjgz
-    ZWJhMzAzZWI2NmYyNzRjMzg0ZDNmZmQwNjZkNmY3MGU2NjYzN2U=
+    YTc3NGQyNDM1N2I4MjNkYmUxOTRlMTNhNDdkNWU0MGY1ZjZlMDNhZDQ5NmFi
+    MGQ4MmViMGE0YzU1MTRmMjI5M2Q2NmE0YTcyNmNmMjRjNTQzNWY2ZWFkNGE4
+    MTlhNGMwMDBkYTc1NjczN2I0YWViOTQyNWRjZjRiM2QwM2I1ZDc=
   data.tar.gz: !binary |-
-    NjA1MDU4ZWY2Mjc0MDZiZTYxM2Y0ZTk3MzQ2MjI2NzdjZDU1Y2FkZTY0MGY5
-    ZDBkNDQ1ZGQ4Zjk5M2MwNThmM2VjNjg4ZWNlNjE3ZjMxMjdkMWI3NDRiYmMy
-    YTc5ZDcxYmUwZWM1MzNjMDVhYTU1ZmEwYTFjNDUxOTUxMDYyY2M=
+    YTYyMGU4MzkxYjUwZTljM2Y3ZGYxZGI1MTUxZGI0ZDc3OGI4YTMyNDQyNTBl
+    NTIxMDM4YTc0ZWM0ODU5ZmE3MWQ0ZDI4ODEzZDAzMmVlYTlhOGFmMGNmYmQy
+    YzRkNjg0OTM0MGYyYzYzNGM1MDMyYjMwNzE5ODZmYjgyMmM4M2I=

data/README.md

@@ -30,8 +30,7 @@ Once installed, you can send telemetry to Application Insights. Here are a few s
 ###Sending a simple event telemetry item###
 ```ruby
 require 'application_insights'
-tc = ApplicationInsights::TelemetryClient.new
-tc.context.instrumentation_key = '<YOUR INSTRUMENTATION KEY GOES HERE>'
+tc = ApplicationInsights::TelemetryClient.new '<YOUR INSTRUMENTATION KEY GOES HERE>'
 tc.track_event 'My event'
 tc.flush
 ```
@@ -39,8 +38,7 @@ tc.flush
 ###Sending an event telemetry item with custom properties and measurements###
 ```ruby
 require 'application_insights'
-tc = ApplicationInsights::TelemetryClient.new
-tc.context.instrumentation_key = '<YOUR INSTRUMENTATION KEY GOES HERE>'
+tc = ApplicationInsights::TelemetryClient.new '<YOUR INSTRUMENTATION KEY GOES HERE>'
 tc.track_event 'My event', :properties => { 'custom property' => 'some value' }, :measurements => { 'custom metric' => 13 }
 tc.flush
 ```
@@ -48,8 +46,7 @@ tc.flush
 ###Sending a trace telemetry item with custom properties###
 ```ruby
 require 'application_insights'
-tc = ApplicationInsights::TelemetryClient.new
-tc.context.instrumentation_key = '<YOUR INSTRUMENTATION KEY GOES HERE>'
+tc = ApplicationInsights::TelemetryClient.new '<YOUR INSTRUMENTATION KEY GOES HERE>'
 tc.track_trace 'My trace statement', :properties => { 'custom property' => 'some value' }
 tc.flush
 ```  
@@ -57,8 +54,7 @@ tc.flush
 ###Sending a metric telemetry item (without and with optional values)###
 ```ruby
 require 'application_insights'
-tc = ApplicationInsights::TelemetryClient.new
-tc.context.instrumentation_key = '<YOUR INSTRUMENTATION KEY GOES HERE>'
+tc = ApplicationInsights::TelemetryClient.new '<YOUR INSTRUMENTATION KEY GOES HERE>'
 tc.track_metric 'My metric', 42
 # with all optional values set
 tc.track_metric 'My metric', 42, :kind => ApplicationInsights::Channel::Contracts::DataPointType::AGGREGATION, :count => 3, :min => 1, :max => 100, :std_dev => 10, :properties => { 'custom property' => 'some value' }
@@ -68,8 +64,7 @@ tc.flush
 ###Sending an exception telemetry item with custom properties and measurements###
 ```ruby
 require 'application_insights'
-tc = ApplicationInsights::TelemetryClient.new
-tc.context.instrumentation_key = '<YOUR INSTRUMENTATION KEY GOES HERE>'
+tc = ApplicationInsights::TelemetryClient.new '<YOUR INSTRUMENTATION KEY GOES HERE>'
 begin
   raise ArgumentError, 'Something has gone wrong!'
 rescue => e
@@ -81,8 +76,7 @@ tc.flush
 ###Configuring context for a telemetry client instance###
 ```ruby
 require 'application_insights'
-tc = ApplicationInsights::TelemetryClient.new
-tc.context.instrumentation_key = '<YOUR INSTRUMENTATION KEY GOES HERE>'
+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'
@@ -110,7 +104,7 @@ require 'application_insights'
 sender = ApplicationInsights::Channel::AsynchronousSender.new
 queue = ApplicationInsights::Channel::AsynchronousQueue.new sender
 channel = ApplicationInsights::Channel::TelemetryChannel.new nil, queue
-tc = ApplicationInsights::TelemetryClient.new channel
+tc = ApplicationInsights::TelemetryClient.new '<YOUR INSTRUMENTATION KEY GOES HERE>', channel
 # Note: the event will be sent on a separate thread; if the app finishes before
 #       the thread finishes, the data is lost
 tc.track_event 'My event'
@@ -122,7 +116,7 @@ require 'application_insights'
 sender = ApplicationInsights::Channel::AsynchronousSender.new
 queue = ApplicationInsights::Channel::AsynchronousQueue.new sender
 channel = ApplicationInsights::Channel::TelemetryChannel.new nil, queue
-tc = ApplicationInsights::TelemetryClient.new channel
+tc = ApplicationInsights::TelemetryClient.new '<YOUR INSTRUMENTATION KEY GOES HERE>', channel
 # flush telemetry if we have 10 or more telemetry items in our queue
 tc.channel.queue.max_queue_length = 10
 # send telemetry to the service in batches of 5

data/application_insights.gemspec

@@ -24,4 +24,5 @@ Gem::Specification.new do |spec|
   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'
 end

data/lib/application_insights.rb

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

data/lib/application_insights/channel/asynchronous_sender.rb

@@ -20,8 +20,9 @@ module ApplicationInsights
         @send_interval = 1.0
         @send_remaining_time = 0
         @send_time = 3.0
-        @lock_send_remaining_time = Mutex.new
+        @lock_work_thread = Mutex.new
         @work_thread = nil
+        @start_notification_processed = true
         super service_endpoint_uri
       end
 
@@ -41,40 +42,37 @@ module ApplicationInsights
       # 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
-        @lock_send_remaining_time.synchronize do
-          # only maintain one working thread at one time
-          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
+        @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
-            @work_thread.abort_on_exception = false
           end
         end
       end
 
-      # Calling this method will shut down the worker thread that checks the {#queue} for new items. The thread will be
-      # allowed to shut down gracefully.
-      def stop
-        @lock_send_remaining_time.synchronize do
-          @send_remaining_time = 0
-        end
-      end
-
       private
 
       def run
         # save the queue locally
         local_queue = @queue
         if local_queue == nil
-          stop
+          @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
@@ -90,9 +88,7 @@ module ApplicationInsights
             break if data.length == 0
 
             # reset the send time
-            @lock_send_remaining_time.synchronize do
-              @send_remaining_time = @send_time
-            end
+            @send_remaining_time = @send_time
 
             # finally send the data
             send data
@@ -106,15 +102,21 @@ module ApplicationInsights
           end
 
           # decrement the remaining time
-          @lock_send_remaining_time.synchronize do
-            @send_remaining_time -= local_send_interval
-            # Check queue as well to avoid missing any 'start' notification occurred during waiting
-            if @send_remaining_time <= 0 && local_queue.empty?
-              @work_thread = nil
-              break
-            end
+          @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

data/lib/application_insights/channel/queue_base.rb

@@ -53,7 +53,7 @@ module ApplicationInsights
       end
 
       # Indicates whether the queue is empty.
-      # @return [true, false] true if the queue is empty
+      # @return [Boolean] true if the queue is empty
       def empty?
         @queue.empty?
       end

data/lib/application_insights/channel/sender_base.rb

@@ -43,7 +43,9 @@ module ApplicationInsights
             'Content-Encoding' => 'gzip'
         }
         request = Net::HTTP::Post.new(uri.path, headers)
-        compressed_data = compress(data_to_send.to_json)
+        # Use JSON.generate instead of to_json, otherwise it will default to ActiveSupport::JSON.encode for Rails app
+        json = JSON.generate(data_to_send)
+        compressed_data = compress(json)
         request.body = compressed_data
 
         http = Net::HTTP.new uri.hostname, uri.port

data/lib/application_insights/channel/telemetry_channel.rb

@@ -1,3 +1,4 @@
+require 'time'
 require_relative 'asynchronous_queue'
 require_relative 'asynchronous_sender'
 require_relative 'telemetry_context'
@@ -62,7 +63,7 @@ module ApplicationInsights
         }
         envelope_attributes = {
           :name => 'Microsoft.ApplicationInsights.' + data_type[0..-5],
-          :time => Time.now.getutc.strftime('%FT%T.%6NZ'),
+          :time => Time.now.iso8601(7),
           :i_key => local_context.instrumentation_key,
           :tags => get_tags(local_context),
           :data => Contracts::Data.new(data_attributes)

data/lib/application_insights/channel/telemetry_context.rb

@@ -62,7 +62,7 @@ module ApplicationInsights
 
       # The property context. This contains free-form properties that you can add to your telemetry.
       # @return [Hash<String, String>] the context object.
-      attr_reader :properties
+      attr_accessor :properties
     end
   end
 end

data/lib/application_insights/rack/track_request.rb

@@ -0,0 +1,84 @@
+require 'rack'
+require_relative '../channel/contracts/request_data'
+require_relative '../telemetry_client'
+
+module ApplicationInsights
+  module Rack
+    # Track every request and sends the request data to Application Insights.
+    class TrackRequest
+      # Initializes a new instance of the class.
+      # @param [Object] app the inner rack application.
+      # @param [String] instrumentation_key to identify which Application Insights application this data is for.
+      # @param [Fixnum] buffer_size the buffer size and the buffered requests would send to Application Insights
+      #   when buffer is full.
+      # @param [Fixnum] send_interval the frequency (in seconds) to check buffer and send buffered requests to Application
+      #   Insights if any.
+      def initialize(app, instrumentation_key, buffer_size=500, send_interval=60)
+        @app = app
+        @instrumentation_key = instrumentation_key
+        @buffer_size = buffer_size
+        @send_interval = send_interval
+      end
+
+      # Track requests and send data to Application Insights asynchronously.
+      # @param [Hash] env the rack environment.
+      def call(env)
+        start = Time.now
+        begin
+          status, headers, response = @app.call(env)
+        rescue Exception => ex
+          status = 500
+          exception = ex
+        end
+        stop = Time.now
+
+        if !@client
+          sender = @sender || Channel::AsynchronousSender.new
+          sender.send_interval = @send_interval
+          queue = Channel::AsynchronousQueue.new sender
+          queue.max_queue_length = @buffer_size
+          channel = Channel::TelemetryChannel.new nil, queue
+          @client = TelemetryClient.new  @instrumentation_key, channel
+        end
+
+        request = ::Rack::Request.new env
+        id = rand(16**32).to_s(16)
+        start_time = start.iso8601(7)
+        duration = format_request_duration(stop - start)
+        success = status.to_i < 400
+        options = {
+            :name => "#{request.request_method} #{request.path}",
+            :http_method => request.request_method,
+            :url => request.url
+        }
+        @client.track_request id, start_time, duration, status, success, options
+
+        if exception != nil
+          @client.track_exception exception, handled_at: 'Unhandled'
+          raise exception
+        end
+
+        [status, headers, response]
+      end
+
+      private
+
+      def sender=(sender)
+        @sender = sender if sender.is_a? Channel::AsynchronousSender
+      end
+
+      def client
+        @client
+      end
+
+      def format_request_duration(duration_seconds)
+        if duration_seconds >= 86400
+          # just return 1 day when it takes more than 1 day which should not happen for requests.
+          return "%d:%02d:%02d:%02d.%07d" % [1, 0, 0, 0, 0]
+        end
+
+        Time.at(duration_seconds).gmtime.strftime("0:%H:%M:%S.%7N")
+      end
+    end
+  end
+end

data/lib/application_insights/telemetry_client.rb

@@ -9,16 +9,20 @@ require_relative 'channel/contracts/data_point_type'
 require_relative 'channel/contracts/metric_data'
 require_relative 'channel/contracts/message_data'
 require_relative 'channel/contracts/stack_frame'
+require_relative 'channel/contracts/request_data'
+require_relative 'channel/contracts/severity_level'
 
 module ApplicationInsights
   # The telemetry client used for sending all types of telemetry. It serves as the main entry point for
   # interacting with the Application Insights service.
   class TelemetryClient
     # Initializes a new instance of the class.
+    # @param [String] instrumentation_key to identify which Application Insights application this data is for.
     # @param [Channel::TelemetryChannel] telemetry_channel the optional telemetry channel to be used instead of
     #   constructing a default one.
-    def initialize(telemetry_channel = nil)
+    def initialize(instrumentation_key = nil, telemetry_channel = nil)
       @context = Channel::TelemetryContext.new
+      @context.instrumentation_key = instrumentation_key
       @channel = telemetry_channel || Channel::TelemetryChannel.new
     end
 
@@ -83,7 +87,7 @@ module ApplicationInsights
         details_attributes = {
           :id => 1,
           :outer_id => 0,
-          :type_name => exception.class,
+          :type_name => exception.class.name,
           :message => exception.message,
           :has_full_stack => exception.backtrace != nil,
           :stack => (exception.backtrace.join("\n") if exception.backtrace),
@@ -159,18 +163,51 @@ module ApplicationInsights
 
     # Sends a single trace statement.
     # @param [String] name the trace statement.
+    # @param [Channel::Contracts::SeverityLevel] severity_level the severity level.
     # @param [Hash] options the options to create the {Channel::Contracts::EventData} object.
     # @option options [Hash] :properties the set of custom properties the client wants attached to this
     #   data item. (defaults to: {})
-    def track_trace(name, options={})
+    def track_trace(name, severity_level = Channel::Contracts::SeverityLevel::INFORMATION, options={})
       data_attributes = {
-        :message => name || 'Null',
-        :properties => options.fetch(:properties) { {} }
+          :message => name || 'Null',
+          :severity_level => severity_level || Channel::Contracts::SeverityLevel::INFORMATION,
+          :properties => options.fetch(:properties) { {} }
       }
       data = Channel::Contracts::MessageData.new data_attributes
       self.channel.write(data, self.context)
     end
 
+    # Sends a single request.
+    # @param [String] id the unique identifier of the request.
+    # @param (String) start_time the start time of the request.
+    # @param [String] duration the duration to process the request.
+    # @param [String] response_code the response code of the request.
+    # @param [Boolean] success indicates whether the request succeeds or not.
+    # @param [Hash] options the options to create the {Channel::Contracts::RequestData} object.
+    # @option options [String] :name the name of the request.
+    # @option options [String] :http_method the http method used for the request.
+    # @option options [String] :url the url of the request.
+    # @option options [Hash] :properties the set of custom properties the client wants attached to this
+    #   data item. (defaults to: {})
+    # @option options [Hash] :measurements the set of custom measurements the client wants to attach to
+    #   this data item (defaults to: {})
+    def track_request(id, start_time, duration, response_code, success, options={})
+      data_attributes = {
+          :id => id || 'Null',
+          :start_time => start_time || Time.now.iso8601(7),
+          :duration => duration || '0:00:00:00.0000000',
+          :response_code => response_code || 200,
+          :success => success = nil ? true : success,
+          :name => options[:name],
+          :http_method => options[:http_method],
+          :url => options[:url],
+          :properties => options.fetch(:properties) { {} },
+          :measurements => options.fetch(:measurements) { {} }
+      }
+      data = Channel::Contracts::RequestData.new data_attributes
+      self.channel.write(data, self.context)
+    end
+
     # Flushes data in the queue. Data in the queue will be sent either immediately irrespective of what sender is
     # being used.
     def flush

data/lib/application_insights/unhandled_exception.rb

@@ -37,9 +37,8 @@ module ApplicationInsights
 
         queue = Channel::SynchronousQueue.new @sender
         channel = Channel::TelemetryChannel.new nil, queue
-        client = TelemetryClient.new channel
-        client.context.instrumentation_key = instrumentation_key
-        client.track_exception($!, {:handled_at => 'Unhandled'})
+        client = TelemetryClient.new instrumentation_key, channel
+        client.track_exception($!, handled_at: 'Unhandled')
         client.flush
       end
     end

data/lib/application_insights/version.rb

@@ -1,3 +1,3 @@
 module ApplicationInsights
-  VERSION = '0.3.0'
+  VERSION = '0.5.0'
 end

data/test/application_insights/channel/test_asynchronous_queue.rb

@@ -1,5 +1,6 @@
 require_relative '../../../lib/application_insights/channel/sender_base'
 require_relative '../../../lib/application_insights/channel/asynchronous_queue'
+require_relative '../mock_sender'
 require 'test/unit'
 
 include ApplicationInsights::Channel
@@ -43,26 +44,4 @@ class TestAsynchronousQueue < Test::Unit::TestCase
     result = queue.flush_notification.wait
     assert_equal true, result
   end
-end
-
-class MockAsynchronousSender
-  def initialize
-    @send_buffer_size = 2
-    @data = []
-    @queue = nil
-    @start_call_count = 0
-  end
-
-  attr_accessor :start_call_count
-  attr_accessor :send_buffer_size
-  attr_accessor :data
-  attr_accessor :queue
-
-  def start
-    @start_call_count += 1
-  end
-
-  def send(data_to_send)
-    @data.push data_to_send
-  end
 end

data/test/application_insights/channel/test_asynchronous_sender.rb

@@ -36,7 +36,7 @@ class TestAsynchronousSender < Test::Unit::TestCase
     sender.invoke_base_start = true
     queue.push 1
     assert_not_nil sender.work_thread
-    sleep 3.0
+    sleep 5.0
     assert_nil sender.work_thread
   end
 

data/test/application_insights/channel/test_synchronous_queue.rb

@@ -1,5 +1,6 @@
 require_relative '../../../lib/application_insights/channel/sender_base'
 require_relative '../../../lib/application_insights/channel/synchronous_queue'
+require_relative '../mock_sender'
 require 'test/unit'
 
 include ApplicationInsights::Channel
@@ -11,32 +12,17 @@ class TestSynchronousQueue < Test::Unit::TestCase
 
   def test_flush_works_as_expected
     sender = MockSynchronousSender.new
+    sender.send_buffer_size = 2
     queue = SynchronousQueue.new sender
     queue.max_queue_length = 3
     (1..7).to_a.each do |i|
       queue.push i
     end
-    assert_equal [[1, 2], [3], [4, 5], [6]], sender.data
+    assert_equal [[1, 2], [3], [4, 5], [6]], sender.buffer
     temp = []
     queue.instance_variable_get('@queue').length.times do |i|
       temp.push queue.instance_variable_get('@queue').pop
     end
     assert_equal [7], temp
   end
-end
-
-class MockSynchronousSender
-  def initialize
-    @send_buffer_size = 2
-    @data = []
-    @queue = nil
-  end
-
-  attr_accessor :send_buffer_size
-  attr_accessor :data
-  attr_accessor :queue
-
-  def send(data_to_send)
-    @data.push data_to_send
-  end
 end

data/test/application_insights/channel/test_telemetry_context.rb

@@ -68,5 +68,8 @@ class TestTelemetryContext < Test::Unit::TestCase
     context = TelemetryContext.new
     assert_not_nil context.properties
     assert_equal 0, context.properties.count
+    expected = {:a => 'a', :b => 'b'}
+    context.properties = expected
+    assert_same expected, context.properties
   end
 end

data/test/application_insights/mock_sender.rb

@@ -0,0 +1,37 @@
+require_relative '../../lib/application_insights/channel/synchronous_sender'
+require_relative '../../lib/application_insights/channel/asynchronous_sender'
+
+include ApplicationInsights::Channel
+
+class MockSynchronousSender < SynchronousSender
+  def initialize
+    @buffer = []
+    super
+  end
+
+  attr_accessor :buffer
+
+  def send(data)
+    @buffer << data
+  end
+end
+
+class MockAsynchronousSender < AsynchronousSender
+  def initialize
+    @buffer = []
+    @start_call_count = 0
+    super
+  end
+
+  attr_accessor :start_call_count
+  attr_accessor :buffer
+
+  def start
+    @start_call_count += 1
+    super
+  end
+
+  def send(data)
+    @buffer << data
+  end
+end

data/test/application_insights/rack/test_track_request.rb

@@ -0,0 +1,139 @@
+require 'test/unit'
+require 'rack/mock'
+require_relative '../mock_sender'
+require_relative '../../../lib/application_insights/rack/track_request'
+
+include ApplicationInsights::Rack
+
+class TestTrackRequest < Test::Unit::TestCase
+  def test_call_works_as_expected
+    response_code = rand(200..204)
+    app = Proc.new {|env| sleep(2); [response_code, {"Content-Type" => "text/html"}, ["Hello Rack!"]]}
+    url = "http://localhost:8080/foo?a=b"
+    http_method = 'PUT'
+    env = Rack::MockRequest.env_for(url, :method => http_method)
+    instrumentation_key = 'key'
+    sender = MockAsynchronousSender.new
+    track_request = TrackRequest.new app, instrumentation_key, 500, 1
+    track_request.send(:sender=, sender)
+    start_time = Time.now
+    result = track_request.call(env)
+    assert_equal app.call(env), result
+    sleep(sender.send_interval)
+
+    assert_equal 1, sender.buffer.count
+    payload = sender.buffer[0]
+    assert_equal instrumentation_key, payload[0].i_key
+
+    request_data = payload[0].data.base_data
+    assert_equal "#{http_method} /foo", request_data.name
+    assert_equal response_code, request_data.response_code
+    assert_equal true, request_data.success
+    assert_equal http_method, request_data.http_method
+    assert_equal url, request_data.url
+    assert_equal true, request_data.duration.start_with?("0:00:00:02")
+    assert_in_epsilon Time.parse(request_data.start_time) - start_time, 0, 0.01
+  end
+
+  def test_call_with_failed_request
+    response_code = rand(400..600)
+    app = Proc.new {|env| [response_code, {"Content-Type" => "text/html"}, ["Hello Rack!"]]}
+    url = "http://localhost:8080/foo"
+    http_method = 'PUT'
+    env = Rack::MockRequest.env_for(url, :method => http_method)
+    instrumentation_key = 'key'
+    sender = MockAsynchronousSender.new
+    track_request = TrackRequest.new app, instrumentation_key, 500, 1
+    track_request.send(:sender=, sender)
+    track_request.call(env)
+    sleep(sender.send_interval)
+
+    payload = sender.buffer[0]
+    request_data = payload[0].data.base_data
+    assert_equal false, request_data.success
+  end
+
+  def test_call_with_unhandled_exception
+    app = Proc.new {|env| raise StandardError, 'Boom!'}
+    env = Rack::MockRequest.env_for( "http://localhost:8080/foo", :method => "GET")
+    instrumentation_key = 'key'
+    sender = MockAsynchronousSender.new
+    track_request = TrackRequest.new app, instrumentation_key, 500, 1
+    track_request.send(:sender=, sender)
+    
+    begin
+      track_request.call(env)
+    rescue => ex
+      assert_equal 'Boom!', ex.message
+    end
+    
+    sleep(sender.send_interval)
+    payload = sender.buffer[0]
+    assert_equal 2, payload.count
+    request_data = payload[0].data.base_data
+    assert_equal false, request_data.success
+    assert_equal 500, request_data.response_code
+
+    exception_data = payload[1].data.base_data
+    assert_equal instrumentation_key, payload[1].i_key
+    assert_equal 'Unhandled', exception_data.handled_at
+  end
+
+  def test_internal_client
+    app = Proc.new {|env| [200, {"Content-Type" => "text/html"}, ["Hello Rack!"]]}
+    env = Rack::MockRequest.env_for('http://localhost:8080/foo', :method => "GET")
+    buffer_size = 30
+    send_interval = 5
+    track_request = TrackRequest.new app, 'key', buffer_size, send_interval
+    client = track_request.send(:client)
+    # test lazy initialization
+    assert_nil client
+
+    track_request.call(env)
+    client = track_request.send(:client)
+    channel = client.channel
+    assert_equal buffer_size, channel.queue.max_queue_length
+    assert_equal send_interval, channel.sender.send_interval
+
+    track_request.call(env)
+    client2 = track_request.send(:client)
+    channel2 = client2.channel
+    assert_same client, client2
+    assert_same channel, channel2
+  end
+
+  def test_format_request_duration_less_than_a_day
+    app = Proc.new {|env| [200, {"Content-Type" => "text/html"}, ["Hello Rack!"]]}
+    track_request = TrackRequest.new app, 'one'
+    duration_seconds = rand(86400) + rand
+    time_span = track_request.send(:format_request_duration, duration_seconds)
+    time_span_format = /^(?<day>\d{1}):(?<hour>\d{2}):(?<minute>\d{2}):(?<second>\d{2}).(?<fraction>\d{7})$/
+    match = time_span_format.match time_span
+    assert_not_nil match
+    days = duration_seconds.to_i/86400
+    assert_equal days, match['day'].to_i
+    hours = (duration_seconds - days * 86400).to_i/3600
+    assert_equal hours, match['hour'].to_i
+    minutes = (duration_seconds - days * 86400 - hours * 3600).to_i/60
+    assert_equal minutes, match['minute'].to_i
+    seconds = (duration_seconds - days * 86400 - hours * 3600 - minutes * 60).to_i
+    assert_equal seconds, match['second'].to_i
+    fraction = ((duration_seconds - duration_seconds.to_i) * 10 ** 7).to_i
+    assert_equal fraction, match['fraction'].to_i
+  end
+
+  def test_format_request_duration_more_than_a_day
+    app = Proc.new {|env| [200, {"Content-Type" => "text/html"}, ["Hello Rack!"]]}
+    track_request = TrackRequest.new app, 'one'
+    duration_seconds = rand(86400..240000) + rand
+    time_span = track_request.send(:format_request_duration, duration_seconds)
+    time_span_format = /^(?<day>\d{1}):(?<hour>\d{2}):(?<minute>\d{2}):(?<second>\d{2}).(?<fraction>\d{7})$/
+    match = time_span_format.match time_span
+    assert_not_nil match
+    assert_equal 1, match['day'].to_i
+    assert_equal 0, match['hour'].to_i
+    assert_equal 0, match['minute'].to_i
+    assert_equal 0, match['second'].to_i
+    assert_equal 0, match['fraction'].to_i
+  end
+end

data/test/application_insights/test_telemetry_client.rb

@@ -14,9 +14,10 @@ class TestTelemetryClient < Test::Unit::TestCase
     assert_not_nil client.channel
 
     channel = Object.new
-    client = TelemetryClient.new channel
+    client = TelemetryClient.new 'a', channel
     assert_not_nil client.context
     assert_same channel, client.channel
+    assert_equal 'a', client.context.instrumentation_key
   end
 
   def test_context_property_works_as_expected
@@ -81,9 +82,19 @@ class TestTelemetryClient < Test::Unit::TestCase
 
   def test_track_trace_view_works_as_expected
     client, sender = self.create_client
-    client.track_trace 'test'
+    client.track_trace 'test', Channel::Contracts::SeverityLevel::WARNING
     client.flush
-    expected = '[{"ver":1,"name":"Microsoft.ApplicationInsights.Message","time":"TIME_PLACEHOLDER","sampleRate":100.0,"tags":{"ai.internal.sdkVersion":"rb:0.1.0"},"data":{"baseType":"MessageData","baseData":{"ver":2,"message":"test"}}}]'
+    expected = '[{"ver":1,"name":"Microsoft.ApplicationInsights.Message","time":"TIME_PLACEHOLDER","sampleRate":100.0,"tags":{"ai.internal.sdkVersion":"rb:0.1.0"},"data":{"baseType":"MessageData","baseData":{"ver":2,"message":"test","severityLevel":2}}}]'
+    sender.data_to_send[0].time = 'TIME_PLACEHOLDER'
+    actual = sender.data_to_send.to_json
+    assert_equal expected, actual
+  end
+
+  def test_track_request_view_works_as_expected
+    client, sender = self.create_client
+    client.track_request 'test', '2015-01-24T23:10:22.7411910-08:00', '0:00:00:02.0000000','200', true
+    client.flush
+    expected = '[{"ver":1,"name":"Microsoft.ApplicationInsights.Request","time":"TIME_PLACEHOLDER","sampleRate":100.0,"tags":{"ai.internal.sdkVersion":"rb:0.1.0"},"data":{"baseType":"RequestData","baseData":{"ver":2,"id":"test","startTime":"2015-01-24T23:10:22.7411910-08:00","duration":"0:00:00:02.0000000","responseCode":"200","success":true}}}]'
     sender.data_to_send[0].time = 'TIME_PLACEHOLDER'
     actual = sender.data_to_send.to_json
     assert_equal expected, actual
@@ -93,7 +104,7 @@ class TestTelemetryClient < Test::Unit::TestCase
     sender = MockTelemetryClientSender.new
     queue = Channel::SynchronousQueue.new sender
     channel = Channel::TelemetryChannel.new nil, queue
-    client = TelemetryClient.new channel
+    client = TelemetryClient.new nil, channel
     return client, sender
   end
 end

data/test/application_insights/test_unhandled_exception.rb

@@ -1,4 +1,5 @@
 require 'test/unit'
+require_relative 'mock_sender'
 require_relative '../../lib/application_insights/unhandled_exception'
 
 include ApplicationInsights
@@ -6,7 +7,7 @@ include ApplicationInsights
 class TestUnhandledException < Test::Unit::TestCase
 
   def test_send
-    sender = MockSender.new
+    sender = MockSynchronousSender.new
     error = 'Boom!'
     instrumentation_key = 'one'
     begin
@@ -20,23 +21,4 @@ class TestUnhandledException < Test::Unit::TestCase
     assert_equal instrumentation_key, payload[0].i_key
     assert_equal 'Unhandled', payload[0].data.base_data.handled_at
   end
-end
-
-class MockSender
-  def initialize
-    @buffer = []
-    @queue = nil
-    @send_buffer_size = 100
-  end
-
-  attr_accessor :buffer
-  attr_accessor :queue
-  attr_accessor :send_buffer_size
-
-  def send(data)
-    @buffer << data
-  end
-
-  def flush
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: application_insights
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Microsoft
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-15 00:00:00.000000000 Z
+date: 2015-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 3.2.2
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 description: This project extends the Application Insights API surface to support
   Ruby.
 email:
@@ -114,6 +128,7 @@ files:
 - lib/application_insights/channel/synchronous_sender.rb
 - lib/application_insights/channel/telemetry_channel.rb
 - lib/application_insights/channel/telemetry_context.rb
+- lib/application_insights/rack/track_request.rb
 - lib/application_insights/telemetry_client.rb
 - lib/application_insights/unhandled_exception.rb
 - lib/application_insights/version.rb
@@ -146,6 +161,8 @@ files:
 - test/application_insights/channel/test_synchronous_sender.rb
 - test/application_insights/channel/test_telemetry_channel.rb
 - test/application_insights/channel/test_telemetry_context.rb
+- test/application_insights/mock_sender.rb
+- test/application_insights/rack/test_track_request.rb
 - test/application_insights/test_telemetry_client.rb
 - test/application_insights/test_unhandled_exception.rb
 homepage: https://github.com/Microsoft/AppInsights-Ruby
@@ -202,6 +219,8 @@ test_files:
 - test/application_insights/channel/test_synchronous_sender.rb
 - test/application_insights/channel/test_telemetry_channel.rb
 - test/application_insights/channel/test_telemetry_context.rb
+- test/application_insights/mock_sender.rb
+- test/application_insights/rack/test_track_request.rb
 - test/application_insights/test_telemetry_client.rb
 - test/application_insights/test_unhandled_exception.rb
 has_rdoc: