perfetto 0.1.0 → 0.1.2

data/lib/perfetto/configure.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Perfetto
+  # Global configuration
+  class Configure
+    extend Configurable
+
+    set :enable_tracing, 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,34 @@
+# frozen_string_literal: true
+
+module Perfetto
+  # To intercept method calls in other classes
+  module Interceptor
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Class methods for the interceptor
+    module ClassMethods
+      if Perfetto::Configure.enable_tracing
+        def pftrace(method_name)
+          original_method = instance_method(method_name)
+          alias_method "pftrace_#{method_name}", method_name
+          define_method(method_name) do |*args, **kwargs, &block|
+            Perfetto.trace_event_begin self.class.name, method_name.to_s
+            original_method.bind(self).call(*args, **kwargs, &block)
+            Perfetto.trace_event_end self.class.name
+          end
+        end
+
+        def pftrace_all
+          instance_methods(false).each do |method_name|
+            pftrace method_name
+          end
+        end
+      else # When tracing is disabled
+        def pftrace(_method_name); end
+        def pftrace_all; end
+      end
+    end
+  end
+end

data/lib/perfetto/perfetto.rb

@@ -0,0 +1,45 @@
+# 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
+    # 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
+
+    # Methods implemented in native extension
+    # We don't want to proxy these methods because they are called very frequently on hot paths
+    #   def self.start_tracing; end
+    #   def self.stop_tracing(_trace_file_name); 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
+  else
+    # Stub methods
+    def self.start_tracing; end
+    def self.stop_tracing(_trace_file_name); 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

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

data/lib/perfetto.rb

@@ -2,7 +2,23 @@
 
 require_relative "perfetto/version"
 
+require_relative "perfetto/core_ext/configurable"
+require_relative "perfetto/configure"
+
+# 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
-  class Error < StandardError; end
-  # Your code goes here...
+  def self.setup(enable_tracing: nil, buffer_size_kb: nil)
+    Configure.enable_tracing = enable_tracing unless enable_tracing.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

metadata

@@ -1,26 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: perfetto
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Kowalski Dark
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-01 00:00:00.000000000 Z
+date: 2024-01-02 00:00:00.000000000 Z
 dependencies: []
 description: Yet another event tracing library for Ruby.
 email:
 - github@akenonet.com
 executables: []
-extensions: []
+extensions:
+- ext/perfetto/extconf.rb
 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/perfetto.rb
 - lib/perfetto/version.rb
 - sig/perfetto.rbs
 homepage: https://github.com/yet-another-ai/perfetto.rb
@@ -32,6 +47,7 @@ post_install_message:
 rdoc_options: []
 require_paths:
 - lib
+- ext
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="