droid-monitor 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cacf9200a217f8fddad33f2483e8828389d2f3b0
+  data.tar.gz: d72042f303c3d823fa269c43b7a27d29f730e7af
+SHA512:
+  metadata.gz: 7397602bc886867993fbc6a857794d3bb276ab5d3b9854bd53dddd5db33b614ff994e2d9f630bf43d11ddaf20ba64dc5c539cffc23455927d75a1224d181fa10
+  data.tar.gz: d1dc33a5e971795173bdfcfb79715d2053a07edd86a1b33be4957b307a9ace465588f2cc80e9445390b4178512f226fe345af69744725003330bc3b19cff8d19

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+
+.idea

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Kazuaki MATSUO
+
+MIT License
+
+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,79 @@
+# Droid::Monitor
+
+Monitoring Android apu or memory usage and create their simple graph with Google API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'droid-monitor'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install droid-monitor
+
+## Usage
+
+See under `sample` file in this repository.
+
+### CPU
+
+```ruby
+# initialize
+@cpu = Droid::Monitor::Cpu.new( { package: "com.android.chrome" } )
+
+# save data into @cpu.cpu_usage
+@cpu.store_dumped_cpu_usage
+
+# export data into filename as google api format
+filename = "sample_data.txt"
+@cpu.save_cpu_usage_as_google_api(filename)
+
+# export data into filename which is used the above command.
+output_file_path = "sample.html"
+graph_opts = { title: "Example", header1: "this graph is just sample"}
+@cpu.create_graph(filename, graph_opts, output_file_path)
+
+```
+
+#### Graph
+
+![](https://github.com/KazuCocoa/droid-monitor/blob/master/doc/images/Screen%20Shot%202015-05-23%20at%2019.46.08.png)
+
+### Memory
+
+```ruby
+# initialize
+@memory = Droid::Monitor::Cpu.new( { package: "com.android.chrome" } )
+
+# save data into @memory.memory_usage
+@memory.store_dumped_memory_details_usage
+
+# export data into filename as google api format
+filename = "sample_data.txt"
+@memory.save_memory_details_as_google_api(filename)
+
+# export data into filename which is used the above command.
+output_file_path = "sample.html"
+graph_opts = { title: "Example", header1: "this graph is just sample"}
+@cpu.create_graph(filename, graph_opts, output_file_path)
+```
+
+#### Graph
+
+![](https://github.com/KazuCocoa/droid-monitor/blob/master/doc/images/Screen%20Shot%202015-05-23%20at%2019.56.41.png)
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/droid-monitor/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/droid-monitor.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'droid/monitor/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "droid-monitor"
+  spec.version       = Droid::Monitor::VERSION
+  spec.authors       = ["Kazuaki MATSUO"]
+  spec.email         = ["fly.49.89.over@gmail.com"]
+  spec.summary       = %q{Monitoring Android cpu or memory usage and create their simple graph with Google API.}
+  spec.description   = %q{Monitoring connected Android devices via adb command. And you can create simple http graph wth Google API.}
+  spec.homepage      = "https://github.com/KazuCocoa/droid-monitor"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = ">= 2.0.0"
+
+  spec.add_dependency "faml"
+  spec.add_dependency "tilt"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "test-unit"
+end

data/lib/droid/monitor.rb

@@ -0,0 +1,49 @@
+require_relative "monitor/version"
+
+module Droid
+  module Monitor
+    class Adb
+      attr_accessor :package, :device_serial, :api_level
+
+      def initialize( opts = {})
+        fail 'opts must be a hash' unless opts.is_a? Hash
+        fail 'Package name is required.' unless opts[:package]
+        @package = opts[:package]
+        @device_serial = opts[:device_serial] || ""
+        @api_level = device_sdk_version
+      end
+
+      # @return [Integer] message from adb command
+      # e.g: 17
+      def device_sdk_version
+        `#{adb_shell} getprop ro.build.version.sdk`.chomp.to_i
+      end
+
+      # @return [String] message from adb command
+      def dump_cpuinfo
+        `#{adb_shell} dumpsys cpuinfo`.chomp
+      end
+
+      # @return [String] message from adb command
+      def dump_meminfo
+        `#{adb_shell} dumpsys meminfo #{@package}`.chomp
+      end
+
+      private
+
+      def adb
+        fail "ANDROID_HOME is not set" unless ENV["ANDROID_HOME"]
+        "#{ENV["ANDROID_HOME"]}/platform-tools/adb"
+      end
+
+      def device_serial_option
+        return "" unless @device_serial && @device_serial != ""
+        "-s \"#{@device_serial}\""
+      end
+
+      def adb_shell
+        "#{adb} #{device_serial_option} shell"
+      end
+    end # class Adb
+  end # module Monitor
+end # module Droid

data/lib/droid/monitor/common/commons.rb

@@ -0,0 +1 @@
+require_relative "utils"

data/lib/droid/monitor/common/utils.rb

@@ -0,0 +1,15 @@
+module Droid
+  module Monitor
+    module Utils
+      def merge_current_time(hash)
+        hash.merge(time: Time.now.strftime('%T.%L'))
+      end
+
+      def save(data, into_file_path)
+        File.open(into_file_path, 'w') do |file|
+          file.puts data
+        end
+      end
+    end
+  end
+end

data/lib/droid/monitor/cpu.rb

@@ -0,0 +1,110 @@
+require_relative "../monitor"
+require_relative "common/commons"
+require_relative "report/google_api_template"
+
+require "json"
+
+module Droid
+  module Monitor
+    class Cpu < Droid::Monitor::Adb
+      attr_reader :cpu_usage
+
+      include Droid::Monitor::Utils
+
+      def initialize(opts = {})
+        super(opts)
+        @cpu_usage = []
+      end
+
+      def clear_cpu_usage
+        @cpu_usage = []
+      end
+
+      def dump_cpu_usage(dump_data)
+        dump = dump_data.scan(/^.*#{self.package}.*$/).map(&:strip).first.split(/\s/).reject(&:empty?)
+        fail 'no package' if /^Load:$/ =~ dump[0]
+        dump
+      rescue StandardError => e
+        puts e
+        []
+      end
+
+      # called directory
+      def store_dumped_cpu_usage
+        self.store_cpu_usage(self.dump_cpu_usage(self.dump_cpuinfo))
+      end
+
+      def save_cpu_usage_as_google_api(file_path)
+        self.save(export_as_google_api_format(@cpu_usage), file_path)
+      end
+
+      def store_cpu_usage(dumped_cpu)
+        @cpu_usage.push self.merge_current_time(transfer_total_cpu_to_hash(dumped_cpu))
+      end
+
+      def transfer_total_cpu_to_hash(dump_cpu_array)
+        if dump_cpu_array.length == 0
+          {
+            total_cpu: '0%',
+            process: 'no package process',
+            user: '0%',
+            kernel: '0%',
+            time: dump_cpu_array.last,
+          }
+        else
+          {
+            total_cpu: dump_cpu_array[0],
+            process: dump_cpu_array[1],
+            user: dump_cpu_array[2],
+            kernel: dump_cpu_array[5],
+            time: dump_cpu_array.last,
+          }
+        end
+      end
+
+      def export_as_google_api_format(from_cpu_usage)
+        google_api_data_format = empty_google_api_format
+
+        from_cpu_usage.each do |hash|
+
+          puts hash
+          a_google_api_data_format = {
+            c: [
+              { v: hash[:time] },
+              { v: hash[:total_cpu].delete('%').to_f },
+              { v: hash[:user].delete('%').to_f },
+              { v: hash[:kernel].delete('%').to_f },
+            ]
+          }
+          google_api_data_format[:rows].push(a_google_api_data_format)
+        end
+
+        JSON.generate google_api_data_format
+      end
+
+      # @params [String] data_file_path A path to data.
+      # @params [Hash] graph_opts A hash regarding graph settings.
+      # @params [String] output_file_path A path you would like to export data.
+      def create_graph(data_file_path, graph_opts = {}, output_file_path)
+        self.save(Droid::Monitor::GoogleApiTemplate.create_graph(data_file_path, graph_opts),
+                  output_file_path)
+      end
+
+      private
+
+      def empty_google_api_format
+        {
+          cols: [
+            { label: 'time', type: 'string' },
+            { label: 'total_cpu', type: 'number' },
+            { label: 'user', type: 'number' },
+            { label: 'kernel', type: 'number' },
+          ],
+          rows: [
+          ],
+        }
+      end
+
+    end # class Cpu
+  end # module Monitor
+end # module Droid

data/lib/droid/monitor/memory.rb

@@ -0,0 +1,202 @@
+require_relative "../monitor"
+require_relative "common/commons"
+require_relative "report/google_api_template"
+
+require "json"
+
+module Droid
+  module Monitor
+    class Memory < Droid::Monitor::Adb
+      attr_reader :memory_usage, :memory_detail_usage
+
+      include Droid::Monitor::Utils
+
+      def initialize(opts = {})
+        super(opts)
+        @memory_usage = []
+        @memory_detail_usage = []
+      end
+
+      def clear_memory_usage
+        @memory_usage = []
+      end
+
+      def clear_memory_detail_usage
+        @memory_detail_usage = []
+      end
+
+      def dump_memory_usage(dump_data)
+        fail "no process" if dump_data == "No process found for: #{@package}"
+        dump_data.scan(/^.*Uptime.*Realtime.*$/).map(&:strip).first.split(/\s/).reject(&:empty?)
+      rescue StandardError => e
+        puts e
+        []
+      end
+
+      def dump_memory_details_usage(dump_data)
+        fail "no process" if dump_data == "No process found for: #{@package}"
+        dump_data.scan(/^.*TOTAL.*$/).map(&:strip).first.split(/\s/).reject(&:empty?)
+      rescue StandardError => e
+        puts e
+        []
+      end
+
+      # called directory
+      def store_dumped_memory_usage
+        self.store_memory_usage(self.dump_memory_usage(self.dump_meminfo))
+      end
+
+      # called directory
+      def store_dumped_memory_details_usage
+        self.store_memory_details_usage(self.dump_memory_details_usage(self.dump_meminfo))
+      end
+
+      def save_memory_as_google_api(file_path)
+        self.save(export_as_google_api_format(@memory_usage), file_path)
+      end
+
+      def save_memory_details_as_google_api(file_path)
+        self.save(export_as_google_api_format(@memory_detail_usage), file_path)
+      end
+
+      # @param [Array] dumped_memory Array of dumped memory data
+      # @return [Hash] Google API formatted data
+      def store_memory_usage(dumped_memory)
+        @memory_usage.push self.merge_current_time(transfer_total_memory_to_hash(dumped_memory))
+      end
+
+      # @param [Array] dumped_memory_details Array of dumped memory data
+      # @return [Hash] Google API formatted data
+      def store_memory_details_usage(dumped_memory_details)
+        @memory_detail_usage.push self.merge_current_time(transfer_total_memory_details_to_hash(dumped_memory_details))
+      end
+
+      def transfer_total_memory_to_hash(data)
+        total_memory(data)
+      end
+
+      def transfer_total_memory_details_to_hash(data)
+        if @api_level.to_i >= 19
+          total_memory_details_api_level_over_44(data)
+        else
+          total_memory_details_api_level_under_43(data)
+        end
+      end
+
+      def export_as_google_api_format(data)
+        if @api_level.to_i >= 19
+          google_api_data_format = empty_google_api_format_over44
+          data.each do |hash|
+            a_google_api_data_format = {
+              c: [
+                { v: hash[:time] },
+                { v: hash[:pss_total] },
+                { v: hash[:private_dirty] },
+                { v: hash[:private_clean] },
+                { v: hash[:swapped_dirty] },
+                { v: hash[:heap_size] },
+                { v: hash[:heap_alloc] },
+                { v: hash[:heap_free] },
+              ],
+            }
+            google_api_data_format[:rows].push(a_google_api_data_format)
+          end
+          JSON.generate google_api_data_format
+        else
+          google_api_data_format = empty_google_api_format_over43
+
+          data.each do |hash|
+            a_google_api_data_format = {
+              c: [
+                { v: hash[:time] },
+                { v: hash[:pss_total] },
+                { v: hash[:shared_dirty] },
+                { v: hash[:private_dirty] },
+                { v: hash[:heap_size] },
+                { v: hash[:heap_alloc] },
+                { v: hash[:heap_free] },
+              ],
+            }
+            google_api_data_format[:rows].push(a_google_api_data_format)
+          end
+
+          JSON.generate google_api_data_format
+        end
+      end
+
+      # @params [String] data_file_path A path to data.
+      # @params [Hash] graph_opts A hash regarding graph settings.
+      # @params [String] output_file_path A path you would like to export data.
+      def create_graph(data_file_path, graph_opts = {}, output_file_path)
+        self.save(Droid::Monitor::GoogleApiTemplate.create_graph(data_file_path, graph_opts),
+                  output_file_path)
+      end
+
+      private
+
+      def empty_google_api_format_over44
+        {
+          cols: [
+            { label: 'time', type: 'string' },
+            { label: 'pss_total', type: 'number' },
+            { label: 'private_dirty', type: 'number' },
+            { label: 'private_clean', type: 'number' },
+            { label: 'swapped_dirty', type: 'number' },
+            { label: 'heap_size', type: 'number' },
+            { label: 'heap_alloc', type: 'number' },
+            { label: 'heap_free', type: 'number' },
+          ],
+          rows: [
+          ],
+        }
+      end
+
+      def empty_google_api_format_over43
+        {
+          cols: [
+            { label: 'time', type: 'string' },
+            { label: 'pss_total', type: 'number' },
+            { label: 'shared_dirty', type: 'number' },
+            { label: 'private_dirty', type: 'number' },
+            { label: 'heap_size', type: 'number' },
+            { label: 'heap_alloc', type: 'number' },
+            { label: 'heap_free', type: 'number' },
+          ],
+          rows: [
+          ],
+        }
+      end
+
+      def total_memory(data)
+        {
+          uptime: data[1].to_i ||= 0,
+          realtime: data[3].to_i ||= 0,
+        }
+      end
+
+      def total_memory_details_api_level_over_44(data)
+        {
+          pss_total: data[1].to_i ||= 0,
+          private_dirty: data[2].to_i ||= 0,
+          private_clean: data[3].to_i ||= 0,
+          swapped_dirty: data[4].to_i ||= 0,
+          heap_size: data[5].to_i ||= 0,
+          heap_alloc: data[6].to_i ||= 0,
+          heap_free: data[7].to_i ||= 0,
+        }
+      end
+
+      def total_memory_details_api_level_under_43(data)
+        {
+          pss_total: data[1].to_i ||= 0,
+          shared_dirty: data[2].to_i ||= 0,
+          private_dirty: data[3].to_i ||= 0,
+          heap_size: data[4].to_i ||= 0,
+          heap_alloc: data[5].to_i ||= 0,
+          heap_free: data[6].to_i ||= 0,
+        }
+      end
+
+    end # class Memory
+  end # module Monitor
+end # module Droid