logstash-input-remote_proc 0.0.22 → 0.0.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0983a9d2e35c35ad804f33c09edb2dcbb3700804
-  data.tar.gz: 3e91fd6e62044ddb991862dfa78179d5f7eba9c8
+  metadata.gz: 18036cd47bafcebcaa5a6039407d6c8abf3d019a
+  data.tar.gz: 4a00dd8d6dec59b760010130ef65b785b3cf8fef
 SHA512:
-  metadata.gz: 1fb45c39cea960ed7106cce6c65c6557df398b7119d6a626d6dbf0430cc0402553f7f45524a6660f594da71869927c5fd55bdea53de872ad775dba856f6f7675
-  data.tar.gz: c5d77173d7ebbd0237656af361dcb128fe7134e4b8d3f716941a64781cc238990db7a1c08bcec558691d064303a3f3972c04174f2302a5737f5e508a30208a63
+  metadata.gz: c02c6b84a1cd161125e1f66798abc9dc0a84ab3a30ee6f405d39659f0b9d2041d71ee22867bb64dac2fcdcca0134e071ca1d4cba5175a8e82ac91b6ac693c870
+  data.tar.gz: b4a7d058b4c53aae5582b48521425c0dd254950e4a53e813780eb34278da78d0847ea22c38988e08ab85c4a4b0349818908cd3abd0823acedb8c21a4337944a9

data/lib/logstash/inputs/remote_proc.rb

@@ -86,8 +86,9 @@ module LogStash
       def register
         @host = Socket.gethostname
 
-        require 'net/ssh/multi'
-        @ssh_session = Net::SSH::Multi.start(on_error: :warn)
+        require 'net/ssh'
+        require 'net/ssh/gateway'
+        @ssh_sessions = []
 
         # Don't forget to close all gateways manually in `stop` method.
         @ssh_gateways = []
@@ -99,18 +100,47 @@ module LogStash
       def run(queue)
         # we can abort the loop if stop? becomes true
         until stop?
-          COMMANDS.keys.each do |method|
-            send("proc_#{method}", queue)
-          end
+          @ssh_sessions.each do |ssh|
+            COMMANDS.each do |method, command|
+              result_data = String.new('')
+              channel = ssh.open_channel do |chan|
+                chan.exec(command) do |ch, success|
+                  next unless success
+
+                  # "on_data" called when the process writes to stdout
+                  ch.on_data { |_c, data| result_data << data }
 
-          @ssh_session.loop(@interval)
+                  # "on_extended_data", called when the process writes to stderr
+                  ch.on_extended_data {} # |_c, _type, _data|
 
+                  ch.on_close(&:close)
+                end
+              end
+              channel.wait
+              next if result_data.empty?
+              result = send("proc_#{method}", result_data)
+              next if result.empty?
+              event = LogStash::Event.new(
+                method => result,
+                host: @host,
+                type: @type || "system-#{method}",
+                metric_name: "system-#{method}",
+                remote_host: channel.connection.transport.host,
+                remote_port: channel.connection.transport.port,
+                command: command,
+                message: result_data
+              )
+              decorate(event)
+              queue << event
+            end
+            ssh.loop
+          end # @ssh_sessions block
           Stud.stoppable_sleep(@interval) { stop? }
-        end # loop
+        end # until loop
       end # def run
 
       def stop
-        @ssh_session.close
+        @ssh_sessions.map(&:close)
         @ssh_gateways.map(&:shutdown!) unless @ssh_gateways.empty?
       end
 
@@ -128,6 +158,7 @@ module LogStash
           prepare_servers!(s)
 
           session_options = {}
+          session_options[:port] = s['port'] if s['port']
           session_options[:password] = s['password'] if s['password']
           if s['ssh_private_key']
             session_options[:auth_methods] = ['publickey']
@@ -144,352 +175,246 @@ module LogStash
                                        s['gateway_username'],
                                        gw_opts)
             @ssh_gateways << gw
-            session_options[:via] = gw
+            @ssh_sessions << gw.ssh(s['host'],
+                                    s['username'],
+                                    session_options)
+          else
+            @ssh_sessions << Net::SSH.start(s['host'],
+                                            s['username'],
+                                            session_options)
           end
-
-          @ssh_session.use("#{s['username']}@#{s['host']}:#{s['port']}",
-                           session_options)
         end
       end
 
       # Process SYSVIPCSHM data
-      def proc_sysvipcshm(queue)
-        @ssh_session.exec(COMMANDS[:sysvipcshm]) do |ch, stream, data|
-          next unless stream == :stdout # ignore :stderr
-          lines = data.split(/$/)
-          _ = lines.shift # Remove column name line
-          sysvipcshm = {}
-          lines.each do |l|
-            t = l.strip.split(/\s+/)
-            next if t.empty? || t.length < 16
-            sysvipcshm[t[1]] = {} # shmid
-            sysvipcshm[t[1]]['key'] = t[0]
-            sysvipcshm[t[1]]['perms'] = t[2]
-            sysvipcshm[t[1]]['size'] = t[3]
-            sysvipcshm[t[1]]['cpid'] = t[4]
-            sysvipcshm[t[1]]['lpid'] = t[5]
-            sysvipcshm[t[1]]['nattch'] = t[6]
-            sysvipcshm[t[1]]['uid'] = t[7]
-            sysvipcshm[t[1]]['gid'] = t[8]
-            sysvipcshm[t[1]]['cuid'] = t[9]
-            sysvipcshm[t[1]]['cgid'] = t[10]
-            sysvipcshm[t[1]]['atime'] = t[11]
-            sysvipcshm[t[1]]['dtime'] = t[12]
-            sysvipcshm[t[1]]['ctime'] = t[13]
-            sysvipcshm[t[1]]['rss'] = t[14]
-            sysvipcshm[t[1]]['swap'] = t[15]
-          end
-          next if sysvipcshm.empty?
-          event = LogStash::Event.new(sysvipcshm: sysvipcshm,
-                                      host: @host,
-                                      type: @type || 'system-sysvipcshm',
-                                      metric_name: 'system-sysvipcshm',
-                                      remote_host: ch[:host],
-                                      command: COMMANDS[:sysvipcshm],
-                                      message: data)
-          decorate(event)
-          queue << event
+      def proc_sysvipcshm(data)
+        return {} unless data
+        lines = data.split(/$/)
+        _ = lines.shift # Remove column name line
+        sysvipcshm = {}
+        lines.each do |l|
+          t = l.strip.split(/\s+/)
+          next if t.empty? || t.length < 16
+          sysvipcshm[t[1]] = {} # shmid
+          sysvipcshm[t[1]]['key'] = t[0]
+          sysvipcshm[t[1]]['perms'] = t[2]
+          sysvipcshm[t[1]]['size'] = t[3]
+          sysvipcshm[t[1]]['cpid'] = t[4]
+          sysvipcshm[t[1]]['lpid'] = t[5]
+          sysvipcshm[t[1]]['nattch'] = t[6]
+          sysvipcshm[t[1]]['uid'] = t[7]
+          sysvipcshm[t[1]]['gid'] = t[8]
+          sysvipcshm[t[1]]['cuid'] = t[9]
+          sysvipcshm[t[1]]['cgid'] = t[10]
+          sysvipcshm[t[1]]['atime'] = t[11]
+          sysvipcshm[t[1]]['dtime'] = t[12]
+          sysvipcshm[t[1]]['ctime'] = t[13]
+          sysvipcshm[t[1]]['rss'] = t[14]
+          sysvipcshm[t[1]]['swap'] = t[15]
         end
+        sysvipcshm
       end
 
       # Process CRYPTO data
-      def proc_crypto(queue)
-        @ssh_session.exec(COMMANDS[:crypto]) do |ch, stream, data|
-          next unless stream == :stdout # ignore :stderr
-          crypto = {}
-          current_crypto = ''
-          data.split(/$/).each do |line|
-            l = line.strip
-            next if l.empty?
-            t = l.split(/\s+:\s+/)
-            next if t.empty? || t.length != 2
-            if 'name'.eql?(t[0])
-              current_crypto = t[1]
-              crypto[current_crypto] = {}
-              next
-            end
-            crypto[current_crypto][t[0]] = t[1] unless current_crypto.empty?
+      def proc_crypto(data)
+        return {} unless data
+        crypto = {}
+        current_crypto = ''
+        data.split(/$/).each do |line|
+          l = line.strip
+          next if l.empty?
+          t = l.split(/\s+:\s+/)
+          next if t.empty? || t.length != 2
+          if 'name'.eql?(t[0])
+            current_crypto = t[1]
+            crypto[current_crypto] = {}
+            next
           end
-          next if crypto.empty?
-          event = LogStash::Event.new(crypto: crypto,
-                                      host: @host,
-                                      type: @type || 'system-crypto',
-                                      metric_name: 'system-crypto',
-                                      remote_host: ch[:host],
-                                      command: COMMANDS[:crypto],
-                                      message: data)
-          decorate(event)
-          queue << event
+          crypto[current_crypto][t[0]] = t[1] unless current_crypto.empty?
         end
+        crypto
       end
 
       # Process MOUNTS data
-      def proc_mounts(queue)
-        @ssh_session.exec(COMMANDS[:mounts]) do |ch, stream, data|
-          next unless stream == :stdout # ignore :stderr
-          mounts = {}
-          data.split(/$/).each do |line|
-            t = line.strip.split(/\s+/)
-            next if t.empty? || t.length < 6
-            # mounted device name
-            device = {}
-            device['mountPoint'] = t[1]
-            device['fsType'] = t[2]
-            device['fsOptions'] = t[3].split(/,/)
-            device['dump'] = t[4]
-            device['pass'] = t[5]
-            mounts[t[0]] = [] unless mounts.include?(t[0])
-            mounts[t[0]] << device
-          end
-          next if mounts.empty?
-          event = LogStash::Event.new(mounts: mounts,
-                                      host: @host,
-                                      type: @type || 'system-mounts',
-                                      metric_name: 'system-mounts',
-                                      remote_host: ch[:host],
-                                      command: COMMANDS[:mounts],
-                                      message: data)
-          decorate(event)
-          queue << event
+      def proc_mounts(data)
+        return {} unless data
+        mounts = {}
+        data.split(/$/).each do |line|
+          t = line.strip.split(/\s+/)
+          next if t.empty? || t.length < 6
+          # mounted device name
+          device = {}
+          device['mountPoint'] = t[1]
+          device['fsType'] = t[2]
+          device['fsOptions'] = t[3].split(/,/)
+          device['dump'] = t[4]
+          device['pass'] = t[5]
+          mounts[t[0]] = [] unless mounts.include?(t[0])
+          mounts[t[0]] << device
         end
+        mounts
       end
 
       # Process NETWIRELESS data.
-      def proc_netwireless(queue)
-        @ssh_session.exec(COMMANDS[:netwireless]) do |ch, stream, data|
-          next unless stream == :stdout # ignore :stderr
-          lines = data.split(/$/)
-          _ = lines.shift # Remove first line
-          _ = lines.shift # Remove second line
-          netwireless = {}
-          lines.each do |l|
-            t = l.strip.split(/[:\s]+/)
-            next if t.empty? || t.length < 11 # Last column WE22 is often empty
-            netwireless[t[0]] = {}
-            netwireless[t[0]]['status'] = t[1].to_i
-            netwireless[t[0]]['linkQuality'] = t[2].to_i
-            netwireless[t[0]]['levelQuality'] = t[3].to_i
-            netwireless[t[0]]['noiseQuality'] = t[4].to_i
-            netwireless[t[0]]['nwidDiscarded'] = t[5].to_i
-            netwireless[t[0]]['cryptDiscarded'] = t[6].to_i
-            netwireless[t[0]]['fragDiscarded'] = t[7].to_i
-            netwireless[t[0]]['retryDiscarded'] = t[8].to_i
-            netwireless[t[0]]['miscDiscarded'] = t[9].to_i
-            netwireless[t[0]]['beaconMissed'] = t[10].to_i
-            netwireless[t[0]]['we22'] = t[11].to_i
-          end
-          next if netwireless.empty?
-          event = LogStash::Event.new(netwireless: netwireless,
-                                      host: @host,
-                                      type: @type || 'system-netwireless',
-                                      metric_name: 'system-netwireless',
-                                      remote_host: ch[:host],
-                                      command: COMMANDS[:netwireless],
-                                      message: data)
-          decorate(event)
-          queue << event
+      def proc_netwireless(data)
+        return {} unless data
+        lines = data.split(/$/)
+        _ = lines.shift # Remove first line
+        _ = lines.shift # Remove second line
+        netwireless = {}
+        lines.each do |l|
+          t = l.strip.split(/[:\s]+/)
+          next if t.empty? || t.length < 11 # Last column WE22 is often empty
+          netwireless[t[0]] = {}
+          netwireless[t[0]]['status'] = t[1].to_i
+          netwireless[t[0]]['linkQuality'] = t[2].to_i
+          netwireless[t[0]]['levelQuality'] = t[3].to_i
+          netwireless[t[0]]['noiseQuality'] = t[4].to_i
+          netwireless[t[0]]['nwidDiscarded'] = t[5].to_i
+          netwireless[t[0]]['cryptDiscarded'] = t[6].to_i
+          netwireless[t[0]]['fragDiscarded'] = t[7].to_i
+          netwireless[t[0]]['retryDiscarded'] = t[8].to_i
+          netwireless[t[0]]['miscDiscarded'] = t[9].to_i
+          netwireless[t[0]]['beaconMissed'] = t[10].to_i
+          netwireless[t[0]]['we22'] = t[11].to_i
         end
+        netwireless
       end
 
       # Process NETDEV data.
-      def proc_netdev(queue)
-        @ssh_session.exec(COMMANDS[:netdev]) do |ch, stream, data|
-          next unless stream == :stdout # ignore :stderr
-          lines = data.split(/$/)
-          _ = lines.shift # Remove first line
-          _ = lines.shift # Remove second line
-          netdev = {}
-          lines.each do |l|
-            t = l.strip.split(/[:\s]+/)
-            next if t.empty? || t.length < 17
-            netdev[t[0]] = {}
-            netdev[t[0]]['rxbytes'] = t[1].to_i
-            netdev[t[0]]['rxpackets'] = t[2].to_i
-            netdev[t[0]]['rxerrs'] = t[3].to_i
-            netdev[t[0]]['rxdrop'] = t[4].to_i
-            netdev[t[0]]['rxfifo'] = t[5].to_i
-            netdev[t[0]]['rxframe'] = t[6].to_i
-            netdev[t[0]]['rxcompressed'] = t[7].to_i
-            netdev[t[0]]['rxmulticast'] = t[8].to_i
-            netdev[t[0]]['txbytes'] = t[9].to_i
-            netdev[t[0]]['txpackets'] = t[10].to_i
-            netdev[t[0]]['txerrs'] = t[11].to_i
-            netdev[t[0]]['txdrop'] = t[12].to_i
-            netdev[t[0]]['txfifo'] = t[13].to_i
-            netdev[t[0]]['txcolls'] = t[14].to_i
-            netdev[t[0]]['txcarrier'] = t[15].to_i
-            netdev[t[0]]['txcompressed'] = t[16].to_i
-          end
-          next if netdev.empty?
-          event = LogStash::Event.new(netdev: netdev,
-                                      host: @host,
-                                      type: @type || 'system-netdev',
-                                      metric_name: 'system-netdev',
-                                      remote_host: ch[:host],
-                                      command: COMMANDS[:netdev],
-                                      message: data)
-          decorate(event)
-          queue << event
+      def proc_netdev(data)
+        return {} unless data
+        lines = data.split(/$/)
+        _ = lines.shift # Remove first line
+        _ = lines.shift # Remove second line
+        netdev = {}
+        lines.each do |l|
+          t = l.strip.split(/[:\s]+/)
+          next if t.empty? || t.length < 17
+          netdev[t[0]] = {}
+          netdev[t[0]]['rxbytes'] = t[1].to_i
+          netdev[t[0]]['rxpackets'] = t[2].to_i
+          netdev[t[0]]['rxerrs'] = t[3].to_i
+          netdev[t[0]]['rxdrop'] = t[4].to_i
+          netdev[t[0]]['rxfifo'] = t[5].to_i
+          netdev[t[0]]['rxframe'] = t[6].to_i
+          netdev[t[0]]['rxcompressed'] = t[7].to_i
+          netdev[t[0]]['rxmulticast'] = t[8].to_i
+          netdev[t[0]]['txbytes'] = t[9].to_i
+          netdev[t[0]]['txpackets'] = t[10].to_i
+          netdev[t[0]]['txerrs'] = t[11].to_i
+          netdev[t[0]]['txdrop'] = t[12].to_i
+          netdev[t[0]]['txfifo'] = t[13].to_i
+          netdev[t[0]]['txcolls'] = t[14].to_i
+          netdev[t[0]]['txcarrier'] = t[15].to_i
+          netdev[t[0]]['txcompressed'] = t[16].to_i
         end
+        netdev
       end
 
       # Process DISKSTATS data.
       # https://www.kernel.org/doc/Documentation/ABI/testing/procfs-diskstats
       # https://www.kernel.org/doc/Documentation/iostats.txt
-      def proc_diskstats(queue)
-        @ssh_session.exec(COMMANDS[:diskstats]) do |ch, stream, data|
-          next unless stream == :stdout # ignore :stderr
-          diskstats = {}
-          data.split(/$/).each do |line|
-            t = line.strip.split(/\s+/)
-            next if t.empty? || t.length < 14
-            diskstats[t[2]] = {} # device name
-            diskstats[t[2]]['major number'] = t[0].to_i
-            diskstats[t[2]]['minor number'] = t[1].to_i
-            diskstats[t[2]]['reads completed'] = t[3].to_i
-            diskstats[t[2]]['reads merged'] = t[4].to_i
-            diskstats[t[2]]['sectors read'] = t[5].to_i
-            diskstats[t[2]]['time spent reading ms'] = t[6].to_i
-            diskstats[t[2]]['writes completed'] = t[7].to_i
-            diskstats[t[2]]['writes merged'] = t[8].to_i
-            diskstats[t[2]]['sectors written'] = t[9].to_i
-            diskstats[t[2]]['time spent writing ms'] = t[10].to_i
-            diskstats[t[2]]['io in progress'] = t[11].to_i
-            diskstats[t[2]]['io time spent ms'] = t[12].to_i
-            diskstats[t[2]]['io weighted time spent ms'] = t[13].to_i
-          end
-          next if diskstats.empty?
-          event = LogStash::Event.new(diskstats: diskstats,
-                                      host: @host,
-                                      type: @type || 'system-diskstats',
-                                      metric_name: 'system-diskstats',
-                                      remote_host: ch[:host],
-                                      command: COMMANDS[:diskstats],
-                                      message: data)
-          decorate(event)
-          queue << event
+      def proc_diskstats(data)
+        return {} unless data
+        diskstats = {}
+        data.split(/$/).each do |line|
+          t = line.strip.split(/\s+/)
+          next if t.empty? || t.length < 14
+          diskstats[t[2]] = {} # device name
+          diskstats[t[2]]['major number'] = t[0].to_i
+          diskstats[t[2]]['minor number'] = t[1].to_i
+          diskstats[t[2]]['reads completed'] = t[3].to_i
+          diskstats[t[2]]['reads merged'] = t[4].to_i
+          diskstats[t[2]]['sectors read'] = t[5].to_i
+          diskstats[t[2]]['time spent reading ms'] = t[6].to_i
+          diskstats[t[2]]['writes completed'] = t[7].to_i
+          diskstats[t[2]]['writes merged'] = t[8].to_i
+          diskstats[t[2]]['sectors written'] = t[9].to_i
+          diskstats[t[2]]['time spent writing ms'] = t[10].to_i
+          diskstats[t[2]]['io in progress'] = t[11].to_i
+          diskstats[t[2]]['io time spent ms'] = t[12].to_i
+          diskstats[t[2]]['io weighted time spent ms'] = t[13].to_i
         end
+        diskstats
       end
 
       # Process VMSTAT data.
-      def proc_vmstat(queue)
-        @ssh_session.exec(COMMANDS[:vmstat]) do |ch, stream, data|
-          next unless stream == :stdout # ignore :stderr
-          vmstat = {}
-          data.split(/$/).each do |line|
-            m = /([^\s]+)\s+(\d+)/.match(line)
-            vmstat[m[1]] = m[2].to_i if m && m.length >= 3
-          end
-          next if vmstat.empty?
-          event = LogStash::Event.new(vmstat: vmstat,
-                                      host: @host,
-                                      type: @type || 'system-vmstat',
-                                      metric_name: 'system-vmstat',
-                                      remote_host: ch[:host],
-                                      command: COMMANDS[:vmstat],
-                                      message: data)
-          decorate(event)
-          queue << event
+      def proc_vmstat(data)
+        return {} unless data
+        vmstat = {}
+        data.split(/$/).each do |line|
+          m = /([^\s]+)\s+(\d+)/.match(line)
+          vmstat[m[1]] = m[2].to_i if m && m.length >= 3
         end
+        vmstat
       end
 
       # Process LOADAVG data.
-      def proc_loadavg(queue)
-        @ssh_session.exec(COMMANDS[:loadavg]) do |ch, stream, data|
-          next unless stream == :stdout # ignore :stderr
-          m = %r{([^\s]+)\s+([^\s]+)\s+([^\s]+)\s+([^\s]+)\/([^\s]+)\s+([^\s$]+)}.match(data)
-          next unless m
-          if m && m.length >= 6
-            loadavg = { '1minute' => m[1].to_f,
-                        '5minutes' => m[2].to_f,
-                        '15minutes' => m[3].to_f,
-                        'running_processes' => m[4].to_i,
-                        'total_processes' => m[5].to_i,
-                        'last_running_pid' => m[6].to_i }
-            event = LogStash::Event.new(loadavg: loadavg,
-                                        host: @host,
-                                        type: @type || 'system-loadavg',
-                                        metric_name: 'system-loadavg',
-                                        remote_host: ch[:host],
-                                        command: COMMANDS[:loadavg],
-                                        message: data)
-            decorate(event)
-            queue << event
-          end
+      def proc_loadavg(data)
+        return {} unless data
+        m = %r{([^\s]+)\s+([^\s]+)\s+([^\s]+)\s+([^\s]+)\/([^\s]+)\s+([^\s$]+)}.match(data)
+        next unless m
+        loadavg = {}
+        if m && m.length >= 6
+          loadavg.merge!('1minute' => m[1].to_f,
+                         '5minutes' => m[2].to_f,
+                         '15minutes' => m[3].to_f,
+                         'running_processes' => m[4].to_i,
+                         'total_processes' => m[5].to_i,
+                         'last_running_pid' => m[6].to_i)
         end
+        loadavg
       end
 
       # Process MEMINFO data.
-      def proc_meminfo(queue)
-        @ssh_session.exec(COMMANDS[:meminfo]) do |ch, stream, data|
-          next unless stream == :stdout # ignore :stderr
-          meminfo = {}
-          data.split(/$/).each do |line|
-            m = /([^\n\t:]+)\s*:\s+(\d+)(\skb)?$/i.match(line)
-            next unless m
-            meminfo[m[1]] = m[2].to_i
-            meminfo[m[1]] *= 1000 if m[3] # m[3] is not nil if `/KB/i` is found
-          end
-          next if meminfo.empty?
+      def proc_meminfo(data)
+        return {} unless data
+        meminfo = {}
+        data.split(/$/).each do |line|
+          m = /([^\n\t:]+)\s*:\s+(\d+)(\skb)?$/i.match(line)
+          next unless m
+          meminfo[m[1]] = m[2].to_i
+          meminfo[m[1]] *= 1000 if m[3] # m[3] is not nil if `/KB/i` is found
+        end
+        unless meminfo.empty?
           meminfo['CalcMemUsed'] = meminfo['MemTotal'] - meminfo['MemFree']
-          event = LogStash::Event.new(meminfo: meminfo,
-                                      host: @host,
-                                      type: @type || 'system-meminfo',
-                                      metric_name: 'system-meminfo',
-                                      remote_host: ch[:host],
-                                      command: COMMANDS[:meminfo],
-                                      message: data)
-          decorate(event)
-          queue << event
         end
+        meminfo
       end
 
       # Process CPUINFO data.
-      def proc_cpuinfo(queue)
-        @ssh_session.exec(COMMANDS[:cpuinfo]) do |ch, stream, data|
-          next unless stream == :stdout # ignore :stderr
-          cpuinfo = {} # TODO(fenicks): change to array
-          num_cpu = 0
-          data.split(/$/).each do |line|
-            next if line.strip.empty?
-            m = /([^\n\t:]+)\s*:\s+(.+)$/.match(line)
-            next unless m
-            # Apply filters
-            value = m[2] # needed to permit assignation and computation
-            num_cpu += 1 if m[1].eql?('processor')
-            value = m[2].split(/\s+/) if m[1] == 'flags'
-            value = m[2].to_i if ['processor',
-                                  'physical id',
-                                  'siblings',
-                                  'core id',
-                                  'cpu cores',
-                                  'apicid',
-                                  'initial apicid',
-                                  'cpuid level',
-                                  'clflush size',
-                                  'cache size',
-                                  'cache_alignment'].include?(m[1])
-            value = m[2].to_f if ['bogomips',
-                                  'cpu MHz'].include?(m[1])
-            value = m[2].to_i * 1000 if m[2] =~ /\skb$/i
-            index = num_cpu - 1
-            cpuinfo[index] = {} unless cpuinfo.include?(index)
-            cpuinfo[index][m[1]] = value
-          end
-          next if cpuinfo.empty?
-          # Other computed fields
-          cpuinfo[0]['cpu cores'] = 1 unless cpuinfo[0].include?('cpu cores')
-          cpuinfo['threads per core'] = num_cpu / cpuinfo[0]['cpu cores']
-          event = LogStash::Event.new(cpuinfo: cpuinfo,
-                                      host: @host,
-                                      type: @type || 'system-cpuinfo',
-                                      metric_name: 'system-cpuinfo',
-                                      remote_host: ch[:host],
-                                      command: COMMANDS[:cpuinfo],
-                                      message: data)
-          decorate(event)
-          queue << event
+      def proc_cpuinfo(data)
+        return {} unless data
+        cpuinfo = {} # TODO(fenicks): change to array
+        num_cpu = 0
+        data.split(/$/).each do |line|
+          next if line.strip.empty?
+          m = /([^\n\t:]+)\s*:\s+(.+)$/.match(line)
+          next unless m
+          # Apply filters
+          value = m[2] # needed to permit assignation and computation
+          num_cpu += 1 if m[1].eql?('processor')
+          value = m[2].split(/\s+/) if m[1] == 'flags'
+          value = m[2].to_i if ['processor',
+                                'physical id',
+                                'siblings',
+                                'core id',
+                                'cpu cores',
+                                'apicid',
+                                'initial apicid',
+                                'cpuid level',
+                                'clflush size',
+                                'cache size',
+                                'cache_alignment'].include?(m[1])
+          value = m[2].to_f if ['bogomips',
+                                'cpu MHz'].include?(m[1])
+          value = m[2].to_i * 1000 if m[2] =~ /\skb$/i
+          index = num_cpu - 1
+          cpuinfo[index] = {} unless cpuinfo.include?(index)
+          cpuinfo[index][m[1]] = value
         end
+        cpuinfo
       end
     end # class LogStash::Inputs::RemoteProc
   end # module LogStash::Inputs

data/logstash-input-remote_proc.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name = 'logstash-input-remote_proc'
-  s.version = '0.0.22'
-  s.licenses = ['Apache License (2.0)']
+  s.version = '0.0.23'
+  s.licenses = ['Apache-2.0']
   s.summary = 'This Logstash plugin collects PROCFS metrics through remote SSH servers.'
   s.description = 'This gem is a Logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/logstash-plugin install gemname. This gem is not a stand-alone program'
   s.authors = ['Christian Kakesa']
@@ -29,7 +29,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'logstash-core', '>= 2.0.0'
   s.add_runtime_dependency 'logstash-codec-plain', '>= 3.0.2'
   s.add_runtime_dependency 'net-ssh', '~> 2.9', '>= 2.9.2'
-  s.add_runtime_dependency 'net-ssh-multi', '~>1.2', '>= 1.2.1'
+  s.add_runtime_dependency 'net-ssh-gateway', '~> 1.2', '>= 1.2.0'
   s.add_runtime_dependency 'stud', '~> 0.0', '>= 0.0.22'
   s.add_development_dependency 'logstash-devutils', '>= 1.1.0'
 end

data/spec/inputs/remote_proc_spec.rb

@@ -1,7 +1,8 @@
 # encoding: utf-8
 require 'logstash/devutils/rspec/spec_helper'
 require 'logstash/inputs/remote_proc'
-require 'net/ssh/multi'
+require 'net/ssh'
+require 'net/ssh/gateway'
 
 describe LogStash::Inputs::RemoteProc do
   let(:config) do
@@ -14,9 +15,8 @@ describe LogStash::Inputs::RemoteProc do
   let(:queue) { [] }
 
   before do
-    ssh_session = spy('Net::SSH::Multi')
-    expect(Net::SSH::Multi).to receive(:start).with(any_args)
-      .and_return(ssh_session)
+    ssh_session = spy('Net::SSH')
+    allow(Net::SSH).to receive(:start).with(any_args).and_return(ssh_session)
   end
 
   it_behaves_like 'an interruptible input plugin' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-input-remote_proc
 version: !ruby/object:Gem::Version
-  version: 0.0.22
+  version: 0.0.23
 platform: ruby
 authors:
 - Christian Kakesa
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-11-10 00:00:00.000000000 Z
+date: 2016-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -66,8 +66,8 @@ dependencies:
         version: '1.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.1
-  name: net-ssh-multi
+        version: 1.2.0
+  name: net-ssh-gateway
   prerelease: false
   type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
@@ -77,7 +77,7 @@ dependencies:
         version: '1.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.1
+        version: 1.2.0
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
@@ -490,7 +490,7 @@ files:
 - vendor/bundle/jruby/1.9/specifications/rake-11.3.0.gemspec
 homepage: https://github.com/fenicks/logstash-input-remote_proc
 licenses:
-- Apache License (2.0)
+- Apache-2.0
 metadata:
   logstash_plugin: 'true'
   logstash_group: input