r7insight 2.7.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8a1f559d3e82a3236af427283f92106b8f10bb88
+  data.tar.gz: 2c8b419df892a83ec90094018f1132fa781e8902
+SHA512:
+  metadata.gz: 3c7f636e0a73c2138d9128923425b7ac4a691ab80db107fbdda4f7aa18d1c6746ab52c841f4ed63d9476787cf70d6606ce3bd1d154c8ea4dc2e2f7d3efbc4356
+  data.tar.gz: c90280cedd4f3eb31cc3a4d5f6585af1d3c5772276382870e005cc956c859c323d90eba727cfd2518c9b01987b0c06b692d169afcb6866ee5aa5966f7bbcd736

data/.gitignore

@@ -0,0 +1,52 @@
+# Created by .ignore support plugin (hsz.mobi)
+### Ruby template
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LE.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'le'
+
+Gem::Specification.new do |gem|
+  gem.name	= "r7insight"
+  gem.version	= "2.7.5"
+  gem.date	= Time.now
+  gem.summary	= "InsightOps logging plugin"
+  gem.licenses    = ["MIT"]
+  gem.description	=<<EOD
+
+
+EOD
+
+  gem.authors	= ["Mark Lacomber", "Stephen Hynes"]
+  gem.email	= "support@rapid7.com"
+  gem.homepage    = "https://github.com/rapid7/r7insight_ruby"
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "bundler"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency 'minitest'
+
+end

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2014 Logentries
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,82 @@
+Logging to InsightOps in Ruby
+=============================
+
+[![Build Status](https://travis-ci.org/rapid7/r7insight_ruby.svg?branch=master)](https://travis-ci.org/rapid7/r7insight_ruby)
+This is a Rapid7 library for logging from Ruby platforms to InsightOps, including Heroku.
+
+It is available on github <https://github.com/rapid7/r7insight_ruby/> and rubygems
+<http://rubygems.org/>.
+
+
+Example
+-------
+
+    Rails.logger.info("information message")
+    Rails.logger.warn("warning message")
+    Rails.logger.debug("debug message")
+
+
+Howto
+-----
+
+You must first register your account details with Rapid7 InsightOps.
+
+Once you have logged in to InsightOps, create a new host with a name of your choice.
+Inside this host, create a new logfile, selecting `Token TCP` (or `Plain TCP/UDP` if using UDP)
+as the source type.
+
+Heroku
+------
+
+To install the gem you must edit the Gemfile in your local heroku environment
+
+Add the following line:
+
+    gem 'r7insight'
+
+Then from the cmd line run the following command:
+
+    bundle install
+
+This will install the gem on your local environment.
+
+The next step is to configure the default rails logger to use the insightops logger.  
+
+
+In your environment configuration file ( for production : `config/environments/production.rb`), add the following:
+
+    Rails.logger = Le.new('LOG_TOKEN', 'REGION')
+
+If you want to keep logging locally in addition to sending logs to in, just add local parameter after the key.
+By default, this will write to the standard Rails log or to STDOUT if not using Rails:
+
+    Rails.logger = Le.new('LOG_TOKEN', 'REGION', :local => true)
+
+You may specify the local log device by providing a filename (String) or IO object (typically STDOUT, STDERR, or an open file):
+
+    Rails.logger = Le.new('LOG_TOKEN', 'REGION', :local => 'log/my_custom_log.log')
+
+If you want the gem to use SSL when streaming logs to insightops, add the ssl parameter and set it to true:
+
+    Rails.logger = Le.new('LOG_TOKEN', 'REGION', :ssl => true)
+
+If you want to print debug messages for the gem to a file called r7insightGem.log, add this:
+
+	Rails.logger = Le.new('LOG_TOKEN', 'REGION', :debug => true)
+
+If you want to use ActiveSupport::TaggedLogging logging, add this:
+
+    Rails.logger = Le.new('LOG_TOKEN', 'REGION', :tag => true)
+
+You can also specify the default level of the logger by adding a :
+
+    Rails.logger = Le.new('LOG_TOKEN', 'REGION', :log_level => Logger::<level>)
+
+For the `LOG_TOKEN` argument, paste the token for the logfile you created earlier in the InsightOps UI or empty string for
+a UDP connection.
+
+For the `REGION` argument, provide the region of your account, e.g: 'eu', 'us'.
+
+Additionally, when connecting via UDP, be sure to specify a port using the udp_port parameter:
+
+    Rails.logger = Le.new('', :udp_port => 13287)

data/Rakefile

@@ -0,0 +1,16 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs = ['lib','test']
+  t.test_files = Dir.glob("test/**/*_spec.rb").sort
+  t.verbose = true
+end
+
+task :default => [:test]
+task :spec => [:test]
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -I lib -r le.rb"
+end

data/lib/le/host/connection.rb

@@ -0,0 +1,315 @@
+require 'socket'
+require 'openssl'
+require 'thread'
+require 'timeout'
+require 'uri'
+
+module Le
+  module Host
+    class CONNECTION
+      DATA_ENDPOINT = '.data.logs.insight.rapid7.com'
+      DATA_PORT_UNSECURE = 80
+      DATA_PORT_SECURE = 443
+      API_SSL_PORT = 20000
+      SHUTDOWN_COMMAND = "DIE!DIE!"  # magic command string for async worker to shutdown
+      SHUTDOWN_MAX_WAIT = 10         # max seconds to wait for queue to clear on shutdown
+      SHUTDOWN_WAIT_STEP = 0.2       # sleep duration (seconds) while waiting to shutdown
+
+
+      include Le::Host::InstanceMethods
+#!      attr_accessor :token, :queue, :started, :thread, :conn, :local, :debug, :ssl, :datahub_enabled, :dathub_ip, :datahub_port, :host_id, :custom_host, :host_name_enabled, :host_name
+      attr_accessor :token, :region,:queue, :started, :thread, :conn, :local, :debug, :ssl, :datahub_enabled, :datahub_ip, :datahub_port, :datahub_endpoint, :host_id, :host_name_enabled, :host_name, :custom_host, :udp_port, :use_data_endpoint
+
+
+      def initialize(token, region, local, debug, ssl, datahub_endpoint, host_id, custom_host, udp_port, use_data_endpoint)
+          if local
+            device = if local.class <= TrueClass
+              if defined?(Rails)
+                Rails.root.join("log","#{Rails.env}.log")
+              else
+                STDOUT
+              end
+            else
+            local
+            end
+          @logger_console = Logger.new(device)
+          end
+
+          @region = region
+          @local = !!local
+          @debug= debug
+          @ssl = ssl
+          @udp_port = udp_port
+          @use_data_endpoint = use_data_endpoint
+
+        @datahub_endpoint = datahub_endpoint
+        if !@datahub_endpoint[0].empty?
+          @datahub_enabled=true
+          @datahub_ip="#{@datahub_endpoint[0]}"
+          @datahub_port=@datahub_endpoint[1]
+        else
+          @datahub_enabled=false
+        end
+
+
+        if (@datahub_enabled && @ssl)
+          puts ("\n\nYou Cannot have DataHub and SSL enabled at the same time.  Please set SSL value to false in your environment.rb file or used Token-Based logging by leaving the Datahub IP address blank. Exiting application. \n\n")
+          exit
+        end
+
+ #check if region was specified
+        if region.empty?
+          puts ("\n\nYou need to specify a region. Options: eu, us")
+        end
+
+ #check if DataHub is enabled... if datahub is not enabled, set the token to the token's parameter.  If DH is enabled, make the token empty.
+        if (!datahub_enabled)
+           @token = token
+        else
+          @token = ''
+
+ #! NOTE THIS @datahub_port conditional MAY NEED TO BE CHANGED IF SSL CAN'T WORK WITH DH
+          @datahub_port = @datahub_port.empty? ?  API_SSL_PORT : datahub_port
+          @datahub_ip = datahub_ip
+        end
+
+        @host_name_enabled=custom_host[0];
+        @host_name= custom_host[1];
+
+
+# Check if host_id is empty -- if not assign, if so, make it an empty string.
+       if !host_id.empty?
+          @host_id = host_id
+          @host_id = "host_id=#{host_id}"
+        else
+          @host_id=''
+        end
+
+
+
+#assign host_name, if no host name is given and host_name_enabled = true... assign a host_name based on the machine name.
+       if @host_name_enabled
+          if host_name.empty?
+            @host_name=Socket.gethostname
+          end
+
+          @host_name="host_name=#{@host_name}"
+        end
+
+
+        @queue = Queue.new
+        @started = false
+        @thread = nil
+
+        if @debug
+          self.init_debug
+        end
+        at_exit { shutdown! }
+      end
+
+      def init_debug
+        filePath = "r7insightGem.log"
+        if File.exist?('log/')
+          filePath = "log/r7insightGem.log"
+        end
+        @debug_logger = Logger.new(filePath)
+      end
+
+      def dbg(message)
+        if @debug
+          @debug_logger.add(Logger::Severity::DEBUG, message)
+        end
+      end
+
+      def write(message)
+
+        if !host_id.empty?
+          message = "#{message} #{ host_id }"
+        end
+
+        if host_name_enabled
+          message="#{message} #{ host_name }"
+        end
+
+        if @local
+          @logger_console.add(Logger::Severity::UNKNOWN, message)
+        end
+
+        if message.scan(/\n/).empty?
+          @queue << "#{ @token } #{ message } \n"
+        else
+          @queue << "#{ message.gsub(/^/, "\1#{ @token } [#{ random_message_id }]") }\n"
+        end
+
+
+        if @started
+          check_async_thread
+        else
+          start_async_thread
+        end
+      end
+
+      def start_async_thread
+        @thread = Thread.new { run() }
+        dbg "LE: Asynchronous socket writer started"
+        @started = true
+      end
+
+      def check_async_thread
+        if not(@thread && @thread.alive?)
+          @thread = Thread.new { run() }
+        end
+      end
+
+      def close
+        dbg "LE: Closing asynchronous socket writer"
+        @started = false
+      end
+
+      def openConnection
+        dbg "LE: Reopening connection to Logentries API server"
+
+
+        if @use_data_endpoint
+            host = @region + DATA_ENDPOINT
+
+            if @ssl
+              port = DATA_PORT_SECURE
+            else
+              port = DATA_PORT_UNSECURE
+            end
+        else
+          if @udp_port
+            host = @region + DATA_ENDPOINT
+            port = @udp_port
+          elsif @datahub_enabled
+            host = @datahub_ip
+            port = @datahub_port
+          else
+            host = @region + DATA_ENDPOINT
+            port = @ssl ? DATA_PORT_SECURE: DATA_PORT_UNSECURE
+          end
+        end
+
+        if @udp_port
+          @conn = UDPSocket.new
+          @conn.connect(host, port)
+        else
+          socket = TCPSocket.new(host, port)
+
+          if @ssl
+	    cert_store = OpenSSL::X509::Store.new
+	    cert_store.set_default_paths
+
+            ssl_context = OpenSSL::SSL::SSLContext.new()
+	    ssl_context.cert_store = cert_store
+
+            ssl_version_candidates = [:TLSv1_2, :TLSv1_1, :TLSv1]
+            ssl_version_candidates = ssl_version_candidates.select { |version| OpenSSL::SSL::SSLContext::METHODS.include? version }
+            if ssl_version_candidates.empty?
+                raise "Could not find suitable TLS version"
+            end
+	    # currently we only set the version when we have no choice
+            ssl_context.ssl_version = ssl_version_candidates[0] if ssl_version_candidates.length == 1
+            ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
+            ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, ssl_context)
+            ssl_socket.hostname = host if ssl_socket.respond_to?(:hostname=)
+            ssl_socket.sync_close = true
+            Timeout::timeout(10) do
+              ssl_socket.connect
+            end
+            @conn = ssl_socket
+          else
+            @conn = socket
+          end
+        end
+
+        dbg "LE: Connection established"
+      end
+
+      def reopenConnection
+        closeConnection
+        root_delay = 0.1
+        loop do
+          begin
+            openConnection
+            break
+          rescue Timeout::Error, Errno::EHOSTUNREACH, Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ETIMEDOUT, EOFError
+            dbg "LE: Unable to connect to Logentries due to timeout(#{ $! })"
+          rescue
+            dbg "LE: Got exception in reopenConnection - #{ $! }"
+            raise
+          end
+          root_delay *= 2
+          if root_delay >= 10
+            root_delay = 10
+          end
+          wait_for = (root_delay + rand(root_delay)).to_i
+          dbg "LE: Waiting for #{ wait_for }ms"
+          sleep(wait_for)
+        end
+      end
+
+      def closeConnection
+        begin
+          if @conn.respond_to?(:sysclose)
+            @conn.sysclose
+          elsif @conn.respond_to?(:close)
+            @conn.close
+          end
+        rescue
+          dbg "LE: couldn't close connection, close with exception - #{ $! }"
+        ensure
+          @conn = nil
+        end
+      end
+
+      def run
+        reopenConnection
+
+        loop do
+          data = @queue.pop
+          break if data == SHUTDOWN_COMMAND
+          loop do
+            begin
+              @conn.write(data)
+            rescue Timeout::Error, Errno::EHOSTUNREACH, Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ETIMEDOUT, EOFError
+              dbg "LE: Connection timeout(#{ $! }), try to reopen connection"
+              reopenConnection
+              next
+            rescue
+              dbg("LE: Got exception in run loop - #{ $! }")
+              raise
+            end
+
+            break
+          end
+        end
+
+        dbg "LE: Closing Asynchronous socket writer"
+
+        closeConnection
+      end
+
+      private
+        def random_message_id
+          @random_message_id_sample_space ||= ('0'..'9').to_a.concat(('A'..'Z').to_a)
+          (0..5).map{ @random_message_id_sample_space.sample }.join
+        end
+
+        # at_exit handler.
+        # Attempts to clear the queue and terminate the async worker cleanly before process ends.
+        def shutdown!
+          return unless @started
+          dbg "LE: commencing shutdown, queue has #{queue.size} entries to clear"
+          queue << SHUTDOWN_COMMAND
+          SHUTDOWN_MAX_WAIT.div(SHUTDOWN_WAIT_STEP).times do
+            break if queue.empty?
+            sleep SHUTDOWN_WAIT_STEP
+          end
+          dbg "LE: shutdown complete, queue is #{queue.empty? ? '' : 'not '}empty with #{queue.size} entries"
+        end
+
+    end
+  end
+end

data/lib/le/host.rb

@@ -0,0 +1,26 @@
+module Le
+  module Host
+
+    def self.new(token, region, local, debug, ssl, datahub_endpoint, host_id, custom_host, udp_port, use_data_endpoint)
+      Le::Host::CONNECTION.new(token, region, local, debug, ssl, datahub_endpoint, host_id, custom_host, udp_port, use_data_endpoint)
+    end
+
+    module InstanceMethods
+      def formatter
+        proc do |severity, datetime, _, msg|
+          message = "#{datetime} "
+          message << format_message(msg, severity)
+        end
+      end
+
+      def format_message(message_in, severity)
+        message_in = message_in.inspect unless message_in.is_a?(String)
+
+        "severity=#{severity}, #{message_in.lstrip}"
+      end
+    end
+
+  end
+end
+
+require File.join(File.dirname(__FILE__), 'host', 'connection')

data/lib/le.rb

@@ -0,0 +1,65 @@
+require File.join(File.dirname(__FILE__), 'le', 'host')
+
+require 'logger'
+
+module Le
+
+  def self.new(token, region, options={})
+
+    opt_local     = options[:local]                     || false
+    opt_debug     = options[:debug]                     || false
+    opt_ssl       = !options.include?(:ssl) ? true : options[:ssl]
+    opt_tag       = options[:tag]                       || false
+    opt_log_level = options[:log_level]                 || Logger::DEBUG
+
+    opt_datahub_enabled = options[:datahub_enabled]     || false
+    opt_datahub_endpoint = options[:datahub_endpoint]   || ['', 10000]
+    opt_datahub_ip = options[:datahub_ip]               || ''
+    opt_datahub_port    = options[:datahub_port]        || 10000
+    opt_host_id = options[:host_id] || ''
+    opt_host_name_enabled = options[:host_name_enabled] || false
+    opt_host_name = options[:host_name]                 || ''
+    opt_custom_host = options[:custom_host]             || [false, '']
+
+    opt_udp_port = options[:udp_port]                   || nil
+    opt_use_data_endpoint = options[:data_endpoint]     || false
+
+    self.checkParams(token, region, opt_datahub_enabled, opt_udp_port)
+
+
+    host = Le::Host.new(token, region, opt_local, opt_debug, opt_ssl, opt_datahub_endpoint, opt_host_id, opt_custom_host, opt_udp_port, opt_use_data_endpoint)
+
+    if defined?(ActiveSupport::TaggedLogging) &&  opt_tag
+      logger = ActiveSupport::TaggedLogging.new(Logger.new(host))
+    elsif defined?(ActiveSupport::Logger)
+      logger = ActiveSupport::Logger.new(host)
+      logger.formatter = host.formatter if host.respond_to?(:formatter)
+    else
+      logger = Logger.new(host)
+      logger.formatter = host.formatter if host.respond_to?(:formatter)
+    end
+
+    logger.level = opt_log_level
+
+    logger
+  end
+
+  def self.checkParams(token, region, opt_datahub_enabled, opt_udp_port)
+    # Check if the key is valid UUID format
+
+    if (!opt_datahub_enabled && !opt_udp_port)  # test Token only when DataHub and UDP are not enabled
+      if (token =~ /\A(urn:uuid:)?[\da-f]{8}-([\da-f]{4}-){3}[\da-f]{12}\z/i) == nil
+         puts "\nLE: It appears the LOGENTRIES_TOKEN you entered is invalid!\n"
+      else
+        (token="")
+      end
+
+      # This checks if region is valid. So far we have Europe and US
+      if !region
+        puts "\nLE: You need to specify region. Options: eu, us"
+      end
+
+   end
+  end
+
+end

data/test/fixtures/log/.gitignore

@@ -0,0 +1 @@
+*.log

data/test/host_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+
+describe Le::Host do
+
+  let(:token)   { '11111111-2222-3333-aaaa-bbbbbbbbbbbb' }
+  let(:local)   { false }
+  let(:debug)   { false }
+  let(:ssl)     { true }
+  let(:udp)     { nil }
+
+
+
+  let(:datahub_endpoint) { ["", 10000] }
+  let(:host_id) { ""}
+  let(:custom_host)	{ [false, ""]}
+  let(:data_endpoint) {true}
+
+  #let(:host)    { Le::Host.new(token, local, debug, ssl) }
+  let(:host)     { Le::Host::HTTP.new(token, local, debug, ssl, datahub_endpoint, host_id, custom_host, udp, data_endpoint) }
+  specify { host.must_be_instance_of Le::Host::HTTP }
+
+end

data/test/http_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'pathname'
+
+describe Le::Host::HTTP do
+
+  let(:token)              { '11111111-2222-3333-aaaa-bbbbbbbbbbbb' }
+  let(:local)              { false }
+  let(:debug)              { false }
+  let(:ssl)                { false }
+  let(:udp)                { nil }
+
+  let(:datahub_endpoint)  { ["", 10000]}
+  let(:host_id)           {""}
+  let(:custom_host)       {[false, ""]}
+  let(:endpoint)       {false}
+
+
+
+#  let(:host)               { Le::Host::HTTP.new(token, local, debug, ssl) }
+  let(:host)               { Le::Host::HTTP.new(token, local, debug, ssl, datahub_endpoint, host_id, custom_host, udp, endpoint) }
+
+  let(:logger_console)     { host.instance_variable_get(:@logger_console) }
+  let(:logger_console_dev) { logger_console.instance_variable_get(:@logdev).dev }
+
+  specify { host.must_be_instance_of Le::Host::HTTP }
+  specify { host.local.must_equal false }
+  specify { host.debug.must_equal false }
+  specify { host.ssl.must_equal false }
+  specify { host.udp_port.must_equal nil }
+  specify {host_id.must_equal ""}
+  specify {custom_host.must_equal [false, ""]}
+
+end

data/test/le_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+describe Le do
+
+  let(:token)              { '11111111-2222-3333-aaaa-bbbbbbbbbbbb' }
+  let(:local)              { false }
+  let(:logger)             { Le.new(token, local: local) }
+  let(:logdev)             { logger.instance_variable_get(:@logdev).dev }
+  let(:logger_console)     { logdev.instance_variable_get(:@logger_console) }
+  let(:logger_console_dev) { logger_console.instance_variable_get(:@logdev).dev }
+
+
+  describe "when non-Rails environment" do
+
+    describe "when initialised with just a token" do
+      let(:logger)         { Le.new(token) }
+      specify { logger.must_be_instance_of Logger }
+      specify { logdev.must_be_instance_of Le::Host::HTTP }
+      specify { logdev.local.must_equal false }
+      specify { logger_console.must_be_nil }
+    end
+
+    describe "and :local is false" do
+      specify { logdev.local.must_equal false }
+      specify { logger_console.must_be_nil }
+    end
+
+    describe "and :local is true" do
+      let(:local)   { true }
+
+      specify { logdev.local.must_equal true }
+      specify { logger_console.must_be_instance_of Logger }
+      specify { logger_console_dev.must_be_instance_of IO }
+    end
+
+
+    describe "and :local => " do
+      let(:local_test_log) { Pathname.new(File.dirname(__FILE__)).join('fixtures','log','local_log.log') }
+      let(:local)   { log_file }
+
+      describe "Pathname" do
+        let(:log_file) { local_test_log }
+
+        specify { logdev.must_be_instance_of Le::Host::HTTP }
+        specify { logdev.local.must_equal true }
+        specify { logger_console.must_be_instance_of Logger }
+        specify { logger_console_dev.must_be_instance_of File }
+        specify { logger_console_dev.path.must_match 'local_log.log' }
+      end
+
+      describe "path string" do
+        let(:log_file) { local_test_log.to_s }
+
+        specify { logdev.must_be_instance_of Le::Host::HTTP }
+        specify { logdev.local.must_equal true }
+        specify { logger_console.must_be_instance_of Logger }
+        specify { logger_console_dev.must_be_instance_of File }
+        specify { logger_console_dev.path.must_match 'local_log.log' }
+      end
+
+      describe "File" do
+        let(:log_file) { File.new(local_test_log, 'w') }
+
+        specify { logdev.must_be_instance_of Le::Host::HTTP }
+        specify { logdev.local.must_equal true }
+        specify { logger_console.must_be_instance_of Logger }
+        specify { logger_console_dev.must_be_instance_of File }
+        specify { logger_console_dev.path.must_match 'local_log.log' }
+      end
+
+    end
+
+  end
+
+  describe "when Rails environment" do
+    before do
+      class Rails
+        def self.root
+          Pathname.new(File.dirname(__FILE__)).join('fixtures')
+        end
+        def self.env
+          'test'
+        end
+      end
+    end
+    after do
+      Object.send(:remove_const, :Rails)
+    end
+
+    describe "and :local is false" do
+      specify { logdev.local.must_equal false }
+      specify { logger_console.must_be_nil }
+    end
+
+    describe "and :local is true" do
+      let(:local)   { true }
+
+      specify { logdev.local.must_equal true }
+      specify { logger_console.must_be_instance_of Logger }
+      specify { logger_console_dev.must_be_instance_of File }
+      specify { logger_console_dev.path.must_match 'test.log' }
+    end
+
+    describe "and :local => " do
+      let(:local_test_log) { Pathname.new(File.dirname(__FILE__)).join('fixtures','log','local_log.log') }
+      let(:local)   { log_file }
+
+      describe "Pathname" do
+        let(:log_file) { local_test_log }
+
+        specify { logdev.must_be_instance_of Le::Host::HTTP }
+        specify { logdev.local.must_equal true }
+        specify { logger_console.must_be_instance_of Logger }
+        specify { logger_console_dev.must_be_instance_of File }
+        specify { logger_console_dev.path.must_match 'local_log.log' }
+      end
+
+      describe "path string" do
+        let(:log_file) { local_test_log.to_s }
+
+        specify { logdev.must_be_instance_of Le::Host::HTTP }
+        specify { logdev.local.must_equal true }
+        specify { logger_console.must_be_instance_of Logger }
+        specify { logger_console_dev.must_be_instance_of File }
+        specify { logger_console_dev.path.must_match 'local_log.log' }
+      end
+
+      describe "File" do
+        let(:log_file) { File.new(local_test_log, 'w') }
+
+        specify { logdev.must_be_instance_of Le::Host::HTTP }
+        specify { logdev.local.must_equal true }
+        specify { logger_console.must_be_instance_of Logger }
+        specify { logger_console_dev.must_be_instance_of File }
+        specify { logger_console_dev.path.must_match 'local_log.log' }
+      end
+
+    end
+
+  end
+
+end

data/test/region.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'pathname'
+
+logger = Le.new('185a71d5-32a7-4007-a12d-3295c75a10e2', 'eu')
+logger.info("ssl")
+
+describe Le::Host::HTTP do
+
+  let(:token)              { '11111111-2222-3333-aaaa-bbbbbbbbbbbb' }
+  let(:region)             {'eu'}
+  let(:local)              { false }
+  let(:debug)              { false }
+  let(:ssl)                { false }
+  let(:udp)                { nil }
+
+  let(:datahub_endpoint)  { ["", 10000]}
+  let(:host_id)           {""}
+  let(:custom_host)       {[false, ""]}
+  let(:endpoint)          {false}
+
+
+  let(:host)               { Le::Host::HTTP.new(token, region, local, debug, ssl, datahub_endpoint, host_id, custom_host, udp, endpoint) }
+
+  let(:logger_console)     { host.instance_variable_get(:@logger_console) }
+  let(:logger_console_dev) { logger_console.instance_variable_get(:@logdev).dev }
+
+  specify { host.must_be_instance_of Le::Host::HTTP }
+  specify {host.region.must_equal 'eu'}
+  specify { host.local.must_equal false }
+  specify { host.debug.must_equal false }
+  specify { host.ssl.must_equal false }
+  specify { host.udp_port.must_equal nil }
+  specify {host_id.must_equal ""}
+  specify {custom_host.must_equal [false, ""]}
+
+
+end

data/test/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'minitest/autorun'
+require 'le'

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: r7insight
+version: !ruby/object:Gem::Version
+  version: 2.7.5
+platform: ruby
+authors:
+- Mark Lacomber
+- Stephen Hynes
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "\n\n"
+email: support@rapid7.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LE.gemspec
+- LICENSE
+- README.md
+- Rakefile
+- lib/le.rb
+- lib/le/host.rb
+- lib/le/host/connection.rb
+- test/fixtures/log/.gitignore
+- test/host_spec.rb
+- test/http_spec.rb
+- test/le_spec.rb
+- test/region.rb
+- test/spec_helper.rb
+homepage: https://github.com/rapid7/r7insight_ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: InsightOps logging plugin
+test_files:
+- test/fixtures/log/.gitignore
+- test/host_spec.rb
+- test/http_spec.rb
+- test/le_spec.rb
+- test/region.rb
+- test/spec_helper.rb