busy-administrator 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 883afd8faafc52f568eea6a1393d2a945654bcf7
+  data.tar.gz: a08973fcbc8caddb7db15d787751ebdc5a151235
+SHA512:
+  metadata.gz: 5ad360f51265c9d1a901327d1a2577ea6ae44504f0a5647b7deeba2753112bbfd093723cbbe1f38ee45cca743cddf35df1ef7a1b7e56e756a278a67f51bd40f4
+  data.tar.gz: a4ea6628c47693c4b551a4e58cea763de0ba9a7ca1897237222e5e491440b7be64ddaa04249e5df9a12985a149de0e050e00bf1fff89ebb83f61fbbee3e35a75

data/lib/busy-administrator/display.rb

@@ -0,0 +1,41 @@
+module BusyAdministrator
+  module Display
+    def self.debug(target, indent: 0)
+      if target.is_a?(Hash)
+        indent_space = " " * (indent * 4)
+        puts indent_space + "{"
+
+        indent += 1
+
+        target.each do |key, value|
+          if value.is_a?(Hash) || value.is_a?(Array)
+            indent_space = " " * (indent * 4)
+            puts indent_space + "#{ key }:"
+
+            self.debug(value, indent: indent + 1)
+          else
+            indent_space = " " * (indent * 4)
+            puts indent_space + "#{ key }: #{ value }"
+          end
+        end
+
+        indent -= 1
+        indent_space = " " * (indent * 4)
+        puts indent_space + "}"
+      elsif target.is_a?(Array)
+        indent_space = " " * (indent * 4)
+        puts indent_space + "["
+
+        target.each do |element|
+          self.debug(element, indent: indent + 1)
+        end
+
+        indent_space = " " * (indent * 4)
+        puts indent_space + "]"
+      else
+        indent_space = " " * (indent * 4)
+        puts indent_space + "#{ target }"
+      end
+    end
+  end
+end

data/lib/busy-administrator/example_generator.rb

@@ -0,0 +1,13 @@
+require 'securerandom'
+
+module BusyAdministrator
+  module ExampleGenerator
+    class << self
+      def generate_string_with_specified_memory_size(memory_size)
+        raise Exception unless memory_size.respond_to?(:mebibytes)
+
+        SecureRandom.random_bytes(memory_size.bytes)
+      end
+    end
+  end
+end

data/lib/busy-administrator/memory_size.rb

@@ -0,0 +1,143 @@
+class Numeric
+  [:mebibytes, :megabytes, :kibibytes, :kilobytes].each do |method|
+    define_method(method) do
+      BusyAdministrator::MemorySize.send(method, self)
+    end
+  end
+
+  alias_method :mebibyte, :mebibytes
+  alias_method :megabyte, :megabytes
+  alias_method :kibibyte, :kibibytes
+  alias_method :kilobyte, :kilobytes
+end
+
+module BusyAdministrator
+  class MemorySize
+    def initialize(bytes:)
+      @bytes = bytes
+    end
+
+    def bytes
+      @bytes
+    end
+
+    def kibibytes
+      @bytes / 1024
+    end
+
+    def kilobytes
+      @bytes / 1000
+    end
+
+    def mebibytes
+      @bytes / 1024 / 1024
+    end
+
+    def megabytes
+      @bytes / 1000 / 1000
+    end
+
+    def +(other)
+      self.class.new(bytes: @bytes + other.bytes)
+    end
+
+    def -(other)
+      self.class.new(bytes: @bytes - other.bytes)
+    end
+
+    def *(number)
+      self.class.new(bytes: @bytes * number)
+    end
+
+    def /(number)
+      self.class.new(bytes: @bytes / number)
+    end
+
+    def ==(other_object)
+      self.bytes == other_object.bytes
+    end
+
+    def >(other_object)
+      self.bytes > other_object.bytes
+    end
+
+    def >=(other_object)
+      self.bytes >= other_object.bytes
+    end
+
+    def <(other_object)
+      self.bytes < other_object.bytes
+    end
+
+    def <=(other_object)
+      self.bytes <= other_object.bytes
+    end
+
+    def to_s
+      if @bytes < 1024
+        "#{ bytes } Bytes"
+      elsif @bytes < 1024 * 1024
+        "#{ kibibytes } KiB"
+      else
+        "#{ mebibytes } MiB"
+      end
+    end
+
+    def inspect
+      to_s
+    end
+
+    class << self
+      def kibibytes(num)
+        new(bytes: num * 1024)
+      end
+
+      def kilobytes(num)
+        new(bytes: num * 1000)
+      end
+
+      def mebibytes(num)
+        new(bytes: num * 1024 * 1024)
+      end
+
+      def megabytes(num)
+        new(bytes: num * 1000 * 1000)
+      end
+
+      def of(target, checked_objects: [])
+        total_size = 0
+
+        unless checked_objects.include?(target.object_id)
+          total_size += ObjectSpace.memsize_of(target)
+
+          checked_objects << target.object_id
+
+          (ObjectSpace.reachable_objects_from(target) || []).each do |reachable_object|
+            return new(bytes: 0) if reachable_object.is_a?(ObjectSpace::InternalObjectWrapper)
+
+            total_size += self.of(reachable_object, checked_objects: checked_objects).bytes
+          end        
+        end
+
+        new(bytes: total_size)
+      end
+
+      def of_all_objects_from(target)
+        total_memory_size = 0
+
+        # ensure that we don't double count duplicates
+        checked_objects = []
+
+        if target.is_a?(Class) || target.is_a?(Module)
+          ObjectSpace.each_object(target).each do |instance|
+            total_memory_size += self.of(instance, checked_objects: checked_objects).bytes
+          end
+        else
+          raise Exception, "target should be a Class or Module"
+        end
+
+        new(bytes: total_memory_size)
+      end
+    end
+  end
+end

data/lib/busy-administrator/memory_utils.rb

@@ -0,0 +1,201 @@
+module BusyAdministrator
+  module MemoryUtils
+    class MemoryAnalyzer
+      attr_reader :pairs
+
+      def initialize
+        @pairs = []
+      end
+
+      def include(key:, value:)
+        @pairs << [key, value.object_id]
+      end
+
+      def analyze(verbose: false)
+        output = {}
+
+        @pairs.each do |pair|
+          key, value = pair
+
+          target = ObjectSpace._id2ref(value)
+
+          if target.is_a?(Class) || target.is_a?(Module)
+            output[key.to_sym] = MemorySize.of_all_objects_from(target)
+          else
+            output[key.to_sym] = MemorySize.of(target)
+          end
+
+          log("#{ key } = #{ output[key.to_sym] } { #{ target.class } }", verbose: verbose)
+        end
+
+        output
+      end
+
+      private
+
+      def log(message, verbose: false)
+        if verbose
+          puts "[BusyAdministrator::MemoryUtils::Analyzer.analyze] #{ message }"
+        end
+      end
+    end
+
+    class << self
+      def trigger_gc
+        GC.start(full_mark:true, immediate_sweep: true, immediate_mark: false)
+      end
+
+      def get_created_object_classes
+        ObjectSpace.each_object.to_a.map(&:class).uniq.select do |target| 
+          target.is_a?(Class) || target.is_a?(Module)
+        end
+      end
+
+      def profile(gc_enabled: true, verbose: false)
+        analyzer = MemoryAnalyzer.new
+        excluded_object_id_storage = []
+        all_object_ids_after_execution = []
+        gc_count_before = 0
+
+        output_container = {
+          memory_usage: {},
+          total_time: 0.0,
+          gc: {
+            count: 0,
+            enabled: false
+          }
+        }
+
+        action("GC Settings") do
+          output_container[:gc][:enabled] = gc_enabled
+
+          if gc_enabled
+            GC.enable
+            log("[Before] Enable GC", verbose: verbose)
+          else
+            GC.disable
+            log("[Before] Disable GC", verbose: verbose)
+          end
+        end
+
+        action("Prepare Object ID Storage Before Execution") do
+          excluded_object_id_storage = get_created_object_ids
+          log("[Before] Object Count: #{ excluded_object_id_storage.size }", verbose: verbose)          
+        end
+        
+        action("Get Memory Usage Before Execution") do
+          memory_usage_before = ProcessUtils.get_memory_usage(:rss)
+          output_container[:memory_usage][:before] = memory_usage_before
+
+          log("[Before] Memory Usage: #{ memory_usage_before }", verbose: verbose)
+        end
+
+        action("Execute Main Action") do
+          gc_count_before = GC.stat[:count]
+          log("[Before] GC Count: #{ gc_count_before }", verbose: verbose)
+
+          log("[Before] Block Start", verbose: verbose)
+
+          total_time = Benchmark.realtime do
+            yield(analyzer) if block_given?
+          end
+
+          output_container[:total_time] = total_time.round(6)
+
+          log("[After] Block End", verbose: verbose)
+          log("[After] Total Time: #{ total_time } seconds", verbose: verbose)
+        end
+
+        action("Compute Specific Stats") do
+          output_container[:specific] = analyzer.analyze(verbose: verbose)
+        end
+
+        action("Run GC if enabled") do 
+          if gc_enabled
+            self.trigger_gc
+            log("[After] Run GC", verbose: verbose)
+          end
+
+          gc_count_after = GC.stat[:count]
+          log("[After] GC Count: #{ gc_count_after }", verbose: verbose)
+
+          gc_count_diff = gc_count_after - gc_count_before
+          output_container[:gc][:count] = gc_count_diff
+
+          log("[Diff] GC Count: #{ gc_count_diff }", verbose: verbose)
+        end
+
+        action("Get Memory Usage After Execution") do
+          memory_usage_after = ProcessUtils.get_memory_usage(:rss)
+          log("[After] Memory Usage: #{ memory_usage_after }", verbose: verbose)
+
+          output_container[:memory_usage][:after] = memory_usage_after
+          output_container[:memory_usage][:diff] = output_container[:memory_usage][:after] - output_container[:memory_usage][:before]
+          log("[Diff] Memory Usage: #{ output_container[:memory_usage] }", verbose: verbose)
+        end
+        
+        action("Get Object Count After Execution") do
+          all_object_ids_after_execution = get_created_object_ids
+          log("[After] Object Count: #{ all_object_ids_after_execution.size }", verbose: verbose)
+
+          all_object_ids_after_execution -= excluded_object_id_storage
+          log("[Diff] Object Count: #{ all_object_ids_after_execution.size }", verbose: verbose)
+          output_container[:object_count] = all_object_ids_after_execution.size
+        end
+
+        action("Compute General Stats") do
+          general = {}
+
+          all_object_ids_after_execution.each do |object_id|
+            target = ObjectSpace._id2ref(object_id)
+            target_class = target.class.name
+
+            general[target_class.to_sym] ||= 0
+            general[target_class.to_sym] += ObjectSpace.memsize_of(target)
+          end
+
+          general.each do |key, value|
+            general[key] = MemorySize.new(bytes: value)
+            log("[Diff] Class #{ key }: #{ general[key] } ")
+          end
+
+          output_container[:general] = general
+        end
+
+        action("Run GC") do
+          GC.enable
+          self.trigger_gc
+        end
+        
+        output_container
+      end
+
+      private
+
+      def action(label)
+        log("Action: #{ label }")
+
+        yield if block_given?
+      end
+
+      def log(message, verbose: false)
+        if verbose
+          puts "[BusyAdministrator::MemoryUtils.profile] #{ message }"
+        end
+      end
+
+      def get_created_object_ids
+        output = ObjectSpace.each_object.to_a.map(&:object_id)
+        output << output.object_id
+
+        output
+      end
+
+      def get_unique_classes_from_object_ids(object_ids_array)
+        object_ids_array.map { |object_id| ObjectSpace._id2ref(object_id) }.map(&:class).uniq.select do |target|
+          target.is_a?(Class) || target.is_a?(Module)
+        end
+      end
+    end
+  end
+end

data/lib/busy-administrator/process_utils.rb

@@ -0,0 +1,30 @@
+module BusyAdministrator
+  module ProcessUtils
+    class << self
+      # http://stackoverflow.com/questions/7880784/what-is-rss-and-vsz-in-linux-memory-management
+      def get_memory_usage(metric = :rss)
+        available_options = [:rss, :vsz]
+
+        if available_options.include?(metric)
+          bytes = `ps -o #{ metric.to_s }= -p #{ Process.pid }`.to_i * 1024
+
+          MemorySize.new(bytes: bytes)
+        else
+          raise Exception, "available_options: #{ available_options.inspect }"
+        end
+      end
+
+      # Does not work in OSX
+      # Will raise NoMemoryError: failed to allocate memory
+      def set_max_memory_usage(mebibytes:)
+        Process.setrlimit(Process::RLIMIT_AS, mebibytes * 1024 * 1024)
+      end
+
+      def get_max_memory_usage
+        bytes = Process.getrlimit(Process::RLIMIT_AS)[1]
+
+        MemorySize.new(bytes: bytes)
+      end
+    end
+  end
+end

data/lib/busy-administrator/version.rb

@@ -0,0 +1,3 @@
+module BusyAdministrator
+  VERSION = '1.0.0'
+end

data/lib/busy-administrator.rb

@@ -0,0 +1,55 @@
+require 'objspace'
+require 'benchmark'
+require 'busy-administrator/display'
+require 'busy-administrator/example_generator'
+require 'busy-administrator/memory_size'
+require 'busy-administrator/memory_utils'
+require 'busy-administrator/process_utils'
+require 'busy-administrator/version'
+
+"""
+require 'busy-administrator'
+
+BusyAdministrator::MemoryUtils.get_created_object_classes
+BusyAdministrator::MemoryUtils.profile(verbose: true) do
+  puts 'something'
+end
+
+class Testing
+  attr_accessor :large_value
+end
+
+BusyAdministrator::MemoryUtils.profile(verbose: true, gc_enabled: false) do |analyzer|
+  data = BusyAdministrator::ExampleGenerator.generate_string_with_specified_memory_size(10.mebibytes)
+
+  testing_a = Testing.new
+  testing_a.large_value = BusyAdministrator::ExampleGenerator.generate_string_with_specified_memory_size(5.mebibytes) 
+
+  testing_b = Testing.new
+  testing_b.large_value = BusyAdministrator::ExampleGenerator.generate_string_with_specified_memory_size(10.mebibytes) 
+
+  analyzer.include(key: 'data', value: data)
+  analyzer.include(key: 'testing_a', value: testing_a)
+  analyzer.include(key: 'testing_b', value: testing_b)
+  analyzer.include(key: 'Testing', value: Testing)
+end
+
+data = BusyAdministrator::ExampleGenerator.generate_string_with_specified_memory_size(10.mebibytes)
+BusyAdministrator::MemorySize.of(data).mebibytes
+BusyAdministrator::MemorySize.of_all_objects_from(SampleClass).mebibytes
+
+BusyAdministrator::ProcessUtils.get_memory_usage(:rss).mebibytes
+BusyAdministrator::ProcessUtils.get_memory_usage(:vsz).mebibytes
+
+# set max memory usage will check vsz
+BusyAdministrator::ProcessUtils.set_max_memory_usage(100.mebibytes)
+BusyAdministrator::ProcessUtils.get_max_memory_usage.mebibytes
+
+TODO:
+Create gem and add tests and documentation
+Add option to set recursion level for MemorySize
+Add advanced analyzer for objects with references to other objects
+"""
+
+module BusyAdministrator
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: busy-administrator
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Joshua Arvin Lat
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !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'
+description: Handy Ruby Dev Tools for the Busy Administrator
+email:
+- joshua.arvin.lat@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/busy-administrator.rb
+- lib/busy-administrator/display.rb
+- lib/busy-administrator/example_generator.rb
+- lib/busy-administrator/memory_size.rb
+- lib/busy-administrator/memory_utils.rb
+- lib/busy-administrator/process_utils.rb
+- lib/busy-administrator/version.rb
+homepage: ''
+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.4.8
+signing_key: 
+specification_version: 4
+summary: Handy Ruby Dev Tools for the Busy Administrator
+test_files: []
+has_rdoc: