azure_application_insights 0.5.7

data/lib/application_insights/channel/queue_base.rb

@@ -0,0 +1,73 @@
+require 'thread'
+
+module ApplicationInsights
+  module Channel
+    # The base class for all types of queues for use in conjunction with an
+    # implementation of {SenderBase}. 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}.
+    class QueueBase
+      # Initializes a new instance of the class.
+      # @param [SenderBase] sender the sender object that will be used in
+      #   conjunction with this queue.
+      def initialize(sender)
+        @queue = Queue.new
+        @max_queue_length = 500
+        self.sender = sender
+      end
+
+      # The maximum number of items that will be held by the queue before the
+      # queue will call the {#flush} method.
+      # @return [Fixnum] the maximum queue size. (defaults to: 500)
+      attr_accessor :max_queue_length
+
+      # The sender that is associated with this queue that this queue will use to
+      # send data to the service.
+      # @return [SenderBase] the sender object.
+      attr_reader :sender
+
+      # Change the sender that is associated with this queue.
+      # @param [SenderBase] sender the sender object.
+      # @return [SenderBase] the sender object.
+      def sender=(sender)
+        @sender = sender
+        @sender.queue = self if sender
+        @sender
+      end
+
+      # Adds the passed in item object to the queue and calls {#flush} if the
+      # size of the queue is larger than {#max_queue_length}. This method does
+      # nothing if the passed in item is nil.
+      # @param [Contracts::Envelope] item the telemetry envelope object to send
+      #   to the service.
+      def push(item)
+        return unless item
+
+        @queue.push(item)
+
+        flush if @queue.length >= @max_queue_length
+      end
+
+      # Pops a single item from the queue and returns it. If the queue is empty,
+      # this method will return nil.
+      # @return [Contracts::Envelope] a telemetry envelope object or nil if the
+      #   queue is empty.
+      def pop
+        return @queue.pop(true)
+      rescue ThreadError
+        return nil
+      end
+
+      # Flushes the current queue by notifying the {#sender}. This method needs
+      # to be overridden by a concrete implementations of the queue class.
+      def flush
+      end
+
+      # Indicates whether the queue is empty.
+      # @return [Boolean] true if the queue is empty
+      def empty?
+        @queue.empty?
+      end
+    end
+  end
+end

data/lib/application_insights/channel/sender_base.rb

@@ -0,0 +1,88 @@
+require 'json'
+require 'net/http'
+require 'openssl'
+require 'stringio'
+require 'zlib'
+require 'logger'
+
+module ApplicationInsights
+  module Channel
+    # The base class for all types of senders for use in conjunction with an
+    # implementation of {QueueBase}. The queue will notify the sender that it
+    # needs to pick up items. The concrete sender implementation will listen to
+    # these notifications and will pull items from the queue using
+    # {QueueBase#pop} getting at most {#send_buffer_size} items.
+    # It will then call {#send} using the list of items pulled from the queue.
+    class 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)
+        @service_endpoint_uri = service_endpoint_uri
+        @queue = nil
+        @send_buffer_size = 100
+        @logger = Logger.new(STDOUT)
+      end
+
+      # The service endpoint URI where this sender will send data to.
+      # @return [String] the service endpoint URI.
+      attr_accessor :service_endpoint_uri
+
+      # The queue that this sender is draining. While {SenderBase} doesn't
+      # implement any means of doing so, derivations of this class do.
+      # @return [QueueBase] the queue instance that this sender is draining.
+      attr_accessor :queue
+
+      # The buffer size for a single batch of telemetry. This is the maximum number
+      # of items in a single service request that this sender is going to send.
+      # @return [Fixnum] the maximum number of items in a telemetry batch.
+      attr_accessor :send_buffer_size
+
+      # The logger for the sender.
+      attr_accessor :logger
+
+      # Immediately sends the data passed in to {#service_endpoint_uri}. If the
+      # service request fails, the passed in items are pushed back to the {#queue}.
+      # @param [Array<Contracts::Envelope>] data_to_send an array of
+      #   {Contracts::Envelope} objects to send to the service.
+      def send(data_to_send)
+        uri = URI(@service_endpoint_uri)
+        headers = {
+          'Accept' => 'application/json',
+          'Content-Type' => 'application/json; charset=utf-8',
+          'Content-Encoding' => 'gzip'
+        }
+        request = Net::HTTP::Post.new(uri.path, headers)
+
+        # 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
+        if uri.scheme.downcase == 'https'
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+
+        response = http.request(request)
+        http.finish if http.started?
+
+        if !response.kind_of? Net::HTTPSuccess
+          @logger.warn('application_insights') { "Failed to send data: #{response.message}" }
+        end
+      end
+
+      private
+
+      def compress(string)
+        wio = StringIO.new("w")
+        w_gz = Zlib::GzipWriter.new wio, nil, nil
+        w_gz.write(string)
+        w_gz.close
+        wio.string
+      end
+    end
+  end
+end

data/lib/application_insights/channel/synchronous_queue.rb

@@ -0,0 +1,45 @@
+require_relative 'queue_base'
+
+module ApplicationInsights
+  module Channel
+    # A synchronous queue for use in conjunction with the {SynchronousSender}.
+    # The queue will call {SenderBase#send} when it reaches {#max_queue_length},
+    # or when the consumer calls {#flush}.
+    #
+    # @example
+    #   require 'application_insights'
+    #   require 'thread'
+    #   queue = ApplicationInsights::Channel::SynchronousQueue.new nil
+    #   queue.max_queue_length = 1
+    #   queue.push 1
+    class SynchronousQueue < QueueBase
+      # Initializes a new instance of the class.
+      # @param [SenderBase] sender the sender object that will be used in
+      #   conjunction with this queue.
+      def initialize(sender)
+        super sender
+      end
+
+      # Flushes the current queue by by calling {#sender}'s
+      # {SenderBase#send} method.
+      def flush
+        local_sender = @sender
+        return unless local_sender
+
+        while true
+          # get at most send_buffer_size items and send them
+          data = []
+          while data.length < local_sender.send_buffer_size
+            item = pop()
+            break if not item
+            data.push item
+          end
+
+          break if data.length == 0
+
+          local_sender.send(data)
+        end
+      end
+    end
+  end
+end

data/lib/application_insights/channel/synchronous_sender.rb

@@ -0,0 +1,17 @@
+require_relative 'sender_base'
+
+module ApplicationInsights
+  module Channel
+    # A synchronous sender that works in conjunction with the {SynchronousQueue}.
+    # The queue will call {#send} on the current instance with the data to send.
+    class SynchronousSender < 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)
+        super service_endpoint_uri
+      end
+    end
+  end
+end

data/lib/application_insights/channel/telemetry_channel.rb

@@ -0,0 +1,131 @@
+require 'time'
+require_relative 'asynchronous_queue'
+require_relative 'asynchronous_sender'
+require_relative 'telemetry_context'
+require_relative 'synchronous_queue'
+require_relative 'synchronous_sender'
+require_relative 'contracts/envelope'
+require_relative 'contracts/data'
+require_relative 'contracts/internal'
+require_relative '../../application_insights/version'
+
+module ApplicationInsights
+  module Channel
+    # The telemetry channel is responsible for constructing a
+    # {Contracts::Envelope} object from the passed in data and specified
+    # telemetry context.
+    #
+    # @example
+    #   require 'application_insights'
+    #   channel = ApplicationInsights::Channel::TelemetryChannel.new
+    #   event = ApplicationInsights::Channel::Contracts::EventData.new name: 'My event'
+    #   channel.write event
+    class TelemetryChannel
+      # Initializes a new instance of the class.
+      # @param [TelemetryContext] context the telemetry context to use when
+      #   sending telemetry data.
+      # @param [QueueBase] queue the queue to enqueue the resulting
+      #   {Contracts::Envelope} to.
+      def initialize(context=nil, queue=nil)
+        @context = context || TelemetryContext.new
+        @queue = queue || SynchronousQueue.new(SynchronousSender.new)
+      end
+
+      # The context associated with this channel. All {Contracts::Envelope}
+      # objects created by this channel will use this value if it's present or if
+      # none is specified as part of the {#write} call.
+      # @return [TelemetryContext] the context instance
+      #   (defaults to: TelemetryContext.new)
+      attr_reader :context
+
+      # The queue associated with this channel. All {Contracts::Envelope} objects
+      # created by this channel will be pushed to this queue.
+      # @return [QueueBase] the queue instance (defaults to: SynchronousQueue.new)
+      attr_reader :queue
+
+      # The sender associated with this channel. This instance will be used to
+      # transmit telemetry to the service.
+      # @return [SenderBase] the sender instance (defaults to: SynchronousSender.new)
+      def sender
+        @queue.sender
+      end
+
+      # Flushes the enqueued data by calling {QueueBase#flush}.
+      def flush
+        @queue.flush
+      end
+
+      # Enqueues the passed in data to the {#queue}. If the caller specifies a
+      # context as well, it will take precedence over the instance in {#context}.
+      # @param [Object] data the telemetry data to send. This will be wrapped in
+      #   an {Contracts::Envelope} before being enqueued to the {#queue}.
+      # @param [TelemetryContext] context the override context to use when
+      #   constructing the {Contracts::Envelope}.
+      # @param [Time|String] time the timestamp of the telemetry used to construct the
+      #   {Contracts::Envelope}.
+      def write(data, context=nil, time=nil)
+        local_context = context || @context
+        raise ArgumentError, 'Context was required but not provided' unless local_context
+
+        if time && time.is_a?(String)
+          local_time = time
+        elsif time && time.is_a?(Time)
+          local_time = time.iso8601(7)
+        else
+          local_time = Time.now.iso8601(7)
+        end
+
+        data_type = data.class.name.gsub(/^.*::/, '')
+        set_properties data, local_context
+        data_attributes = {
+            :base_type => data_type,
+            :base_data => data
+        }
+        envelope_attributes = {
+          :name => 'Microsoft.ApplicationInsights.' + data_type[0..-5],
+          :time => local_time,
+          :i_key => local_context.instrumentation_key,
+          :tags => get_tags(local_context),
+          :data => Contracts::Data.new(data_attributes)
+        }
+        envelope = Contracts::Envelope.new envelope_attributes
+        @queue.push(envelope)
+      end
+
+      private
+
+      def get_tags(context)
+        hash = {}
+        internal_context_attributes = {
+          :sdk_version => 'rb:' + ApplicationInsights::VERSION
+        }
+        internal_context = Contracts::Internal.new internal_context_attributes
+
+        [internal_context,
+          context.application,
+          context.cloud,
+          context.device,
+          context.user,
+          context.session,
+          context.location,
+          context.operation].each { |c|  hash.merge!(c.to_h) if c }
+
+        hash.delete_if { |k, v| v.nil? }
+
+        hash
+      end
+
+      def set_properties(data, context)
+        if context.properties
+          properties = data.properties || {}
+          context.properties.each do |key, value|
+            unless properties.key?(key)
+              properties[key] = value
+            end
+          end
+          data.properties = properties
+        end
+      end
+    end
+  end
+end

data/lib/application_insights/channel/telemetry_context.rb

@@ -0,0 +1,85 @@
+require_relative 'contracts/application'
+require_relative 'contracts/cloud'
+require_relative 'contracts/device'
+require_relative 'contracts/user'
+require_relative 'contracts/session'
+require_relative 'contracts/operation'
+require_relative 'contracts/location'
+
+module ApplicationInsights
+  module Channel
+    # Represents the context for sending telemetry to the
+    # Application Insights service.
+    #
+    # @example
+    #   require 'application_insights'
+    #   context = ApplicationInsights::Channel::TelemetryContext.new
+    #   context.instrumentation_key = '<YOUR INSTRUMENTATION KEY GOES HERE>'
+    #   context.application.id = 'My application'
+    #   context.application.ver = '1.2.3'
+    #   context.device.id = 'My current device'
+    #   context.device.oem_name = 'Asus'
+    #   context.device.model = 'X31A'
+    #   context.device.type = "Other"
+    #   context.user.id = 'santa@northpole.net'
+    class TelemetryContext
+      # Initializes a new instance of the class.
+      def initialize
+        @instrumentation_key = nil
+        @application = Contracts::Application.new
+        @cloud = Contracts::Cloud.new
+        @device = Contracts::Device.new
+        @user = Contracts::User.new
+        @session = Contracts::Session.new
+        @operation = Contracts::Operation.new
+        @location = Contracts::Location.new
+        @properties = {}
+      end
+
+      # The instrumentation key that is used to identify which
+      # Application Insights application this data is for.
+      # @return [String] the instrumentation key.
+      attr_accessor :instrumentation_key
+
+      # The application context. This contains properties of the
+      # application you are running.
+      # @return [Contracts::Application] the context object.
+      attr_accessor :application
+
+      # The cloud context. This contains properties of the
+      # cloud role you are generating telemetry for.
+      # @return [Contracts::Cloud] the context object.
+      attr_accessor :cloud
+
+      # The device context. This contains properties of the
+      # device you are running on.
+      # @return [Contracts::Device] the context object.
+      attr_accessor :device
+
+      # The user context. This contains properties of the
+      # user you are generating telemetry for.
+      # @return [Contracts::User] the context object.
+      attr_accessor :user
+
+      # The session context. This contains properties of the
+      # session you are generating telemetry for.
+      # @return [Contracts::Session] the context object.
+      attr_accessor :session
+
+      # The operation context. This contains properties of the
+      # operation you are generating telemetry for.
+      # @return [Contracts::Operation] the context object.
+      attr_accessor :operation
+
+      # The location context. This contains properties of the
+      # location you are generating telemetry from.
+      # @return [Contracts::Location] the context object.
+      attr_accessor :location
+
+      # The property context. This contains free-form properties
+      # that you can add to your telemetry.
+      # @return [Hash<String, String>] the context object.
+      attr_accessor :properties
+    end
+  end
+end

data/lib/application_insights/rack/track_request.rb

@@ -0,0 +1,158 @@
+require 'rack'
+require 'securerandom'
+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
+
+        @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
+
+      # Track requests and send data to Application Insights asynchronously.
+      # @param [Hash] env the rack environment.
+      def call(env)
+        # Build a request ID, incorporating one from our request if one exists.
+        request_id = request_id_header(env['HTTP_REQUEST_ID'])
+        env['ApplicationInsights.request.id'] = request_id
+
+        start = Time.now
+        begin
+          status, headers, response = @app.call(env)
+        rescue Exception => ex
+          status = 500
+          exception = ex
+        end
+        stop = Time.now
+
+        start_time = start.iso8601(7)
+        duration = format_request_duration(stop - start)
+        success = status.to_i < 400
+
+        request = ::Rack::Request.new env
+        options = options_hash(request)
+
+        data = request_data(request_id, start_time, duration, status, success, options)
+        context = telemetry_context(request_id, env['HTTP_REQUEST_ID'])
+
+        @client.channel.write data, context, start_time
+
+        if exception
+          @client.track_exception exception, handled_at: 'Unhandled'
+          raise exception
+        end
+
+        [status, headers, response]
+      end
+
+      private
+
+      def sender=(sender)
+        if sender.is_a? Channel::AsynchronousSender
+          @sender = sender
+          @client.channel.queue.sender = @sender
+        end
+      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 "%02d.%02d:%02d:%02d.%07d" % [1, 0, 0, 0, 0]
+        end
+
+        Time.at(duration_seconds).gmtime.strftime("00.%H:%M:%S.%7N")
+      end
+
+      def request_id_header(request_id)
+        valid_request_id_header = valid_request_id(request_id)
+
+        length = valid_request_id_header ? 5 : 10
+        id = SecureRandom.base64(length)
+
+        if valid_request_id_header
+          request_id_has_end = %w[. _].include?(request_id[-1])
+          request_id << '.' unless request_id_has_end
+
+          return "#{request_id}#{id}_"
+        end
+
+        "|#{id}."
+      end
+
+      def valid_request_id(request_id)
+        request_id && request_id[0] == '|'
+      end
+
+      def operation_id(id)
+        # Returns the root ID from the '|' to the first '.' if any.
+        root_start = id[0] == '|' ? 1 : 0
+
+        root_end = id.index('.')
+        root_end = root_end ? root_end - 1 : id.length - root_start
+
+        id[root_start..root_end]
+      end
+
+      def options_hash(request)
+        {
+            name: "#{request.request_method} #{request.path}",
+            http_method: request.request_method,
+            url: request.url,
+            properties: {
+              params: request.params.to_json,
+              requestBody: request.body.to_json
+            }
+        }
+      end
+
+      def request_data(request_id, start_time, duration, status, success, options)
+        Channel::Contracts::RequestData.new(
+            :id => request_id || 'Null',
+            :start_time => start_time || Time.now.iso8601(7),
+            :duration => duration || '0:00:00:00.0000000',
+            :response_code => status || 200,
+            :success => success == nil ? true : success,
+            :name => options[:name],
+            :http_method => options[:http_method],
+            :url => options[:url],
+            :properties => options[:properties] || {},
+            :measurements => options[:measurements] || {}
+        )
+      end
+
+      def telemetry_context(request_id, request_id_header)
+        context = Channel::TelemetryContext.new
+        context.instrumentation_key = @instrumentation_key
+        context.operation.id = operation_id(request_id)
+        context.operation.parent_id = request_id_header
+
+        context
+      end
+    end
+  end
+end