azure_application_insights 0.5.7

data/test/application_insights/channel/test_sender_base.rb

@@ -0,0 +1,94 @@
+require_relative '../../../lib/application_insights/channel/queue_base'
+require_relative '../../../lib/application_insights/channel/sender_base'
+require_relative '../test_logger'
+require 'socket'
+require 'test/unit'
+require 'thread'
+
+include ApplicationInsights::Channel
+
+class TestSenderBase < Test::Unit::TestCase
+  def test_initialize
+    sender = SenderBase.new 'http://tempuri.org'
+    assert_equal 'http://tempuri.org', sender.service_endpoint_uri
+    assert_nil sender.queue
+    assert_equal 100, sender.send_buffer_size
+  end
+
+  def test_service_endpoint_uri
+    sender = SenderBase.new 'http://tempuri.org'
+    assert_equal 'http://tempuri.org', sender.service_endpoint_uri
+    sender.service_endpoint_uri = 'http://live.com'
+    assert_equal 'http://live.com', sender.service_endpoint_uri
+  end
+
+  def test_sender_queue_attribute
+    sender = SenderBase.new 'http://tempuri.org'
+    assert_nil sender.queue
+    temp = Object.new
+    sender.queue = temp
+    assert_equal temp, sender.queue
+  end
+
+  def test_send_buffer_size_works_as_expected
+    sender = SenderBase.new 'http://tempuri.org'
+    assert_equal 100, sender.send_buffer_size
+    sender.send_buffer_size = 42
+    assert_equal 42, sender.send_buffer_size
+  end
+
+  def test_send_works_as_expected_with_400_code
+    thread, port = execute_server '400 BadRequest'
+    test_logger = TestLogger.new
+    sender = SenderBase.new 'http://localhost:' + port.to_s + '/track'
+    sender.logger = test_logger
+    sender.queue = []
+    sender.send([1, 2])
+    thread.join
+    assert_equal [], sender.queue
+    assert_true test_logger.messages.include?('BadRequest')
+  end
+
+  def test_send_works_as_expected_with_500_code
+    thread, port = execute_server '500 InternalServerError'
+    test_logger = TestLogger.new
+    sender = SenderBase.new 'http://localhost:' + port.to_s + '/track'
+    sender.logger = test_logger
+    sender.queue = []
+    sender.send([1, 2])
+    thread.join
+    assert_equal [], sender.queue
+    assert_true test_logger.messages.include?('InternalServerError')
+  end
+
+  def execute_server(code)
+    port = 50000 + Random.rand(10000)
+    thread = Thread.new {
+      server = TCPServer.new(port)
+      client = server.accept
+      request = ''
+      read_buffer_size = 64
+      while true
+        temp = client.recv(read_buffer_size)
+        request += temp
+        break if temp.length < read_buffer_size
+      end
+      request = request.split(/\n/)[-1]
+      response = request
+      headers = [
+          "HTTP/1.1 " + code,
+          "Content-Type: application/json",
+          "Content-Length: #{response.length}\r\n\r\n"
+      ].join("\r\n")
+      client.puts headers
+      client.puts response
+      client.close
+    }
+
+    while thread.status != 'sleep'
+      sleep 0.1
+    end
+
+    return thread, port
+  end
+end

data/test/application_insights/channel/test_synchronous_queue.rb

@@ -0,0 +1,28 @@
+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
+
+class TestSynchronousQueue < Test::Unit::TestCase
+  def test_initialize
+    SynchronousQueue.new(MockSynchronousSender.new)
+  end
+
+  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.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

data/test/application_insights/channel/test_synchronous_sender.rb

@@ -0,0 +1,11 @@
+require_relative '../../../lib/application_insights/channel/synchronous_sender'
+require 'test/unit'
+
+include ApplicationInsights::Channel
+
+class TestSynchronousSender < Test::Unit::TestCase
+  def test_initialize
+    sender = SynchronousSender.new
+    assert_equal 'https://dc.services.visualstudio.com/v2/track', sender.service_endpoint_uri
+  end
+end

data/test/application_insights/channel/test_telemetry_channel.rb

@@ -0,0 +1,167 @@
+require_relative '../../../lib/application_insights/channel/telemetry_channel'
+require_relative '../../../lib/application_insights/channel/telemetry_context'
+require_relative '../../../lib/application_insights/channel/synchronous_queue'
+require_relative '../../../lib/application_insights/channel/synchronous_sender'
+require 'test/unit'
+require 'time'
+
+include ApplicationInsights::Channel
+
+class TestTelemetryChannel < Test::Unit::TestCase
+  def test_initialize
+    channel = TelemetryChannel.new
+    assert_not_nil channel.context
+    assert_not_nil channel.queue
+    assert_not_nil channel.sender
+  end
+
+  def test_context_works_as_expected
+    context = TelemetryContext.new
+    channel = TelemetryChannel.new
+    assert_not_nil channel.context
+    assert_not_same context, channel.context
+    channel = TelemetryChannel.new context
+    assert_same context, channel.context
+  end
+
+  def test_queue_works_as_expected
+    queue = SynchronousQueue.new SynchronousSender.new
+    channel = TelemetryChannel.new
+    assert_not_nil channel.queue
+    assert_not_same queue, channel.queue
+    channel = TelemetryChannel.new nil, queue
+    assert_same queue, channel.queue
+  end
+
+  def test_sender_works_as_expected
+    queue = SynchronousQueue.new SynchronousSender.new
+    channel = TelemetryChannel.new
+    assert_not_nil channel.sender
+    assert_not_same queue.sender, channel.sender
+    channel = TelemetryChannel.new nil, queue
+    assert_same queue.sender, channel.sender
+  end
+
+  def test_flush_works_as_expected
+    queue = MockTelemetryChannelQueue.new SynchronousSender.new
+    channel = TelemetryChannel.new nil, queue
+    assert_equal 0, queue.flush_count
+    channel.flush
+    assert_equal 1, queue.flush_count
+  end
+
+  def test_write_works_as_expected
+    queue = MockTelemetryChannelQueue.new SynchronousSender.new
+    context = TelemetryContext.new
+    context.instrumentation_key = 'instrumentation key'
+    channel = TelemetryChannel.new context, queue
+    expected = MockTelemetryItemData.new
+    channel.write expected
+    assert_equal 1, queue.queue.count
+    actual = queue.queue[0]
+    assert_not_nil actual
+    assert_equal 1, actual.ver
+    assert_equal 100, actual.sample_rate
+    assert_equal 'Microsoft.ApplicationInsights.MockTelemetryItem', actual.name
+    assert_not_nil actual.time
+    assert_equal 'instrumentation key', actual.i_key
+    assert_not_nil actual.tags
+    assert_equal 1, actual.tags.count
+    assert_equal 'rb:'+ ApplicationInsights::VERSION, actual.tags['ai.internal.sdkVersion']
+    assert_not_nil actual.data
+    assert_equal 'MockTelemetryItemData', actual.data.base_type
+    assert_same expected, actual.data.base_data
+  end
+
+  def test_write_custom_timestamp
+    queue = MockTelemetryChannelQueue.new SynchronousSender.new
+    context = TelemetryContext.new
+    context.instrumentation_key = 'instrumentation key'
+    channel = TelemetryChannel.new context, queue
+    data = MockTelemetryItemData.new
+    timestamp = (Time.now - 5).iso8601(7)
+
+    channel.write data
+    actual = queue.queue[0]
+    assert_not_equal timestamp, actual.time
+
+    channel.write data, nil, timestamp
+    actual = queue.queue[1]
+    assert_equal timestamp, actual.time
+  end
+
+  def test_write_custom_timestamp_accept_string_time_type
+    queue = MockTelemetryChannelQueue.new SynchronousSender.new
+    context = TelemetryContext.new
+    context.instrumentation_key = 'instrumentation key'
+    channel = TelemetryChannel.new context, queue
+    data = MockTelemetryItemData.new
+
+    timestamp_string = (Time.now - 5).iso8601(7)
+    channel.write data, nil, timestamp_string
+    actual = queue.queue[0]
+    assert_equal timestamp_string, actual.time
+
+    timestamp_time = Time.now - 5
+    channel.write data, nil, timestamp_time
+    actual = queue.queue[1]
+    assert_equal timestamp_time.iso8601(7), actual.time
+  
+    timestamp_invalid = {:invalid => "invalid timestamp"}
+    channel.write data, nil, timestamp_invalid
+    actual = queue.queue[2]
+    assert_not_equal timestamp_invalid, actual.time
+  end
+
+  def test_get_tags_works_as_expected
+    queue = MockTelemetryChannelQueue.new SynchronousSender.new
+    context = TelemetryContext.new
+    context.application.ver = 'ver'
+    context.cloud.role_name = 'role name'
+    context.device.id = 'device id'
+    context.user.id = 'user id'
+    context.session.id = 'session id'
+    context.location.ip = 'ip'
+    context.operation.id = 'operation id'
+    channel = TelemetryChannel.new context, queue
+    expected = MockTelemetryItemData.new
+    channel.write expected
+
+    assert_equal 1, queue.queue.count
+    tags = queue.queue[0].tags
+    assert_equal 'rb:'+ ApplicationInsights::VERSION, tags['ai.internal.sdkVersion']
+    assert_equal 'ver', tags['ai.application.ver']
+    assert_equal 'role name', tags['ai.cloud.role']
+    assert_equal 'device id', tags['ai.device.id']
+    assert_equal 'user id', tags['ai.user.id']
+    assert_equal 'session id', tags['ai.session.id']
+    assert_equal 'ip', tags['ai.location.ip']
+    assert_equal 'operation id', tags['ai.operation.id']
+  end
+end
+
+class MockTelemetryItemData
+  def initialize
+    @properties = {}
+  end
+
+  attr_accessor :properties
+end
+
+class MockTelemetryChannelQueue < QueueBase
+  def initialize(sender)
+    super sender
+    @queue = []
+    @flush_count = 0
+  end
+
+  attr_accessor :flush_count, :queue
+
+  def push(data)
+    @queue.push data
+  end
+
+  def flush
+    @flush_count += 1
+  end
+end

data/test/application_insights/channel/test_telemetry_context.rb

@@ -0,0 +1,83 @@
+require_relative '../../../lib/application_insights/channel/telemetry_context'
+require 'test/unit'
+
+include ApplicationInsights::Channel
+
+class TestTelemetryContext < Test::Unit::TestCase
+  def test_initialize
+    context = TelemetryContext.new
+    assert_nil context.instrumentation_key
+    assert_not_nil context.application
+    assert_not_nil context.device
+    assert_not_nil context.user
+    assert_not_nil context.session
+    assert_not_nil context.operation
+    assert_not_nil context.location
+    assert_not_nil context.properties
+  end
+
+  def test_application_works_as_expected
+    context = TelemetryContext.new
+    assert_not_nil context.application
+    expected = Contracts::Application.new
+    context.application = expected
+    assert_same expected, context.application
+  end
+
+  def test_cloud_works_as_expected
+    context = TelemetryContext.new
+    assert_not_nil context.cloud
+    expected = Contracts::Cloud.new
+    context.cloud = expected
+    assert_same expected, context.cloud
+  end
+
+  def test_device_works_as_expected
+    context = TelemetryContext.new
+    assert_not_nil context.device
+    expected = Contracts::Device.new
+    context.device = expected
+    assert_same expected, context.device
+  end
+
+  def test_user_works_as_expected
+    context = TelemetryContext.new
+    assert_not_nil context.user
+    expected = Contracts::User.new
+    context.user = expected
+    assert_same expected, context.user
+  end
+
+  def test_session_works_as_expected
+    context = TelemetryContext.new
+    assert_not_nil context.session
+    expected = Contracts::Session.new
+    context.session = expected
+    assert_same expected, context.session
+  end
+
+  def test_operation_works_as_expected
+    context = TelemetryContext.new
+    assert_not_nil context.operation
+    expected = Contracts::Operation.new
+    context.operation = expected
+    assert_same expected, context.operation
+  end
+
+  def test_location_works_as_expected
+    context = TelemetryContext.new
+    assert_not_nil context.location
+    expected = Contracts::Location.new
+    context.location = expected
+    assert_same expected, context.location
+  end
+
+  def test_properties_works_as_expected
+    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,182 @@
+require 'test/unit'
+require 'mocha/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
+
+  TIME_SPAN_FORMAT = /^(?<day>\d{2})\.(?<hour>\d{2}):(?<minute>\d{2}):(?<second>\d{2}).(?<fraction>\d{7})$/
+
+  def test_call_works_as_expected
+    response_code = rand(200..204)
+    app = Proc.new {|env| sleep(2.5); [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
+
+    SecureRandom.expects(:base64).with(10).returns('y0NM2eOY/fnQPw==')
+    result = track_request.call(env)
+
+    app_result = app.call(env)
+    assert_equal app_result, 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?("00.00:00:02")
+    assert Time.parse(request_data.start_time) - start_time < 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 client initialization
+    assert_equal ApplicationInsights::TelemetryClient, client.class
+
+    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
+  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)
+    
+    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)
+    
+    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
+
+  def test_request_id_is_generated_correctly
+    app = Proc.new {|env| [200, {"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, 0
+    track_request.send(:sender=, sender)
+
+    # ignores ids that don't begin with | (16 chars)
+    env['HTTP_REQUEST_ID'] = 'ab456_1.ea6741a'
+    SecureRandom.expects(:base64).with(10).returns('y0NM2eOY/fnQPw==')
+    track_request.call(env)
+    assert_equal '|y0NM2eOY/fnQPw==.', env['ApplicationInsights.request.id']
+
+    # appends to ids with a dot (8 chars)
+    env['HTTP_REQUEST_ID'] = '|1234.'
+    SecureRandom.expects(:base64).with(5).returns('eXsMFHs=')
+    track_request.call(env)
+    assert_equal '|1234.eXsMFHs=_', env['ApplicationInsights.request.id']
+
+    # appends to ids with an underscore (8 chars)
+    env['HTTP_REQUEST_ID'] = '|1234_'
+    SecureRandom.expects(:base64).with(5).returns('eXsMFHs=')
+    track_request.call(env)
+    assert_equal '|1234_eXsMFHs=_', env['ApplicationInsights.request.id']
+
+    # appends a dot if neither a dot or underscore are present (8 chars)
+    env['HTTP_REQUEST_ID'] = '|ab456_1.ea6741a'
+    SecureRandom.expects(:base64).with(5).returns('eXsMFHs=')
+    track_request.call(env)
+    assert_equal '|ab456_1.ea6741a.eXsMFHs=_', env['ApplicationInsights.request.id']
+
+    # generates a stand-alone id if one is not provided (16 chars)
+    env.delete('HTTP_REQUEST_ID')
+    SecureRandom.expects(:base64).with(10).returns('y0NM2eOY/fnQPw==')
+    track_request.call(env)
+    assert_equal '|y0NM2eOY/fnQPw==.', env['ApplicationInsights.request.id']
+  end
+end

data/test/application_insights/test_logger.rb

@@ -0,0 +1,10 @@
+class TestLogger < Logger
+    def initialize
+      @strio = StringIO.new
+      super(@strio)
+    end
+  
+    def messages
+      @strio.string
+    end
+  end