crystalruby 0.2.3 → 0.3.1

data/lib/crystalruby/library.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CrystalRuby
   class Library
     include Typemaps
@@ -8,7 +10,8 @@ module CrystalRuby
     CR_COMPILE_MUX = Mutex.new
     CR_ATTACH_MUX = Mutex.new
 
-    attr_accessor :name, :methods, :chunks, :root_dir, :lib_dir, :src_dir, :codegen_dir, :reactor
+    attr_accessor :name, :methods, :exposed_methods, :chunks, :root_dir,
+                  :lib_dir, :src_dir, :codegen_dir, :shards
 
     @libs_by_name = {}
 
@@ -29,7 +32,9 @@ module CrystalRuby
     def initialize(name)
       self.name = name
       self.methods = {}
+      self.exposed_methods = {}
       self.chunks = []
+      self.shards = {}
       initialize_library!
     end
 
@@ -44,7 +49,7 @@ module CrystalRuby
       ].each do |dir|
         FileUtils.mkdir_p(dir)
       end
-      IO.write  main_file, "require \"./#{config.crystal_codegen_dir}/index\"\n" unless File.exist?(main_file)
+      IO.write main_file, "require \"./#{config.crystal_codegen_dir}/index\"\n" unless File.exist?(main_file)
 
       return if File.exist?(shard_file)
 
@@ -56,7 +61,7 @@ module CrystalRuby
 
     # Generates and stores a reference to a new CrystalRuby::Function
     # and triggers the generation of the crystal code. (See write_chunk)
-    def crystalize_method(method, args, returns, function_body, async, &block)
+    def crystallize_method(method, args, returns, function_body, async, &block)
       CR_ATTACH_MUX.synchronize do
         methods.each_value(&:unattach!)
         method_key = "#{method.owner.name}/#{method.name}"
@@ -69,9 +74,26 @@ module CrystalRuby
           lib: self,
           &block
         ).tap do |func|
-          func.define_crystalized_methods!(self)
+          func.define_crystallized_methods!(self)
           func.register_custom_types!(self)
-          write_chunk(method.owner.name, method.name, func.chunk)
+          write_chunk(func.owner_name, method.name, func.chunk)
+        end
+      end
+    end
+
+    def expose_method(method, args, returns)
+      CR_ATTACH_MUX.synchronize do
+        methods.each_value(&:unattach!)
+        method_key = "#{method.owner.name}/#{method.name}"
+        methods[method_key] = Function.new(
+          method: method,
+          args: args,
+          returns: returns,
+          ruby: true,
+          lib: self
+        ).tap do |func|
+          func.register_custom_types!(self)
+          write_chunk(func.owner_name, method.name, func.ruby_interface)
         end
       end
     end
@@ -88,8 +110,8 @@ module CrystalRuby
       src_dir / "shard.yml"
     end
 
-    def crystalize_chunk(mod, chunk_name, body)
-      write_chunk(mod.name, chunk_name, body)
+    def crystallize_chunk(mod, chunk_name, body)
+      write_chunk(mod.respond_to?(:name) ? name : "main", chunk_name, body)
     end
 
     def instantiated?
@@ -102,7 +124,15 @@ module CrystalRuby
         file_digest = Digest::MD5.hexdigest chunk_data
         fname = chunk[:chunk_name]
         index_contents.include?("#{chunk[:module_name]}/#{fname}_#{file_digest}.cr")
-      end
+      end && shards_installed?
+    end
+
+    def shards_installed?
+      shard_file_content = nil
+      shards.all? do |k, v|
+        dependencies ||= shard_file_contents["dependencies"]
+        dependencies[k] == v
+      end && CrystalRuby::Compilation.shard_check?(src_dir)
     end
 
     def index_contents
@@ -112,50 +142,126 @@ module CrystalRuby
     end
 
     def register_type!(type)
-      @types_cache ||= {}
-      @types_cache[type.name] = type.type_defn
+      write_chunk("types", type.crystal_class_name, build_type(type.crystal_class_name, type.type_defn))
     end
 
-    def type_modules
-      (@types_cache || {}).map do |type_name, expr|
-        parts = type_name.split("::")
-        typedef = parts[0...-1].each_with_index.reduce("") do |acc, (part, index)|
-          acc + "#{"  " * index}module #{part}\n"
-        end
-        typedef += "#{"  " * (parts.size - 1)}alias #{parts.last} = #{expr}\n"
-        typedef + parts[0...-1].reverse.each_with_index.reduce("") do |acc, (_part, index)|
-          acc + "#{"  " * (parts.size - 2 - index)}end\n"
-        end
-      end.join("\n")
+    def build_type(type_name, expr)
+      parts = type_name.split("::")
+      typedef = parts[0...-1].each_with_index.reduce("") do |acc, (part, index)|
+        acc + "#{"  " * index}module #{part}\n"
+      end
+      typedef += "#{"  " * parts.size}#{expr}\n"
+      typedef + parts[0...-1].reverse.each_with_index.reduce("") do |acc, (_part, index)|
+        acc + "#{"  " * (parts.size - 2 - index)}end\n"
+      end
+    end
+
+    def shard_file_contents
+      @shard_file_contents ||= YAML.safe_load(IO.read(shard_file))
+    rescue StandardError
+      @shard_file_contents ||= { "name" => "src", "version" => "0.1.0", "dependencies" => {} }
+    end
+
+    def shard_file_contents=(contents)
+      IO.write(shard_file, JSON.load(contents.to_json).to_yaml)
+    end
+
+    def shard_dependencies
+      shard_file_contents["dependencies"] ||= {}
+    end
+
+    def require_shard(name, opts)
+      @shards[name.to_s] = JSON.parse(opts.merge("_crystalruby_managed" => true).to_json)
+      rewrite_shards_file!
+    end
+
+    def rewrite_shards_file!
+      dependencies = shard_dependencies
+
+      dirty = @shards.any? do |k, v|
+        dependencies[k] != v
+      end || (@shards.empty? && dependencies.any?)
+
+      return unless dirty
+
+      if @shards.empty?
+        shard_file_contents.delete("dependencies")
+      else
+        shard_file_contents["dependencies"] = @shards
+      end
+
+      self.shard_file_contents = shard_file_contents
     end
 
     def requires
-      chunks.map do |chunk|
-        chunk_data = chunk[:body]
-        file_digest = Digest::MD5.hexdigest chunk_data
-        fname = chunk[:chunk_name]
-        "require \"./#{chunk[:module_name]}/#{fname}_#{file_digest}.cr\"\n"
-      end.join("\n")
+      Template::Type.render({}) +
+        Template::Primitive.render({}) +
+        Template::FixedWidth.render({}) +
+        Template::VariableWidth.render({}) +
+        chunks.map do |chunk|
+          chunk_data = chunk[:body]
+          file_digest = Digest::MD5.hexdigest chunk_data
+          fname = chunk[:chunk_name]
+          "require \"./#{chunk[:module_name]}/#{fname}_#{file_digest}.cr\"\n"
+        end.join("\n") + shards.keys.map do |shard_name|
+                           "require \"#{shard_name}\"\n"
+                         end.join("\n")
     end
 
     def build!
       CR_COMPILE_MUX.synchronize do
-        File.write codegen_dir / "index.cr", Template::Index.render(
-          type_modules: type_modules,
-          requires: requires
-        )
-
+        File.write codegen_dir / "index.cr", Template::Index.render(requires: requires)
         unless compiled?
+          FileUtils.rm_f(lib_file)
+
+          if shard_dependencies.any? && shards.empty?
+            rewrite_shards_file!
+          end
+
+          CrystalRuby::Compilation.install_shards!(src_dir)
           CrystalRuby::Compilation.compile!(
             verbose: config.verbose,
             debug: config.debug,
             src: main_file,
-            lib: lib_file
+            lib: "#{lib_file}.part"
           )
+          FileUtils.mv("#{lib_file}.part", lib_file)
+          attach!
         end
       end
     end
 
+    def attach!
+      CR_ATTACH_MUX.synchronize do
+        lib_file = self.lib_file
+        lib_methods = methods
+        lib_methods.values.reject(&:ruby).each(&:attach_ffi_func!)
+        singleton_class.class_eval do
+          extend FFI::Library
+          ffi_lib lib_file
+          %i[yield init].each do |method_name|
+            singleton_class.undef_method(method_name) if singleton_class.method_defined?(method_name)
+            undef_method(method_name) if method_defined?(method_name)
+          end
+          attach_function :init, %i[string pointer pointer], :void
+          attach_function :yield, %i[], :int
+          lib_methods.each_value.select(&:ruby).each do |method|
+            attach_function :"register_#{method.name.to_s.gsub("?", "q").gsub("=", "eq").gsub("!", "bang")}_callback", %i[pointer], :void
+          end
+        end
+
+        if CrystalRuby.config.single_thread_mode
+          Reactor.init_single_thread_mode!
+        else
+          Reactor.start!
+        end
+
+        Reactor.schedule_work!(self, :init, name, Reactor::ERROR_CALLBACK, Types::Type::ARC_MUTEX.to_ptr, :void,
+                               blocking: true, async: false)
+        methods.values.select(&:ruby).each(&:register_callback!)
+      end
+    end
+
     def digest
       Digest::MD5.hexdigest(File.read(codegen_dir / "index.cr")) if File.exist?(codegen_dir / "index.cr")
     end
@@ -165,31 +271,31 @@ module CrystalRuby
     end
 
     def write_chunk(module_name, chunk_name, body)
+      module_name = module_name.gsub("::", "__MOD__")
       chunks.delete_if { |chnk| chnk[:module_name] == module_name && chnk[:chunk_name] == chunk_name }
-      chunks << { module_name: module_name, chunk_name: chunk_name, body: body }
+      chunk = { module_name: module_name, chunk_name: chunk_name, body: body }
+      chunks << chunk
       existing = Dir.glob(codegen_dir / "**/*.cr")
 
       current_index_contents = index_contents
-      chunks.each do |chunk|
-        module_name, chunk_name, body = chunk.values_at(:module_name, :chunk_name, :body)
+      module_name, chunk_name, body = chunk.values_at(:module_name, :chunk_name, :body)
 
-        file_digest = Digest::MD5.hexdigest body
-        filename = (codegen_dir / module_name / "#{chunk_name}_#{file_digest}.cr").to_s
+      file_digest = Digest::MD5.hexdigest body
+      filename = (codegen_dir / module_name / "#{chunk_name}_#{file_digest}.cr").to_s
 
-        unless current_index_contents.include?("#{module_name}/#{chunk_name}_#{file_digest}.cr")
-          methods.each_value(&:unattach!)
-          @compiled = false
-        end
+      unless current_index_contents.include?("#{module_name}/#{chunk_name}_#{file_digest}.cr")
+        methods.each_value(&:unattach!)
+        @compiled = false
+      end
 
-        unless existing.delete(filename)
-          FileUtils.mkdir_p(codegen_dir / module_name)
-          File.write(filename, body)
-        end
-        existing.select do |f|
-          f =~ /#{config.crystal_codegen_dir / module_name / "#{chunk_name}_[a-f0-9]{32}\.cr"}/
-        end.each do |fl|
-          File.delete(fl) unless fl.eql?(filename)
-        end
+      unless existing.delete(filename)
+        FileUtils.mkdir_p(codegen_dir / module_name)
+        File.write(filename, body)
+      end
+      existing.select do |f|
+        f =~ /#{config.crystal_codegen_dir / module_name / "#{chunk_name}_[a-f0-9]{32}\.cr"}/
+      end.each do |fl|
+        File.delete(fl) unless fl.eql?(filename)
       end
     end
   end

data/lib/crystalruby/reactor.rb

@@ -1,13 +1,17 @@
 module CrystalRuby
+  require 'json'
   # The Reactor represents a singleton Thread responsible for running all Ruby/crystal interop code.
   # Crystal's Fiber scheduler and GC assume all code is run on a single thread.
-  # This class is responsible for multiplexing Ruby and Crystal code on a single thread.
-  # Functions annotated with async: true, are executed using callbacks to allow these to be interleaved without blocking.
-
+  # This class is responsible for multiplexing Ruby and Crystal code onto a single thread.
+  # Functions annotated with async: true, are executed using callbacks to allow these to be interleaved
+  # without blocking multiple Ruby threads.
   module Reactor
     module_function
 
     class SingleThreadViolation < StandardError; end
+    class StopReactor < StandardError; end
+
+    @single_thread_mode = false
 
     REACTOR_QUEUE = Queue.new
 
@@ -39,13 +43,15 @@ module CrystalRuby
       end
     end
 
-    ERROR_CALLBACK = FFI::Function.new(:void, %i[string string int]) do |error_type, message, tid|
+    ERROR_CALLBACK = FFI::Function.new(:void, %i[string string string int]) do |error_type, message, backtrace, tid|
       error_type = error_type.to_sym
       is_exception_type = Object.const_defined?(error_type) && Object.const_get(error_type).ancestors.include?(Exception)
       error_type = is_exception_type ? Object.const_get(error_type) : RuntimeError
-      raise error_type.new(message) unless THREAD_MAP.key?(tid)
+      error = error_type.new(message)
+      error.set_backtrace(JSON.parse(backtrace))
+      raise error  unless THREAD_MAP.key?(tid)
 
-      THREAD_MAP[tid][:error] = error_type.new(message)
+      THREAD_MAP[tid][:error] = error
       THREAD_MAP[tid][:result] = nil
       THREAD_MAP[tid][:cond].signal
     end
@@ -55,20 +61,41 @@ module CrystalRuby
     end
 
     def await_result!
-      mux, cond = thread_conditions.values_at(:mux, :cond)
-      cond.wait(mux)
-      raise THREAD_MAP[thread_id][:error] if THREAD_MAP[thread_id][:error]
+      mux, cond, result, err = thread_conditions.values_at(:mux, :cond, :result, :error)
+      cond.wait(mux) unless (result || err)
+      result, err, thread_conditions[:result], thread_conditions[:error] = thread_conditions.values_at(:result, :error)
+      if err
+        combined_backtrace = err.backtrace[0..(err.backtrace.index{|m| m.include?('call_blocking_function')} || 2) - 3] + caller[5..-1]
+        err.set_backtrace(combined_backtrace)
+        raise err
+      end
+
+      result
+    end
+
+    def halt_loop!
+      raise StopReactor
+    end
 
-      THREAD_MAP[thread_id][:result]
+    def stop!
+      if @main_loop
+        schedule_work!(self, :halt_loop!, :void, blocking: true, async: false)
+        @main_loop.join
+        @main_loop = nil
+        CrystalRuby.log_info "Reactor loop stopped"
+      end
     end
 
     def start!
       @main_loop ||= Thread.new do
+        @main_thread_id = Thread.current.object_id
         CrystalRuby.log_debug("Starting reactor")
         CrystalRuby.log_debug("CrystalRuby initialized")
-        loop do
-          REACTOR_QUEUE.pop[]
+        while true
+          handler, *args = REACTOR_QUEUE.pop
+          send(handler, *args)
         end
+      rescue StopReactor => e
       rescue StandardError => e
         CrystalRuby.log_error "Error: #{e}"
         CrystalRuby.log_error e.backtrace
@@ -80,26 +107,40 @@ module CrystalRuby
     end
 
     def yield!(lib: nil, time: 0.0)
-      schedule_work!(lib, :yield, nil, async: false, blocking: false, lib: lib) if running? && lib
+      schedule_work!(lib, :yield, :int, async: false, blocking: false, lib: lib) if running? && lib
       nil
     end
 
-    def current_thread_id=(val)
-      @current_thread_id = val
+    def invoke_async!(receiver, op_name, *args, thread_id, callback, lib)
+      receiver.send(op_name, *args, thread_id, callback)
+      yield!(lib: lib, time: 0)
     end
 
-    def current_thread_id
-      @current_thread_id
+    def invoke_blocking!(receiver, op_name, *args, tvars)
+      tvars[:error] = nil
+      begin
+        tvars[:result] = receiver.send(op_name, *args)
+      rescue StopReactor => e
+        tvars[:cond].signal
+        raise
+      rescue StandardError => e
+        tvars[:error] = e
+      end
+      tvars[:cond].signal
+    end
+
+    def invoke_await!(receiver, op_name, *args, lib)
+      outstanding_jobs = receiver.send(op_name, *args)
+      yield!(lib: lib, time: 0) unless outstanding_jobs == 0
     end
 
     def schedule_work!(receiver, op_name, *args, return_type, blocking: true, async: true, lib: nil)
-      if @single_thread_mode
+      if @single_thread_mode || (Thread.current.object_id == @main_thread_id && op_name != :yield)
         unless Thread.current.object_id == @main_thread_id
           raise SingleThreadViolation,
                 "Single thread mode is enabled, cannot run in multi-threaded mode. " \
                 "Reactor was started from: #{@main_thread_id}, then called from #{Thread.current.object_id}"
         end
-
         return receiver.send(op_name, *args)
       end
 
@@ -107,31 +148,9 @@ module CrystalRuby
       tvars[:mux].synchronize do
         REACTOR_QUEUE.push(
           case true
-          when async
-            lambda {
-              receiver.send(
-                op_name, *args, tvars[:thread_id],
-                CALLBACKS_MAP[return_type]
-              )
-              yield!(lib: lib, time: 0)
-            }
-          when blocking
-            lambda {
-              tvars[:error] = nil
-              Reactor.current_thread_id = tvars[:thread_id]
-              begin
-                result = receiver.send(op_name, *args)
-              rescue StandardError => e
-                tvars[:error] = e
-              end
-              tvars[:result] = result unless tvars[:error]
-              tvars[:cond].signal
-            }
-          else
-            lambda {
-              outstanding_jobs = receiver.send(op_name, *args)
-              yield!(lib: lib, time: 0) unless outstanding_jobs == 0
-            }
+          when async then [:invoke_async!, receiver, op_name, *args, tvars[:thread_id], CALLBACKS_MAP[return_type], lib]
+          when blocking then [:invoke_blocking!, receiver, op_name, *args, tvars]
+          else [:invoke_await!, receiver, op_name, *args, lib]
           end
         )
         return await_result! if blocking

data/lib/crystalruby/source_reader.rb

@@ -0,0 +1,92 @@
+module CrystalRuby
+  module SourceReader
+    module_function
+
+    # Reads code line by line from a given source location and returns the first valid Ruby expression found
+    def extract_expr_from_source_location(source_location)
+      lines = source_location.then{|f,l| IO.readlines(f)[l-1..]}
+      lines[0] = lines[0][/CRType.*/] if lines[0] =~ /<\s+CRType/ || lines[0] =~ /= CRType/
+      lines.each.with_object([]) do |line, expr_source|
+        break expr_source.join("") if (Prism.parse((expr_source << line).join("")).success?)
+      end
+    rescue
+      raise "Failed to extract expression from source location: #{source_location}. Ensure the file exists and the line number is correct. Extraction from a REPL is not supported"
+    end
+
+    def search_node(result, node_type)
+      result.breadth_first_search do |node|
+        node_type === node
+      end
+    end
+
+    # Given a proc, extracts the source code of the block passed to it
+    # If raw is true, the source is expected to be Raw Crystal code captured
+    # in a string or Heredoc literal. Otherwise the Ruby code (assumed to be valid Crystal)
+    # is extracted.
+    def extract_source_from_proc(block, raw: false)
+      block_source = extract_expr_from_source_location(block.source_location)
+      parsed_source = Prism.parse(block_source).value
+
+      node = parsed_source.statements.body[0].arguments&.arguments&.find{|x| search_node(x, Prism::StatementsNode) }
+      node ||= parsed_source.statements.body[0]
+      body_node =  search_node(node, Prism::StatementsNode)
+
+      return raw ?
+        extract_raw_string_node(body_node) :
+        node_to_s(body_node)
+    end
+
+    def extract_raw_string_node(node)
+      search_node(node, Prism::InterpolatedStringNode)&.parts&.map(&:unescaped)&.join("") ||
+      search_node(node, Prism::StringNode).unescaped
+    end
+
+
+    # Simple helper function to turn a SyntaxTree node back into a Ruby string
+    # The default formatter will turn a break/return of [1,2,3] into a brackless 1,2,3
+    # Can't have that in Crystal as it turns it into a Tuple
+    def node_to_s(node)
+      node&.slice || ''
+    end
+
+    # Given a method, extracts the source code of the block passed to it
+    # and also converts any keyword arguments given in the method definition as a
+    # named map of keyword names to Crystal types.
+    # Also supports basic ffi symbol types.
+    #
+    # E.g.
+    #
+    # def add a: Int32 | Int64, b: :int
+    #
+    # The above will be converted to:
+    # {
+    #   a: Int32 | Int64, # Int32 | Int64 is a Crystal type
+    #   b: :int           # :int is an FFI type shorthand
+    # }
+    # If raw is true, the source is expected to be Raw Crystal code captured
+    # in a string or Heredoc literal. Otherwise the Ruby code (assumed to be valid Crystal)
+    # is extracted.
+    def extract_args_and_source_from_method(method, raw: false)
+      method_source = extract_expr_from_source_location(method.source_location)
+      parsed_source = Prism.parse(method_source).value
+      params =  search_node(parsed_source, Prism::ParametersNode)
+      args = params ? params.keywords.map{|kw| [kw.name, node_to_s(kw.value)] }.to_h : {}
+      body_node =  parsed_source.statements.body[0].body
+      if body_node.respond_to?(:rescue_clause) && body_node.rescue_clause
+        wrapped = %{begin\n#{body_node.statements.slice}\n#{body_node.rescue_clause.slice}\nend}
+        body_node = Prism.parse(wrapped).value
+      end
+      body = raw ?  extract_raw_string_node(body_node) : node_to_s(body_node)
+
+      args.transform_values! do |type_exp|
+        if CrystalRuby::Typemaps::CRYSTAL_TYPE_MAP.key?(type_exp[1..-1].to_sym)
+          type_exp[1..-1].to_sym
+        else
+          TypeBuilder.build_from_source(type_exp, context: method.owner)
+        end
+      end.to_h
+      return args, body
+    end
+
+  end
+end

data/lib/crystalruby/template.rb

@@ -1,12 +1,23 @@
 module CrystalRuby
   module Template
-    Dir[File.join(File.dirname(__FILE__), "templates", "*.cr")].each do |file|
+    class Renderer < Struct.new(:raw_value)
+      require 'erb'
+      def render(context)
+        if context.kind_of?(::Hash)
+          raw_value % context
+        else
+          ERB.new(raw_value, trim_mode: "%").result(context)
+        end
+      end
+    end
+
+    (
+      Dir[File.join(File.dirname(__FILE__), "templates", "**", "*.cr")] +
+      Dir[File.join(File.dirname(__FILE__), "types", "**", "*.cr")]
+    ).each do |file|
       template_name = File.basename(file, File.extname(file)).split("_").map(&:capitalize).join
       template_value = File.read(file)
-      template_value.define_singleton_method(:render) do |context|
-        self % context
-      end
-      const_set(template_name, template_value)
+      const_set(template_name, Renderer.new(template_value))
     end
   end
 end

data/lib/crystalruby/templates/function.cr

@@ -3,8 +3,8 @@
 # Crystal code can simply call this method directly, enabling generated crystal code
 # to call other generated crystal code without overhead.
 
-module %{module_name}
-  def self.%{fn_name}(%{fn_args}) : %{fn_ret_type}
+%{module_or_class} %{module_name} %{superclass}
+  def %{fn_scope}%{fn_name}(%{fn_args}) : %{fn_ret_type}
     %{fn_body}
   end
 end
@@ -16,13 +16,13 @@ fun %{lib_fn_name}(%{lib_fn_args}): %{lib_fn_ret_type}
   begin
     %{convert_lib_args}
     begin
-      return_value = %{module_name}.%{fn_name}(%{arg_names})
+      return_value = %{receiver}.%{fn_name}(%{arg_names})%{block_converter}
       return %{convert_return_type}
     rescue ex
-      CrystalRuby.report_error("RuntimeError", ex.message.to_s, 0)
+      CrystalRuby.report_error("RuntimeError", ex.message.to_s, ex.backtrace.to_json, 0)
     end
   rescue ex
-    CrystalRuby.report_error("ArgumentError", ex.message.to_s, 0)
+    CrystalRuby.report_error("ArgumentError", ex.message.to_s, ex.backtrace.to_json, 0)
   end
   return %{error_value}
 end
@@ -37,25 +37,26 @@ fun %{lib_fn_name}_async(%{lib_fn_args} thread_id: UInt32,  callback : %{callbac
     CrystalRuby.increment_task_counter
     spawn do
       begin
-        return_value = %{module_name}.%{fn_name}(%{arg_names})
-        converted = %{convert_return_type}
+        return_value = %{receiver}.%{fn_name}(%{arg_names})%{block_converter}
         CrystalRuby.queue_callback(->{
+          converted = %{convert_return_type}
           %{callback_call}
           CrystalRuby.decrement_task_counter
         })
       rescue ex
         exception = ex.message.to_s
+        backtrace = ex.backtrace.to_json
         CrystalRuby.queue_callback(->{
-          CrystalRuby.error_callback.call("RuntimeError".to_unsafe, exception.to_unsafe, thread_id)
+          CrystalRuby.report_error("RuntimeError", exception, backtrace, thread_id)
           CrystalRuby.decrement_task_counter
         })
       end
     end
   rescue ex
-
     exception = ex.message.to_s
+    backtrace = ex.backtrace.to_json
     CrystalRuby.queue_callback(->{
-      CrystalRuby.error_callback.call("RuntimeError".to_unsafe, ex.message.to_s.to_unsafe, thread_id)
+      CrystalRuby.report_error("RuntimeError", ex.message.to_s, backtrace, thread_id)
       CrystalRuby.decrement_task_counter
     })
   end