stapsdt 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cd54b0665a386aa7d0edb3fdb1faf98efe8ff64a3fe60bbe386836a549248db4
+  data.tar.gz: 86b1d0c8a8a0d3e335312032821696338699fcaba43e30d036a06fa7b2cffb07
+SHA512:
+  metadata.gz: 2d21b28243a2814a90b2d55ddd39479ee03f45cdf2a90bd92f8bbdbd66723cb01bee87dbeb025f4755047543c161ca9d636c08fd22754b4de3d16e13145e07ff
+  data.tar.gz: dae381c9a71a7ed3a529409c1554ba73daa8ab75c6c484f1eda4bde9899087ee7f61453ee776a57148a093969956352ad85068ce299d6fb0835ecad9d7261bd5

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+vendor/

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "ext/libstapsdt"]
+	path = ext/libstapsdt
+	url = https://github.com/sthima/libstapsdt

data/.rubocop.yml

@@ -0,0 +1,8 @@
+Style/StringLiterals:
+    EnforcedStyle: double_quotes
+
+Layout/IndentationWidth:
+    Width: 4
+
+Metrics/BlockLength:
+    Exclude: test/**/*_test.rb

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.1
+before_install: gem install bundler -v 1.16.4

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at sylvain.joyeux@13robotics.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+gem 'rubocop', group: :development
+gem 'solargraph', group: :development
+gem 'debase', group: :development
+gem 'ruby-debug-ide', group: :development
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Sylvain Joyeux
+
+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,114 @@
+# StapSDT
+
+Runtime definition of StapSDT (Dtrace) probes within Ruby programs
+
+This gem allows one to define StapSDT probes on Linux, and then use the StapSDT tooling
+to list and inspect them (mainly the bcc suite of tools)
+
+## Installation
+
+This gem requires that libelf is installed on the system. On Ubuntu systems, do
+
+~~~
+sudo apt-get install libelf-dev
+~~~
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'stapsdt'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install stapsdt
+
+## Usage
+
+An example should be worth a 1000 words. Let's create `example.rb` with:
+
+```ruby
+require 'stapsdt'
+
+puts "PID: #{Process.pid}"
+
+provider = StapSDT::Provider.new('example')
+
+probe = provider.add_probe("test", String, Integer)
+provider.load
+
+i = 0
+loop do
+    probe.fire("some string", i += 1)
+end
+```
+
+and run it with `bundle exec example.rb`
+
+Then, `/usr/share/bcc/tools/tplist -p 25175 example:test` (replace 25175 with
+the PID shown by the script) will display:
+
+~~~
+example:test [sema 0x0]
+  1 location(s)
+  2 argument(s)
+~~~
+
+Finally, `sudo /usr/share/bcc/tools/trace -p 25175 -M 10 'u::test "%s - %llu" arg1, arg2'`
+
+~~~
+PID     TID     COMM            FUNC             -
+25175   25175   ruby            test             some string - -1241438585
+25175   25175   ruby            test             some string - -1241438584
+25175   25175   ruby            test             some string - -1241438583
+25175   25175   ruby            test             some string - -1241438582
+25175   25175   ruby            test             some string - -1241438581
+25175   25175   ruby            test             some string - -1241438580
+25175   25175   ruby            test             some string - -1241438579
+25175   25175   ruby            test             some string - -1241438578
+25175   25175   ruby            test             some string - -1241438577
+25175   25175   ruby            test             some string - -1241438576
+~~~
+
+Note that the probes can be inspected and traced only after the provider has
+been loaded. They won't appear until then.
+
+## Thanks
+
+Thanks to Matheus Marchini who wrote [this medium article](https://medium.com/sthima-insights/we-just-got-a-new-super-power-runtime-usdt-comes-to-linux-814dc47e909f)
+showing the same capability on Node.js and Python. I would not even have
+realized it was possible before that.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then,
+run `rake test` to run the tests. You can also run `bin/console` for an
+interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+To release a new version, update the version number in `version.rb`, and then
+run `bundle exec rake release`, which will create a git tag for the version,
+push git commits and tags, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/rock-core/ruby-stapsdt. This project is intended to be a safe,
+welcoming space for collaboration, and contributors are expected to adhere to
+the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT
+License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Usdt project’s codebases, issue trackers, chat
+rooms and mailing lists is expected to follow the [code of
+conduct](https://github.com/[USERNAME]/usdt/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+require "rake/extensiontask"
+
+task :build => :compile
+
+Rake::ExtensionTask.new("stapsdt") do |ext|
+  ext.lib_dir = "lib/stapsdt"
+end
+
+task :default => [:clobber, :compile, :test]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "usdt"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/example.rb

@@ -0,0 +1,13 @@
+require 'stapsdt'
+
+puts "PID: #{Process.pid}"
+
+provider = StapSDT::Provider.new('example')
+
+probe = provider.add_probe("test", String, Integer)
+provider.load
+
+i = 0
+loop do
+    probe.fire("some string", i += 1)
+end

data/ext/stapsdt/extconf.rb

@@ -0,0 +1,19 @@
+require "mkmf"
+
+unless system("make", "-C", File.join(__dir__, "..", "libstapsdt"))
+    raise "Failed to compile libstapstd"
+end
+
+dir_config('libstapsdt',
+           [File.join(__dir__, '..', 'libstapsdt', 'src')],
+           [File.join(__dir__, '..', 'libstapsdt', 'out')])
+
+unless find_library('elf', 'elf_begin')
+    abort "cannot link to libelf"
+end
+
+unless find_library('stapsdt', 'probeIsEnabled')
+    abort "cannot link to libstapsdt.a"
+end
+
+create_makefile("stapsdt/stapsdt")

data/ext/stapsdt/stapsdt.c

@@ -0,0 +1,232 @@
+#include "stapsdt.h"
+
+VALUE rb_mProvider;
+VALUE rb_mProbe;
+VALUE rb_mStapSDT;
+
+typedef struct Provider
+{
+    SDTProvider_t* provider;
+} Provider_t;
+
+typedef struct Probe
+{
+    VALUE input_args[MAX_ARGUMENTS];
+    SDTProbe_t* probe;
+} Probe_t;
+
+void provider_free(Provider_t* wrap)
+{
+    providerDestroy(wrap->provider);
+    xfree(wrap);
+}
+
+VALUE provider_new(VALUE self, VALUE _name)
+{
+    char const* name = StringValueCStr(_name);
+    SDTProvider_t* provider = providerInit(name);
+    if (!provider)
+        rb_raise(rb_eRuntimeError, "could not create provider with name %s", name);
+
+    Provider_t* wrap = ALLOC(Provider_t);
+    wrap->provider = provider;
+    return rb_data_object_wrap(rb_mProvider, wrap, NULL, (RUBY_DATA_FUNC)provider_free);
+}
+
+void interpretError(int result, Provider_t* wrap)
+{
+    if (result != -1)
+        return;
+
+    if (wrap->provider->errno == noError)
+        return;
+
+    rb_raise(rb_eRuntimeError, "%s", wrap->provider->error);
+}
+
+VALUE provider_load(VALUE self)
+{
+    Provider_t* wrap;
+    Data_Get_Struct(self, Provider_t, wrap);
+    int result = providerLoad(wrap->provider);
+    interpretError(result, wrap);
+    return Qnil;
+}
+
+VALUE provider_unload(VALUE self)
+{
+    Provider_t* wrap;
+    Data_Get_Struct(self, Provider_t, wrap);
+    int result = providerUnload(wrap->provider);
+    interpretError(result, wrap);
+    return Qnil;
+}
+
+VALUE provider_add_probe(int argc, VALUE* argv, VALUE self)
+{
+    VALUE input_args[MAX_ARGUMENTS];
+    int args[MAX_ARGUMENTS];
+    if (argc < 1)
+        rb_raise(rb_eArgError, "expected at least 1 argument, got 0");
+    if (argc > MAX_ARGUMENTS + 1)
+        rb_raise(rb_eArgError,
+            "libstapstd only supports up to %i arguments, got %i",
+                MAX_ARGUMENTS, argc - 1);
+
+    for (int i = 0; i < argc - 1; ++i)
+    {
+        VALUE arg_type = argv[i + 1];
+        input_args[i] = arg_type;
+        if (arg_type == rb_cString || arg_type == rb_cFloat || arg_type == rb_cInteger)
+            args[i] = uint64;
+        else
+            args[i] = NUM2INT(arg_type);
+    }
+
+    char const* probe_name = StringValueCStr(argv[0]);
+
+    Provider_t* wrap;
+    Data_Get_Struct(self, Provider_t, wrap);
+
+    SDTProbe_t* probe = NULL;
+    if (argc == 1)
+        probe = providerAddProbe(wrap->provider, probe_name, 0);
+    else if (argc == 2)
+        probe = providerAddProbe(wrap->provider, probe_name, 1,
+            (ArgType_t)args[0]);
+    else if (argc == 3)
+        probe = providerAddProbe(wrap->provider, probe_name, 2,
+            (ArgType_t)args[0], (ArgType_t)args[1]);
+    else if (argc == 4)
+        probe = providerAddProbe(wrap->provider, probe_name, 3,
+            (ArgType_t)args[0], (ArgType_t)args[1], (ArgType_t)args[2]);
+    else if (argc == 5)
+        probe = providerAddProbe(wrap->provider, probe_name, 4,
+            (ArgType_t)args[0], (ArgType_t)args[1], (ArgType_t)args[2],
+            (ArgType_t)args[3]);
+    else if (argc == 6)
+        probe = providerAddProbe(wrap->provider, probe_name, 5,
+            (ArgType_t)args[0], (ArgType_t)args[1], (ArgType_t)args[2],
+            (ArgType_t)args[3], (ArgType_t)args[4]);
+    else if (argc == 7)
+        probe = providerAddProbe(wrap->provider, probe_name, 6,
+            (ArgType_t)args[0], (ArgType_t)args[1], (ArgType_t)args[2],
+            (ArgType_t)args[3], (ArgType_t)args[4], (ArgType_t)args[5]);
+
+    if (!probe)
+        rb_raise(rb_eArgError, "failed to create probe");
+
+    Probe_t* probe_wrap = ALLOC(Probe_t);
+    memcpy(probe_wrap->input_args, input_args, sizeof(VALUE)*(argc - 1));
+    probe_wrap->probe = probe;
+    /* NOTE: probes cannot be deallocated. They're freed when the provider is */
+    return rb_data_object_wrap(rb_mProbe, probe_wrap, NULL, NULL);
+}
+
+VALUE probe_fire(int argc, VALUE* argv, VALUE self)
+{
+
+    uint64_t args[MAX_ARGUMENTS];
+    VALUE block_args[MAX_ARGUMENTS];
+    VALUE* in_args;
+
+    Probe_t* wrap;
+    Data_Get_Struct(self, Probe_t, wrap);
+    int expected_argc = wrap->probe->argCount;
+
+    if (rb_block_given_p()) {
+        if (argc != 0)
+        {
+            rb_raise(rb_eArgError, "cannot provide arguments "\
+                "and block at the same time");
+        }
+
+        if (!probeIsEnabled(wrap->probe)) {
+            return Qfalse;
+        }
+
+        VALUE block_ret = rb_yield_values(0);
+        if (!NIL_P(block_ret)) {
+            argc = RARRAY_LEN(block_ret);
+            if (argc != expected_argc)
+                rb_raise(rb_eArgError, "expected %i argument(s), got %i",
+                    expected_argc, argc);
+
+            for (int i = 0; i < argc; ++i)
+                block_args[i] = rb_ary_entry(block_ret, i);
+
+            in_args = block_args;
+        }
+    }
+    else {
+        if (argc != expected_argc)
+            rb_raise(rb_eArgError, "expected %i argument(s), got %i",
+                expected_argc, argc);
+
+        in_args = argv;
+    }
+
+    for (int i = 0; i < argc; ++i)
+    {
+        if (wrap->input_args[i] == rb_cString)
+        {
+            char const* s = StringValueCStr(in_args[i]);
+            args[i] = *(uint64_t*)&s;
+        }
+        else if (wrap->input_args[i] == rb_cFloat)
+        {
+            double d = NUM2DBL(in_args[i]);
+            args[i] = *(uint64_t*)&d;
+        }
+        else
+            args[i] = NUM2ULL(in_args[i]);
+    }
+
+    if (argc == 0)
+        probeFire(wrap->probe);
+    if (argc == 1)
+        probeFire(wrap->probe, args[0]);
+    if (argc == 2)
+        probeFire(wrap->probe, args[0], args[1]);
+    if (argc == 3)
+        probeFire(wrap->probe, args[0], args[1], args[2]);
+    if (argc == 4)
+        probeFire(wrap->probe, args[0], args[1], args[2], args[3]);
+    if (argc == 5)
+        probeFire(wrap->probe, args[0], args[1], args[2], args[3], args[4]);
+    if (argc == 6)
+        probeFire(wrap->probe, args[0], args[1], args[2], args[3], args[4], args[5]);
+
+    return probeIsEnabled(wrap->probe) ? Qtrue : Qfalse;
+}
+
+VALUE probe_enabled_p(VALUE self)
+{
+    Probe_t* wrap;
+    Data_Get_Struct(self, Probe_t, wrap);
+    return probeIsEnabled(wrap->probe) ? Qtrue : Qfalse;
+}
+
+VALUE probe_name(VALUE self)
+{
+    Probe_t* wrap;
+    Data_Get_Struct(self, Probe_t, wrap);
+    return rb_str_new_cstr(wrap->probe->name);
+}
+
+void
+Init_stapsdt(void)
+{
+    rb_mStapSDT = rb_define_module("StapSDT");
+    rb_mProvider = rb_define_class_under(rb_mStapSDT, "Provider", rb_cObject);
+    rb_define_singleton_method(rb_mProvider, "new", provider_new, 1);
+    rb_define_method(rb_mProvider, "add_probe_c", provider_add_probe, -1);
+    rb_define_method(rb_mProvider, "load_c", provider_load, 0);
+    rb_define_method(rb_mProvider, "unload_c", provider_unload, 0);
+
+    rb_mProbe = rb_define_class_under(rb_mStapSDT, "Probe", rb_cObject);
+    rb_define_method(rb_mProbe, "fire", probe_fire, -1);
+    rb_define_method(rb_mProbe, "enabled?", probe_enabled_p, 0);
+    rb_define_method(rb_mProbe, "name", probe_name, 0);
+}
+

data/ext/stapsdt/stapsdt.h

@@ -0,0 +1,7 @@
+#ifndef STAPSDT_H
+#define STAPSDT_H 1
+
+#include "ruby.h"
+#include <libstapsdt.h>
+
+#endif /* USDT_H */

data/lib/stapsdt.rb

@@ -0,0 +1,23 @@
+require "stapsdt/version"
+require "stapsdt/stapsdt"
+require "stapsdt/provider"
+require "stapsdt/probe"
+
+# Runtime definition of StapSDT (Dtrace) probes on Linux
+#
+# To use, create a {StapSDT::Provider} instance, define probes with
+# {StapSDT::Provider#add_probe}. Once the provider is loaded with {Provider#load},
+# the StapSDT probes are available to tracing tools such as bcc's tplist and
+# trace. Within the program, the {Probe} objects returned by add_probe can be
+# fired with {Probe#fire}.
+module StapSDT
+    ARG_UINT8 = 1
+    ARG_INT8 = -1
+    ARG_UINT16 = 2
+    ARG_INT16 = -2
+    ARG_UINT32 = 4
+    ARG_INT32 = -4
+    ARG_UINT64 = 8
+    ARG_INT64 = -8
+end
+

data/lib/stapsdt/probe.rb

@@ -0,0 +1,17 @@
+module StapSDT
+    # A single USDT probe
+    #
+    # Probe objects are exclusively created with {Provider#add_probe}
+    class Probe
+        private_class_method :new
+
+        # @!method fire(*args)
+        #
+        # @param [Array] args arguments matching the types defined when
+        #   the probe was created
+
+        # @!method enabled?
+        #
+        # Whether the probe is being traced
+    end
+end

data/lib/stapsdt/provider.rb

@@ -0,0 +1,62 @@
+module StapSDT
+    # Collection of probes that can be activated and deactivated
+    #
+    # Providers are the entry point for probe definition
+    #
+    # After creation, probes are added with {#add_probe} and then
+    # activated with {#load}. Probes can only be defined before the
+    # provider gets loaded.
+    class Provider
+        class StateError < RuntimeError; end
+
+        def initialize
+            @loaded = false
+        end
+
+        # Whether this provider has been loaded
+        def loaded?
+            @loaded
+        end
+
+        private :load_c, :unload_c, :add_probe_c
+
+        # Load the provider
+        #
+        # @raise [StateError] if the provider was already loaded. Call
+        #   {#unload} first in this case
+        def load
+            raise StateError, "already loaded, call #unload first" if loaded?
+
+            load_c
+            @loaded = true
+        end
+
+        # Unloads the provider
+        #
+        # Does nothing if the provider was not yet loaded
+        def unload
+            return unless loaded?
+
+            unload_c
+            @loaded = false
+        end
+
+        # Add a new probe to this provider
+        #
+        # Probes must be added before the provider is loaded. Call {#unload} to
+        # add new probes to an already-loaded provider
+        #
+        # @param [String] probe_name the name of the probe
+        # @param [Array] arg_types the type of probe arguments.
+        #   It is either one of the ARG_ constants defined within {StapSDT},
+        #   or one of the Integer, Float and String classes.
+        # @return [Probe]
+        # @raise [StateError] if the provider was already loaded
+        def add_probe(probe_name, *arg_types)
+            if loaded?
+                raise StateError, "already loaded, call #unload before adding new probes"
+            end
+            add_probe_c(probe_name, *arg_types)
+        end
+    end
+end

data/lib/stapsdt/version.rb

@@ -0,0 +1,3 @@
+module StapSDT
+    VERSION = "0.1.0"
+end

data/stapsdt.gemspec

@@ -0,0 +1,30 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "stapsdt/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "stapsdt"
+  spec.version       = StapSDT::VERSION
+  spec.authors       = ["Sylvain Joyeux"]
+  spec.email         = ["sylvain.joyeux@13robotics.com"]
+
+  spec.summary       = %q{Define SDT (DTrace) probes at runtime in a Ruby program}
+  spec.homepage      = "https://github.com/rock-core/ruby-stapsdt"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/stapsdt/extconf.rb"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: stapsdt
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sylvain Joyeux
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  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'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: 
+email:
+- sylvain.joyeux@13robotics.com
+executables: []
+extensions:
+- ext/stapsdt/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".gitmodules"
+- ".rubocop.yml"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- example.rb
+- ext/stapsdt/extconf.rb
+- ext/stapsdt/stapsdt.c
+- ext/stapsdt/stapsdt.h
+- lib/stapsdt.rb
+- lib/stapsdt/probe.rb
+- lib/stapsdt/provider.rb
+- lib/stapsdt/version.rb
+- stapsdt.gemspec
+homepage: https://github.com/rock-core/ruby-stapsdt
+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.7.6
+signing_key: 
+specification_version: 4
+summary: Define SDT (DTrace) probes at runtime in a Ruby program
+test_files: []