{"id":13428166,"url":"https://github.com/airbrake/airbrake","last_synced_at":"2025-05-11T05:48:59.665Z","repository":{"id":417728,"uuid":"2263819","full_name":"airbrake/airbrake","owner":"airbrake","description":"The official Airbrake library for Ruby applications","archived":false,"fork":false,"pushed_at":"2024-12-21T01:08:22.000Z","size":2828,"stargazers_count":974,"open_issues_count":19,"forks_count":392,"subscribers_count":52,"default_branch":"master","last_synced_at":"2025-04-30T07:05:54.951Z","etag":null,"topics":["airbrake","apm","capistrano","crash-reporting","delayed-job","error-monitoring","logger","performance-monitoring","rails","rake","resque","ruby","shoryuken","sidekiq","sinatra","sneakers"],"latest_commit_sha":null,"homepage":"https://airbrake.io","language":"Ruby","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/airbrake.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE.md","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2011-08-24T19:33:00.000Z","updated_at":"2025-04-26T15:36:30.000Z","dependencies_parsed_at":"2024-06-18T11:08:11.550Z","dependency_job_id":"c2de8858-1710-4dc0-b933-cf74a34b03e0","html_url":"https://github.com/airbrake/airbrake","commit_stats":{"total_commits":1720,"total_committers":240,"mean_commits":7.166666666666667,"dds":0.6627906976744187,"last_synced_commit":"73af58d32eb2372931e4b892920606f131aee379"},"previous_names":[],"tags_count":210,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/airbrake%2Fairbrake","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/airbrake%2Fairbrake/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/airbrake%2Fairbrake/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/airbrake%2Fairbrake/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/airbrake","download_url":"https://codeload.github.com/airbrake/airbrake/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":251720909,"owners_count":21632735,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["airbrake","apm","capistrano","crash-reporting","delayed-job","error-monitoring","logger","performance-monitoring","rails","rake","resque","ruby","shoryuken","sidekiq","sinatra","sneakers"],"created_at":"2024-07-31T01:00:48.019Z","updated_at":"2025-05-08T02:32:27.323Z","avatar_url":"https://github.com/airbrake.png","language":"Ruby","readme":"Airbrake\n========\n\n[![Build Status](https://github.com/airbrake/airbrake/workflows/airbrake/badge.svg)](https://github.com/airbrake/airbrake/actions)\n[![Code Climate](https://codeclimate.com/github/airbrake/airbrake.svg)](https://codeclimate.com/github/airbrake/airbrake)\n[![Gem Version](https://badge.fury.io/rb/airbrake.svg)](http://badge.fury.io/rb/airbrake)\n[![Documentation Status](http://inch-ci.org/github/airbrake/airbrake.svg?branch=master)](http://inch-ci.org/github/airbrake/airbrake)\n[![Downloads](https://img.shields.io/gem/dt/airbrake.svg?style=flat)](https://rubygems.org/gems/airbrake)\n[![Reviewed by Hound](https://img.shields.io/badge/Reviewed_by-Hound-8E64B0.svg)](https://houndci.com)\n\n\u003cp align=\"center\"\u003e\n  \u003cimg src=\"https://airbrake-github-assets.s3.amazonaws.com/brand/airbrake-full-logo.png\" width=\"200\"\u003e\n\u003c/p\u003e\n\n* [Airbrake README](https://github.com/airbrake/airbrake)\n* [Airbrake Ruby README](https://github.com/airbrake/airbrake-ruby)\n* [YARD API documentation](http://www.rubydoc.info/gems/airbrake-ruby)\n\nIntroduction\n------------\n\n[Airbrake][airbrake.io] is an online tool that provides robust exception\ntracking in any of your Ruby applications. In doing so, it allows you to easily\nreview errors, tie an error to an individual piece of code, and trace the cause\nback to recent changes. The Airbrake dashboard provides easy categorization,\nsearching, and prioritization of exceptions so that when errors occur, your team\ncan quickly determine the root cause.\n\nKey features\n------------\n\n![The Airbrake Dashboard][dashboard]\n\nThis library is built on top of [Airbrake Ruby][airbrake-ruby]. The difference\nbetween _Airbrake_ and _Airbrake Ruby_ is that the `airbrake` gem is just a\ncollection of integrations with frameworks or other libraries. The\n`airbrake-ruby` gem is the core library that performs exception sending and\nother heavy lifting.\n\nNormally, you just need to depend on this gem, select the integration you are\ninterested in and follow the instructions for it. If you develop a pure\nframeworkless Ruby application or embed Ruby and don't need any of the listed\nintegrations, you can depend on the `airbrake-ruby` gem and ignore this gem\nentirely.\n\nThe list of integrations that are available in this gem includes:\n\n* [Heroku support][heroku-docs] (as an [add-on][heroku-addon])\n* Web frameworks\n  * [Rails](#rails)\n  * [Sinatra](#sinatra)\n  * [Rack applications](#rack)\n* Job processing libraries\n  * [ActiveJob](#activejob)\n  * [Resque](#resque)\n  * [Sidekiq](#sidekiq)\n  * [DelayedJob](#delayedjob)\n  * [Shoryuken](#shoryuken)\n  * [Sneakers](#sneakers)\n* Other libraries\n  * [ActionCable](#actioncable)\n  * [Rake](#rake)\n  * [Logger](#logger)\n* [Plain Ruby scripts](#plain-ruby-scripts)\n\nDeployment tracking:\n\n* Using [Capistrano](#capistrano)\n* Using the [Rake task](#rake-task)\n\nInstallation\n------------\n\n### Bundler\n\nAdd the Airbrake gem to your Gemfile:\n\n```ruby\ngem 'airbrake'\n```\n\n### Manual\n\nInvoke the following command from your terminal:\n\n```bash\ngem install airbrake\n```\n\nConfiguration\n-------------\n\n### Rails\n\n#### Integration\n\nTo integrate Airbrake with your Rails application, you need to know your\n[project id and project key][project-idkey]. Set `AIRBRAKE_PROJECT_ID` \u0026\n`AIRBRAKE_PROJECT_KEY` environment variables with your project's values and\ngenerate the Airbrake config:\n\n```bash\nexport AIRBRAKE_PROJECT_ID=\u003cPROJECT ID\u003e\nexport AIRBRAKE_PROJECT_KEY=\u003cPROJECT KEY\u003e\n\nrails g airbrake\n```\n\n[Heroku add-on][heroku-addon] users can omit specifying the key and the\nid. Heroku add-on's environment variables will be used ([Heroku add-on\ndocs][heroku-docs]):\n\n```bash\nrails g airbrake\n```\n\nThis command will generate the Airbrake configuration file under\n`config/initializers/airbrake.rb`. Make sure that this file is checked into your\nversion control system. This is enough to start Airbraking.\n\nIn order to configure the library according to your needs, open up the file and\nedit it. [The full list of supported configuration options][config] is available\nonline.\n\nTo test the integration, invoke a special Rake task that we provide:\n\n```ruby\nrake airbrake:test\n```\n\nIn case of success, a test exception should appear in your dashboard.\n\n#### The notify_airbrake controller helpers\n\nThe Airbrake gem defines two helper methods available inside Rails controllers:\n`#notify_airbrake` and `#notify_airbrake_sync`. If you want to notify Airbrake\nfrom your controllers manually, it's usually a good idea to prefer them over\n[`Airbrake.notify`][airbrake-notify], because they automatically add\ninformation from the Rack environment to notices. `#notify_airbrake` is\nasynchronous, while `#notify_airbrake_sync` is synchronous (waits for responses\nfrom the server and returns them). The list of accepted arguments is identical\nto `Airbrake.notify`.\n\n#### Additional features: user reporting, sophisticated API\n\nThe library sends all uncaught exceptions automatically, attaching the maximum\npossible amount information that can help you to debug errors. The Airbrake gem\nis capable of reporting information about the currently logged in user (id,\nemail, username, etc.), if you use an authentication library such as Devise. The\nlibrary also provides a special API for manual error\nreporting. [The description of the API][airbrake-api] is available online.\n\n#### Automatic integration with Rake tasks and Rails runner\n\nAdditionally, the Rails integration offers automatic exception reporting in any\nRake tasks\u003csup\u003e[[link](#rake)]\u003c/sup\u003e and [Rails runner][rails-runner].\n\n#### Integration with filter_parameters\n\nIf you want to reuse `Rails.application.config.filter_parameters` in Airbrake\nyou can configure your notifier the following way:\n\n```rb\n# config/initializers/airbrake.rb\nAirbrake.configure do |c|\n  c.blocklist_keys = Rails.application.config.filter_parameters\nend\n```\n\nThere are a few important details:\n\n1. You must load `filter_parameter_logging.rb` before the Airbrake config\n2. If you use Lambdas to configure `filter_parameters`, you need to convert them\n   to Procs. Otherwise you will get `ArgumentError`\n3. If you use Procs to configure `filter_parameters`, the procs must return an\n   Array of keys compatible with the Airbrake allowlist/blocklist option\n   (String, Symbol, Regexp)\n\nConsult the\n[example application](https://github.com/kyrylo/airbrake-ruby-issue108), which\nwas created to show how to configure `filter_parameters`.\n\n##### filter_parameters dot notation warning\n\nThe dot notation introduced in [rails/pull/13897][rails-13897] for\n`filter_parameters` (e.g. a key like `credit_card.code`) is unsupported for\nperformance reasons. Instead, simply specify the `code` key. If you have a\nstrong opinion on this, leave a comment in\nthe [dedicated issue][rails-sub-keys].\n\n##### Logging\n\nIn new Rails apps, by default, all the Airbrake logs are written into\n`log/airbrake.log`. In older versions we used to write to wherever\n`Rails.logger` writes. If you wish to upgrade your app to the new behaviour,\nplease configure your logger the following way:\n\n```ruby\nc.logger = Airbrake::Rails.logger\n```\n\n### Sinatra\n\nTo use Airbrake with Sinatra, simply `require` the gem, [configure][config] it\nand `use` our Rack middleware.\n\n```ruby\n# myapp.rb\nrequire 'sinatra/base'\nrequire 'airbrake'\n\nAirbrake.configure do |c|\n  c.project_id = 113743\n  c.project_key = 'fd04e13d806a90f96614ad8e529b2822'\n\n  # Display debug output.\n  c.logger.level = Logger::DEBUG\nend\n\nclass MyApp \u003c Sinatra::Base\n  use Airbrake::Rack::Middleware\n\n  get('/') { 1/0 }\nend\n\nrun MyApp.run!\n```\n\nTo run the app, add a file called `config.ru` to the same directory and invoke\n`rackup` from your console.\n\n```ruby\n# config.ru\nrequire_relative 'myapp'\n```\n\nThat's all! Now you can send a test request to `localhost:9292` and check your\nproject's dashboard for a new error.\n\n```bash\ncurl localhost:9292\n```\n\n### Rack\n\nTo send exceptions to Airbrake from any Rack application, simply `use` our Rack\nmiddleware, and [configure][config] the notifier.\n\n```ruby\nrequire 'airbrake'\nrequire 'airbrake/rack'\n\nAirbrake.configure do |c|\n  c.project_id = 113743\n  c.project_key = 'fd04e13d806a90f96614ad8e529b2822'\nend\n\nuse Airbrake::Rack::Middleware\n```\n\n**Note:** be aware that by default the library doesn't filter any parameters,\nincluding user passwords. To filter out passwords\n[add a filter](https://github.com/airbrake/airbrake-ruby#airbrakeadd_filter).\n\n#### Appending information from Rack requests\n\nIf you want to append additional information from web requests (such as HTTP\nheaders), define a special filter such as:\n\n```ruby\nAirbrake.add_filter do |notice|\n  next unless (request = notice.stash[:rack_request])\n  notice[:params][:remoteIp] = request.env['REMOTE_IP']\nend\n```\n\nThe `notice` object carries a real `Rack::Request` object in\nits [stash](https://github.com/airbrake/airbrake-ruby#noticestash--noticestash).\nRack requests will always be accessible through the `:rack_request` stash key.\n\n#### Optional Rack request filters\n\nThe library comes with optional predefined builders listed below.\n\n##### RequestBodyFilter\n\n`RequestBodyFilter` appends Rack request body to the notice. It accepts a\n`length` argument, which tells the filter how many bytes to read from the body.\n\nBy default, up to 4096 bytes is read:\n\n```ruby\nAirbrake.add_filter(Airbrake::Rack::RequestBodyFilter.new)\n```\n\nYou can redefine how many bytes to read by passing an Integer argument to the\nfilter. For example, read up to 512 bytes:\n\n```ruby\nAirbrake.add_filter(Airbrake::Rack::RequestBodyFilter.new(512))\n```\n\n#### Sending custom route breakdown performance\n\n##### Arbitrary code performance instrumentation\n\nFor every route in your app Airbrake collects performance breakdown\nstatistics. If you need to monitor a specific operation, you can capture your\nown breakdown:\n\n```ruby\ndef index\n  Airbrake::Rack.capture_timing('operation name') do\n    call_operation(...)\n  end\n\n  call_other_operation\nend\n```\n\nThat will benchmark `call_operation` and send performance information to\nAirbrake, to the corresponding route (under the 'operation name' label).\n\n##### Method performance instrumentation\n\nAlternatively, you can measure performance of a specific method:\n\n```ruby\nclass UsersController\n  extend Airbrake::Rack::Instrumentable\n\n  def index\n    call_operation(...)\n  end\n  airbrake_capture_timing :index\nend\n```\n\nSimilarly to the previous example, performance information of the `index` method\nwill be sent to Airbrake.\n\n### Sidekiq\n\nWe support Sidekiq v2+. The configurations steps for them are identical. Simply\n`require` our integration and you're done:\n\n```ruby\nrequire 'airbrake/sidekiq'\n```\n\nIf you required Sidekiq before Airbrake, then you don't even have to `require`\nanything manually and it should just work out-of-box.\n\n\n#### Airbrake::Sidekiq::RetryableJobsFilter\n\nBy default, Airbrake notifies of all errors, including reoccurring errors during\na retry attempt. To filter out these errors and only get notified when Sidekiq\nhas exhausted its retries you can add the `RetryableJobsFilter`:\n\n```ruby\nAirbrake.add_filter(Airbrake::Sidekiq::RetryableJobsFilter.new)\n```\n\nThe filter accepts an optional `max_retries` parameter. When set, it configures\nthe amount of allowed job retries that won't trigger an Airbrake notification.\nNormally, this parameter is configured by the job itself but this setting takes\nthe highest precedence and forces the value upon all jobs, so be careful when\nyou use it. By default, it's not set.\n\n```ruby\nAirbrake.add_filter(\n  Airbrake::Sidekiq::RetryableJobsFilter.new(max_retries: 10)\n)\n```\n\n### ActiveJob\n\nNo additional configuration is needed. Simply ensure that you have configured\nyour Airbrake notifier with your queue adapter.\n\n### Resque\n\nSimply `require` the Resque integration:\n\n```ruby\nrequire 'airbrake/resque'\n```\n\n#### Integrating with Rails applications\n\nIf you're working with Resque in the context of a Rails application, create a\nnew initializer in `config/initializers/resque.rb` with the following content:\n\n```ruby\n# config/initializers/resque.rb\nrequire 'airbrake/resque'\nResque::Failure.backend = Resque::Failure::Airbrake\n```\n\nNow you're all set.\n\n#### General integration\n\nAny Ruby app using Resque can be integrated with Airbrake. If you can require\nthe Airbrake gem *after* Resque, then there's no need to require\n`airbrake/resque` anymore:\n\n```ruby\nrequire 'resque'\nrequire 'airbrake'\n\nResque::Failure.backend = Resque::Failure::Airbrake\n```\n\nIf you're unsure, just configure it similar to the Rails approach. If you use\nmultiple backends, then continue reading the needed configuration steps in\n[the Resque wiki][resque-wiki] (it's fairly straightforward).\n\n### DelayedJob\n\nSimply `require` our integration and you're done:\n\n```ruby\nrequire 'airbrake/delayed_job'\n```\n\nIf you required DelayedJob before Airbrake, then you don't even have to `require`\nanything manually and it should just work out-of-box.\n\n### Shoryuken\n\nSimply `require` our integration and you're done:\n\n```ruby\nrequire 'airbrake/shoryuken'\n```\n\nIf you required Shoryuken before Airbrake, then you don't even have to `require`\nanything manually and it should just work out-of-box.\n\n### Sneakers\n\nSimply `require` our integration and you're done:\n\n```ruby\nrequire 'airbrake/sneakers'\n```\n\nIf you required Sneakers before Airbrake, then you don't even have to `require`\nanything manually and it should just work out-of-box.\n\n### ActionCable\n\nThe ActionCable integration sends errors occurring in ActionCable actions and\nsubscribed/unsubscribed events. If you use Rails with ActionCable, there's\nnothing to do, it's already loaded. If you use ActionCable outside Rails, simply\nrequire it:\n\n```ruby\nrequire 'airbrake/rails/action_cable'\n```\n\n### Rake\n\nAirbrake offers Rake tasks integration, which is used by our Rails\nintegration\u003csup\u003e[[link](#rails)]\u003c/sup\u003e. To integrate Airbrake in any project,\njust `require` the gem in your `Rakefile`, if it hasn't been required and\n[configure][config] the notifier.\n\n```ruby\n# Rakefile\nrequire 'airbrake'\n\nAirbrake.configure do |c|\n  c.project_id = 113743\n  c.project_key = 'fd04e13d806a90f96614ad8e529b2822'\nend\n\ntask :foo do\n  1/0\nend\n```\n\n### Logger\n\nIf you want to convert your log messages to Airbrake errors, you can use our\nintegration with Ruby's `Logger` class from stdlib. All you need to do is to\nwrap your logger in Airbrake's decorator class:\n\n```ruby\nrequire 'airbrake/logger'\n\n# Create a normal logger\nlogger = Logger.new($stdout)\n\n# Wrap it\nlogger = Airbrake::AirbrakeLogger.new(logger)\n```\n\nNow you can use the `logger` object exactly the same way you use it. For\nexample, calling `fatal` on it will both log your message and send it to the\nAirbrake dashboard:\n\n```\nlogger.fatal('oops')\n```\n\nThe Logger class will attempt to utilize the default Airbrake notifier to\ndeliver messages. It's possible to redefine it via `#airbrake_notifier`:\n\n```ruby\n# Assign your own notifier.\nlogger.airbrake_notifier = Airbrake::NoticeNotifier.new\n```\n\n#### Airbrake severity level\n\nIn order to reduce the noise from the Logger integration it's possible to\nconfigure Airbrake severity level. For example, if you want to send only fatal\nmessages from Logger, then configure it as follows:\n\n```ruby\n# Send only fatal messages to Airbrake, ignore anything below this level.\nlogger.airbrake_level = Logger::FATAL\n```\n\nBy default, `airbrake_level` is set to `Logger::WARN`, which means it\nsends warnings, errors and fatal error messages to Airbrake.\n\n#### Configuring Airbrake logger integration with a Rails application\n\nIn order to configure a production logger with Airbrake integration, simply\noverwrite `Rails.logger` with a wrapped logger in an `after_initialize`\ncallback:\n\n```ruby\n# config/environments/production.rb\nconfig.after_initialize do\n  # Standard logger with Airbrake integration:\n  # https://github.com/airbrake/airbrake#logger\n  Rails.logger = Airbrake::AirbrakeLogger.new(Rails.logger)\nend\n```\n\n#### Configuring Rails APM SQL query stats when using Rails engines\n\nBy default, the library collects Rails SQL performance stats. For standard Rails\napps no extra configuration is needed. However if your app uses [Rails\nengines](https://guides.rubyonrails.org/engines.html), you need to take an\nadditional step to make sure that the file and line information is present for\nqueries being executed in the engine code.\n\nSpecifically, you need to make sure that your\n[`Rails.backtrace_cleaner`](https://api.rubyonrails.org/classes/ActiveSupport/BacktraceCleaner.html)\nhas a silencer that doesn't silence engine code (will be silenced by\ndefault). For example, if your engine is called `blorgh` and its main directory\nis in the root of your project, you need to extend the default silencer provided\nwith Rails and add the path to your engine:\n\n```rb\n# config/initializers/backtrace_silencers.rb\n\n# Delete default silencer(s).\nRails.backtrace_cleaner.remove_silencers!\n\n# Define custom silencer, which adds support for the \"blorgh\" engine\nRails.backtrace_cleaner.add_silencer do |line|\n  app_dirs_pattern = %r{\\A/?(app|config|lib|test|blorgh|\\(\\w*\\))}\n  !app_dirs_pattern.match?(line)\nend\n```\n\n### Plain Ruby scripts\n\nAirbrake supports _any_ type of Ruby applications including plain Ruby scripts.\nIf you want to integrate your script with Airbrake, you don't have to use this\ngem. The [Airbrake Ruby][airbrake-ruby] gem provides all the needed tooling.\n\nDeploy tracking\n---------------\n\nBy notifying Airbrake of your application deployments, all errors are resolved\nwhen a deploy occurs, so that you'll be notified again about any errors that\nreoccur after a deployment. Additionally, it's possible to review the errors in\nAirbrake that occurred before and after a deploy.\n\nThere are several ways to integrate deployment tracking with your application,\nthat are described below.\n\n### Capistrano\n\nThe library supports Capistrano v2 and Capistrano v3. In order to configure\ndeploy tracking with Capistrano simply `require` our integration from your\nCapfile:\n\n```ruby\n# Capfile\nrequire 'airbrake/capistrano'\n```\n\nIf you use Capistrano 3, define the `after :finished` hook, which executes the\ndeploy notification task (Capistrano 2 doesn't require this step).\n\n```ruby\n# config/deploy.rb\nnamespace :deploy do\n  after :finished, 'airbrake:deploy'\nend\n```\n\nIf you version your application, you can set the `:app_version` variable in\n`config/deploy.rb`, so that information will be attached to your deploy.\n\n```ruby\n# config/deploy.rb\nset :app_version, '1.2.3'\n```\n\n### Rake task\n\nA Rake task can accept several arguments shown in the table below:\n\n| Key       | Required | Default   | Example |\n------------|----------|-----------|----------\nENVIRONMENT | No       | Rails.env | production\nUSERNAME    | No       | nil       | john\nREPOSITORY  | No       | nil       | https://github.com/airbrake/airbrake\nREVISION    | No       | nil       | 38748467ea579e7ae64f7815452307c9d05e05c5\nVERSION     | No       | nil       | v2.0\n\n#### In Rails\n\nSimply invoke `rake airbrake:deploy` and pass needed arguments:\n\n```bash\nrake airbrake:deploy USERNAME=john ENVIRONMENT=production REVISION=38748467 REPOSITORY=https://github.com/airbrake/airbrake\n```\n\n#### Anywhere\n\nMake sure to `require` the library Rake integration in your Rakefile.\n\n```ruby\n# Rakefile\nrequire 'airbrake/rake/tasks'\n```\n\nThen, invoke it like shown in the example for Rails.\n\nSupported Rubies\n----------------\n\n* CRuby \u003e= 2.6.0\n* JRuby \u003e= 9k\n\nContact\n-------\n\nIn case you have a problem, question or a bug report, feel free to:\n\n* [file an issue][issues]\n* [send us an email](mailto:support@airbrake.io)\n* [tweet at us][twitter]\n* chat with us (visit [airbrake.io][airbrake.io] and click on the round orange\n  button in the bottom right corner)\n\nLicense\n-------\n\nThe project uses the MIT License. See LICENSE.md for details.\n\nDevelopment \u0026 testing\n---------------------\n\nIn order to run the test suite, first of all, clone the repo, and install\ndependencies with Bundler.\n\n```bash\ngit clone https://github.com/airbrake/airbrake.git\ncd airbrake\nbundle\n```\n\nNext, run unit tests.\n\n```bash\nbundle exec rake\n```\n\nIn order to test integrations with frameworks and other libraries, install their\ndependencies with help of the following command:\n\n```bash\nbundle exec appraisal install\n```\n\nTo run integration tests for a specific framework, use the `appraisal` command.\n\n```bash\nbundle exec appraisal rails-4.2 rake spec:integration:rails\nbundle exec appraisal sinatra rake spec:integration:sinatra\n```\n\nPro tip: [GitHub Actions config](/.github/workflows/test.yml) has the list of\nall the integration tests and commands to invoke them.\n\n[airbrake.io]: https://airbrake.io\n[airbrake-ruby]: https://github.com/airbrake/airbrake-ruby\n[issues]: https://github.com/airbrake/airbrake/issues\n[twitter]: https://twitter.com/airbrake\n[project-idkey]: https://github.com/airbrake/airbrake-ruby#project_id--project_key\n[config]: https://github.com/airbrake/airbrake-ruby#config-options\n[airbrake-api]: https://github.com/airbrake/airbrake-ruby#api\n[rails-runner]: http://guides.rubyonrails.org/command_line.html#rails-runner\n[resque-wiki]: https://github.com/resque/resque/wiki/Failure-Backends#using-multiple-failure-backends-at-once\n[heroku-addon]: https://elements.heroku.com/addons/airbrake\n[heroku-docs]: https://devcenter.heroku.com/articles/airbrake\n[dashboard]: https://s3.amazonaws.com/airbrake-github-assets/airbrake/airbrake-dashboard.png\n[rails-13897]: https://github.com/rails/rails/pull/13897\n[rails-sub-keys]: https://github.com/airbrake/airbrake-ruby/issues/137\n[airbrake-notify]: https://github.com/airbrake/airbrake-ruby#airbrakenotify\n","funding_links":[],"categories":["Error Logging","Maintenance \u0026 Monitoring","Ruby","Error Handling","错误日志","Error Handling and Monitoring"],"sub_categories":["Security","Exception Notification","安全"],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fairbrake%2Fairbrake","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fairbrake%2Fairbrake","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fairbrake%2Fairbrake/lists"}