perfetto 0.1.15-x86_64-linux

data/lib/perfetto/configure.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Perfetto
+  # Global configuration
+  class Configure
+    extend Configurable
+
+    set :enable_tracing, false
+    set :enable_fiber, false
+    set :buffer_size_kb, 1024
+  end
+end

data/lib/perfetto/core_ext/configurable.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Copy-pasted from https://github.com/midori-rb/midori.rb/blob/master/lib/midori/core_ext/configurable.rb
+# rubocop:disable Style/OptionalBooleanParameter
+# rubocop:disable Style/DocumentDynamicEvalDefinition
+module Configurable
+  # Sets an option to the given value.
+  # @param [Symbol] option the name of config
+  # @param [Object] value value to the name
+  # @param [Boolean] read_only Generate option= method or not
+  # @return [nil] nil
+  def set(option, value = (not_set = true), read_only = false)
+    raise ArgumentError if not_set
+
+    setter = proc { |val| set option, val }
+    getter = proc { value }
+
+    define_singleton("#{option}=", setter) unless read_only
+    define_singleton(option, getter)
+    define_singleton("#{option}?", "!!#{option}") unless method_defined? "#{option}?"
+
+    self
+  end
+
+  private
+
+  # Dynamically defines a method on settings.
+  # @param [String] name method name
+  # @param [Proc] content method content
+  # @return [nil] nil
+  def define_singleton(name, content = Proc.new)
+    singleton_class.class_eval do
+      undef_method(name) if method_defined? name
+      if content.is_a?(String)
+        class_eval("def #{name}() #{content}; end", __FILE__,
+                   __LINE__ - 1)
+      else
+        define_method(name, &content)
+      end
+    end
+  end
+end
+
+# rubocop:enable Style/OptionalBooleanParameter
+# rubocop:enable Style/DocumentDynamicEvalDefinition

data/lib/perfetto/interceptor.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/AbcSize
+# rubocop:disable Metrics/MethodLength
+
+module Perfetto
+  # To intercept method calls in other classes
+  module Interceptor
+    def self.included(base)
+      if Perfetto::Configure.enable_tracing?
+        base.extend ImplMethods
+      else
+        base.extend StubMethods
+      end
+    end
+
+    # Stub methods
+    module StubMethods
+      def perfetto_trace_instance_method(_method_name); end
+      def perfetto_trace_class_method(_method_name); end
+      def perfetto_trace_all; end
+
+      def perfetto_traced_instance_method?(_method_name)
+        false
+      end
+
+      def perfetto_traced_class_method?(_method_name)
+        false
+      end
+
+      def perfetto_traced_instance_methods
+        []
+      end
+
+      def perfetto_traced_class_methods
+        []
+      end
+    end
+
+    # Real Implementation
+    module ImplMethods
+      def perfetto_trace_instance_method(method_name)
+        return if method_name.to_s.start_with? "_pfi_"
+
+        perfetto_traced_instance_methods << method_name
+
+        original_method = instance_method(method_name)
+        alias_method "_pfi_#{method_name}", method_name
+
+        define_method(method_name) do |*args, **kwargs, &block|
+          category = self.class.name
+          task_name = "#{self.class.name}##{method_name}"
+          Perfetto.trace_event_begin category, task_name
+          original_method.bind(self).call(*args, **kwargs, &block)
+        ensure
+          Perfetto.trace_event_end self.class.name
+        end
+      end
+
+      def perfetto_trace_class_method(method_name)
+        return if method_name.to_s.start_with? "_pfc_"
+
+        perfetto_traced_class_methods << method_name
+
+        original_method = singleton_class.instance_method(method_name)
+        singleton_class.send(:alias_method, "_pfc_#{method_name}", method_name)
+
+        define_singleton_method(method_name) do |*args, **kwargs, &block|
+          category = name
+          task_name = "#{name}::#{method_name}"
+          Perfetto.trace_event_begin category, task_name
+          original_method.bind(self).call(*args, **kwargs, &block)
+        ensure
+          Perfetto.trace_event_end name
+        end
+      end
+
+      def perfetto_trace_all
+        original_method_added = singleton_class.instance_method(:method_added)
+        define_singleton_method(:method_added) do |method_name|
+          original_method_added.bind(self).call(method_name)
+          return if perfetto_traced_instance_method?(method_name)
+
+          perfetto_trace_instance_method method_name
+        end
+
+        original_singleton_method_added = singleton_class.instance_method(:singleton_method_added)
+        define_singleton_method(:singleton_method_added) do |method_name|
+          original_singleton_method_added.bind(self).call(method_name)
+          return if perfetto_traced_class_method?(method_name)
+
+          perfetto_trace_class_method method_name
+        end
+      end
+
+      def perfetto_traced_instance_method?(method_name)
+        perfetto_traced_instance_methods.include? method_name
+      end
+
+      def perfetto_traced_class_method?(method_name)
+        perfetto_traced_class_methods.include? method_name
+      end
+
+      def perfetto_traced_instance_methods
+        @perfetto_traced_instance_methods ||= []
+      end
+
+      def perfetto_traced_class_methods
+        @perfetto_traced_class_methods ||= []
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/AbcSize
+# rubocop:enable Metrics/MethodLength

data/lib/perfetto/middleware.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Perfetto
+  # Rack middleware
+  class Middleware
+    def initialize(app, options = {})
+      @app = app
+      @options = options
+      @env_proc = options[:env_proc]
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def perfetto_traced_call(env)
+      category = "RackMiddleware"
+      method = env["REQUEST_METHOD"] || "UNKNOWN"
+      path = env["PATH_INFO"] || "UNKNOWN PATH"
+      task_name = "#{method} #{path}"
+      env_str = @env_proc&.call(env) || { env: "unknown" }.to_json
+
+      Perfetto.trace_event_begin_with_debug_info category, task_name, "env", env_str
+      begin
+        @app.call(env)
+      ensure
+        Perfetto.trace_event_end category
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def call(env)
+      if Perfetto::Configure.enable_tracing?
+        perfetto_traced_call(env)
+      else
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/perfetto/perfetto.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Ruby wrapper for native extension
+module Perfetto
+  class << self
+    alias start_tracing_native start_tracing
+    alias stop_tracing_native stop_tracing
+  end
+
+  if Perfetto::Configure.enable_tracing?
+    if Perfetto::Configure.enable_fiber?
+      class << self
+        # Replace thread based methods with fiber based methods
+        alias thread_trace_event_begin trace_event_begin
+        alias thread_trace_event_end trace_event_end
+        alias thread_trace_event_instant trace_event_instant
+        alias thread_trace_event_begin_with_debug_info trace_event_begin_with_debug_info
+        alias thread_trace_event_instant_with_debug_info trace_event_instant_with_debug_info
+
+        alias trace_event_begin fiber_trace_event_begin
+        alias trace_event_end fiber_trace_event_end
+        alias trace_event_instant fiber_trace_event_instant
+        alias trace_event_begin_with_debug_info fiber_trace_event_begin_with_debug_info
+        alias trace_event_instant_with_debug_info fiber_trace_event_instant_with_debug_info
+      end
+    end
+
+    # Default arguments implemented in this wrapper
+    def self.start_tracing
+      start_tracing_native Configure.buffer_size_kb
+    end
+
+    def self.stop_tracing(trace_file_name = "#{Time.now.strftime("%Y%m%d-%H-%M-%S")}.pftrace")
+      stop_tracing_native trace_file_name
+    end
+  else
+    # Stub methods
+    def self.start_tracing; end
+    def self.stop_tracing(trace_file_name = nil); end
+    def self.trace_event_begin(_class_name, _method_name); end
+    def self.trace_event_end(_class_name); end
+    def self.trace_counter(_class_name, _counter_name, _counter_value); end
+    def self.trace_counter_i64(_class_name, _counter_name, _counter_value); end
+    def self.trace_counter_double(_class_name, _counter_name, _counter_value); end
+    def self.trace_event_instant(_class_name, _method_name); end
+    def self.trace_event_begin_with_debug_info(_class_name, _method_name, _debug_key, _debug_value); end
+    def self.trace_event_instant_with_debug_info(_class_name, _method_name, _debug_key, _debug_value); end
+  end
+end

data/lib/perfetto/version.rb

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

data/lib/perfetto.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "perfetto/version"
+
+require_relative "perfetto/core_ext/configurable"
+require_relative "perfetto/configure"
+
+# Rack middleware
+require_relative "perfetto/middleware"
+
+# To minimize the overhead of tracing at runtime
+# we determine whether to enable instrumentations
+# at the first call to 'setup' method instead of
+# every call to bussiness logics being traced.
+module Perfetto
+  def self.setup(enable_tracing: nil, enable_fiber: nil, buffer_size_kb: nil)
+    Configure.enable_tracing = enable_tracing unless enable_tracing.nil?
+    Configure.enable_fiber = enable_fiber unless enable_fiber.nil?
+    Configure.buffer_size_kb = buffer_size_kb unless buffer_size_kb.nil?
+
+    # Native extension
+    require_relative "perfetto/perfetto_native"
+    # Ruby wrapper
+    require_relative "perfetto/perfetto"
+    # Instrumentation Helper
+    require_relative "perfetto/interceptor"
+  end
+end

data/perfetto.gemspec

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "lib/perfetto/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "perfetto"
+  spec.version = Perfetto::VERSION
+  spec.authors = ["Kowalski Dark"]
+  spec.email = ["github@akenonet.com"]
+
+  spec.summary = "Yet another event tracing library for Ruby."
+  spec.description = "Yet another event tracing library for Ruby."
+  spec.homepage = "https://github.com/yet-another-ai/perfetto.rb"
+  spec.required_ruby_version = ">= 3.3.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+
+  # 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(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = %w[lib ext]
+  spec.extensions = ["ext/perfetto/extconf.rb"]
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+  spec.metadata["rubygems_mfa_required"] = "true"
+end

data/sig/perfetto.rbs

@@ -0,0 +1,4 @@
+module Perfetto
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: perfetto
+version: !ruby/object:Gem::Version
+  version: 0.1.15
+platform: x86_64-linux
+authors:
+- Kowalski Dark
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-02-10 00:00:00.000000000 Z
+dependencies: []
+description: Yet another event tracing library for Ruby.
+email:
+- github@akenonet.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- README.md
+- Rakefile
+- example/example.png
+- example/example.rb
+- ext/perfetto/LICENSE
+- ext/perfetto/README.md
+- ext/perfetto/extconf.rb
+- ext/perfetto/perfetto.c
+- ext/perfetto/perfetto_internal.cc
+- ext/perfetto/perfetto_internal.h
+- ext/perfetto/sdk.cc
+- ext/perfetto/sdk.h
+- lib/perfetto.rb
+- lib/perfetto/configure.rb
+- lib/perfetto/core_ext/configurable.rb
+- lib/perfetto/interceptor.rb
+- lib/perfetto/middleware.rb
+- lib/perfetto/perfetto.rb
+- lib/perfetto/perfetto_native.so
+- lib/perfetto/version.rb
+- perfetto.gemspec
+- sig/perfetto.rbs
+homepage: https://github.com/yet-another-ai/perfetto.rb
+licenses: []
+metadata:
+  homepage_uri: https://github.com/yet-another-ai/perfetto.rb
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 3.4.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: Yet another event tracing library for Ruby.
+test_files: []