instrumental_tools 1.0.0.rc2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6737135b417f062d69eaa14a98b0b1746564a7cd
-  data.tar.gz: 7055fa1984c0b741d95e741f19cd4c602272bdb4
+  metadata.gz: 8871b4d7d488bafeb4a58f5d82caad26ba139c00
+  data.tar.gz: 5901bebe60f6303dbb00cacba6f376ffa1b61c88
 SHA512:
-  metadata.gz: 837a097722be8ec8716c065f0846285346c0bf5e4d3c5d0ca8980ec58b822a2d00a013fe0c96e5ae9078dd390feb7f13452a9abd14938a1cbbee3933784f8511
-  data.tar.gz: b756454e6b3d7305e354121646a0202045c4f7223155fe1db475e640e401fb0b74885778a39ce82e1601915057c18e849fac3d10ae9f5b67b66fba1800e3ff1c
+  metadata.gz: 71a0be3021518f008517cfbf8d0802ca80de6c3362df63f9d70aabaf0a86eac6341fec2018f7c4de1047b0e4e30639f155085182d35c3e59b7b0f23f8a55081c
+  data.tar.gz: 5c55425bdb4b2cd64adee1c7aa363d918bbb18175a106796cd29145dc3b17d69be1adba0e5f94af61ee864d98af8665a3b73143420169b2b804e1960207f82b8

data/BUILD.md

@@ -0,0 +1,50 @@
+# Building instrumental-tools
+
+## The Gem
+
+Building the `instrumental_tools` gem can be done via:
+
+```
+rake gem
+```
+
+This will produce a .gem file suitable for release. As a shortcut for the RubyGems release process, you can issue the following command:
+
+```
+rake release
+```
+
+to push a new copy of the gem directly to RubyGems. This presumes you have the correct `rubygems_api_key` available in your system Gem config.
+
+## `deb`, `rpm` and `tgz` packages
+
+Building new `deb`, `rpm` and `tgz` packages can be done via the following rake commands:
+
+For 32 bit Linux:
+
+```
+rake package:linux-x86:package # builds `rpm` and `deb`
+rake package:linux-x86:tarball # buidls tgz
+```
+
+For 64 bit Linux:
+
+```
+rake package:linux-x86_64:package
+rake package:linux-x86_64:tarball
+```
+
+
+For Mac OS X:
+
+```
+rake package:osx:tarball
+```
+
+`deb` and `rpm` packages should be pushed to PackageCloud. You will need to ensure you have the `package_cloud` gem installed (`bundle install` should install it for you - see the [PackageCloud instructions](https://packagecloud.io/docs#cli_install) otherwise). You will also need write credentials to PackageCloud available in `~/.packagecloud`; they will follow the format:
+
+```
+{"url":"https://packagecloud.io","token":"YOUR PACKAGECLOUD API TOKEN"}
+```
+
+On release, the tarball should be uploaded to the Github releases page and linked to from the main README.md.

data/CHANGELOG.md

@@ -1,10 +1,14 @@
-### Unreleased
+### 1.0.0 [?]
 * Configurable pid and log file locations
 * Pid and log file default to $HOME
 * Process control commands do not require API key
 * Omit "-d" in favor of "start" and "stop", "foreground" runs process in foreground
 * Configurable reporting interval
 * Custom scripts may be executed and have their output sent to Instrumental (See [CUSTOM_METRICS.md](CUSTOM_METRICS.md))
+* Support dropping privileges at startup
+* Example scripts for monitoring Docker and MySQL
+* Example startup scripts for starting process at boot time
+* Example Chef and Puppet recipes
 
 ### 0.6.0 [August 11th, 2014]
 * Don't report swap usage if it's zero (Patrick Wyatt)

data/CUSTOM_METRICS.md

@@ -1,6 +1,6 @@
 # Custom Metric Scripts
 
-You may have specific pieces of architecture that you would like `instrument_server` to monitor. As of version 0.7.0 of the `instrument_server` gem, you may pass the `-e` flag to `instrument_server` on startup to enable this functionality. There are several [examples](examples/) of scripts that you may use for your infrastructure, or you can [write your own](#writing_custom_scripts).
+You may have specific pieces of architecture that you would like `instrument_server` to monitor. As of version 1.0.0 of the `instrument_server` gem, you may pass the `-e` flag to `instrument_server` on startup to enable this functionality. There are several [examples](examples/) of scripts that you may use for your infrastructure, or you can [write your own](#writing_custom_scripts).
 
 ## Installing Custom Scripts
 
@@ -28,6 +28,12 @@ Your script is expected to output data in the following format on `STDOUT` in or
 METRIC_NAME METRIC_VALUE
 ```
 
+or
+
+```
+METRIC_NAME METRIC_VALUE UNIX_TIME_IN_SECONDS
+```
+
 For example, if a script named `application_load` were to report two metrics, `memory` and `load`, to the `instrument_server` process, its output should be:
 
 ```
@@ -43,6 +49,8 @@ HOST_NAME.SCRIPT_NAME.METRIC_NAME
 
 Using the previous example, if the `application_load` script ran on a host named `app-0001`, its `memory` and `load` metrics would be submitted to Instrumental as `app-0001.application_load.memory` and `app-0001.application_load.load`.
 
+The optional third parameter of the above formats, `UNIX_TIME_IN_SECONDS`, represents the time under which the submitted metric should be measured. Generally you do not need to provide this value, as `instrument_server` will default to recording the time when it receives the metric from your script as the time under which the measurement should be recorded.
+
 ### Exit Codes
 
 If you do not want the output of your script submitted to Instrumental, your process should exit with a non-zero exit code. Its `STDOUT` output will still be provided to your script on the next iteration.

data/INSTALL.md

@@ -0,0 +1,89 @@
+# Package Locations
+
+## PackageCloud
+
+Prebuilt `deb` and `rpm` packages are available via the [packagecloud.io](https://packagecloud.io/) service. These files are also available to download directly:
+
+* 64-bit Debian package (Ubuntu, Debian) [https://s3.amazonaws.com/instrumental-tools/1.0.0/instrumental-tools_1.0.0_amd64.deb](https://s3.amazonaws.com/instrumental-tools/1.0.0/instrumental-tools_1.0.0_amd64.deb)
+* 32-bit Debian package (Ubuntu, Debian) [https://s3.amazonaws.com/instrumental-tools/1.0.0/instrumental-tools_1.0.0_i386.deb](https://s3.amazonaws.com/instrumental-tools/1.0.0/instrumental-tools_1.0.0_i386.deb)
+* 64-bit RPM package (RHEL, Amazon AMI) [https://s3.amazonaws.com/instrumental-tools/1.0.0/instrumental-tools_1.0.0_amd64.rpm](https://s3.amazonaws.com/instrumental-tools/1.0.0/instrumental-tools_1.0.0_amd64.rpm)
+* 32-bit RPM package (RHEL, Amazon AMI) [https://s3.amazonaws.com/instrumental-tools/1.0.0/instrumental-tools_1.0.0_i386.rpm](https://s3.amazonaws.com/instrumental-tools/1.0.0/instrumental-tools_1.0.0_i386.rpm)
+* 64-bit Linux tarball (CoreOS, etc.) [https://s3.amazonaws.com/instrumental-tools/1.0.0/instrumental-tools_1.0.0_linux-x86_64.tar.gz](https://s3.amazonaws.com/instrumental-tools/1.0.0/instrumental-tools_1.0.0_linux-x86_64.tar.gz)
+* 32-bit Linux tarball (CoreOS, etc.) [https://s3.amazonaws.com/instrumental-tools/1.0.0/instrumental-tools_1.0.0_linux-x86.tar.gz](https://s3.amazonaws.com/instrumental-tools/1.0.0/instrumental-tools_1.0.0_linux-x86.tar.gz)
+* 64-bit Mac OS X tarball [https://s3.amazonaws.com/instrumental-tools/1.0.0/instrumental-tools_1.0.0_osx.tar.gz](https://s3.amazonaws.com/instrumental-tools/1.0.0/instrumental-tools_1.0.0_osx.tar.gz)
+
+# Ubuntu
+
+```sh
+sudo apt-get install curl
+curl https://packagecloud.io/install/repositories/expectedbehavior/instrumental/script.deb | sudo bash
+sudo apt-get install instrumental-tools
+```
+
+# Debian
+
+```sh
+su -c "apt-get install curl"
+su -c "curl https://packagecloud.io/install/repositories/expectedbehavior/instrumental/script.deb | bash"
+su -c "apt-get install instrumental-tools"
+```
+
+# Enterprise Linux (CentOS, AWS Linux, RedHat)
+
+```sh
+curl https://packagecloud.io/install/repositories/expectedbehavior/instrumental/script.rpm | sudo bash
+sudo yum install instrumental-tools
+```
+
+# Other ( CoreOS, et al )
+
+## Installing the software
+
+```sh
+sudo mkdir -p /opt/instrumental-tools/
+sudo tar -zxvf ./instrumental-tools_1.0.0_linux-x86_64.tar.gz -C /opt/instrumental-tools/ --strip 1
+sudo cp /opt/instrumental-tools/etc/instrumental.yml /etc/
+```
+
+# RubyGems
+
+```sh
+sudo gem install instrumental_tools
+```
+
+Installing `instrumental_tools` via Rubygems will not create the `/opt/instrumental-tools/` directory on your server or setup the process to run on startup. It is advisable that you install the software via the `deb` or `rpm` packages if your system supports its.
+
+## Adding to system startup
+
+### systemd
+
+```sh
+sudo cp /opt/instrumental-tools/lib/app/systemd/instrument_server.service  /etc/systemd/system/
+sudo systemctl enable instrument_server.service
+sudo systemctl start instrument_server
+```
+
+### sysvinit (update-rc.d)
+
+```sh
+sudo cp /opt/instrumental-tools/lib/app/debian/instrument_server /etc/init.d/
+sudo update-rc.d instrument_server defaults
+sudo /etc/init.d/instrument_server start
+```
+
+### sysvinit (chkconfig)
+
+```sh
+sudo cp /opt/instrumental-tools/lib/app/rpm/instrument_server /etc/init.d/
+sudo chkconfig --add instrument_server
+sudo chkconfig instrument_server on
+sudo service instrument_server start
+```
+
+# Chef
+
+An example Chef cookbook for installing `instrumental-tools` is available in [`chef/instrumental_tools`](chef/instrumental_tools).
+
+# Puppet
+
+An example Puppet module for installing `instrumental-tools` is available in [`puppet/instrumental_tools`](puppet/instrumental_tools).

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011 Fastest Forward
+Copyright (c) 2015 Expected Behavior
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,10 +1,30 @@
 # Instrumental Tools
 
-A collection of scripts useful for monitoring servers and services with Instrumental ([www.instrumentalapp.com](http://www.instrumentalapp.com/)).
+A collection of tools for monitoring servers with Instrumental ([www.instrumentalapp.com](http://www.instrumentalapp.com/)).
 
-## instrument_server
+## Operating System Support
 
-Monitor server activity by collecting information on CPU and memory usage, disk IO, filesystem usage, etc.
+`instrumental_tools` is currently officially supported on 32-bit and 64-bit Linux, as well as Mac OS X. There are prebuilt packages available for Debian and RHEL-based systems.
+
+## Installation
+
+Installation instructions for supported platforms is available in [INSTALL.md](INSTALL.md). The recommended installation method is to use a prebuilt package, which will automatically install the application as a service in your operating system's startup list.
+
+Once you've installed the package, you will want to edit the `/etc/instrumental.yml` file with your Instrumental API key. Example `/etc/instrumental.yml`:
+
+## Sent Metrics
+
+The default `instrument_server` behavior will collect metrics on the following data:
+
+* CPU (`user`, `nice`, `system`, `idle`, `iowait` and `total in use`)
+* Load (at 1 minute, 5 minute and 15 minute intervals)
+* Memory (`used`, `free`, `buffers`, `cached`, `free_percent` )
+* Swap (`used`, `free`, `free_percent`)
+* Disk Capacity (`total`, `used`, `available`, `available percent` for all mounted disks)
+* Disk Usage (`percent_utilization` for all mounted disks)
+* Filesystem stats (`open_files`, `max_open_files`)
+
+## Command Line Usage
 
 Basic usage:
 

data/Rakefile

@@ -1 +1,258 @@
+
 require 'bundler/gem_tasks'
+require 'etc'
+require 'fileutils'
+require 'socket'
+require 'yaml'
+
+PACKAGE_CATEGORY       = "Utilities"
+PACKAGECLOUD_REPO      = "expectedbehavior/instrumental"
+CONFIG_DIR             = "conf"
+CONFIG_DEST            = "/etc/"
+
+GEMSPEC                = Bundler::GemHelper.instance.gemspec
+SPEC_PATH              = Bundler::GemHelper.instance.spec_path
+PACKAGE_NAME           = GEMSPEC.name.gsub("_", "-") # Debian packages cannot include _ in name
+VERSION                = GEMSPEC.version
+TRAVELING_RUBY_VERSION = "20150210-2.1.5"
+TRAVELING_RUBY_FILE    = "packaging/traveling-ruby-#{TRAVELING_RUBY_VERSION}-%s.tar.gz"
+DEST_DIR               = File.join("/opt/", PACKAGE_NAME)
+PACKAGE_OUTPUT_NAME    = [PACKAGE_NAME, VERSION].join("_")
+LICENSE                = Array(GEMSPEC.licenses).first || "None"
+VENDOR                 = Array(GEMSPEC.authors).first || Etc.getlogin
+MAINTAINER             = Array(GEMSPEC.email).first || [Etc.getlogin, Socket.gethostname].join("@")
+HOMEPAGE               = GEMSPEC.homepage || ""
+DESCRIPTION            = GEMSPEC.description || ""
+SUPPORTED_DISTROS      = {
+                           'deb' => ['ubuntu/precise', 'ubuntu/lucid', 'ubuntu/trusty', 'ubuntu/utopic', 'debian/lenny', 'debian/squeeze', 'debian/wheezy'],
+                           'rpm' => ['el/5', 'el/6', 'el/7']
+                         }
+EXTRA_ARGS             = {
+                           'deb' => '--deb-init debian/instrument_server --after-install debian/after-install.sh --before-remove debian/before-remove.sh --after-remove debian/after-remove.sh --deb-user nobody --deb-group nogroup',
+                           'rpm' => '--rpm-init rpm/instrument_server --after-install rpm/after-install.sh --before-remove rpm/before-remove.sh --after-remove rpm/after-remove.sh --rpm-user nobody --rpm-group nobody --rpm-os linux --rpm-attr "-,nobody,nobody:/opt/instrumental-tools/" --directories /opt/instrumental-tools/'
+                         }
+
+
+ARCHITECTURES          = {
+                           'linux-x86' => {
+                             runtime:      TRAVELING_RUBY_FILE % "linux-x86",
+                             arch:         "i386",
+                             packages:     %w{deb rpm},
+                             platform:     "linux",
+                             packagecloud: true
+                            },
+                           'linux-x86_64' => {
+                             runtime:      TRAVELING_RUBY_FILE % "linux-x86_64",
+                             arch:         "amd64",
+                             packages:     %w{deb rpm},
+                             platform:     "linux",
+                             packagecloud: true
+                           },
+                           'osx' => {
+                             runtime:      TRAVELING_RUBY_FILE % "osx",
+                             arch:         "x86_64",
+                             packages:     [],
+                             platform:     "darwin",
+                             packagecloud: false
+                           }
+                         }
+
+
+WRAPPER_SCRIPT = <<-EOSCRIPT
+#!/bin/bash
+set -e
+
+# Figure out where this script is located.
+SELFDIR="`dirname \"$0\"`"
+SELFDIR="`cd \"$SELFDIR\" && pwd`"
+
+# Tell Bundler where the Gemfile and gems are.
+export BUNDLE_GEMFILE="$SELFDIR/lib/vendor/Gemfile"
+unset BUNDLE_IGNORE_CONFIG
+
+# Run the actual app using the bundled Ruby interpreter.
+exec "$SELFDIR/lib/ruby/bin/ruby" -rbundler/setup "$SELFDIR/lib/app/%s" "$@"
+EOSCRIPT
+
+BUNDLE_CONFIG = <<-EOBUNDLECONFIG
+BUNDLE_PATH: .
+BUNDLE_WITHOUT: development
+BUNDLE_DISABLE_SHARED_GEMS: '1'
+EOBUNDLECONFIG
+
+
+desc "Package your app"
+task :package => ARCHITECTURES.map { |name, _| "package:%s" % name }
+
+ARCHITECTURES.each do |name, config|
+  namespace "package" do
+
+    has_packaging = Array(config[:packages]).size > 0
+
+    if has_packaging
+      desc "Package your app for %s" % name
+      task name => ["%s:package" % name]
+    else
+      desc "Package your app for %s" % name
+      task name => ["%s:tarball" % name]
+    end
+
+    namespace name do
+      desc "Create a tarball for %s" % name
+      task "tarball" => [:bundle_install, config[:runtime]] do
+        create_tarball(create_directory_bundle(name))
+      end
+
+      if has_packaging
+        desc "Create packages (%s) for %s" % [config[:packages].join(","), name]
+        task "package" => [:bundle_install, config[:runtime]] do
+          create_packages(create_tarball(create_directory_bundle(name, DEST_DIR)), config[:platform], config[:arch], config[:packages])
+        end
+      end
+
+      if config[:packagecloud]
+        namespace "packagecloud" do
+          desc "Push packages (%s) to package_cloud" % config[:packages].join(",")
+          task "push" do
+            packages     = create_packages(create_tarball(create_directory_bundle(name, DEST_DIR)), config[:platform], config[:arch], config[:packages])
+            by_extension = packages.group_by { |path| File.extname(path)[1..-1] }
+            by_extension.each do |extension, files|
+              distros = SUPPORTED_DISTROS[extension]
+              distros.each do |distro|
+                repo = File.join(PACKAGECLOUD_REPO, distro)
+                files.each do |file|
+                  yank_cmd = "package_cloud yank %s %s" % [repo, file]
+                  puts yank_cmd
+                  system(yank_cmd)
+                  sh "package_cloud push %s %s" % [repo, file]
+                end
+              end
+            end
+          end
+        end
+      end
+
+    end
+  end
+
+
+  file config[:runtime] do
+    download_runtime(name)
+  end
+end
+
+namespace "package" do
+
+  desc "Install gems to local directory"
+  task :bundle_install do
+    if RUBY_VERSION !~ /^2\.1\./
+      abort "You can only 'bundle install' using Ruby 2.1, because that's what Traveling Ruby uses."
+    end
+
+    tmp_package_dir = File.join("packaging", "tmp")
+    spec_path       = SPEC_PATH
+    cache_dir       = File.join("packaging", "vendor", "*", "*", "cache", "*")
+
+    sh "rm -rf %s"                     % tmp_package_dir
+    sh "mkdir -p %s"                   % tmp_package_dir
+    sh "cp %s Gemfile Gemfile.lock %s" % [spec_path, tmp_package_dir]
+
+    GEMSPEC.require_paths.each do |path|
+      sh "ln -sf %s %s" % [File.expand_path(path), tmp_package_dir]
+    end
+
+    Bundler.with_clean_env do
+      sh "cd %s && env BUNDLE_IGNORE_CONFIG=1 bundle install --path ../vendor --without development" % tmp_package_dir
+    end
+
+    sh "rm -rf %s" % tmp_package_dir
+    sh "rm -f %s"  % cache_dir
+  end
+
+end
+
+def create_packages(directory, platform, architecture, package_formats)
+  Array(package_formats).map { |pkg| create_package(directory, pkg, platform, architecture) }
+end
+
+def create_package(tarball, pkg, platform, architecture)
+  output_name = [[PACKAGE_OUTPUT_NAME, architecture].join("_"), pkg].join(".")
+  extra_args  = EXTRA_ARGS[pkg] || ""
+  sh "fpm -s tar -t %s -f -n %s -v %s -a %s --license \"%s\" --vendor \"%s\" --maintainer \"%s\" --url \"%s\" --description \"%s\" --category \"%s\" --config-files %s -C %s -p %s %s %s" % [pkg, PACKAGE_NAME, VERSION, architecture, LICENSE, VENDOR, MAINTAINER, HOMEPAGE, DESCRIPTION, PACKAGE_CATEGORY, CONFIG_DEST, File.basename(tarball, ".tar.gz"), output_name, extra_args, tarball]
+  output_name
+end
+
+def create_directory_bundle(target, prefix = nil)
+  package_dir         = [PACKAGE_NAME, VERSION, target].join("_")
+  prefixed_dir        = if prefix
+                          File.join(package_dir, prefix)
+                        else
+                          package_dir
+                        end
+  lib_dir             = File.join(prefixed_dir, "lib")
+  config_dest_dir     = File.join(package_dir, CONFIG_DEST)
+  app_dir             = File.join(lib_dir, "app")
+  ruby_dir            = File.join(lib_dir, "ruby")
+  dest_vendor_dir     = File.join(lib_dir, "vendor")
+  vendor_dir          = File.join("packaging", "vendor")
+  traveling_ruby_file = "packaging/traveling-ruby-%s-%s.tar.gz" % [TRAVELING_RUBY_VERSION, target]
+  spec_path           = SPEC_PATH
+  bundle_dir          = File.join(dest_vendor_dir, ".bundle")
+
+
+  sh "rm -rf %s"   % package_dir
+  sh "mkdir %s"    % package_dir
+  sh "mkdir -p %s" % prefixed_dir
+  sh "mkdir -p %s" % config_dest_dir
+  sh "mkdir -p %s" % app_dir
+
+  GEMSPEC.files.each do |file|
+    destination_dir = File.join(app_dir, File.dirname(file))
+    FileUtils.mkdir_p(destination_dir)
+
+    sh "cp %s %s" % [file, destination_dir]
+  end
+
+  Dir[File.join(CONFIG_DIR, "*")].each do |file|
+    sh "cp %s %s" % [file, config_dest_dir]
+  end
+
+  sh "mkdir %s"          % ruby_dir
+  sh "tar -xzf %s -C %s" % [traveling_ruby_file, ruby_dir]
+
+  GEMSPEC.executables.each do |file|
+    destination = File.join(prefixed_dir, file)
+
+    File.open(destination, "w") { |f| f.write(WRAPPER_SCRIPT % File.join("bin", file)) }
+
+    sh "chmod +x %s" % destination
+  end
+
+  sh "cp -pR %s %s"                  % [vendor_dir, lib_dir]
+  sh "cp %s Gemfile Gemfile.lock %s" % [spec_path, dest_vendor_dir]
+
+  GEMSPEC.require_paths.each do |path|
+    sh "ln -sf ../app/%s %s" % [path, File.join(dest_vendor_dir, path)]
+  end
+
+  FileUtils.mkdir_p(bundle_dir)
+  File.open(File.join(bundle_dir, "config"), "w") { |f| f.write(BUNDLE_CONFIG) }
+  package_dir
+end
+
+def create_tarball(package_dir)
+  gzip_file   = "%s.tar.gz" % package_dir
+
+  sh "tar -czf %s %s" % [gzip_file, package_dir]
+
+  gzip_file
+end
+
+def download_runtime(target)
+  traveling_ruby_name     = ["traveling-ruby", TRAVELING_RUBY_VERSION, target].join("-")
+  traveling_ruby_file     = "%s.tar.gz" % traveling_ruby_name
+  traveling_ruby_releases = "http://d6r77u77i8pq3.cloudfront.net/releases"
+  traveling_ruby_url      = File.join(traveling_ruby_releases, traveling_ruby_file)
+
+  sh "cd packaging && curl -L -O --fail %s" % traveling_ruby_url
+end

data/TEST.md

@@ -0,0 +1,9 @@
+# Testing Installation
+
+You can test installation of `instrumental_tools` by running the [ServerSpec tests](test/integration/default/serverspec/). From the `chef` or `puppet` directories, run the following command:
+
+```
+bundle exec kitchen verify
+```
+
+to test installation and setup procedures for the `instrumental_tools` command. You must have [Vagrant](https://www.vagrantup.com/) installed; currently the KitchenCI integration is setup to use [VMWare Fusion](http://www.vmware.com/products/fusion) and the [VMWare Fusion Vagrant provider](https://www.vagrantup.com/vmware); you can configure a separate provider for your specific setup by change the `provider` flag in the `.kitchen.yml` file for your particular setup.

data/bin/instrument_server

@@ -8,35 +8,48 @@ rescue Gem::LoadError
   puts '  gem install instrumental_agent'
   exit 1
 end
+
 require 'etc'
 require 'instrumental_agent'
 require 'fileutils'
 require 'optparse'
 require 'socket'
+require 'tmpdir'
+
 $: << File.join(File.dirname(__FILE__), "..", "lib")
 require 'instrumental_tools/version'
 require 'instrumental_tools/server_controller'
 
 def require_api_key(options, parser)
-  if options[:api_key].to_s.strip.empty?
+  if options[:api_key].to_s.strip.empty? && !File.exists?(options[:config_file])
     print parser.help
     exit 1
   end
 end
 
-default_script_directory = File.join(Dir.home, '.instrumental_scripts')
+
+cur_directory         = Dir.pwd
+home_directory        = Dir.home rescue nil
+script_location       = File.expand_path(File.dirname(__FILE__))
+tmp_dir               = Dir.tmpdir
+script_data_directory = [cur_directory, home_directory, script_location, tmp_dir].compact.detect { |dir| File.writable?(dir) }
+
+default_script_directory = File.join(script_data_directory, '.instrumental_scripts')
 default_command          = :foreground
 
 options = {
   :collector       => 'collector.instrumentalapp.com',
   :port            => '8000',
   :hostname        => Socket.gethostname,
-  :pid_location    => File.join(Dir.home, 'instrument_server.pid'),
-  :log_location    => File.join(Dir.home, 'instrument_server.log'),
+  :pid_location    => File.join(script_data_directory, 'instrument_server.pid'),
+  :log_location    => File.join(script_data_directory, 'instrument_server.log'),
+  :tmp_location    => Dir.tmpdir,
   :enable_scripts  => false,
   :script_location => default_script_directory,
   :report_interval => 30,
-  :debug           => false
+  :debug           => false,
+  :config_file     => '/etc/instrumental.yml',
+  :user            => nil
 }
 
 option_parser = OptionParser.new do |opts|
@@ -49,6 +62,10 @@ Default command: #{default_command.to_s}
     options[:api_key] = api_key
   end
 
+  opts.on('-f', '--config-file PATH', "Config file with location of your API key (default #{options[:config_file]})") do |path|
+    options[:config_file] = path
+  end
+
   opts.on('-c', '--collector COLLECTOR[:PORT]', "Collector (default #{options[:collector]}:#{options[:port]})") do |collector|
     address, port = collector.split(':')
     options[:collector] = address
@@ -79,6 +96,14 @@ Default command: #{default_command.to_s}
     options[:script_location] = path
   end
 
+  opts.on('-u', '--user USER_TO_RUN_AS', "User to run instrument_server as. You must have permissions to drop privileges to this user.") do |u|
+    options[:user] = u
+  end
+
+  opts.on('-t', '--temp-dir TEMP_DIRECTORY', "Where to store temporary files (default #{options[:tmp_location]})") do |t|
+    options[:tmp_location] = t
+  end
+
   opts.on('--debug', "Print all sent metrics to the log") do
     options[:debug] = true
   end
@@ -91,9 +116,25 @@ end
 
 option_parser.parse!
 
+if options[:user]
+  desired_uid = Etc.getpwnam(options[:user]).uid
+  Process::Sys.setuid(desired_uid)
+  if desired_uid && desired_uid != 0
+    begin
+      Process::Sys.setuid(0)
+    rescue Errno::EPERM
+      nil
+    else
+      puts "Cannot drop privileges to #{options[:user]}"
+      exit 1
+    end
+  end
+end
+
 command = ARGV.first && ARGV.first.to_sym
 command ||= default_command
 
+
 options[:api_key] ||= ENV["INSTRUMENTAL_TOKEN"]
 
 if options[:pid_location].to_s.strip.empty?
@@ -148,7 +189,7 @@ running_as_daemon = [:start, :restart].include?(command)
 
 controller = ServerController.spawn(
                :name        => File.basename(__FILE__),
-               :path        => Dir.pwd,
+               :path        => options[:tmp_location],
                :pid_file    => options[:pid_location],
                :verbose     => true,
                :log_file    => options[:log_location],
@@ -165,7 +206,7 @@ end
 
 if running_as_daemon
   begin
-    Timeout.timeout(5) do
+    Timeout.timeout(1) do
       Process.waitpid(controller.pid)
     end
   rescue Timeout::Error

data/chef/.kitchen.yml

@@ -0,0 +1,16 @@
+---
+driver:
+  name: vagrant
+  provider: vmware_fusion
+
+provisioner:
+  name: chef_solo
+
+platforms:
+  - name: ubuntu-12.04
+  - name: centos-6.6
+
+suites:
+  - name: default
+    run_list: ["instrumental_tools"]
+    attributes:

data/chef/Berksfile

@@ -0,0 +1,4 @@
+source "https://supermarket.chef.io"
+
+cookbook "packagecloud"
+cookbook "instrumental_tools", path: "instrumental_tools"

data/chef/Berksfile.lock

@@ -0,0 +1,9 @@
+DEPENDENCIES
+  instrumental_tools
+    path: instrumental_tools
+  packagecloud
+
+GRAPH
+  instrumental_tools (0.0.0)
+    packagecloud (>= 0.0.0)
+  packagecloud (0.0.17)

data/chef/instrumental_tools/attributes/default.rb

@@ -0,0 +1,2 @@
+default[:instrumental] = {}
+default[:instrumental][:api_key] = nil

data/chef/instrumental_tools/metadata.rb

@@ -0,0 +1,3 @@
+name "instrumental_tools"
+
+depends "packagecloud"