telebugs 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 14237978a4696093518f0a95eefa25363b7f6adaa2acc1c02d5e8cfcddb63b93
+  data.tar.gz: 61c664b448c4098fabdf4d49684f49b18494ec0e16e8d6dea5e7043cad19e8bf
+SHA512:
+  metadata.gz: eef345a4aaf248ce14462ed2cfeaf6ef6b410c42b377b911bf47a48dd2742c401af8c16fa3680c229e1a6235e963937fcdfd17494dae039fc39b93f7785f783e
+  data.tar.gz: ebe99794663078f5d9a8528eeb71d5dec959bb937787fde07ae242e4060738ac013fbbf0a9710506fd0e0bf04b7fb003ac8ed8938857181b4e61e3ee345eb397

data/.standard.yml

@@ -0,0 +1 @@
+ruby_version: 3.0

data/LICENSE.md

@@ -0,0 +1,20 @@
+# The MIT License
+
+Copyright © 2024 Telebugs
+
+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,95 @@
+# Telebugs for Ruby
+
+Simple error monitoring for developers. Monitor production errors in real-time
+and get them reported to Telegram with Telebugs.
+
+- [FAQ](https://telebugs.com/faq)
+- [Telebugs News](https://t.me/TelebugsNews)
+- [Telebugs Community](https://t.me/TelebugsCommunity)
+
+## Introduction
+
+Any Ruby application or script can be integrated with
+[Telebugs](https://telebugs.com) using the `telebugs` gem. The gem is designed
+to be simple and easy to use. It provides a simple API to send errors to
+Telebugs, which will then be reported to your Telegram project. This guide will
+help you get started with Telebugs for Ruby.
+
+For full details, please refer to the [Telebugs documentation](https://telebugs.com/new/docs/integrations/ruby).
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```sh
+bundle add telebugs
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```sh
+gem install telebugs
+```
+
+## Usage
+
+This is the minimal example that you can use to test Telebugs for Ruby with your
+project:
+
+```rb
+require "telebugs"
+
+Telebugs.configure do |c|
+  c.api_key = "YOUR_API_KEY"
+end
+
+begin
+  1 / 0
+rescue ZeroDivisionError => e
+  Telebugs.notify(error: e)
+end
+
+sleep 2
+
+puts "An error was sent to Telebugs asynchronously.",
+  "It will appear in your dashboard shortly.",
+  "A notification was also sent to your Telegram chat."
+```
+
+Replace `YOUR_API_KEY` with your actual API key. You can ask
+[@TelebugsBot](http://t.me/TelebugsBot) for your API key or find it in
+your project's dashboard.
+
+## Telebugs for Ruby integrations
+
+Telebugs for Ruby is a standalone gem that can be used with any Ruby application
+or script. It can be integrated with any Ruby framework or library.
+
+We provide official integrations for the following Ruby platforms:
+
+- [Ruby on Rails](https://github.com/telebugs/telebugs-rails)
+
+## Ruby support policy
+
+Telebugs for Ruby supports the following Ruby versions:
+
+- Ruby 3.0+
+
+If you need support older rubies or other Ruby implementations, please contact
+us at [help@telebugs.com](mailto:help@telebugs.com).
+
+## 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 the created tag, 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/telebugs/telebugs-ruby.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+task default: :test

data/lib/telebugs/backtrace.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Telebugs
+  # Represents a cross-Ruby backtrace from exceptions (including JRuby Java
+  # exceptions). Provides information about stack frames (such as line number,
+  # file and method) in convenient for Telebugs format.
+  module Backtrace
+    module Patterns
+      # The pattern that matches standard Ruby stack frames, such as
+      # ./spec/report_spec.rb:43:in `block (3 levels) in <top (required)>'
+      RUBY = %r{\A
+        (?<file>.+)       # Matches './spec/report_spec.rb'
+        :
+        (?<line>\d+)      # Matches '43'
+        :in\s
+        `(?<function>.*)' # Matches "`block (3 levels) in <top (required)>'"
+      \z}x
+
+      # The pattern that matches JRuby Java stack frames, such as
+      # org.jruby.ast.NewlineNode.interpret(NewlineNode.java:105)
+      JAVA = %r{\A
+        (?<function>.+)  # Matches 'org.jruby.ast.NewlineNode.interpret'
+        \(
+          (?<file>
+            (?:uri:classloader:/.+(?=:)) # Matches '/META-INF/jruby.home/protocol.rb'
+            |
+            (?:uri_3a_classloader_3a_.+(?=:)) # Matches 'uri_3a_classloader_3a_/gems/...'
+            |
+            [^:]+        # Matches 'NewlineNode.java'
+          )
+          :?
+          (?<line>\d+)?  # Matches '105'
+        \)
+      \z}x
+
+      # The pattern that tries to assume what a generic stack frame might look
+      # like, when exception's backtrace is set manually.
+      GENERIC = %r{\A
+        (?:from\s)?
+        (?<file>.+)              # Matches '/foo/bar/baz.ext'
+        :
+        (?<line>\d+)?            # Matches '43' or nothing
+        (?:
+          in\s`(?<function>.+)'  # Matches "in `func'"
+        |
+          :in\s(?<function>.+)   # Matches ":in func"
+        )?                       # ... or nothing
+      \z}x
+
+      # The pattern that matches exceptions from PL/SQL such as
+      # ORA-06512: at "STORE.LI_LICENSES_PACK", line 1945
+      # @note This is raised by https://github.com/kubo/ruby-oci8
+      OCI = /\A
+        (?:
+          ORA-\d{5}
+          :\sat\s
+          (?:"(?<function>.+)",\s)?
+          line\s(?<line>\d+)
+        |
+          #{GENERIC}
+        )
+      \z/x
+
+      # The pattern that matches CoffeeScript backtraces usually coming from
+      # Rails & ExecJS
+      EXECJS = /\A
+        (?:
+          # Matches 'compile ((execjs):6692:19)'
+          (?<function>.+)\s\((?<file>.+):(?<line>\d+):\d+\)
+        |
+          # Matches 'bootstrap_node.js:467:3'
+          (?<file>.+):(?<line>\d+):\d+(?<function>)
+        |
+          # Matches the Ruby part of the backtrace
+          #{RUBY}
+        )
+      \z/x
+    end
+
+    def self.parse(error)
+      return [] if error.backtrace.nil? || error.backtrace.none?
+
+      parse_backtrace(error)
+    end
+
+    # Checks whether the given exception was generated by JRuby's VM.
+    def self.java_exception?(error)
+      if defined?(Java::JavaLang::Throwable) &&
+          error.is_a?(Java::JavaLang::Throwable)
+        return true
+      end
+
+      return false unless error.respond_to?(:backtrace)
+
+      (Patterns::JAVA =~ error.backtrace.first) != nil
+    end
+
+    class << self
+      private
+
+      def best_regexp_for(error)
+        if java_exception?(error)
+          Patterns::JAVA
+        elsif oci_exception?(error)
+          Patterns::OCI
+        elsif execjs_exception?(error)
+          Patterns::EXECJS
+        else
+          Patterns::RUBY
+        end
+      end
+
+      def oci_exception?(error)
+        defined?(OCIError) && error.is_a?(OCIError)
+      end
+
+      def execjs_exception?(error)
+        return false unless defined?(ExecJS::RuntimeError)
+        return true if error.is_a?(ExecJS::RuntimeError)
+        return true if error.cause&.is_a?(ExecJS::RuntimeError)
+
+        false
+      end
+
+      def stack_frame(regexp, stackframe)
+        if (match = match_frame(regexp, stackframe))
+          return {
+            file: match[:file],
+            line: (Integer(match[:line]) if match[:line]),
+            function: match[:function]
+          }
+        end
+
+        {file: nil, line: nil, function: stackframe}
+      end
+
+      def match_frame(regexp, stackframe)
+        match = regexp.match(stackframe)
+        return match if match
+
+        Patterns::GENERIC.match(stackframe)
+      end
+
+      def parse_backtrace(error)
+        regexp = best_regexp_for(error)
+
+        error.backtrace.map.with_index do |stackframe, i|
+          frame = stack_frame(regexp, stackframe)
+          next(frame) unless frame[:file]
+
+          frame
+        end
+      end
+    end
+  end
+end

data/lib/telebugs/code_hunk.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Telebugs
+  # Represents a small hunk of code consisting of a base line and a couple lines
+  # around it
+  class CodeHunk
+    MAX_LINE_LEN = 200
+
+    # How many lines should be read around the base line.
+    AROUND_LINES = 2
+
+    def self.get(file, line)
+      start_line = [line - AROUND_LINES, 1].max
+
+      lines = get_lines(file, start_line, line + AROUND_LINES)
+      return {start_line: 0, lines: []} if lines.empty?
+
+      {
+        start_line: start_line,
+        lines: lines
+      }
+    end
+
+    private_class_method def self.get_lines(file, start_line, end_line)
+      lines = []
+      return lines unless (cached_file = get_from_cache(file))
+
+      cached_file.with_index(1) do |l, i|
+        next if i < start_line
+        break if i > end_line
+
+        lines << l[0...MAX_LINE_LEN].rstrip
+      end
+
+      lines
+    end
+
+    private_class_method def self.get_from_cache(file)
+      Telebugs::FileCache[file] ||= File.foreach(file)
+    rescue
+      nil
+    end
+  end
+end

data/lib/telebugs/config.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Telebugs
+  # Represents the Telebugs config. A config contains all the options that you
+  # can use to configure a +Telebugs::Notifier+ instance.
+  class Config
+    ERROR_API_URL = "https://api.telebugs.com/2024-03-28/errors"
+
+    attr_accessor :api_key,
+      :root_directory,
+      :middleware
+
+    attr_reader :api_url
+
+    class << self
+      attr_writer :instance
+
+      def instance
+        @instance ||= new
+      end
+    end
+
+    def initialize
+      reset
+    end
+
+    def api_url=(url)
+      @api_url = URI(url)
+    end
+
+    def reset
+      self.api_key = nil
+      self.api_url = ERROR_API_URL
+      self.root_directory = File.realpath(
+        (defined?(Bundler) && Bundler.root) ||
+        Dir.pwd
+      )
+
+      @middleware = MiddlewareStack.new
+    end
+  end
+end

data/lib/telebugs/error_message.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Telebugs
+  # Parses error messages to make them more consistent.
+  module ErrorMessage
+    # On Ruby 3.1+, the error highlighting gem can produce messages that can
+    # span over multiple lines. We don't want to display multiline error titles.
+    # Therefore, we want to strip out the higlighting part so that the errors
+    # look consistent.
+    RUBY_31_ERROR_HIGHLIGHTING_DIVIDER = "\n\n"
+
+    # The options for +String#encode+
+    ENCODING_OPTIONS = {invalid: :replace, undef: :replace}.freeze
+
+    def self.parse(error)
+      return unless (msg = error.message)
+
+      msg.encode(Encoding::UTF_8, **ENCODING_OPTIONS)
+        .split(RUBY_31_ERROR_HIGHLIGHTING_DIVIDER)
+        .first
+    end
+  end
+end

data/lib/telebugs/file_cache.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Telebugs
+  module FileCache
+    MAX_SIZE = 50
+    MUTEX = Mutex.new
+
+    # Associates the value given by +value+ with the key given by +key+. Deletes
+    # entries that exceed +MAX_SIZE+.
+    def self.[]=(key, value)
+      MUTEX.synchronize do
+        data[key] = value
+        data.delete(data.keys.first) if data.size > MAX_SIZE
+      end
+    end
+
+    # Retrieve an object from the cache.
+    def self.[](key)
+      MUTEX.synchronize do
+        data[key]
+      end
+    end
+
+    # Checks whether the cache is empty. Needed only for the test suite.
+    def self.empty?
+      MUTEX.synchronize do
+        data.empty?
+      end
+    end
+
+    def self.reset
+      MUTEX.synchronize do
+        @data = {}
+      end
+    end
+
+    private_class_method def self.data
+      @data ||= {}
+    end
+  end
+end

data/lib/telebugs/middleware.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Telebugs
+  # Represents a middleware that can be used to filter out errors.
+  # You must inherit from this class and implement the #call method.
+  class Middleware
+    DEFAULT_WEIGHT = 0
+
+    def weight
+      DEFAULT_WEIGHT
+    end
+
+    def call(_report)
+      raise NotImplementedError, "You must implement the #call method"
+    end
+  end
+end

data/lib/telebugs/middleware_stack.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Telebugs
+  # MiddlewareStack represents an ordered array of middleware.
+  #
+  # A middleware is an object that responds to <b>#call</b> (typically a Proc or a
+  # class that implements the call method). The <b>#call</b> method must accept
+  # exactly one argument: the report object.
+  #
+  # When you add a new middleware to the stack, it gets inserted according to its
+  # <b>weight</b>. Smaller weight means the middleware will be somewhere in the
+  # beginning of the array. Larger - in the end.
+  class MiddlewareStack
+    attr_reader :middlewares
+
+    def initialize
+      @middlewares = []
+    end
+
+    def use(new_middleware)
+      @middlewares = (@middlewares << new_middleware).sort_by(&:weight).reverse
+    end
+
+    def call(report)
+      @middlewares.each do |middleware|
+        middleware.call(report)
+      end
+    end
+  end
+end

data/lib/telebugs/notifier.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Telebugs
+  # Notifier is reponsible for sending reports to Telebugs.
+  class Notifier
+    class << self
+      attr_writer :instance
+
+      def instance
+        @instance ||= new
+      end
+    end
+
+    def initialize
+      @sender = Sender.new
+      @middleware = Config.instance.middleware
+    end
+
+    def notify(error)
+      Telebugs::Promise.new(error) do
+        report = Report.new(error)
+
+        @middleware.call(report)
+        next if report.ignored
+
+        @sender.send(report)
+      end
+    end
+  end
+end

data/lib/telebugs/promise.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Telebugs
+  # Wraps Concurrent::Promise to provide a consistent API for promises that we
+  # can control.
+  class Promise
+    def initialize(...)
+      @future = Concurrent::Promises.future(...)
+    end
+
+    def value
+      @future.value
+    end
+
+    def reason
+      @future.reason
+    end
+
+    def wait
+      @future.wait
+    end
+
+    def fulfilled?
+      @future.fulfilled?
+    end
+
+    def rejected?
+      @future.rejected?
+    end
+
+    def then(...)
+      @future.then(...)
+    end
+
+    def rescue(...)
+      @future.rescue(...)
+    end
+  end
+end

data/lib/telebugs/report.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Telebugs
+  # Represents a piece of information that will be sent to Telebugs API to
+  # report an error.
+  class Report
+    # The list of possible exceptions that might be raised when an object is
+    # converted to JSON
+    JSON_EXCEPTIONS = [
+      IOError,
+      NotImplementedError,
+      JSON::GeneratorError,
+      Encoding::UndefinedConversionError
+    ].freeze
+
+    # The maxium size of the JSON data in bytes
+    MAX_REPORT_SIZE = 64000
+
+    # The maximum size of hashes, arrays and strings in the report.
+    DATA_MAX_SIZE = 10000
+
+    attr_reader :data
+    attr_accessor :ignored
+
+    def initialize(error)
+      @ignored = false
+      @truncator = Truncator.new(DATA_MAX_SIZE)
+
+      @data = {
+        errors: errors_as_json(error)
+      }
+    end
+
+    # Converts the report to JSON. Calls +to_json+ on each object inside the
+    # reports' data. Truncates report data, JSON representation of which is
+    # bigger than {MAX_REPORT_SIZE}.
+    def to_json(*_args)
+      loop do
+        begin
+          json = @data.to_json
+        rescue *JSON_EXCEPTIONS
+          # TODO: log the error
+        else
+          return json if json && json.bytesize <= MAX_REPORT_SIZE
+        end
+
+        break if truncate == 0
+      end
+    end
+
+    private
+
+    def errors_as_json(error)
+      WrappedError.new(error).unwrap.map do |e|
+        {
+          type: e.class.name,
+          message: ErrorMessage.parse(e),
+          backtrace: attach_code(Backtrace.parse(e))
+        }
+      end
+    end
+
+    def attach_code(backtrace)
+      backtrace.each do |frame|
+        next unless frame[:file]
+        next unless File.exist?(frame[:file])
+        next unless frame[:line]
+        next unless frame_belogns_to_root_directory?(frame)
+        next if %r{vendor/bundle}.match?(frame[:file])
+
+        frame[:code] = CodeHunk.get(frame[:file], frame[:line])
+      end
+    end
+
+    def frame_belogns_to_root_directory?(frame)
+      frame[:file].start_with?(Telebugs::Config.instance.root_directory)
+    end
+
+    def truncate
+      @data.each_key do |key|
+        @data[key] = @truncator.truncate(@data[key])
+      end
+
+      @truncator.reduce_max_size
+    end
+  end
+end

data/lib/telebugs/sender.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Telebugs
+  # Responsible for sending HTTP requests to Telebugs.
+  class Sender
+    CONTENT_TYPE = "application/json"
+
+    USER_AGENT = "telebugs-ruby/#{Telebugs::VERSION} (#{RUBY_ENGINE}/#{RUBY_VERSION})"
+
+    def initialize
+      @config = Config.instance
+      @authorization = "Bearer #{@config.api_key}"
+    end
+
+    def send(data)
+      req = build_request(@config.api_url, data)
+
+      resp = build_https(@config.api_url).request(req)
+      if resp.code_type == Net::HTTPCreated
+        return JSON.parse(resp.body)
+      end
+
+      begin
+        reason = JSON.parse(resp.body)
+      rescue JSON::ParserError
+        nil
+      end
+
+      raise HTTPError, "#{resp.code_type} (#{resp.code}): #{reason}"
+    end
+
+    private
+
+    def build_request(uri, data)
+      Net::HTTP::Post.new(uri.request_uri).tap do |req|
+        req["Authorization"] = @authorization
+        req["Content-Type"] = CONTENT_TYPE
+        req["User-Agent"] = USER_AGENT
+
+        req.body = data.to_json
+      end
+    end
+
+    def build_https(uri)
+      Net::HTTP.new(uri.host, uri.port).tap do |https|
+        https.use_ssl = uri.is_a?(URI::HTTPS)
+      end
+    end
+  end
+end

data/lib/telebugs/truncator.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Telebugs
+  # This class is responsible for the truncation of too-big objects. Mainly, you
+  # should use it for simple objects such as strings, hashes, & arrays.
+  class Truncator
+    # The options for +String#encode+
+    ENCODING_OPTIONS = {invalid: :replace, undef: :replace}.freeze
+
+    # The temporary encoding to be used when fixing invalid strings with
+    # +ENCODING_OPTIONS+
+    TEMP_ENCODING = "utf-16"
+
+    # Encodings that are eligible for fixing invalid characters
+    SUPPORTED_ENCODINGS = [Encoding::UTF_8, Encoding::ASCII].freeze
+
+    # What to append when something is a circular reference
+    CIRCULAR = "[Circular]"
+
+    # What to append when something is truncated
+    TRUNCATED = "[Truncated]"
+
+    # The types that can contain references to itself
+    CIRCULAR_TYPES = [Array, Hash, Set].freeze
+
+    # Maximum size of hashes, arrays and strings
+    def initialize(max_size)
+      @max_size = max_size
+    end
+
+    # Performs deep truncation of arrays, hashes, sets & strings. Uses a
+    # placeholder for recursive objects (`[Circular]`).
+    def truncate(object, seen = Set.new)
+      if seen.include?(object.object_id)
+        return CIRCULAR if CIRCULAR_TYPES.any? { |t| object.is_a?(t) }
+
+        return object
+      end
+      truncate_object(object, seen << object.object_id)
+    end
+
+    # Reduces maximum allowed size of hashes, arrays, sets & strings by half.
+    def reduce_max_size
+      @max_size /= 2
+    end
+
+    private
+
+    def truncate_object(object, seen)
+      case object
+      when Hash then truncate_hash(object, seen)
+      when Array then truncate_array(object, seen)
+      when Set then truncate_set(object, seen)
+      when String then truncate_string(object)
+      when Numeric, TrueClass, FalseClass, Symbol, NilClass then object
+      else
+        truncate_string(stringify_object(object))
+      end
+    end
+
+    def truncate_string(str)
+      fixed_str = replace_invalid_characters(str)
+      return fixed_str if fixed_str.length <= @max_size
+
+      (fixed_str.slice(0, @max_size) + TRUNCATED).freeze
+    end
+
+    def stringify_object(object)
+      object.to_json
+    rescue *Report::JSON_EXCEPTIONS
+      object.to_s
+    end
+
+    def truncate_hash(hash, seen)
+      truncated_hash = {}
+      hash.each_with_index do |(key, val), idx|
+        break if idx + 1 > @max_size
+
+        truncated_hash[key] = truncate(val, seen)
+      end
+
+      truncated_hash.freeze
+    end
+
+    def truncate_array(array, seen)
+      array.slice(0, @max_size).map! { |elem| truncate(elem, seen) }.freeze
+    end
+
+    def truncate_set(set, seen)
+      truncated_set = Set.new
+
+      set.each do |elem|
+        truncated_set << truncate(elem, seen)
+        break if truncated_set.size >= @max_size
+      end
+
+      truncated_set.freeze
+    end
+
+    # Replaces invalid characters in a string with arbitrary encoding.
+    # @see https://github.com/flori/json/commit/3e158410e81f94dbbc3da6b7b35f4f64983aa4e3
+    def replace_invalid_characters(str)
+      utf8_string = SUPPORTED_ENCODINGS.include?(str.encoding)
+      return str if utf8_string && str.valid_encoding?
+
+      temp_str = str.dup
+      temp_str.encode!(TEMP_ENCODING, **ENCODING_OPTIONS) if utf8_string
+      temp_str.encode!("utf-8", **ENCODING_OPTIONS)
+    end
+  end
+end

data/lib/telebugs/version.rb

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

data/lib/telebugs/wrapped_error.rb

@@ -0,0 +1,22 @@
+module Telebugs
+  # WrappedError unwraps an error and its causes up to a certain depth.
+  class WrappedError
+    MAX_NESTED_ERRORS = 3
+
+    def initialize(error)
+      @error = error
+    end
+
+    def unwrap
+      error_list = []
+      error = @error
+
+      while error && error_list.size < MAX_NESTED_ERRORS
+        error_list << error
+        error = error.cause
+      end
+
+      error_list
+    end
+  end
+end

data/lib/telebugs.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "concurrent"
+require "net/https"
+require "json"
+
+require_relative "telebugs/version"
+require_relative "telebugs/config"
+require_relative "telebugs/promise"
+require_relative "telebugs/notifier"
+require_relative "telebugs/sender"
+require_relative "telebugs/wrapped_error"
+require_relative "telebugs/report"
+require_relative "telebugs/error_message"
+require_relative "telebugs/backtrace"
+require_relative "telebugs/file_cache"
+require_relative "telebugs/code_hunk"
+require_relative "telebugs/middleware"
+require_relative "telebugs/middleware_stack"
+require_relative "telebugs/truncator"
+
+module Telebugs
+  # The general error that this library uses when it wants to raise.
+  Error = Class.new(StandardError)
+
+  HTTPError = Class.new(Error)
+
+  class << self
+    def configure
+      yield Config.instance
+    end
+
+    def notify(error:)
+      Notifier.instance.notify(error)
+    end
+  end
+end

data/sig/telebugs.rbs

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

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: telebugs
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kyrylo Silin
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-06-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.23'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.23'
+description: |
+  Telebugs Ruby is an SDK for Telebugs (https://telebugs.com/), a simple error monitoring tool for developers. With
+  Telebugs, you can track production errors in real-time and report them to Telegram.
+email:
+- help@telebugs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".standard.yml"
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/telebugs.rb
+- lib/telebugs/backtrace.rb
+- lib/telebugs/code_hunk.rb
+- lib/telebugs/config.rb
+- lib/telebugs/error_message.rb
+- lib/telebugs/file_cache.rb
+- lib/telebugs/middleware.rb
+- lib/telebugs/middleware_stack.rb
+- lib/telebugs/notifier.rb
+- lib/telebugs/promise.rb
+- lib/telebugs/report.rb
+- lib/telebugs/sender.rb
+- lib/telebugs/truncator.rb
+- lib/telebugs/version.rb
+- lib/telebugs/wrapped_error.rb
+- sig/telebugs.rbs
+homepage: https://telebugs.com
+licenses: []
+metadata:
+  homepage_uri: https://telebugs.com
+  source_code_uri: https://github.com/telebugs/telebugs-ruby
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+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: Report errors to Telebugs with the offical Ruby SDK
+test_files: []