tracecap_opentelemetry 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fde9ea889bca035b08e7ba5bf42789128c409610eba1b82571b269f5a9b42590
+  data.tar.gz: 96cdf9ad2854bea43bdd885020bf39186ec1cc21000a58ada3b2ab3f6a123e03
+SHA512:
+  metadata.gz: 89099e9f1000d1991df66175917ab6e9a79f643becbc4d38132d37be10309c508a0e670aca7e4ba6c4bf4a5e084644d11e054a7f03e256b53ae4a3df4296ed68
+  data.tar.gz: 56b336cb010aa999f965c43781fdb34f52de3abc8b3c7ddefaaf4361b91e77eb7c39d03bdfeee9a3bd28a67beb48b16525ae85e279e410186b21a8720abd2e07

data/.gitignore

@@ -0,0 +1,4 @@
+tmp
+*.gem
+*.bundle
+*.so

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    tracecap_opentelemetry (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    benchmark-ips (2.8.4)
+    rake (13.0.3)
+    rake-compiler (1.1.1)
+      rake
+
+PLATFORMS
+  ruby
+  x86_64-linux
+
+DEPENDENCIES
+  benchmark-ips
+  rake-compiler
+  tracecap_opentelemetry!
+
+BUNDLED WITH
+   2.2.9

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Theo Julienne
+
+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,36 @@
+# tracecap-ruby-opentelemetry
+
+Exports OpenTelemetry-compatible spans via USDT for tracecap ingestion.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tracecap_opentelemetry'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install tracecap_opentelemetry
+
+## Usage
+
+To emit traces, use `TracecapOpenTelemetry::Exporter` as an OpenTelemetry exporter. `TracecapOpenTelemetry::active?` can also be used to see if a tracer is listening.
+
+The spans can be traced directly with `dtrace`:
+```
+$ sudo dtrace -n 'ruby-span { trace(arg0); trace(copyinstr(arg1)); trace(copyinstr(arg2)); }'
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/tracecap/tracecap-ruby-opentelemetry.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,7 @@
+require "rake/extensiontask"
+require "bundler/gem_tasks"
+task :default => :spec
+
+Rake::ExtensionTask.new "tracecap_opentelemetry" do |ext|
+  ext.lib_dir = "lib/tracecap_opentelemetry"
+end

data/debug/benchmark.rb

@@ -0,0 +1,22 @@
+require 'benchmark/ips'
+require 'tracecap_opentelemetry'
+
+def recurse(n, &block)
+  if n > 0
+    recurse(n-1, &block)
+  else
+    block.call()
+  end
+end
+
+recurse(500) do # make the stack deep before benchmarking
+  Benchmark.ips do |x|
+    x.report("tracing") do
+      TracecapOpenTelemetry::emit_span(0, 0, "hello", "world", "{}")
+    end
+
+    x.report("active check") do
+      TracecapOpenTelemetry::active?
+    end
+  end
+end

data/ext/tracecap_opentelemetry/depend

@@ -0,0 +1,8 @@
+
+$(OBJS): $(HDRS) $(ruby_headers)
+
+probes.h: $(srcdir)/probes.d
+	dtrace -o probes.h -h -s $(srcdir)/probes.d
+
+probes.o: $(srcdir)/probes.d
+	dtrace -o probes.o -G -s $(srcdir)/probes.d

data/ext/tracecap_opentelemetry/extconf.rb

@@ -0,0 +1,15 @@
+require "mkmf"
+
+create_makefile "tracecap_opentelemetry/tracecap_opentelemetry"
+
+# patch in dtrace bits, since mkmf seems to be missing options to override this?
+
+new_mf = []
+File.open('Makefile', 'r') do |f|
+  f.each_line do |line|
+    line.gsub!(/^OBJS = /, 'OBJS = probes.o ') if RUBY_PLATFORM =~ /linux/
+    line.gsub!(/^HDRS = /, 'HDRS = probes.h ')
+    new_mf << line
+  end
+end
+File.write('Makefile', new_mf.join())

data/ext/tracecap_opentelemetry/probes.d

@@ -0,0 +1,12 @@
+provider tracecap_ruby_opentracing {
+  probe ruby__span(uint64_t duration, const char *component, const char *description, struct ruby_span_extra *context);
+};
+struct ruby_span_extra {
+  uint64_t ns_since_end;
+
+  uint64_t rb_stack_len;
+  const char *rb_stack;
+
+  uint64_t metadata_len;
+  const char *metadata;
+};

data/ext/tracecap_opentelemetry/tracecap_opentelemetry.c

@@ -0,0 +1,146 @@
+#include <sys/time.h>
+#include <signal.h>
+#include <pthread.h>
+
+#include <ruby/ruby.h>
+#include <ruby/debug.h>
+
+#include "probes.h"
+
+#define BUF_SIZE 2048
+
+struct ruby_span_extra {
+  uint64_t ns_since_end;
+
+  uint64_t rb_stack_len;
+  const char *rb_stack;
+
+  uint64_t metadata_len;
+  const char *metadata;
+};
+
+static struct {
+  VALUE stack_written_frames[BUF_SIZE];
+  int stack_written_lines[BUF_SIZE];
+  char *stack_written_offsets[BUF_SIZE];
+  int stack_last_depth;
+  char stack[81920];
+
+  VALUE frames_buffer[BUF_SIZE];
+  int lines_buffer[BUF_SIZE];
+} _tracecap_data;
+
+static inline uint64_t tracecap_update_stack()
+{
+  int num;
+  int stack_left = sizeof(_tracecap_data.stack);
+
+  // read in the latest set of frames/lines
+  num = rb_profile_frames(0, sizeof(_tracecap_data.frames_buffer) / sizeof(VALUE), _tracecap_data.frames_buffer, _tracecap_data.lines_buffer);
+
+  // work out how many are the same as previously calculated
+  int same = 0;
+  char *stack_curr = _tracecap_data.stack;
+  for (int i = 0; i < num && i < _tracecap_data.stack_last_depth; i++) {
+    if (_tracecap_data.frames_buffer[num - 1 - i] == _tracecap_data.stack_written_frames[i] && _tracecap_data.lines_buffer[num - 1 - i] == _tracecap_data.stack_written_lines[i])
+      same++;
+    else
+      break;
+  }
+
+  if (same > 0) {
+    stack_curr = _tracecap_data.stack_written_offsets[same - 1];
+    stack_left = (int)(_tracecap_data.stack + sizeof(_tracecap_data.stack) - stack_curr);
+  }
+
+  int i;
+  for (i = same; i < num; i++) {
+    VALUE frame = _tracecap_data.frames_buffer[num - 1 - i];
+    int line = _tracecap_data.lines_buffer[num - 1 - i];
+
+    _tracecap_data.stack_written_frames[i] = frame;
+    _tracecap_data.stack_written_lines[i] = line;
+
+    VALUE name = rb_profile_frame_full_label(frame);
+    VALUE file = rb_profile_frame_path(frame);
+    char *file_str = StringValueCStr(file);
+    char maybe_package[128] = {0};
+    char *gems_slash = strstr(file_str, "/gems/");
+    char *next = gems_slash;
+    
+    // find the last occurance of /gems/
+    while (next != NULL && *next != 0) {
+      next = strstr(next + 1, "/gems/");
+      if (next != NULL) {
+        gems_slash = next;
+      }
+    }
+
+    if (gems_slash != NULL) {
+      char *gem_name_start = gems_slash + strlen("/gems/");
+      char *inside_gem = strchr(gem_name_start, '/');
+      if (inside_gem != NULL) {
+        file_str = inside_gem + 1; // skip over '/'
+        snprintf(maybe_package, sizeof(maybe_package), "%.*s", (int)(inside_gem - gem_name_start), gem_name_start);
+      }
+    }
+
+    if (stack_left > 0) {
+      int n = snprintf(stack_curr, stack_left, "%s:%s:%d:%s\n", maybe_package, file_str, line, StringValueCStr(name));
+      stack_left -= n;
+      stack_curr += n;
+    } else {
+      break;
+    }
+
+    _tracecap_data.stack_written_offsets[i] = stack_curr;
+  }
+
+  *stack_curr = '\0';
+  _tracecap_data.stack_last_depth = i;
+
+  return (uint64_t)(stack_curr - _tracecap_data.stack);
+}
+
+VALUE rb_tracecap_emit_span(VALUE self, VALUE duration, VALUE since_end, VALUE component, VALUE description, VALUE metadata)
+{
+  if (TRACECAP_RUBY_OPENTRACING_RUBY_SPAN_ENABLED()) {
+    uint64_t duration_ns = NUM2ULL(duration);
+    uint64_t since_end_ns = NUM2ULL(since_end);
+    const char *component_c = StringValueCStr(component);
+    const char *description_c = StringValueCStr(description);
+
+    struct ruby_span_extra span_extra;
+
+    int stack_len = tracecap_update_stack();
+
+    /*
+      probe ruby__span(uint64_t duration, const char *component, const char *description, struct ruby_span_extra *context);
+      We could optionally adjust `since_end` here to compensate for any additional time spent in this function.
+    */
+    span_extra.ns_since_end = since_end_ns;
+    span_extra.rb_stack_len = stack_len;
+    span_extra.rb_stack = _tracecap_data.stack;
+    span_extra.metadata_len = (int)RSTRING_LEN(metadata);
+    span_extra.metadata = StringValuePtr(metadata);
+    TRACECAP_RUBY_OPENTRACING_RUBY_SPAN(duration_ns, component_c, description_c, &span_extra);
+  }
+  return Qnil;
+}
+
+VALUE
+rb_tracecap_is_active(VALUE self)
+{
+  return TRACECAP_RUBY_OPENTRACING_RUBY_SPAN_ENABLED() ? Qtrue : Qfalse;
+}
+
+void
+Init_tracecap_opentelemetry(void) {
+  VALUE tracecap_opentelemetry;
+
+  _tracecap_data.stack_last_depth = 0;
+
+  tracecap_opentelemetry = rb_const_get(rb_cObject, rb_intern("TracecapOpenTelemetry"));
+  rb_define_singleton_method(tracecap_opentelemetry, "emit_span", rb_tracecap_emit_span, 5);
+  rb_define_singleton_method(tracecap_opentelemetry, "active?", rb_tracecap_is_active, 0);
+}

data/lib/tracecap_opentelemetry.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "tracecap_opentelemetry/version"
+
+module TracecapOpenTelemetry
+end
+
+require "tracecap_opentelemetry/tracecap_opentelemetry"
+require "tracecap_opentelemetry/exporter"

data/lib/tracecap_opentelemetry/exporter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'opentelemetry/sdk'
+
+module TracecapOpenTelemetry
+  class Exporter < OpenTelemetry::SDK::Trace::Export::InMemorySpanExporter # pretend to be this for now for 'simple_exporter?' check
+    def initialize
+      @stopped = false
+    end
+
+    def export(spans, timeout: nil)
+      return FAILURE if @stopped
+
+      return SUCCESS unless TracecapOpenTelemetry::active?
+
+      Array(spans).each do |span|
+        tags = span.attributes
+        component = tags["db.system"] || tags["component"] || "Trace"
+
+        operation = span.name
+
+        context = tags.dup
+        context["span_id"] = span.hex_span_id
+        context["span_parent_id"] = span.hex_parent_span_id if span.hex_parent_span_id != "0000000000000000"
+        json_ctx = JSON.dump(context)
+
+        start_time_nsec = span.start_timestamp.to_i
+        end_time_nsec = span.end_timestamp.to_i
+        now_nsec = (Time.now.to_r * 1_000_000_000).to_i
+        duration = end_time_nsec - start_time_nsec
+        end_delta = now_nsec - end_time_nsec
+
+        TracecapOpenTelemetry::emit_span(duration, end_delta, component.to_s, operation.to_s, json_ctx)
+      end
+
+      SUCCESS
+    end
+
+    def force_flush(timeout: nil)
+      SUCCESS
+    end
+
+    def shutdown(timeout: nil)
+      @stopped = true
+      SUCCESS
+    end
+  end
+end

data/lib/tracecap_opentelemetry/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TracecapOpenTelemetry
+  VERSION = "0.1.0"
+end

data/tracecap_opentelementry.gemspec

@@ -0,0 +1,31 @@
+require_relative 'lib/tracecap_opentelemetry/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "tracecap_opentelemetry"
+  spec.version       = TracecapOpenTelemetry::VERSION
+  spec.authors       = ["Theo Julienne"]
+  spec.email         = ["theo.julienne@gmail.com"]
+
+  spec.summary       = %q{Exports OpenTelemetry spans via USDT for tracecap ingestion}
+  spec.homepage      = "https://github.com/tracecap/tracecap-ruby-opentelemetry"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/tracecap/tracecap-ruby-opentelemetry"
+
+  # 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/tracecap_opentelemetry/extconf.rb'
+
+  spec.add_development_dependency 'rake-compiler'
+  spec.add_development_dependency 'benchmark-ips'
+  
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: tracecap_opentelemetry
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Theo Julienne
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2021-08-18 00:00:00.000000000 Z
+dependencies:
+- !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: benchmark-ips
+  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'
+description: 
+email:
+- theo.julienne@gmail.com
+executables: []
+extensions:
+- ext/tracecap_opentelemetry/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- debug/benchmark.rb
+- ext/tracecap_opentelemetry/depend
+- ext/tracecap_opentelemetry/extconf.rb
+- ext/tracecap_opentelemetry/probes.d
+- ext/tracecap_opentelemetry/tracecap_opentelemetry.c
+- lib/tracecap_opentelemetry.rb
+- lib/tracecap_opentelemetry/exporter.rb
+- lib/tracecap_opentelemetry/version.rb
+- tracecap_opentelementry.gemspec
+homepage: https://github.com/tracecap/tracecap-ruby-opentelemetry
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/tracecap/tracecap-ruby-opentelemetry
+  source_code_uri: https://github.com/tracecap/tracecap-ruby-opentelemetry
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.9
+signing_key: 
+specification_version: 4
+summary: Exports OpenTelemetry spans via USDT for tracecap ingestion
+test_files: []