azure_application_insights 0.5.7

data/lib/application_insights/telemetry_client.rb

@@ -0,0 +1,229 @@
+require_relative 'channel/telemetry_context'
+require_relative 'channel/telemetry_channel'
+require_relative 'channel/contracts/page_view_data'
+require_relative 'channel/contracts/exception_data'
+require_relative 'channel/contracts/exception_details'
+require_relative 'channel/contracts/event_data'
+require_relative 'channel/contracts/data_point'
+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(instrumentation_key = nil, telemetry_channel = nil)
+      @context = Channel::TelemetryContext.new
+      @context.instrumentation_key = instrumentation_key
+      @channel = telemetry_channel || Channel::TelemetryChannel.new
+    end
+
+    # The context associated with this client. All data objects created by this
+    # client will be accompanied by this value.
+    # @return [Channel::TelemetryContext] the context instance.
+    attr_reader :context
+
+    # The channel associated with this telemetry client. All data created by this
+    # client will be passed along with the {#context} object to
+    # {Channel::TelemetryChannel#write}
+    # @return [Channel::TelemetryChannel] the channel instance.
+    attr_reader :channel
+
+    # Send information about the page viewed in the application (a web page for
+    # instance).
+    # @param [String] name the name of the page that was viewed.
+    # @param [String] url the URL of the page that was viewed.
+    # @param [Hash] options the options to create the
+    #   {Channel::Contracts::PageViewData} object.
+    # @option options [Fixnum] :duration the duration of the page view in
+    #   milliseconds. (defaults to: 0)
+    # @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_page_view(name, url, options={})
+      data_attributes = {
+        :name => name || 'Null',
+        :url => url,
+        :duration => options[:duration],
+        :properties => options[:properties] || {},
+        :measurements => options[:measurements] || {}
+      }
+      data = Channel::Contracts::PageViewData.new data_attributes
+      self.channel.write(data, self.context)
+    end
+
+    # Send information about a single exception that occurred in the application.
+    # @param [Exception] exception the exception that the client wants to send.
+    # @param [Hash] options the options to create the
+    #   {Channel::Contracts::ExceptionData} object.
+    # @option options [String] :handled_at the type of exception
+    #   (defaults to: 'UserCode')
+    # @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_exception(exception, options={})
+      return unless exception.is_a? Exception
+
+      parsed_stack = []
+      if exception.backtrace
+        frame_pattern = /^(?<file>.*):(?<line>\d+)(\.|:in `((?<method>.*)'$))/
+
+        exception.backtrace.each_with_index do |frame, counter|
+          match = frame_pattern.match frame
+          stack_frame = Channel::Contracts::StackFrame.new(
+            :assembly => 'Unknown',
+            :file_name => match['file'],
+            :level => counter,
+            :line => match['line'],
+            :method => match['method']
+          )
+
+          parsed_stack << stack_frame
+        end
+      end
+
+      details = Channel::Contracts::ExceptionDetails.new(
+        :id => 1,
+        :outer_id => 0,
+        :type_name => exception.class.name,
+        :message => exception.message,
+        :has_full_stack => exception.backtrace != nil,
+        :stack => (exception.backtrace.join("\n") if exception.backtrace),
+        :parsed_stack => parsed_stack
+      )
+
+      data = Channel::Contracts::ExceptionData.new(
+        :handled_at => options.fetch(:handled_at, 'UserCode'),
+        :exceptions => [details],
+        :properties => options[:properties] || {},
+        :measurements => options[:measurements] || {}
+      )
+
+      self.channel.write(data, self.context)
+    end
+
+    # Send information about a single event that has occurred in the context of
+    # the application.
+    # @param [String] name the data to associate to this event.
+    # @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: {})
+    # @option options [Hash] :measurements the set of custom measurements the
+    #   client wants to attach to this data item (defaults to: {})
+    def track_event(name, options={})
+      data = Channel::Contracts::EventData.new(
+        :name => name || 'Null',
+        :properties => options[:properties] || {},
+        :measurements => options[:measurements] || {}
+      )
+
+      self.channel.write(data, self.context)
+    end
+
+    # Send information about a single metric data point that was captured for
+    # the application.
+    # @param [String] name the name of the metric that was captured.
+    # @param [Fixnum] value the value of the metric that was captured.
+    # @param [Hash] options the options to create the
+    #   {Channel::Contracts::MetricData} object.
+    # @option options [Channel::Contracts::DataPointType] :type the type of the
+    #   metric (defaults to: {Channel::Contracts::DataPointType::AGGREGATION})
+    # @option options [Fixnum] :count the number of metrics that were aggregated
+    #   into this data point (defaults to: 0)
+    # @option options [Fixnum] :min the minimum of all metrics collected that
+    #   were aggregated into this data point (defaults to: 0)
+    # @option options [Fixnum] :max the maximum of all metrics collected that
+    #   were aggregated into this data point (defaults to: 0)
+    # @option options [Fixnum] :std_dev the standard deviation of all metrics
+    #   collected that were aggregated into this data point (defaults to: 0)
+    # @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_metric(name, value, options={})
+      data_point = Channel::Contracts::DataPoint.new(
+        :name => name || 'Null',
+        :value => value || 0,
+        :kind => options[:type] || Channel::Contracts::DataPointType::AGGREGATION,
+        :count => options[:count],
+        :min => options[:min],
+        :max => options[:max],
+        :std_dev => options[:std_dev]
+      )
+
+      data = Channel::Contracts::MetricData.new(
+        :metrics => [data_point],
+        :properties => options[:properties] || {}
+      )
+
+      self.channel.write(data, self.context)
+    end
+
+    # 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, severity_level = nil, options={})
+      data = Channel::Contracts::MessageData.new(
+        :message => name || 'Null',
+        :severity_level => severity_level || Channel::Contracts::SeverityLevel::INFORMATION,
+        :properties => options[:properties] || {}
+      )
+
+      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 = Channel::Contracts::RequestData.new(
+        :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[:properties] || {},
+        :measurements => options[:measurements] || {}
+      )
+
+      self.channel.write(data, self.context, start_time)
+    end
+
+    # Flushes data in the queue. Data in the queue will be sent either immediately
+    # irrespective of what sender is being used.
+    def flush
+      self.channel.flush
+    end
+  end
+end

data/lib/application_insights/unhandled_exception.rb

@@ -0,0 +1,49 @@
+require_relative 'telemetry_client'
+require_relative 'channel/telemetry_channel'
+require_relative 'channel/synchronous_queue'
+require_relative 'channel/synchronous_sender'
+
+include ApplicationInsights
+
+module ApplicationInsights
+  module UnhandledException
+    @sender = nil
+
+    # Auto collects unhandled exception and send to the Application Insights service.
+    # @param (string) instrumentation_key used to identify which Application
+    #   Insights application this data is for.
+    # @example
+    #   require 'application_insights'
+    #   ApplicationInsights::UnhandledException.collect('<YOUR INSTRUMENTATION KEY GOES HERE>')
+    #   raise Exception, 'Boom!'
+    def self.collect(instrumentation_key)
+      at_exit do
+        # Avoid sending exception more than once if this method got invoked multiple times
+        send(instrumentation_key) unless @sender
+      end
+    end
+
+    # @api private
+    # Send the last raised exception to the Application Insights service if
+    # telemetry_sender is not customized.
+    # @param (string) instrumentation_key used to identify which Application
+    #   Insights application this data is for.
+    # @param (SenderBase) telemetry_sender used to send the last raised exception.
+    def self.send(instrumentation_key, telemetry_sender = nil)
+      if $! && !$!.is_a?(SystemExit) && !$!.is_a?(SignalException)
+        if telemetry_sender
+          @sender = telemetry_sender
+        elsif !@sender
+          # Use a synchronized sender to guarantee the data would be sent out once flush
+          @sender = Channel::SynchronousSender.new
+        end
+
+        queue = Channel::SynchronousQueue.new @sender
+        channel = Channel::TelemetryChannel.new nil, queue
+        client = TelemetryClient.new instrumentation_key, channel
+        client.track_exception($!, handled_at: 'Unhandled')
+        client.flush
+      end
+    end
+  end
+end

data/lib/application_insights/version.rb

@@ -0,0 +1,3 @@
+module ApplicationInsights
+  VERSION = '0.5.7'.freeze
+end

data/lib/application_insights.rb

@@ -0,0 +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

data/test/application_insights/channel/contracts/test_application.rb

@@ -0,0 +1,44 @@
+require_relative '../../../../lib/application_insights/channel/contracts/application'
+require 'test/unit'
+
+include ApplicationInsights::Channel
+
+class TestApplication < Test::Unit::TestCase
+  def test_initialize
+    item = Contracts::Application.new
+    assert_not_nil item
+  end
+
+  def test_ver_works_as_expected
+    expected = 'Test string'
+    item = Contracts::Application.new
+    item.ver = expected
+    actual = item.ver
+    assert_equal expected, actual
+    expected = 'Other string'
+    item.ver = expected
+    actual = item.ver
+    assert_equal expected, actual
+  end
+
+  def test_build_works_as_expected
+    expected = 'Test string'
+    item = Contracts::Application.new
+    item.build = expected
+    actual = item.build
+    assert_equal expected, actual
+    expected = 'Other string'
+    item.build = expected
+    actual = item.build
+    assert_equal expected, actual
+  end
+
+  def test_to_json_works_as_expected
+    item = Contracts::Application.new
+    item.ver = 'Test string'
+    item.build = 'Test string'
+    actual = item.to_json
+    expected = '{"ai.application.ver":"Test string","ai.application.build":"Test string"}'
+    assert_equal expected, actual
+  end
+end

data/test/application_insights/channel/contracts/test_cloud.rb

@@ -0,0 +1,44 @@
+require_relative '../../../../lib/application_insights/channel/contracts/cloud'
+require 'test/unit'
+
+include ApplicationInsights::Channel
+
+class TestCloud < Test::Unit::TestCase
+  def test_initialize
+    item = Contracts::Cloud.new
+    assert_not_nil item
+  end
+
+  def test_role_name_works_as_expected
+    expected = 'Test string'
+    item = Contracts::Cloud.new
+    item.role_name = expected
+    actual = item.role_name
+    assert_equal expected, actual
+    expected = 'Other string'
+    item.role_name = expected
+    actual = item.role_name
+    assert_equal expected, actual
+  end
+
+  def test_role_instance_works_as_expected
+    expected = 'Test string'
+    item = Contracts::Cloud.new
+    item.role_instance = expected
+    actual = item.role_instance
+    assert_equal expected, actual
+    expected = 'Other string'
+    item.role_instance = expected
+    actual = item.role_instance
+    assert_equal expected, actual
+  end
+
+  def test_to_json_works_as_expected
+    item = Contracts::Cloud.new
+    item.role_name = 'Role name'
+    item.role_instance = 'Role instance'
+    actual = item.to_json
+    expected = '{"ai.cloud.role":"Role name","ai.cloud.roleInstance":"Role instance"}'
+    assert_equal expected, actual
+  end
+end

data/test/application_insights/channel/contracts/test_data.rb

@@ -0,0 +1,44 @@
+require_relative '../../../../lib/application_insights/channel/contracts/data'
+require 'test/unit'
+
+include ApplicationInsights::Channel
+
+class TestData < Test::Unit::TestCase
+  def test_initialize
+    item = Contracts::Data.new
+    assert_not_nil item
+  end
+
+  def test_base_type_works_as_expected
+    expected = 'Test string'
+    item = Contracts::Data.new
+    item.base_type = expected
+    actual = item.base_type
+    assert_equal expected, actual
+    expected = 'Other string'
+    item.base_type = expected
+    actual = item.base_type
+    assert_equal expected, actual
+  end
+
+  def test_base_data_works_as_expected
+    expected = { 'key' => 'value' }
+    item = Contracts::Data.new
+    item.base_data = expected
+    actual = item.base_data
+    assert_equal expected, actual
+    expected = { 'key' => 'value' }
+    item.base_data = expected
+    actual = item.base_data
+    assert_equal expected, actual
+  end
+
+  def test_to_json_works_as_expected
+    item = Contracts::Data.new
+    item.base_type = 'Test string'
+    item.base_data = { 'key' => 'value' }
+    actual = item.to_json
+    expected = '{"baseType":"Test string","baseData":{"key":"value"}}'
+    assert_equal expected, actual
+  end
+end

data/test/application_insights/channel/contracts/test_data_point.rb

@@ -0,0 +1,109 @@
+require_relative '../../../../lib/application_insights/channel/contracts/data_point'
+require 'test/unit'
+
+include ApplicationInsights::Channel
+
+class TestDataPoint < Test::Unit::TestCase
+  def test_initialize
+    item = Contracts::DataPoint.new
+    assert_not_nil item
+  end
+
+  def test_name_works_as_expected
+    expected = 'Test string'
+    item = Contracts::DataPoint.new
+    item.name = expected
+    actual = item.name
+    assert_equal expected, actual
+    expected = 'Other string'
+    item.name = expected
+    actual = item.name
+    assert_equal expected, actual
+  end
+
+  def test_kind_works_as_expected
+    expected = 5
+    item = Contracts::DataPoint.new
+    item.kind = expected
+    actual = item.kind
+    assert_equal expected, actual
+    expected = 3
+    item.kind = expected
+    actual = item.kind
+    assert_equal expected, actual
+  end
+
+  def test_value_works_as_expected
+    expected = 1.5
+    item = Contracts::DataPoint.new
+    item.value = expected
+    actual = item.value
+    assert_equal expected, actual
+    expected = 4.8
+    item.value = expected
+    actual = item.value
+    assert_equal expected, actual
+  end
+
+  def test_count_works_as_expected
+    expected = 42
+    item = Contracts::DataPoint.new
+    item.count = expected
+    actual = item.count
+    assert_equal expected, actual
+    expected = 13
+    item.count = expected
+    actual = item.count
+    assert_equal expected, actual
+  end
+
+  def test_min_works_as_expected
+    expected = 1.5
+    item = Contracts::DataPoint.new
+    item.min = expected
+    actual = item.min
+    assert_equal expected, actual
+    expected = 4.8
+    item.min = expected
+    actual = item.min
+    assert_equal expected, actual
+  end
+
+  def test_max_works_as_expected
+    expected = 1.5
+    item = Contracts::DataPoint.new
+    item.max = expected
+    actual = item.max
+    assert_equal expected, actual
+    expected = 4.8
+    item.max = expected
+    actual = item.max
+    assert_equal expected, actual
+  end
+
+  def test_std_dev_works_as_expected
+    expected = 1.5
+    item = Contracts::DataPoint.new
+    item.std_dev = expected
+    actual = item.std_dev
+    assert_equal expected, actual
+    expected = 4.8
+    item.std_dev = expected
+    actual = item.std_dev
+    assert_equal expected, actual
+  end
+
+  def test_to_json_works_as_expected
+    item = Contracts::DataPoint.new
+    item.name = 'Test string'
+    item.kind = 5
+    item.value = 1.5
+    item.count = 42
+    item.min = 1.5
+    item.max = 1.5
+    item.std_dev = 1.5
+    actual = item.to_json
+    expected = '{"name":"Test string","kind":5,"value":1.5,"count":42,"min":1.5,"max":1.5,"stdDev":1.5}'
+    assert_equal expected, actual
+  end
+end