met_on_the_middle 0.1.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e57a849172420e708be4f89acaf2722b6e41aa6f
+  data.tar.gz: b90079be8aae22ba88cfe564e66a8a2466eeeb3b
+SHA512:
+  metadata.gz: 129067d4d81f42928fa08028a7f2bf5331291bb0bf64365c8d7587e42326421b32bc66f870f2641d19c41b9d0e4579c3d364b9207d7bb19c4f2b229699b637b1
+  data.tar.gz: f4564a9a5308193f305efce34e341ed62a6d10de580b1814f109bcded89c814d89f4abe6f50ef447c7dbbbdfbf0e21e42114ada35d13ed08cdb40f447d53c19d

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+*.gem

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.0
+before_install: gem install bundler -v 1.14.5

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in met_on_the_middle.gemspec
+gemspec

data/README.md

@@ -0,0 +1,52 @@
+# MetOnTheMiddle
+
+Gemma per l'estrapolazione di dati da inviare poi a vari 
+sistemi di analisi
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'met_on_the_middle', source: 'http://XXXXXX:XXXXXX@gem.archimedianet.it' 
+```
+
+And then execute:
+
+    $ bundle
+    
+Installare l'inizializzatore con le varie opzioni dell'applicativo
+
+    $ bundle exec rails g met_on_the_middle:install
+      
+
+
+## Usage
+
+Per implementare nuove metriche:
+
+creare una nuova classe derivata da
+
+    MetOnTheMiddle::Readers::Base
+    
+come quelle già presenti, leggere direttamente la documentazione 
+su tale classe
+
+Nel caso non esistesse un ActiveSupport::Notifications che fa al caso vostro
+registratelo come definito nella 
+[documentazione](http://guides.rubyonrails.org/active_support_instrumentation.html)
+ e registrate quindi la vostra classe per quell'evento
+ 
+Ricordardarsi di aggiungere la classe corretta nell'array dei readers nella 
+configurazione dell'inizializer
+ 
+ 
+Aggiungere quindi su zabbix all'host interessato il Template Rails preparato.
+Ho estraolato anche il template e posizionato in doc/zbx_export_templates.xml
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "met_on_the_middle"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here
+
+cd spec/dummy
+bundle install
+bundle exec rake db:migrate
+bundle exec rake db:seed

data/lib/met_on_the_middle.rb

@@ -0,0 +1,42 @@
+module MetOnTheMiddle
+
+end
+
+require 'met_on_the_middle/readers/base'
+require 'met_on_the_middle/readers/database_time'
+require 'met_on_the_middle/readers/request_count'
+require 'met_on_the_middle/readers/total_time'
+require 'met_on_the_middle/readers/view_time'
+
+require 'met_on_the_middle/senders/base'
+require 'met_on_the_middle/senders/file_system'
+require 'met_on_the_middle/senders/zabbix'
+
+require 'met_on_the_middle/version'
+require 'met_on_the_middle/root_middleware'
+require 'met_on_the_middle/configuration'
+require 'met_on_the_middle/request'
+require 'met_on_the_middle/collector'
+require 'met_on_the_middle/tracker'
+require 'met_on_the_middle/worker'
+
+
+module MetOnTheMiddle
+  # Your code goes here...
+
+  class << self
+    attr_writer :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+end
+
+
+require 'met_on_the_middle/railtie' if defined?(Rails)

data/lib/met_on_the_middle/collector.rb

@@ -0,0 +1,35 @@
+module MetOnTheMiddle
+  class Collector
+
+    MAX_QUEUE_SIZE_AUTOCLEAR = 100
+    attr_accessor :sender, :data
+
+    delegate :clear, :size, :empty?, to: :data
+
+    def initialize(sender)
+      self.sender = sender
+      @data = Hash.new
+    end
+
+    def add(request)
+      @data[request.time]=request
+    end
+
+
+    def submit
+      Marshal.load(Marshal.dump(@data)).each do |k, v|
+        self.sender.write(v)
+      end
+      self.clear
+    rescue Exception => e
+      if self.size>MAX_QUEUE_SIZE_AUTOCLEAR
+
+        pre_clear = self.keys[self.size/2]
+
+        self.reject! {|k, v| k<pre_clear}
+
+      end
+    end
+
+  end
+end

data/lib/met_on_the_middle/configuration.rb

@@ -0,0 +1,69 @@
+module MetOnTheMiddle
+  class Configuration
+
+    ##
+    # Regular expression per selezionare l'event matcher
+    attr_accessor :notifications_event_matcher
+
+    # type of timer to use, valid options are
+    # :sleep (default), :eventmachine, or :synchrony
+    attr_accessor :event_mode
+
+    ##
+    # Tempo in secondi ogni quanto eseguire un flush dei dati
+    attr_accessor :flush_interval
+
+    ##
+    # Enviroments dove installare il middleware
+    # default a sola produzione
+    attr_accessor :mounting_enviroments
+
+    ##
+    # Definisce la classe da utilizzare per spedire/registrazione le informazioni
+    # Default a MetOnTheMiddle::Senders::FileSystem configurato per scrivere
+    # in un file dentro alla cartella log dell'applicativo Rails
+    attr_accessor :sender
+
+    attr_accessor :logger
+
+
+    attr_reader :tracker
+
+    def initialize
+      @notifications_event_matcher = /.*/
+      @event_mode= :sleep
+      @tracker = nil
+      @logger = Rails.logger
+      @sender = Senders::FileSystem.new(Rails.root.join('log/met_on_the_middle.log'))
+      @flush_interval = 60
+      @mounting_enviroments = [:production]
+      self.readers = [:RequestCount, :TotalTime, :DatabaseTime, :ViewTime]
+    end
+
+
+    def dump
+
+      {
+          notifications_event_matcher: :notifications_event_matcher,
+          event_mode: :event_mode
+      }
+
+    end
+
+
+    def readers=(array)
+      @_readers = array.collect {|c|
+        if c.is_a?(Symbol)
+          Readers.const_get(c)
+        else
+          c
+        end
+      }
+    end
+
+    def readers
+      @_readers
+    end
+
+  end
+end

data/lib/met_on_the_middle/generators/install_generator.rb

@@ -0,0 +1,10 @@
+module MetOnTheMiddle::Generators
+  class InstallGenerator < Rails::Generators::Base
+
+    source_root File.expand_path("../templates", __FILE__)
+
+    def create_initializer_file
+      copy_file "initializer.rb", "config/initializers/met_on_the_middle.rb"
+    end
+  end
+end

data/lib/met_on_the_middle/generators/templates/initializer.rb

@@ -0,0 +1,41 @@
+MetOnTheMiddle.configure do |cfg|
+
+  #cfg.notifications_event_matcher = /.*/
+
+  # type of timer to use, valid options are
+  # :sleep (default), :eventmachine, or :synchrony
+  # cfg.event_mode = :sleep
+
+  # Default Logger
+  #cfg.logger = Rails.logger
+
+  # Tempo in secondi ogni quanto eseguire un flush dei dati
+  # cfg.flush_interval = 60
+
+  # Elenco Classi da Utilizzare per estrapolare le informazioni
+  # Può essere anche una classe oltre ad un symbol
+  #
+  #cfg.readers = [:RequestCount, :TotalTime, :DatabaseTime, :ViewTime]
+
+  ##
+  # Definisce la classe da utilizzare per spedire/registrazione le informazioni
+  # Default a MetOnTheMiddle::Senders::FileSystem configurato per scrivere
+  # in un file dentro alla cartella log dell'applicativo Rails
+  #cfg.sender =  MetOnTheMiddle::Senders::FileSystem.new(Rails.root.join('log/met_on_the_middle.log'))
+
+  ##
+  # Configurazione per Zabbix
+  #
+  # cfg.sender =  MetOnTheMiddle::Senders::Zabbix.new(
+  #   server_host: '127.0.0.1',
+  #   port: 10051,
+  #   identify_host:'nome.mio.host'
+  # )
+
+  ##
+  # Configurazione per definire in quali enviroments montare il middleware
+  # cfg.mounting_enviroments = [:production]
+
+
+
+end

data/lib/met_on_the_middle/railtie.rb

@@ -0,0 +1,45 @@
+module MetOnTheMiddle
+  class Railtie < Rails::Railtie
+
+
+    generators do
+      require File.expand_path('../../../lib/met_on_the_middle/generators/install_generator', __FILE__)
+    end
+
+    initializer "met_on_the_middle.append_root_middleware" do |app|
+      if MetOnTheMiddle.configuration.mounting_enviroments.include?(Rails.env.to_sym)
+        app.middleware.insert_before(Rack::Sendfile, 'MetOnTheMiddle::RootMiddleware')
+      else
+        Rails.logger.info {
+          "MetOnTheMiddle::RootMiddleware non installato
+           per configurazione dell'enviroment: #{Rails.env.to_sym.inspect}->
+           #{MetOnTheMiddle.configuration.mounting_enviroments.inspect}"
+        }
+      end
+    end
+
+
+=begin
+    initializer "met_on_the_middle.define_notification_subscription" do
+
+      variabile_mia = '123123'
+
+      ActiveSupport::Notifications.subscribe MetOnTheMiddle.configuration.notifications_event_matcher do |*args|
+        event = ActiveSupport::Notifications::Event.new *args
+
+        raise variabile_mia.inspect
+
+        event.name # => "process_action.action_controller"
+        event.duration # => 10 (in milliseconds)
+        event.payload # => {:extra=>information}
+
+        # Rails.logger.info "#{event.inspect} Received!"
+        # Rails.logger.info "----------"
+      end
+
+    end
+=end
+
+
+  end
+end

data/lib/met_on_the_middle/readers/base.rb

@@ -0,0 +1,56 @@
+module MetOnTheMiddle::Readers
+  ##
+  # Classe base del reader, la quale deve rispondere con la chiave da
+  # utilizzare per dare un label al dato inviato (chiave per zabbix)
+  #
+  class Base
+    include Singleton
+    extend SingleForwardable
+
+    def_delegators :instance, :parse, :to_key_value, :register_subscription
+
+    attr_accessor :key
+
+    def initialize(key)
+      @key = key
+    end
+
+    ##
+    # Regular expression to match notifications
+    # Serve per attivare la subscription a determinati eventi di
+    # ActiveSupport::Notifications
+    def match_subscription
+      ''
+    end
+
+    #
+    # metodo da utilizzare per parsare i dati
+    #
+    # @author Bonetti Marino
+    #
+    #
+    # @param [ActiveSupport::Notifications::Event] event proveniente dalla subscription
+    # @option opts [MetOnTheMiddle::Request] :request oggetto che raggruppa la richiesta, utile se si
+    #                                devono sommare dati
+    #
+    # @return il valore da salvare ed inviare nei provider di registrazione
+    def parse(event, request: nil)
+      event.name
+    end
+
+    def to_key_value(event, request: nil)
+      return @key, parse(event, request: request)
+    end
+
+
+    def register_subscription(tracker)
+      ActiveSupport::Notifications.subscribe match_subscription do |*args|
+        if not tracker.nil? and not tracker.actual_request.nil?
+          event = ActiveSupport::Notifications::Event.new *args
+          tracker.add *self.to_key_value(event, request: tracker.actual_request)
+        end
+      end
+    end
+
+  end
+end

data/lib/met_on_the_middle/readers/database_time.rb

@@ -0,0 +1,18 @@
+module MetOnTheMiddle::Readers
+  class DatabaseTime < Base
+
+    def initialize
+      super :database_time
+    end
+
+    def match_subscription
+      'sql.active_record'
+    end
+
+    def parse(e, request: nil)
+      return e.duration if request.nil?
+      (e.duration+(request.get(key)||0)).round(2)
+    end
+
+  end
+end

data/lib/met_on_the_middle/readers/request_count.rb

@@ -0,0 +1,17 @@
+module MetOnTheMiddle::Readers
+  class RequestCount < Base
+
+    def initialize
+      super(:request_count)
+    end
+
+    def match_subscription
+      'met_on_the_middle.total_time'
+    end
+
+    def parse(event, request: nil)
+      1
+    end
+
+  end
+end

data/lib/met_on_the_middle/readers/total_time.rb

@@ -0,0 +1,17 @@
+module MetOnTheMiddle::Readers
+  class TotalTime < Base
+
+    def initialize
+      super(:total_time)
+    end
+
+    def match_subscription
+      'met_on_the_middle.total_time'
+    end
+
+    def parse(event,request:nil)
+      event.duration.round(2)
+    end
+
+  end
+end

data/lib/met_on_the_middle/readers/view_time.rb

@@ -0,0 +1,22 @@
+module MetOnTheMiddle::Readers
+  class ViewTime < Base
+
+    def initialize
+      super :view_time
+    end
+
+    def match_subscription
+      /render_(partial|template).action_view/
+    end
+
+    def parse(e, request: nil)
+      path = e.payload[:identifier].split('/views/', 2)
+
+      duration = 0
+      duration = e.duration if path[1]
+
+      (duration+(request.get(key)||0)).round(2)
+    end
+
+  end
+end

data/lib/met_on_the_middle/request.rb

@@ -0,0 +1,24 @@
+module MetOnTheMiddle
+  ##
+  # Classe che si occupa di raggruppare le informazioni per richiesta,
+  # se la chiave è già presente, il valore viene sommato
+  class Request
+
+    attr_accessor :time
+    attr_reader :data
+
+    def initialize(time=Time.new)
+      @time = time
+      @data = {}
+    end
+
+    def add(key, value)
+      @data[key]=value
+    end
+
+    def get(key)
+      @data[key]
+    end
+
+  end
+end

data/lib/met_on_the_middle/root_middleware.rb

@@ -0,0 +1,64 @@
+module MetOnTheMiddle
+  class RootMiddleware
+
+
+    attr_reader :tracker
+
+    def initialize(app)
+      @app = app
+
+      generate_tracker
+
+      if defined?(PhusionPassenger)
+        PhusionPassenger.on_event(:starting_worker_process) do |forked|
+          if forked
+            generate_tracker
+          end
+        end
+      end
+
+    end
+
+    def generate_tracker
+      @tracker = Tracker.new(MetOnTheMiddle.configuration)
+      @tracker.start!
+
+      ##
+      # TODO trovare sistema migliore per individuare se siamo lanciati tramite
+      # rake oppure tramite server
+      unless File.basename($0) == 'rake'
+        register_subscriptions
+      end
+    end
+
+    ##
+    # Serve per essere multy trade safe
+    def call(env)
+      dup._call(env)
+    end
+
+    def _call(env)
+      response = nil
+
+      @tracker.request_block do
+
+        ActiveSupport::Notifications.instrument "met_on_the_middle.total_time" do
+          response = @app.call(env)
+        end
+
+      end
+
+
+      response
+    end
+
+
+    def register_subscriptions
+      MetOnTheMiddle.configuration.readers.each do |r|
+        r.register_subscription(@tracker)
+      end
+    end
+
+
+  end
+end

data/lib/met_on_the_middle/senders/base.rb

@@ -0,0 +1,16 @@
+module MetOnTheMiddle::Senders
+  ##
+  # Classe base per la registrazione delle informazioni
+  class Base
+
+    # Metodo per scrivere la richiesta
+    #
+    # @author Bonetti Marino
+    #
+    # @param [Request] reuqest
+    def write(request)
+
+    end
+
+  end
+end

data/lib/met_on_the_middle/senders/file_system.rb

@@ -0,0 +1,21 @@
+module MetOnTheMiddle::Senders
+  class FileSystem < Base
+
+    attr_accessor :logger
+
+    def initialize(path)
+      self.logger = ::Logger.new(path, 2)
+    end
+
+
+    def write(request)
+      self.logger.info request.time.to_s do
+        keys = []
+        request.data.each do |k, v|
+          keys<<"#{k}:#{v}"
+        end
+        keys.join("|")
+      end
+    end
+  end
+end

data/lib/met_on_the_middle/senders/zabbix.rb

@@ -0,0 +1,45 @@
+require 'socket'
+require 'zabbix_protocol'
+
+SERVER_PORT = 10051
+
+
+module MetOnTheMiddle::Senders
+  class Zabbix < Base
+
+
+    attr_accessor :server_host, :port, :identify_host
+
+    ##
+    # Inizializzatore, configurazioni:
+    #
+    # server_host: host del server
+    # port: porta del server
+    # identify_host: nome dell'host da cui partono i dati
+    def initialize(cfgs)
+      self.server_host= cfgs[:server_host]
+      self.port= cfgs[:port]
+      self.identify_host= cfgs[:identify_host]
+    end
+
+    def write(request)
+      TCPSocket.open(server_host, port) do |sock|
+        datas = []
+        request.data.each do |k, v|
+          datas<<{"key":k,"value":v}
+        end
+
+        data = {
+            "request" => "sender data",
+            "data" =>datas.collect{|d| d.merge("host" => identify_host)}
+        }
+
+        sock.print ZabbixProtocol.dump(data)
+        #p ZabbixProtocol.load(sock.read)
+        #=> {"response"=>"success", "info"=>"Processed 0 Failed 1 Total 1 Seconds spent 0.000018"}
+      end
+    end
+
+
+  end
+end

data/lib/met_on_the_middle/tracker.rb

@@ -0,0 +1,118 @@
+module MetOnTheMiddle
+  class Tracker
+    extend Forwardable
+
+    def_delegators :actual_request, :add
+
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+    end
+
+    # check to see if we should start a worker for this process.
+    # if you are using this externally, use #start! instead as this
+    # method may change
+    def check_worker
+      return if @worker # already running
+      return unless start_worker?
+      logger.debug {"config: #{config.dump}"}
+      @pid = $$
+      logger.debug {">> starting up worker for pid #{@pid}..."}
+
+      @worker = Worker.new(timer: config.event_mode)
+      @worker.run_periodically(config.flush_interval) do
+        flush
+      end
+
+    end
+
+    # primary collector object used by this tracker
+    def collector
+      @collector ||= MetOnTheMiddle::Collector.new(@config.sender)
+    end
+
+
+    # send all current data to Metrics
+    def flush
+      logger.debug {"flushing pid #{@pid} (#{Time.now}).."}
+      start = Time.now
+      # thread safety is handled internally for stores
+      # queue = build_flush_queue(collector)
+      # queue.submit unless queue.empty?
+      unless collector.empty?
+        logger.debug {"logica di invio dati - #{collector.inspect}"}
+
+        collector.submit
+
+        logger.debug { "#### #{collector.size} - GarbageCollector - #{GC.stat.inspect}" }
+
+      end
+
+      logger.info {"flushed pid #{@pid} in #{(Time.now - start)*1000.to_f}ms"}
+    rescue Exception => error
+      logger.error {"submission failed permanently: #{error}"}
+    end
+
+    # given current state, should the tracker start a reporter thread?
+    def should_start?
+      true
+    end
+
+    # start worker thread, one per process.
+    # if this process has been forked from an one with an active
+    # worker thread we don't need to worry about cleanup, the worker
+    # thread will not pass with the fork
+    def start!
+      check_worker if should_start?
+    end
+
+    def actual_request
+      @_actual_request
+    end
+
+    ##
+    # Si occupa di ragruppare per richiesta
+    def request_block
+      @_actual_request = Request.new
+      yield
+      collector.add @_actual_request
+    end
+
+    private
+
+    # access to client instance
+    def client
+      @client ||= prepare_client
+    end
+
+    # use custom faraday adapter if running in evented context
+    def custom_adapter
+      case config.event_mode
+        when :eventmachine
+          :em_http
+        when :synchrony
+          :em_synchrony
+        else
+          nil
+      end
+    end
+
+    def logger
+      Rails.logger
+    end
+
+    # should we spin up a worker? wrap this in a process check
+    # so we only actually check once per process. this allows us
+    # to check again if the process forks.
+    def start_worker?
+      if @pid_checked == $$
+        false
+      else
+        @pid_checked = $$
+        should_start?
+      end
+    end
+
+  end
+end

data/lib/met_on_the_middle/version.rb

@@ -0,0 +1,3 @@
+module MetOnTheMiddle
+  VERSION = '0.1.6'
+end

data/lib/met_on_the_middle/worker.rb

@@ -0,0 +1,94 @@
+module MetOnTheMiddle
+  class Worker
+    attr_reader :timer
+
+    # available options:
+    #  * timer - type of timer to use, valid options are
+    #            :sleep (default), :eventmachine, or :synchrony
+    #  * sync  - try to synchronize timer executions to whole
+    #            minutes or subdivisions thereof
+    def initialize(options={})
+      @interrupt = false
+      @timer = (options[:timer] || :sleep).to_sym
+      @sync = options[:sync] || false
+    end
+
+    # run the given block every <period> seconds, looping
+    # infinitely unless @interrupt becomes true.
+    #
+    def run_periodically(period, &block)
+      @proc = block # store
+
+      if [:eventmachine, :synchrony].include?(timer)
+        compensated_repeat(period) # threading is already handled
+      else
+        @thread = Thread.new {compensated_repeat(period)}
+      end
+    end
+
+    # Give some structure to worker start times so when possible
+    # they will be in sync.
+    #
+    def start_time(period)
+      if @sync
+        earliest = Time.now + period
+        # already on a whole minute
+        return earliest if earliest.sec == 0
+        if period > 30
+          # bump to whole minute
+          earliest + (60-earliest.sec)
+        else
+          # ensure sync to whole minute if minute is evenly divisible
+          earliest + (period-(earliest.sec%period))
+        end
+      else
+        if period > 30
+          # ensure some wobble in start times,
+          # trade a slightly irregular first period for a more even
+          # distribution for network requests between processes
+          start = Time.now
+          start + (60-start.sec) + rand(60)
+        else
+          Time.now + period
+        end
+      end
+    end
+
+    # stop worker loop at the beginning of the next round
+    # of execution
+    def stop!
+      @interrupt = true
+    end
+
+    private
+
+    # run continuous loop executing every <period>, will start
+    # at <first_run> if set otherwise will auto-determine
+    # appropriate time for first run
+    def compensated_repeat(period, first_run = nil)
+      next_run = first_run || start_time(period)
+      until @interrupt do
+        now = Time.now
+        if now >= next_run
+          @proc.call
+
+          while next_run <= now
+            next_run += period # schedule future run
+          end
+        end
+
+        interval = next_run - now
+        case timer
+          when :eventmachine
+            EM.add_timer(interval) {compensated_repeat(period, next_run)}
+            break
+          when :synchrony
+            EM::Synchrony.sleep(interval)
+          else
+            sleep(next_run - now)
+        end
+      end
+    end
+
+  end
+end

data/met_on_the_middle.gemspec

@@ -0,0 +1,38 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'met_on_the_middle/version'
+
+Gem::Specification.new do |spec|
+  spec.name = "met_on_the_middle"
+  spec.version = MetOnTheMiddle::VERSION
+  spec.authors = ["MarinoBonetti"]
+  spec.email = ["marinobonetti@gmail.com"]
+
+  spec.summary = 'Metric on the middle'
+  spec.description = 'Little app to send configurable datas to various destinations'
+  spec.homepage = "http://www.archimedianet.it"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features|doc)/})
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) {|f| File.basename(f)}
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "zabbix_protocol", "~> 0.1.5"
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "curb", "~> 0.9.3"
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: met_on_the_middle
+version: !ruby/object:Gem::Version
+  version: 0.1.6
+platform: ruby
+authors:
+- MarinoBonetti
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-06-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zabbix_protocol
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: curb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+description: Little app to send configurable datas to various destinations
+email:
+- marinobonetti@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/met_on_the_middle.rb
+- lib/met_on_the_middle/collector.rb
+- lib/met_on_the_middle/configuration.rb
+- lib/met_on_the_middle/generators/install_generator.rb
+- lib/met_on_the_middle/generators/templates/initializer.rb
+- lib/met_on_the_middle/railtie.rb
+- lib/met_on_the_middle/readers/base.rb
+- lib/met_on_the_middle/readers/database_time.rb
+- lib/met_on_the_middle/readers/request_count.rb
+- lib/met_on_the_middle/readers/total_time.rb
+- lib/met_on_the_middle/readers/view_time.rb
+- lib/met_on_the_middle/request.rb
+- lib/met_on_the_middle/root_middleware.rb
+- lib/met_on_the_middle/senders/base.rb
+- lib/met_on_the_middle/senders/file_system.rb
+- lib/met_on_the_middle/senders/zabbix.rb
+- lib/met_on_the_middle/tracker.rb
+- lib/met_on_the_middle/version.rb
+- lib/met_on_the_middle/worker.rb
+- met_on_the_middle.gemspec
+homepage: http://www.archimedianet.it
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+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.7
+signing_key: 
+specification_version: 4
+summary: Metric on the middle
+test_files: []
+has_rdoc: