application_insights 0.5.3 → 0.5.4

data/lib/application_insights/channel/event.rb

@@ -1,64 +1,68 @@
-require_relative 'queue_base'
-require 'thread'
-
-module ApplicationInsights
-  module Channel
-    # An event class that allows simple cross-thread signalling.
-    #
-    # An object of this type managers an internal flag that can be set to true via the {#set} method and reset via the
-    # {#clear} method. Calling the {#wait} method will block until the flag is set to true.
-    # @example
-    #   require 'application_insights'
-    #   require 'thread'
-    #   event = ApplicationInsights::Channel::Event.new
-    #   Thread.new do
-    #     sleep 1
-    #     event.set
-    #   end
-    #   puts 'Main screen turn on.'
-    #   result = event.wait
-    #   puts 'All your base are belong to us.'
-    class Event
-      # Initializes a new instance of the class.
-      def initialize
-        @mutex = Mutex.new
-        @condition_variable = ConditionVariable.new
-        @signal = false
-      end
-
-      # The signal value for this object. Note that the value of this property is not synchronized
-      # with respect to {#set} and {#clear} meaning that it could return false positives or negatives.
-      # @return [Boolean] the signal value.
-      attr_reader :signal
-
-      # Sets the internal flag to true. Calling this method will also cause all waiting threads to awaken.
-      def set
-        @mutex.synchronize do
-          @signal = true
-          @condition_variable.broadcast
-        end
-      end
-
-      # Sets the internal flag to false.
-      def clear
-        @mutex.synchronize do
-          @signal = false
-        end
-      end
-
-      # Calling this method will block until the internal flag is set to true. If the flag is set to true before calling
-      # this method, we will return immediately. If the timeout parameter is specified, the method will unblock after the
-      # specified number of seconds.
-      # @param [Fixnum] timeout the timeout for the operation in seconds.
-      # @return [Boolean] the value of the internal flag on exit.
-      def wait(timeout=nil)
-        @mutex.synchronize do
-          if @signal == false
-            @condition_variable.wait @mutex, (timeout == nil) ? nil : timeout
-          end
-          @signal
-        end
-      end
-    end
-  end
-end
+require_relative 'queue_base'
+require 'thread'
+
+module ApplicationInsights
+  module Channel
+    # An event class that allows simple cross-thread signalling.
+    #
+    # An object of this type managers an internal flag that can be set to true
+    # via the {#set} method and reset via the {#clear} method. Calling the
+    # {#wait} method will block until the flag is set to true.
+    #
+    # @example
+    #   require 'application_insights'
+    #   require 'thread'
+    #   event = ApplicationInsights::Channel::Event.new
+    #   Thread.new do
+    #     sleep 1
+    #     event.set
+    #   end
+    #   puts 'Main screen turn on.'
+    #   result = event.wait
+    #   puts 'All your base are belong to us.'
+    class Event
+      # Initializes a new instance of the class.
+      def initialize
+        @mutex = Mutex.new
+        @condition_variable = ConditionVariable.new
+        @signal = false
+      end
+
+      # The signal value for this object. Note that the value of this property is
+      # not synchronized with respect to {#set} and {#clear} meaning that it
+      # could return false positives or negatives.
+      # @return [Boolean] the signal value.
+      attr_reader :signal
+
+      # Sets the internal flag to true. Calling this method will also cause all
+      # waiting threads to awaken.
+      def set
+        @mutex.synchronize do
+          @signal = true
+          @condition_variable.broadcast
+        end
+      end
+
+      # Sets the internal flag to false.
+      def clear
+        @mutex.synchronize do
+          @signal = false
+        end
+      end
+
+      # Calling this method will block until the internal flag is set to true.
+      # If the flag is set to true before calling this method, we will return
+      # immediately. If the timeout parameter is specified, the method will
+      # unblock after the specified number of seconds.
+      # @param [Fixnum] timeout the timeout for the operation in seconds.
+      # @return [Boolean] the value of the internal flag on exit.
+      def wait(timeout=nil)
+        @mutex.synchronize do
+          @condition_variable.wait(@mutex, timeout) unless @signal
+        end
+
+        @signal
+      end
+    end
+  end
+end

data/lib/application_insights/channel/queue_base.rb

@@ -1,62 +1,65 @@
-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
-        @sender = sender
-        @sender.queue = self if 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
-
-      # 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)
-        unless item
-          return
-        end
-
-        @queue.push(item)
-        if @queue.length >= @max_queue_length
-          flush
-        end
-      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
-        begin
-          return @queue.pop(TRUE)
-        rescue ThreadError => _
-          return nil
-        end
-      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
+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
+        @sender = sender
+        @sender.queue = self if 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
+
+      # 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

@@ -1,72 +1,79 @@
-require 'json'
-require 'net/http'
-require 'openssl'
-require 'stringio'
-require 'zlib'
-
-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
-      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
-
-      # 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)
-      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
+require 'json'
+require 'net/http'
+require 'openssl'
+require 'stringio'
+require 'zlib'
+
+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
+      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
+
+      # 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?
+      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

@@ -1,39 +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
+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