proceso 0.0.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3d49661725405e398e78ba8b53acd8d9c28d8110
-  data.tar.gz: 0acfd2992fe40aa6c188f747eb1b934ae43accb6
+  metadata.gz: 5ba2fac203e9bf0d1bec8ad20defc3ff07582c5f
+  data.tar.gz: a40f55f136b868bd641129c5c8680feb2e3855d6
 SHA512:
-  metadata.gz: c41bda0b3153f6564b05cfb806eafa005d2bc69947af100a0393f2a22e07059b7653a9ba4b0008fdebae2af70e7f089ecfd8f970c3d6826615d588e1d21842c6
-  data.tar.gz: f4788aace60dd4ed5c3f6c8b23f8a10046fcaa3b3b86ace7f01ac57bf3a16ed7b9f8ca31c345223efd8d4990214e4e6f5918a1048abf6baac87bc87b37dcda81
+  metadata.gz: c9d453e1d265a4d3625328733ceadc4cbc26a34cd22c90cf131512ca1f57caf5fcabb54da937953a4c14802c17221f59f149bd588249541a3ebaa02b4c548dfd
+  data.tar.gz: d914eddb8fe44c1fdafaf6c73b689481f7a94c9b06b26e1ee66d738d4120dc910958b227227a4a7b528e4994abb7f06a0d593a35874dc35a24e17c949b16872a

data/ext/proceso/darwin.c

@@ -0,0 +1,69 @@
+#ifdef __APPLE__
+
+#include "darwin.h"
+
+int rb_sysctl_kern_argmax() {
+  int ret, argmax;
+  int mib[2] = { CTL_KERN, KERN_ARGMAX };
+  size_t buf_size = sizeof(argmax);
+  ret = sysctl(mib, 2, &argmax, &buf_size, NULL, 0);
+  if (ret == 0) {
+    return argmax;
+  }
+  return 0;
+}
+
+int rb_sysctl_kern_procargs2(int pid, char **process_name, int argmax, size_t buf_size) {
+  int ret, nargs;
+  int mib[3] = { CTL_KERN, KERN_PROCARGS, pid };
+  char *process;
+  process = (char *)malloc(argmax);
+  ret = sysctl(mib, 3, process, &buf_size, NULL, 0);
+  if (ret < 0) {
+    free(process);
+    return 0;
+  }
+  memcpy(&nargs, process, sizeof(nargs));
+  *process_name = process + sizeof(nargs);
+  return 1;
+}
+
+int rb_process_info(int pid, int flavor, void *pti, int size) {
+  int ret = proc_pidinfo(pid, flavor, 0, pti, size);
+  if ((ret == 0) || (ret != size)) {
+    return 0;
+  } else {
+    return 1;
+  }
+}
+
+/* List of Processes */
+int * rb_process_list() {
+  int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_ALL, 0};
+  size_t buf_size;
+  int ret;
+  int list[4096];
+  ret = sysctl(mib, 4, NULL, &buf_size, NULL, 0);
+  if (ret >= 0) {
+    struct kinfo_proc *processes = NULL;
+    int i, nb_entries;
+    nb_entries = buf_size / sizeof(struct kinfo_proc);
+    processes = (struct kinfo_proc*) malloc(buf_size);
+    if (processes != NULL) {
+      ret = sysctl(mib, 4, processes, &buf_size, NULL, 0);
+      if (ret >= 0) {
+        for (i = 0; i < nb_entries; i++) {
+          int pid = processes[i].kp_proc.p_pid;
+          list[i] = pid;
+        }
+        free(processes);
+        return list;
+      }
+      free(processes);
+      return 0;
+    }
+  }
+  return 0;
+}
+
+#endif

data/ext/proceso/darwin.h

@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/sysctl.h>
+#include <signal.h>
+
+#if defined(__APPLE__)
+#  include <mach/mach.h>
+#  include <libproc.h>
+#endif
+
+
+int rb_sysctl_kern_argmax();
+int rb_sysctl_kern_procargs2(int pid, char **process_name, int argmax, size_t buf_size);
+int rb_process_info(int pid, int flavor, void *pti, int size);
+int * rb_process_list();

data/ext/proceso/extconf.rb

@@ -1,3 +1,19 @@
 require "mkmf"
 
-create_makefile('proceso/proceso')
+RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+
+def have_platform(name)
+  have_header("#{name}.h")
+  $objs.unshift "#{name}.o"
+end
+
+
+$objs = ["utility.o", "pid.o", "proceso.o"]
+case RUBY_PLATFORM
+when /linux/ then have_platform("linux")
+when /darwin/ then have_platform("darwin")
+else
+  raise "#{RUBY_PLATFORM} is not currently supported. Send Pull Request for platform support"
+end
+
+create_makefile('proceso/proceso')

data/ext/proceso/linux.c

@@ -0,0 +1,90 @@
+#if defined(__linux) || defined(__LINUX__) || defined(__linux__)
+
+#include "linux.h"
+// const char *format = "%d %s %c %d %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %ld %ld %ld %ld %ld %ld %lu %lu %ld %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %lu %llu";
+
+int rb_proc_ncpu() {
+  int ncpu = 0;
+  char buffer[120];
+  FILE *fp;
+  fp = fopen("/proc/cpuinfo","r");
+  if(!fp)
+    return 0;
+  while(fgets(buffer,120,fp)){
+    if(strncmp(buffer,"processor",9) == 0)
+      ++ncpu;
+  }
+  fclose(fp);
+  return ncpu;
+}
+int rb_proc_pid_rss(int pid) {
+  const char *format = "%*d %*s %*c %*d %*d %*d %*d %*d %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*ld %*ld %*ld %*ld %*ld %*ld %*lu %*lu %ld";
+  int rss_size = 0;
+  char buffer[256];
+  FILE *fp;
+  sprintf(buffer, "/proc/%d/stat", pid);
+  fp = fopen(buffer, "r");
+  if (!fp)
+    return 0;
+  fscanf(fp, format, &rss_size);
+  fclose(fp);
+  return rss_size;
+}
+
+int rb_proc_pid_vsize(int pid) {
+  const char *format = "%*d %*s %*c %*d %*d %*d %*d %*d %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*ld %*ld %*ld %*ld %*ld %*ld %*lu %lu";
+  int vsize = 0;
+  char buffer[256];
+  FILE *fp;
+  sprintf(buffer, "/proc/%d/stat", pid);
+  fp = fopen(buffer, "r");
+  if (!fp)
+    return 0;
+  fscanf(fp, format, &vsize);
+  fclose(fp);
+  return vsize;
+}
+
+float rb_proc_pid_stime(int pid) {
+  const char *format = "%*d %*s %*c %*d %*d %*d %*d %*d %*lu %*lu %*lu %*lu %*lu %*lu %lu";
+  int stime = 0;
+  char buffer[256];
+  FILE *fp;
+  sprintf(buffer, "/proc/%d/stat", pid);
+  fp = fopen(buffer, "r");
+  if (!fp)
+    return 0;
+  fscanf(fp, format, &stime);
+  fclose(fp);
+  return stime / 1000000.0;
+}
+
+float rb_proc_pid_utime(int pid) {
+  const char *format = "%*d %*s %*c %*d %*d %*d %*d %*d %*lu %*lu %*lu %*lu %*lu %lu";
+  int utime = 0;
+  char buffer[256];
+  FILE *fp;
+  sprintf(buffer, "/proc/%d/stat", pid);
+  fp = fopen(buffer, "r");
+  if (!fp)
+    return 0;
+  fscanf(fp, format, &utime);
+  fclose(fp);
+  return utime / 1000000.0;
+}
+
+char * rb_proc_pid_cmdline(int pid) {
+  char buffer[512];
+  FILE *fp;
+  char *cmdline;
+  size_t size = 0;
+  sprintf(buffer, "/proc/%d/cmdline", pid);
+  fp = fopen(buffer, "rb");
+  if (!fp)
+    return NULL;
+  getdelim(&cmdline, &size, 0 , fp);
+  fclose(fp);
+  return cmdline;
+}
+
+#endif

data/ext/proceso/linux.h

@@ -0,0 +1,64 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/sysctl.h>
+#include <signal.h>
+
+#ifndef __LINUX__
+#  define __LINUX__
+#endif
+
+struct proc_pid_stat {
+    int pid;      // %d
+    char comm[256];   // %s
+    char state;     // %c
+    int ppid;     // %d
+    int pgrp;     // %d
+    int session;    // %d
+    int tty_nr;     // %d
+    int tpgid;      // %d
+    unsigned long flags;  // %lu
+    unsigned long minflt; // %lu
+    unsigned long cminflt;  // %lu
+    unsigned long majflt; // %lu
+    unsigned long cmajflt;  // %lu
+    unsigned long utime;  // %lu
+    unsigned long stime;  // %lu
+    long cutime;    // %ld
+    long cstime;    // %ld
+    long priority;    // %ld
+    long nice;      // %ld
+    long num_threads;   // %ld
+    long itrealvalue;   // %ld
+    unsigned long starttime;  // %lu
+    unsigned long vsize;  // %lu
+    long rss;     // %ld
+    unsigned long rlim;   // %lu
+    unsigned long startcode;  // %lu
+    unsigned long endcode;  // %lu
+    unsigned long startstack; // %lu
+    unsigned long kstkesp;  // %lu
+    unsigned long kstkeip;  // %lu
+    unsigned long signal; // %lu
+    unsigned long blocked;  // %lu
+    unsigned long sigignore;  // %lu
+    unsigned long sigcatch; // %lu
+    unsigned long wchan;  // %lu
+    unsigned long nswap;  // %lu
+    unsigned long cnswap; // %lu
+    int exit_signal;    // %d
+    int processor;    // %d
+    unsigned long rt_priority;  // %lu
+    unsigned long policy; // %lu
+    unsigned long long delayacct_blkio_ticks; // %llu
+};
+
+int rb_proc_ncpu();
+int rb_proc_pid_vsize(int pid);
+int rb_proc_pid_rss(int pid);
+float rb_proc_pid_stime(int pid);
+float rb_proc_pid_utime(int pid);
+char * rb_proc_pid_cmdline(int pid);
+char * rb_proc_pid_name(int pid);

data/ext/proceso/pid.c

@@ -0,0 +1,87 @@
+#include "proceso.h"
+
+static VALUE rb_cProcesoPID;
+
+static VALUE
+proceso__process_init(VALUE self, VALUE pid) {
+  rb_iv_set(self, "@pid", pid);
+  return self;
+}
+
+/* PID running? */
+static VALUE
+proceso__process_running(VALUE self) {
+  int pid = iv2pid(self);
+  rb_pid_t i = getpgid(pid);
+  if (i < 0) {
+    return Qfalse;
+  }
+  return Qtrue;
+}
+
+/* PID command line */
+static VALUE
+proceso__process_command(VALUE self) {
+  int pid = iv2pid(self);
+  char *process_cmd = rb_process_command(pid);
+  if (process_cmd == NULL)
+    return Qnil;
+  return rb_str_new2(process_cmd);
+}
+
+/* PID Resident Size (bytes) */
+static VALUE
+proceso__process_rss(VALUE self) {
+  int ret = rb_process_memory_size(iv2pid(self), PROCESS_RSS);
+  return INT2NUM(ret);
+}
+
+/* PID Virtual Size (bytes) */
+static VALUE
+proceso__process_vms(VALUE self) {
+  int ret = rb_process_memory_size(iv2pid(self), PROCESS_VMS);
+  return INT2NUM(ret);
+}
+
+/* PID User CPU */
+static VALUE
+proceso__process_user_cpu(VALUE self) {
+  float val = rb_process_cpu_times(iv2pid(self), FCPU_USR);
+  return rb_float_new(val);
+}
+
+/* PID System CPU */
+static VALUE
+proceso__process_system_cpu(VALUE self) {
+  float val = rb_process_cpu_times(iv2pid(self), FCPU_SYS);
+  return rb_float_new(val);
+}
+
+/* PID CPU Usage */
+static VALUE
+proceso__process_cpu_usage(VALUE self) {
+  int ncpu = rb_hw_ncpu();
+  float u1, u2;
+  float usage;
+  u1 = rb_process_cpu_times(iv2pid(self), FCPU_USR);
+  usleep(100000);
+  u2 = rb_process_cpu_times(iv2pid(self), FCPU_USR);
+  usage = ncpu * ((u2 - u1) * 100);
+  return rb_float_new(usage);
+}
+
+void Init__proceso_pid() {
+
+  VALUE rb_mProceso  = rb_define_module("Proceso");
+  rb_cProcesoPID = rb_define_class_under(rb_mProceso, "PID", rb_cObject);
+
+  rb_define_method(rb_cProcesoPID, "initialize", proceso__process_init, 1);
+  rb_define_method(rb_cProcesoPID, "running?", proceso__process_running, 0);
+  rb_define_method(rb_cProcesoPID, "command", proceso__process_command, 0);
+  rb_define_method(rb_cProcesoPID, "resident_size", proceso__process_rss, 0);
+  rb_define_method(rb_cProcesoPID, "virtual_size", proceso__process_vms, 0);
+  rb_define_method(rb_cProcesoPID, "user_cpu_times", proceso__process_user_cpu, 0);
+  rb_define_method(rb_cProcesoPID, "system_cpu_times", proceso__process_system_cpu, 0);
+  rb_define_method(rb_cProcesoPID, "cpu_usage", proceso__process_cpu_usage, 0);
+
+}

data/ext/proceso/proceso.c

@@ -0,0 +1,36 @@
+#include "proceso.h"
+
+static VALUE rb_mProceso;
+
+int iv2pid(VALUE self) {
+  return FIX2INT(rb_iv_get(self, "@pid"));
+}
+
+#ifdef __APPLE__
+/* Process PIDs */
+static VALUE
+proceso__pids(VALUE self) {
+  int *pids = rb_process_list();
+  VALUE processes = rb_ary_new();
+  int i;
+  for(i = 0; i < sizeof(pids); i++) {
+    rb_ary_push(processes, INT2NUM(pids[i]));
+  }
+  return processes;
+}
+#endif
+
+void Init_proceso() {
+
+  rb_mProceso        = rb_define_module("Proceso");
+
+  rb_define_const(rb_mProceso, "NCPU", INT2NUM(rb_hw_ncpu()));
+
+#ifdef __APPLE__
+  rb_define_singleton_method(rb_mProceso, "pids", proceso__pids, 0);
+#endif
+
+  Init__proceso_pid();
+}
+
+

data/ext/proceso/proceso.h

@@ -0,0 +1,20 @@
+#ifndef PROCESO_H
+
+#define PROCSEO_H
+
+#define PROCESS_RSS 0
+#define PROCESS_VMS 1
+#define FCPU_USR 0
+#define FCPU_SYS 1
+
+#include <ruby.h>
+
+#if defined(__APPLE__)
+#  include "darwin.h"
+#elif defined(__linux) || defined(__linux__) || defined(__LINUX__)
+#  include "linux.h"
+#endif
+
+#include "utility.h"
+
+#endif // PROCESO_H

data/ext/proceso/utility.c

@@ -0,0 +1,88 @@
+#include "proceso.h"
+
+int rb_hw_ncpu() {
+  int ncpu = 0;
+#if defined(__APPLE__)
+  int mib[2] = { CTL_HW, HW_NCPU };
+  int ret;
+  size_t len;
+  len = sizeof(ncpu);
+  ret = sysctl(mib, 2, &ncpu, &len, NULL, 0);
+  if (ret == -1) {
+    return 0;
+  }
+#elif defined(__LINUX__)
+  ncpu = rb_proc_ncpu();
+#endif
+  return ncpu;
+}
+
+float rb_process_cpu_times(int pid, int flag) {
+  int ret;
+#if defined(__APPLE__)
+  struct proc_taskinfo pti;
+  ret = rb_process_info(pid, PROC_PIDTASKINFO, &pti, sizeof(pti));
+  if (ret == 0)
+    return 0.0;
+  if (flag == FCPU_SYS) { // total system
+    return (float)pti.pti_total_system / 1000000000.0;
+  } else {
+    return (float)pti.pti_total_user / 1000000000.0;
+  }
+#elif defined(__LINUX__)
+  if (flag == FCPU_SYS) {
+    return rb_proc_pid_stime(pid);
+  } else {
+    return rb_proc_pid_utime(pid);
+  }
+#endif
+  return 0.0;
+}
+
+char * rb_process_command(int pid) {
+  int ret;
+  char *process_name;
+#if defined(__APPLE__)
+  int argmax;
+  argmax = rb_sysctl_kern_argmax();
+  if (argmax) {
+    ret = rb_sysctl_kern_procargs2(pid, &process_name, argmax, (size_t)argmax);
+    if (ret == 1)
+      return process_name;
+  }
+#elif defined(__LINUX__)
+  process_name = rb_proc_pid_cmdline(pid);
+  return process_name;
+#endif
+  return NULL;
+}
+
+int rb_process_memory_size(int pid, int flag) {
+  int result = 0;
+#if defined(__APPLE__)
+  kern_return_t kr;
+  task_t task;
+  kr = task_for_pid(mach_task_self(), pid, &task);
+  if (kr == KERN_SUCCESS) {
+    task_basic_info_data_t basic_info;
+    mach_msg_type_number_t count = TASK_BASIC_INFO_COUNT;
+    kr = task_info(task, TASK_BASIC_INFO, (task_info_t)&basic_info, &count);
+    if (kr == KERN_SUCCESS) {
+      if (count == TASK_BASIC_INFO_COUNT) {
+        if (flag == 1) {
+          result = (int)basic_info.virtual_size;
+        } else {
+          result = (int)basic_info.resident_size;
+        }
+      }
+    }
+  }
+#elif defined(__LINUX__)
+  if (flag == 1) {
+    result = rb_proc_pid_vsize(pid);
+  } else {
+    result = rb_proc_pid_rss(pid);
+  }
+#endif
+  return result;
+}

data/ext/proceso/utility.h

@@ -0,0 +1,4 @@
+int rb_hw_ncpu();
+int rb_process_memory_size(int pid, int flag);
+float rb_process_cpu_times(int pid, int flag);
+char * rb_process_command(int pid);

data/lib/proceso/middleware.rb

@@ -0,0 +1,71 @@
+require 'rack'
+
+module Proceso
+  class Middleware
+
+    SUBSCRIPTION = 'proceso.usage'
+
+    def self.report
+      subscribe do |name, start, finish, id, payload|
+        puts
+        puts "******* PROCESO INFORMATION *******"
+        mem_used    = (payload[:mem_used].to_f / 1024.0).round(1)
+        cpu_used    = payload[:cpu_used].to_f.round(1)
+        path        = payload[:request].path_info
+        resp_time   = payload[:resp_time]
+        puts "MEM: #{mem_used}KB CPU: #{cpu_used} RESP: #{resp_time}ms PATH: #{path}"
+        puts "******* END OF PROCESO INFORMATION *******"
+        puts
+      end
+    end
+
+    def self.subscribe(&blk)
+      return unless defined?(ActiveSupport::Notifications)
+      ActiveSupport::Notifications.subscribe(SUBSCRIPTION, &blk)
+    end
+
+    attr_reader :app, :pid, :notifier
+
+    def initialize(app)
+      @app = app
+      @notifier ||= ActiveSupport::Notifications if defined?(ActiveSupport::Notifications)
+      @pid = Process.pid
+    end
+
+    def call(env)
+      measure_process_usage(env) do
+        @app.call(env)
+      end
+    end
+
+    def measure_process_usage(env)
+      mem_1   = process.mem_size
+      cpu_1   = process.user_cpu_times
+      resp_1  = Time.now.to_i
+      response = yield
+      mem_2 = process.mem_size
+      cpu_2 = process.user_cpu_times
+      resp_2  = Time.now.to_i
+      process_usage = process_info(env, (mem_2 - mem_1), (cpu_2 - cpu_1), (resp_2 - resp_1))
+      notifier.instrument(SUBSCRIPTION, process_usage)
+      response
+    end
+
+    def process_info(env, mem_used, cpu_used, resp_time)
+      req = Rack::Request.new(env)
+      {
+        pid: process.pid,
+        mem_used: mem_used,
+        cpu_used: cpu_used,
+        resp_time: resp_time,
+        request: req
+      }
+    end
+
+    def process
+      @process ||= Proceso::PID.new(pid)
+    end
+
+  end
+end
+

data/lib/proceso/pid.rb

@@ -0,0 +1,26 @@
+module Proceso
+  class PID
+
+    attr_accessor :pid
+
+    def path
+      File.dirname(command)
+    end
+
+    def executable
+      File.basename(command)
+    end
+
+    def mem_size(format = :bytes)
+      rss = resident_size
+      rss *= 1024 if RUBY_PLATFORM =~ /linux/
+      case format.to_s
+      when "bytes" then rss
+      when "kb", "kilobytes" then rss.to_f / 1024.0
+      when "mb", "megabytes" then rss.to_f / 1024.0 / 1024.0
+      when "gb", "gigabytes" then rss.to_f / 1024.0 / 1024.0 / 1024.0
+      end
+    end
+
+  end
+end

data/lib/proceso/version.rb

@@ -1,3 +1,3 @@
 module Proceso
-  VERSION = "0.0.0"
-end
+  VERSION = "0.1.1"
+end

data/lib/proceso.rb

@@ -1 +1,29 @@
-require 'proceso/proceso'
+require 'proceso/proceso'
+require 'proceso/pid'
+
+module Proceso
+  extend self
+
+  if RUBY_PLATFORM =~ /linux/
+    def pids
+      Dir["/proc/*"].select do
+        |x| x =~ /\/\d+$/
+      end.map(&File.method(:basename)).map(&:to_i)
+    end
+  end
+
+  def processes
+    pids.map do |i|
+      Proceso::PID.new(i)
+    end
+  end
+
+  def current
+    @current ||= Proceso::PID.new(Process.pid)
+  end
+
+end
+
+if defined?(Rails) || defined?(Rack)
+  require 'proceso/middleware'
+end

data/spec/proceso/pid_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Proceso::PID do
+
+  let(:process) { Proceso::PID.new($$) }
+
+  it "should create new Process object with pid" do
+    expect { Proceso::PID.new($$) }.to_not raise_error
+  end
+
+  it "creates new Base object without argument will raise error" do
+    expect { Proceso::PID.new }.to raise_error
+  end
+
+  it "should be running" do
+    process.running?.should be_true
+  end
+
+  it "should return process command" do
+    process.command.should =~ /ruby/
+  end
+
+  it "should return executable name" do
+    process.executable.should == "ruby"
+  end
+
+  it "should return path name" do
+    process.path.should =~ /bin$/
+  end
+
+  it "should return resident size in bytes" do
+    process.resident_size.should be_kind_of(Numeric)
+    process.stub(:resident_size).and_return(100)
+    process.resident_size.should == 100
+  end
+
+  it "should return virtual size in bytes" do
+    process.virtual_size.should be_kind_of(Numeric)
+    process.stub(:virtual_size).and_return(100)
+    process.virtual_size.should == 100
+  end
+
+  it "should return cpu usage" do
+    process.cpu_usage.should be_kind_of(Float)
+    process.stub(:cpu_usage).and_return(0.1)
+    process.cpu_usage.should == 0.1
+  end
+
+  it "should return user cpu times" do
+    process.user_cpu_times.should be_kind_of(Float)
+    process.stub(:user_cpu_times).and_return(0.1)
+    process.user_cpu_times.should == 0.1
+  end
+
+  it "should return system cpu times" do
+    process.system_cpu_times.should be_kind_of(Float)
+    process.stub(:system_cpu_times).and_return(0.1)
+    process.system_cpu_times.should == 0.1
+  end
+
+  it "should return mem size" do
+    process.mem_size.should be_kind_of(Numeric)
+    rss = process.resident_size
+    process.stub(:resident_size).and_return(rss)
+    rss *= 1024 if RUBY_PLATFORM =~ /linux/
+    process.mem_size.should == rss
+    process.mem_size(:kb).should == (rss / 1024.0)
+    process.mem_size(:mb).should == (rss / 1024.0 / 1024.0)
+    process.mem_size(:gb).should == (rss / 1024.0 / 1024.0 / 1024.0)
+  end
+
+end

data/spec/proceso_spec.rb

@@ -2,42 +2,22 @@ require "spec_helper"
 
 describe Proceso do
 
-  let(:process) { Proceso::Info.new($$) }
-
-  it "should create new Process object with pid" do
-    expect { Proceso::Info.new($$) }.to_not raise_error
-  end
-
-  it "creates new Base object without argument will raise error" do
-    expect { Proceso::Info.new }.to raise_error
-  end
-
-  it "should be running" do
-    process.running?.should be_true
-  end
-
-  it "should return process name" do
-    process.name.should =~ /ruby/
-  end
-
-  it "should return resident size in bytes" do
-    process.resident_size.should be_kind_of(Numeric)
-  end
-
-  it "should return virtual size in bytes" do
-    process.virtual_size.should be_kind_of(Numeric)
+  it "should return cpu core" do
+     Proceso::NCPU.should_not == 0
   end
 
-  it "should return cpu usage" do
-    process.cpu_usage.should be_kind_of(Float)
+  it "should return list of pids" do
+    Proceso.pids.should be_kind_of(Array)
   end
 
-  it "should return user cpu times" do
-    process.user_cpu_times.should be_kind_of(Float)
+  it "should return list of Proceso::PID objects" do
+    Proceso.processes.should be_kind_of(Array)
+    Proceso.processes.last.should be_kind_of(Proceso::PID)
   end
 
-  it "should return system cpu times" do
-    process.system_cpu_times.should be_kind_of(Float)
+  it "should return current process" do
+    Proceso.current.should_not be_nil
+    Proceso.current.pid.should == Process.pid
   end
 
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: proceso
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Bryan Goines
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-14 00:00:00.000000000 Z
+date: 2013-12-22 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -74,11 +88,23 @@ extensions:
 - ext/proceso/extconf.rb
 extra_rdoc_files: []
 files:
+- lib/proceso/middleware.rb
+- lib/proceso/pid.rb
 - lib/proceso/version.rb
 - lib/proceso.rb
+- ext/proceso/extconf.rb
+- ext/proceso/darwin.c
+- ext/proceso/linux.c
+- ext/proceso/pid.c
+- ext/proceso/proceso.c
+- ext/proceso/utility.c
+- ext/proceso/darwin.h
+- ext/proceso/linux.h
+- ext/proceso/proceso.h
+- ext/proceso/utility.h
+- spec/proceso/pid_spec.rb
 - spec/proceso_spec.rb
 - spec/spec_helper.rb
-- ext/proceso/extconf.rb
 homepage: https://github.com/bry4n/proceso
 licenses:
 - MIT
@@ -105,5 +131,6 @@ signing_key:
 specification_version: 4
 summary: Simple process information gather
 test_files:
+- spec/proceso/pid_spec.rb
 - spec/proceso_spec.rb
 - spec/spec_helper.rb