process_observer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0db88799a99a3c3460d56f238c79855d55f3193efb73c3e3f3353b9392605383
+  data.tar.gz: b30813b905a168e86ecb874e883e8bbe989bf40542b0eeb66e79adfac05a0640
+SHA512:
+  metadata.gz: 532689e20fd3c59307c037cee48b7e698c36d5beda99a07dc62f7720b92626c6e48fd8c84f8fb0fcc8058982e31cb745636c479685b4ec5adf7bbf5453659126
+  data.tar.gz: 79f1831d0c430ac1504a4a4140f7efd68a416c19f38771b8c26e56b088ab1409e21b94832a6a62d4d1ec96a60a071ab80625e99e79c4e2a4f97536aca13ffedb

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    process_observer (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.11.3)
+    rake (12.3.3)
+
+PLATFORMS
+  x64-mingw32
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  minitest (~> 5.0)
+  process_observer!
+  rake (~> 12.0)
+
+BUNDLED WITH
+   2.0.2

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Fizvlad
+
+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,22 @@
+# ProcessObserver
+
+This small gem may be used to obtain information about processes suing OS specific 
+console applications. Currently it is `tasklist` for Windows and `ps` for Linux.
+
+## Installation
+
+You can install this gem executing `gem install process_observer` in console.
+
+Then simply include it with `include "process_observer"`
+
+## Usage
+
+You can find documentation here: https://www.rubydoc.info/gems/process_observer.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/fizvlad/process_observer/issues.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,14 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = Dir[ "test/**/test_*.rb" ]
+end
+
+task :doc do
+  puts `yardoc`
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "process_observer"
+require "irb"
+
+IRB.start(__FILE__)

data/lib/process_observer/exceptions.rb

@@ -0,0 +1,27 @@
+module ProcessObserver
+
+  ##
+  # Module with exceptions which might be raised.
+  module Exceptions
+
+    ##
+    # String contains some special character which is not allowed.
+    class SpecialCharacterError < ArgumentError; end
+    
+    ##
+    # This platform is currently unsupported.
+    class UnsupportedPlatformError < ArgumentError; end
+
+    ##
+    # Expected to see single process.
+    class MultipleProcessError < RuntimeError; end
+
+    ##
+    # UTF-8 encoding is required.
+    class EncodingError < RuntimeError; end
+
+  end
+
+  include Exceptions
+
+end

data/lib/process_observer/linux.rb

@@ -0,0 +1,42 @@
+module ProcessObserver
+
+  ##
+  # Module with methods to interact with Linux.
+  module Linux
+
+    ##
+    # Process list executable.
+    EXE = "ps"
+
+    ##
+    # Output format.
+    OUTPUT_FORMAT = "-o \"pid,comm,stat,time,rss\""
+
+    ##
+    # Call processes list executable with provided options string.
+    #
+    # @param options [String] options string.
+    #
+    # @return [Array<Process>] array of processes.
+    def self.call(options = "-A")
+      raise ArgumentError, "Provide options string", caller if options.to_s.empty?
+      command = "#{EXE} #{options} #{OUTPUT_FORMAT}"
+      Log.debug "Executing: #{command}"
+      re = `#{command}`.chomp
+      csv = CSV.parse(re.each_line.map { |line| line.strip.squeeze(" ") }.join("\n"), col_sep: " ")
+
+      enum = csv.to_a.drop(1) # Skip header
+      enum.map do |data|
+        LinuxProcess.new(
+          pid:  data[0],
+          comm: data[1],
+          stat: data[2],
+          time: data[3],
+          rss:  data[4]
+        )
+      end
+    end
+
+  end
+
+end

data/lib/process_observer/log.rb

@@ -0,0 +1,32 @@
+require "logger"
+
+module ProcessObserver
+
+  ##
+  # Logging methods
+  module Log
+
+    ##
+    # Loggers
+    @@loggers = {
+      debug: Logger.new(STDOUT),
+      warn: Logger.new(STDERR)
+    }
+    @@loggers[:debug].level = Logger::DEBUG
+    @@loggers[:warn].level = Logger::WARN
+
+    ##
+    # Send warning.
+    def self.warn(*args)
+      @@loggers[:warn].warn(args.join("\n"))
+    end
+
+    ##
+    # Send debug message.
+    def self.debug(*args)
+      @@loggers[:debug].debug(args.join("\n")) if $DEBUG
+    end
+
+  end
+
+end

data/lib/process_observer/main.rb

@@ -0,0 +1,57 @@
+module ProcessObserver
+
+  ##
+  # List of all active processes.
+  #
+  # @return [Array<Process>]
+  def self.all
+    case
+      when OS.windows?
+        Windows.call
+      when OS.linux?
+        Linux.call
+      else
+        raise UnsupportedPlatformError, "This platform is currently unsupported", caller
+    end
+  end
+
+  ##
+  # List of all running processes.
+  #
+  # @return [Array<Process>]
+  def self.running
+    case
+      when OS.windows?
+        Windows.call(fi: "STATUS eq RUNNING")
+      when OS.linux?
+        Linux.call.select { |process| process.status.include?("R") }
+      else
+        raise UnsupportedPlatformError, "This platform is currently unsupported", caller
+    end
+  end
+
+  ##
+  # Requests info about current Ruby process.
+  #
+  # @return [Process]
+  def self.this
+    pid = ::Process.pid
+    case
+      when OS.windows?
+        arr = Windows.call(fi: "PID eq #{pid}")
+      when OS.linux?
+        arr = Linux.call.select { |process| process.pid == pid }
+      else
+        raise UnsupportedPlatformError, "This platform is currently unsupported", caller
+    end
+    raise MultipleProcessError, "Expected single process, got: #{arr.size}", caller if arr.size != 1
+    arr[0]
+  end
+
+  ##
+  # @return [Integer] used memory in KB.
+  def self.used_memory
+    self.all.sum(0, &:memory)
+  end
+
+end

data/lib/process_observer/os.rb

@@ -0,0 +1,34 @@
+module ProcessObserver
+
+  ##
+  # Module with methods to identify current platform.
+  #
+  # Source: https://stackoverflow.com/a/171011/9293044
+  module OS
+
+    ##
+    # Whether Windows is used.
+    def OS.windows?
+      (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM) != nil
+    end
+
+    ##
+    # Whether Mac is used.
+    def OS.mac?
+     (/darwin/ =~ RUBY_PLATFORM) != nil
+    end
+
+    ##
+    # Whether Unix (not Windows) is used.
+    def OS.unix?
+      !OS.windows?
+    end
+
+    ##
+    # Whether Linux (Unix but not Mac) is used.
+    def OS.linux?
+      OS.unix? and not OS.mac?
+    end
+  end
+
+end

data/lib/process_observer/process.rb

@@ -0,0 +1,232 @@
+module ProcessObserver
+
+  ##
+  # Class representing process.
+  class Process
+
+    ##
+    # @return [String] name name of the executable or command.
+    attr_reader :name
+
+    ##
+    # @return [Integer] pid process ID.
+    attr_reader :pid
+
+    ##
+    # @return [Integer, nil] memory amount of consumed memory.
+    attr_reader :memory
+
+    ##
+    # Initialize new process.
+    #
+    # @param options [Hash]
+    #
+    # @option options [String] name name of the executable or command.
+    # @option options [Integer] pid process ID.
+    # @option options [Integer, nil] memory amount of consumed memory.
+    def initialize(options)
+      @name   = options[:image_name].to_s
+      @pid    = options[:pid].to_i
+      @memory = options[:memory] ? options[:memory].to_i : nil
+    end
+
+  end
+
+  ##
+  # Class representing process in Windows.
+  class WindowsProcess < Process
+
+    ##
+    # @return [String] name of the executable.
+    attr_reader :image_name
+
+    ##
+    # @return [Integer] process ID.
+    attr_reader :pid
+
+    ##
+    # @return [String, nil] session name.
+    attr_reader :session_name
+
+    ##
+    # @return [Integer, nil] session number.
+    attr_reader :session
+
+    ##
+    # @return [Integer, nil] memory usage in KB.
+    attr_reader :mem_usage
+
+    ##
+    # @return [String, nil] process status.
+    attr_reader :status
+
+    ##
+    # @return [String, nil] user which started process.
+    attr_reader :user_name
+
+    ##
+    # @return [String, nil] process runtime.
+    attr_reader :cpu_time
+
+    ##
+    # @return [String, nil] title of process window.
+    attr_reader :window_title
+
+    ##
+    # @return [Array<String>] services.
+    attr_reader :services
+
+    ##
+    # @return [Array<String>] used DLLs.
+    attr_reader :modules
+
+    ##
+    # @return [String, nil] name of app package name.
+    attr_reader :package_name
+
+    ##
+    # Initialize new process.
+    #
+    # @param options [Hash]
+    #
+    # @option options [String] image_name name of the executable.
+    # @option options [Integer] pid process ID.
+    # @option options [String, nil] session_name session name.
+    # @option options [Integer, nil] session session number.
+    # @option options [Integer, nil] mem_usage memory usage in KB.
+    # @option options [String, nil] status process status.
+    # @option options [String, nil] user_name user which started process.
+    # @option options [String, nil] cpu_time process runtime.
+    # @option options [String, nil] window_title title of process window.
+    # @option options [Array<String>, nil] services services.
+    # @option options [Array<String>, nil] modules used DLLs.
+    # @option options [String, nil] package_name name of app package name.
+    def initialize(options)
+      @image_name   = options[:image_name].to_s
+      @pid          = options[:pid].to_i
+      @session_name = options[:session_name] ? options[:session_name].to_s                     : nil
+      @session      = options[:session]      ? options[:session].to_i                          : nil
+      @mem_usage    = options[:mem_usage]    ? options[:mem_usage].to_s.gsub(/[^\d]/, "").to_i : nil
+      @status       = options[:status]       ? options[:status].to_s                           : nil
+      @user_name    = options[:user_name]    ? options[:user_name].to_s                        : nil
+      @cpu_time     = options[:cpu_time]     ? options[:cpu_time].to_s                         : nil
+      @window_title = options[:window_title] ? options[:window_title].to_s                     : nil
+      @services     = options[:services]     ? options[:services].to_s.split(",")              : []
+      @modules      = options[:modules]      ? options[:modules].to_s.split(",")               : []
+      @package_name = options[:package_name] ? options[:package_name].to_s                     : nil
+
+      super(
+        name: @image_name,
+        pid: @pid,
+        memory: @mem_usage
+      )
+    end
+
+    ##
+    # @return [String] PID and name of process.
+    def to_s
+      "Process ##{@pid} #{@image_name}"
+    end
+
+    ##
+    # Inspect all stored data.
+    #
+    # @param [String] splitter
+    #
+    # @return [String] all accessable info in human-readable form.
+    def inspect(splitter = "; ")
+      to_s +
+      (@session_name || @session ? "#{splitter}Session: #{@session_name}(#{@session})" : "") +
+      (@mem_usage ? "#{splitter}Memory usage: #{@mem_usage} KB" : "") +
+      (@status ? "#{splitter}Status: #{@status}" : "") +
+      (@user_name || @cpu_time ? "#{splitter}Launched by: #{@user_name}, runs for #{@cpu_time}" : "") +
+      (@window_title ? "#{splitter}Title: #{@window_title}" : "") + 
+      (@services.empty? ? "" : "#{splitter}Services: #{@services.join(",")}") +
+      (@modules.empty? ? "" : "#{splitter}Modules: #{@modules.join(",")}") +
+      (@package_name ? "#{splitter}Package name: #{@package_name}" : "")
+    end
+
+    ##
+    # Compare with other process by PID.
+    def ==(other)
+      WindowsProcess === other && other.pid == @pid
+    end
+
+  end
+
+  ##
+  # Class representing process in Unix.
+  class LinuxProcess < Process
+
+    ##
+    # @return [String] command which launched process.
+    attr_reader :comm
+
+    ##
+    # @return [Integer] process ID.
+    attr_reader :pid
+
+    ##
+    # @return [String, nil] process status.
+    attr_reader :stat
+
+    ##
+    # @return [String, nil] amount of time process is running.
+    attr_reader :time
+
+    ##
+    # @return [Integer, nil] amount of used CPU memory in KB.
+    attr_reader :rss
+
+    ##
+    # Initialize new process.
+    #
+    # @param options [Hash]
+    #
+    # @option options [String] comm command which launched process.
+    # @option options [Integer] pid process ID.
+    # @option options [String, nil] stat process status.
+    # @option options [String, nil] time amount of time process is running.
+    # @option options [Integer, nil] rss amount of used CPU memory in KB.
+    def initialize(options)
+      @comm = options[:comm].to_s
+      @pid  = options[:pid].to_i
+      @stat = options[:stat] ? options[:stat].to_s : nil
+      @time = options[:time] ? options[:time].to_s : nil
+      @rss  = options[:rss]  ? options[:rss].to_i  : nil
+
+      super(
+        name: @comm,
+        pid: @pid,
+        memory: @rss
+      )
+    end
+
+    ##
+    # @return [String] PID and command of process.
+    def to_s
+      "Process ##{@pid} #{@comm}"
+    end
+
+    ##
+    # Inspect all stored data.
+    #
+    # @param [String] splitter
+    #
+    # @return [String] all accessable info in human-readable form.
+    def inspect(splitter = "; ")
+      to_s +
+      (@stat ? "#{splitter}Status: #{@stat}" : "") +
+      (@time ? "#{splitter}Time running: #{@time}" : "") +
+      (@rss ? "#{splitter}Memory: #{@rss} KB" : "")
+    end
+
+    ##
+    # Compare with other process by PID.
+    def ==(other)
+      LinuxProcess === other && other.pid == @pid
+    end
+
+  end
+
+end

data/lib/process_observer/version.rb

@@ -0,0 +1,7 @@
+module ProcessObserver
+
+  ##
+  # Module version.
+  VERSION = "0.1.0"
+
+end

data/lib/process_observer/windows.rb

@@ -0,0 +1,157 @@
+require "csv"
+
+module ProcessObserver
+
+  ##
+  # Module with methods to interact with Windows.
+  module Windows
+
+    ##
+    # Task list executable.
+    EXE = "tasklist"
+
+    ##
+    # Method to turn hash with call parameters into call string argument.
+    #
+    # @note: this method currently raises error when meet string with double quote.
+    #
+    # @param hash [Hash] not empty hash.
+    #
+    # @return [String]
+    def self.to_arg(hash)
+      raise ArgumentError, "Empty hash", caller if hash.empty?
+
+      hash.map do |key, value|
+        case value
+          when TrueClass, FalseClass, NilClass # Boolean or nil
+            value ? "/#{key}" : ""
+          when String
+            raise Exceptions::SpecialCharacterError, "Please don't use double quotes in string", caller if value.include?('"')
+            "/#{key} \"#{value}\""
+          else
+            "/#{key} #{value}"
+        end
+      end
+      .join(" ").strip.gsub(/\s+/, " ")
+    end
+
+    ##
+    # Call task list executable with provided options.
+    #
+    # @param options [Hash] hash with call options.
+    #
+    # @option options [Boolean] svc (false) return services for each process.
+    # @option options [Boolean] apps (false) return store processes.
+    # @option options [Boolean] v (false) return extended info.
+    # @option options [true, String, nil] m (nil) return tasks using given module or all modules if +true+.
+    # @option options [String, nil] fi (nil) filter.
+    # @option options [:csv, :table, :list] fo (:csv) format of output.
+    #   if +:csv+ is chosen output will be parsed with CSV library and
+    #   returned as array of {Process}, otherwise whole string will be returned.
+    #
+    # @return [String, Array<Process>] call output
+    def self.call(options = {})
+      raise EncodingError, "Please use `chcp 65001` to switch to UTF-8 first" if `chcp`.slice(/\d+/).to_i != 65001
+
+      call_params = {}
+      call_params[:svc]  = !!options[:svc]
+      call_params[:apps] = !!options[:apps]
+      call_params[:v]    = !!options[:v]
+      case 
+        when options[:m].nil?    then call_params[:m] = nil
+        when options[:m] == true then call_params[:m] = true
+        else call_params[:m] = options[:m].to_s
+      end
+      call_params[:fi]   = options[:fi].to_s unless options[:fi].nil?
+
+      call_params[:fo]   = options[:fo] || :csv
+      raise ArgumentError, "Unknown format option #{call_params[:fo]}", caller unless [:csv, :table, :list].include?(call_params[:fo])
+
+      Log.debug "Call parameters: #{call_params}"
+      command = call_params.empty? ? "#{EXE}" : "#{EXE} #{to_arg(call_params)}"
+      Log.debug "Executing: #{command}"
+      re = `#{command}`.chomp
+
+      if call_params[:fo] == :csv
+        csv = CSV.parse(re)
+        enum = csv.to_a.drop(1) # Skip header
+        case
+          when call_params[:v] && call_params[:apps]
+            # Extended info fow apps
+            enum.map do |data|
+              WindowsProcess.new(
+                image_name: data[0],
+                pid: data[1],
+                session_name: data[2],
+                session: data[3],
+                mem_usage: data[4],
+                status: data[5],
+                user_name: data[6],
+                cpu_time: data[7],
+                window_title: data[8],
+                package_name: data[9]
+              )
+            end
+          when call_params[:v]
+            # Extended info
+            enum.map do |data|
+              WindowsProcess.new(
+                image_name: data[0],
+                pid: data[1],
+                session_name: data[2],
+                session: data[3],
+                mem_usage: data[4],
+                status: data[5],
+                user_name: data[6],
+                cpu_time: data[7],
+                window_title: data[8]
+              )
+            end
+          when call_params[:apps]
+            # Apps
+            enum.map do |data|
+              WindowsProcess.new(
+                image_name: data[0],
+                pid: data[1],
+                mem_usage: data[2],
+                package_name: data[3]
+              )
+            end
+          when call_params[:m]
+            # Modules
+            enum.map do |data|
+              WindowsProcess.new(
+                image_name: data[0],
+                pid: data[1],
+                modules: data[2]
+              )
+            end
+          when call_params[:svc]
+            # Services
+            enum.map do |data|
+              WindowsProcess.new(
+                image_name: data[0],
+                pid: data[1],
+                services: data[2]
+              )
+            end
+          else
+            # Regular mode
+            enum.map do |data|
+              WindowsProcess.new(
+                image_name: data[0],
+                pid: data[1],
+                session_name: data[2],
+                session: data[3],
+                mem_usage: data[4]
+              )
+            end
+        end
+      else
+        re.strip
+      end
+    end
+
+  end
+
+end

data/lib/process_observer.rb

@@ -0,0 +1,12 @@
+require_relative "./process_observer/version"
+require_relative "./process_observer/main"
+require_relative "./process_observer/exceptions"
+require_relative "./process_observer/process"
+require_relative "./process_observer/os"
+require_relative "./process_observer/windows"
+require_relative "./process_observer/linux"
+require_relative "./process_observer/log"
+
+##
+# Module containing everything.
+module ProcessObserver; end

data/process_observer.gemspec

@@ -0,0 +1,32 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "process_observer/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "process_observer"
+  spec.version       = ProcessObserver::VERSION
+  spec.authors       = ["Fizvlad"]
+  spec.email         = ["fizvlad@mail.ru"]
+
+  spec.summary       = "Small gem to get info about current list of processes."
+  spec.homepage      = "https://github.com/fizvlad/process-observer-rb"
+  spec.license       = "MIT"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/fizvlad/process-observer-rb"
+  spec.metadata["changelog_uri"] = "https://github.com/fizvlad/process-observer-rb/releases"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.test_files    = Dir[ "test/**/test_*.rb" ]
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">=2.5.0"
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 12.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

data/test/test_process_observer.rb

@@ -0,0 +1,9 @@
+require_relative "./helper"
+
+class ProcessObserverTest < Minitest::Test
+
+  def test_that_it_has_a_version_number
+    refute_nil ::ProcessObserver::VERSION
+  end
+  
+end

data/test/test_windows_utility.rb

@@ -0,0 +1,17 @@
+require_relative "./helper"
+
+class ProcessObserverTest < Minitest::Test
+
+  def test_hash_to_str
+    assert_equal("/one_param 42", ProcessObserver::Windows.to_arg(one_param: 42))
+    assert_equal("/one_param", ProcessObserver::Windows.to_arg(one_param: true))
+    assert_equal("/first /second", ProcessObserver::Windows.to_arg(first: true, second: true))
+    assert_equal("/first", ProcessObserver::Windows.to_arg(first: true, second: false))
+    assert_equal("/first", ProcessObserver::Windows.to_arg(first: true, second: nil))
+    assert_equal("/first /second \"str example\"", ProcessObserver::Windows.to_arg(first: true, second: "str example"))
+    assert_raises(ProcessObserver::SpecialCharacterError) do
+      ProcessObserver::Windows.to_arg(first: true, second: "str with quote: \"")
+    end
+  end
+
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: process_observer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Fizvlad
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: 
+email:
+- fizvlad@mail.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- lib/process_observer.rb
+- lib/process_observer/exceptions.rb
+- lib/process_observer/linux.rb
+- lib/process_observer/log.rb
+- lib/process_observer/main.rb
+- lib/process_observer/os.rb
+- lib/process_observer/process.rb
+- lib/process_observer/version.rb
+- lib/process_observer/windows.rb
+- process_observer.gemspec
+- test/test_process_observer.rb
+- test/test_windows_utility.rb
+homepage: https://github.com/fizvlad/process-observer-rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/fizvlad/process-observer-rb
+  source_code_uri: https://github.com/fizvlad/process-observer-rb
+  changelog_uri: https://github.com/fizvlad/process-observer-rb/releases
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.4
+signing_key: 
+specification_version: 4
+summary: Small gem to get info about current list of processes.
+test_files:
+- test/test_process_observer.rb
+- test/test_windows_utility.rb