initial commit

Author: sax

.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

Gemfile

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

LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Eric Saxby
+
+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.

README.md

@@ -0,0 +1,99 @@
+# rails-dtrace
+
+The rails-dtrace gem hooks into the ActiveSupport::Notifications
+instruments in Rails, turning them into DTrace probes.
+
+## Requirements
+
+An OS that supports DTrace. For example:
+* MacOS X
+* Illumos
+* SmartOS
+* Solaris
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ruby-usdt', :git => 'https://github.com/chrisa/ruby-usdt.git',
+        :submodules => true, :branch => 'disable_provider'
+gem 'rails-dtrace'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+## Warning
+
+This gem in an experiment in progress. The code does not have automated
+tests, and the performance impact of ActiveSupport::Notifications
+combined with ruby-usdt and libusdt are unknown. **DO NOT USE THIS IN
+PRODUCTION** unless you love risk.
+
+Also, this gem requires experimental behavior in libusdt/ruby-usdt.
+Core behavior may drastically change between releases/commits of this
+gem. When this is no longer the case (and I figure out how to write
+tests around this gem) these warnings will disappear.
+
+## Usage
+
+Once you add the gem to your Rails application, it will automatically
+subscribe to all notifications, turning them into DTrace probes. The
+arguments to the probes will be:
+
+* `arg0` - Start time of notification - Integer
+* `arg1` - End time of notification - Integer
+* `arg2` - Unique identifier of notification - String
+* `arg3` - Stringified hash of notification payload - String
+
+The following dtrace command can be used, as an example:
+
+```bash
+sudo dtrace -n 'ruby*:rails:: { printf("%d %d %s %s", arg0, arg1,
+  copyinstr(arg2), copyinstr(arg3)) }'
+```
+
+Notifications are lazy-loaded, so even though rails-dtrace subscribes to
+all available instruments, they will only be converted to probes as
+they fire in Rails code. For this reason, in order to get a full picture
+of what is happening in a Rails process, enough load should be generated
+to ensure that all important probes are registered before tracing.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Suggestions for Contributions
+
+* How the F do you test this thing?
+* Can Rails instruments be detected at initialization time?
+* Notifications do start/end in one instrument. DTrace probes tend to
+  fire multiple probes, on entry and exit. This lets you write scripts
+  to do neat analytics on event timing. Can Notifications be hacked to
+  do this?
+* The Responder turns the Notification payload (a hash) into a string.
+  This can surely be better.
+
+## License
+
+Copyright 2012 Eric Saxby
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

lib/rails-dtrace.rb

@@ -0,0 +1,4 @@
+require "rails-dtrace/version"
+require "rails-dtrace/responder"
+
+require 'rails-dtrace/railtie' if defined?(Rails)

lib/rails-dtrace/railtie.rb

@@ -0,0 +1,9 @@
+module DTrace
+  class Railtie < Rails::Railtie
+
+    initializer 'railtie.configure_rails.initialization' do
+      DTrace::Responder.logger = Rails.logger
+      ActiveSupport::Notifications.subscribe(/.*/, DTrace::Responder)
+    end
+  end
+end

lib/rails-dtrace/responder.rb

@@ -0,0 +1,41 @@
+require 'usdt'
+
+=begin
+
+Problems:
+* How do you dynamically enable/disable probes?
+* Split name on '.' sucks
+* Notifications include entry AND exit. Can we fire our own entry/exit probes?
+
+=end
+
+module DTrace
+  class Responder
+    cattr_reader :probes, :provider
+    cattr_writer :logger
+
+    @@provider = USDT::Provider.create :ruby, :rails
+    @@probes = {}
+    @@enabled = false
+
+    def self.logger
+      @@logger || Logger.new
+    end
+
+    def self.call(name, started, finished, unique_id, payload)
+      unless probes.keys.include?(name)
+        func_name, probe_name = name.split('.')
+        p = @@provider.probe(func_name, probe_name, :integer, :integer, :string, :string)
+        probes[name] = p
+        logger.debug "Adding dtrace probe: #{name}"
+        @@provider.disable if @@enabled
+        @@provider.enable
+        @@enabled = true
+      end
+
+      if probes[name].enabled?
+        probes[name].fire(started.to_i, finished.to_i, unique_id, payload.inspect)
+      end
+    end
+  end
+end

lib/rails-dtrace/version.rb

@@ -0,0 +1,3 @@
+module Dtrace
+  VERSION = "0.0.1"
+end

rails-dtrace.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/rails-dtrace/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Eric Saxby"]
+  gem.email         = ["[email protected]"]
+  gem.description   = %q{TODO: Write a gem description}
+  gem.summary       = %q{TODO: Write a gem summary}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| ::File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "rails-dtrace"
+  gem.require_paths = ["lib"]
+  gem.version       = Dtrace::VERSION
+
+  gem.add_dependency 'ruby-usdt'
+  gem.add_development_dependency 'rspec'
+end

spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end