Use Module#prepend for Rake integration if Ruby version is new enough

[tobyhs]

Goal

To fix #556 (an infinite mutual recursion issue when something else monkey patches Rake::Task with Module#prepend)

Changeset

Changed

lib/bugsnag/integrations/rake.rb was updated to use Module#prepend if it was available on the currently running Ruby version.

Tests

• spec/fixtures/tasks/Rakefile was changed so that the code previous to my lib changes would cause an infinite loop in some versions of Ruby
• The user who reported the issue mentioned that he no longer encounters the issue with my branch

Discussion

Alternative Approaches

Another approach might be to use a global or thread-local variable to keep track of Rake task names that are running and to return early if you encounter the same task name again, but that seems error-prone and possibly messy.

Outstanding Questions

The duplicate logic is bad, but trying to figure out a way to refactor it with metaprogramming seemed bad too.

Linked issues

Fixes #556

Review

For the submitter, initial self-review:

• Commented on code changes inline explain the reasoning behind the approach
• Reviewed the test cases added for completeness and possible points for discussion
• A changelog entry was added for the goal of this pull request
• Check the scope of the changeset - is everything in the diff required for the pull request?
• This pull request is ready for:
  • Initial review of the intended approach, not yet feature complete
  • Structural review of the classes, functions, and properties modified
  • Final review

For the pull request reviewer(s), this changeset has been reviewed for:

• Consistency across platforms for structures or concepts added or modified
• Consistency between the changeset and the goal stated above
• Internal consistency with the rest of the library - is there any overlap between existing interfaces and any which have been added?
• Usage friction - is the proposed change in usage cumbersome or complicated?
• Performance and complexity - are there any cases of unexpected O(n^3) when iterating, recursing, flat mapping, etc?
• Concurrency concerns - if components are accessed asynchronously, what issues will arise
• Thoroughness of added tests and any missing edge cases
• Idiomatic use of the language

[tomlongridge]

LGTM 👍