It ships with a few improvements that I really like, so I'm excited to update my apps to the latest version.
Let's have a look at each major change briefly π
Active Job Continuations. Jobs became "resumable". You can break them up into discrete steps and resume from the last unfinished step.
Useful for deployments and long-running jobs, but I'm sure there will be other use cases.
Structured Event Reporting. Events can be emitted along with a set of structured parameters, which is great for processing them programmatically.
Event subscribers can receive events (including the parameters), and can decide to process them accordingly.
Local CI. Faster feedback loop thanks to running the test suite and other checks locally. It's customizable by editing config/ci.rb.
An integration with gh can ensure PRs are green before merging.
Markdown Rendering. In your controller, use respond_to with format.md and then call render markdown: object to have Rails call object.to_markdown and send the result back.
Deprecated Associations. Associations can be marked as deprecated: true to report their usage via a variety of means.
Helpful in large code bases where just dropping an association is non-trivial.
Kamal Improvements. I don't use Kamal, but 8.1 makes it easy to load secrets from encrypted credential files and it supports registry-free deployments.
These were the major changes, but there's much more, so feel free to have a look at the changelog:
1. Vacuum, I/O performance, and query performance gains. 2. JSON_TABLE for converting JSON documents into tables. 3. More features added to MERGE. 4. Simpler upgrades when using logical replication + failover!
π‘ Rails tip: Rails 7 shipped with error handling infrastructure
It's a small module, but I find it extremely useful, especially when integrating with third-party APIs, as you usually want to gracefully inform the user the API is down, but still report that internally.
Ready?
At a high level:
- there are multiple subscribers registered with the error reporter
- each error is passed to each subscriber
- the reporter offers methods for detecting, reporting, and swallowing exceptions thrown by the app
Let's take a close look at those methods.
Rails.error.handle - runs the block, swallows and records any exceptions raised by it
If no exceptions are raised then the block value is returned.
If an exception is raised then nil is returned, unless a fallback is given, but more on that in a minute.
π‘ Ruby meta-programming: lazy accessors are simple to implement and more robust than lazy computations via ||=
Meta-programming can be fun, productive, and helpful. Let's have a look at another example, including a bigger engineering lesson.
β¬οΈ Let's go!
What's a lazy accessor?
It's an accessor with a block of code to determine a value. That block of code is called only on first use; subsequent calls reuse the value the block returned.
In short: lazy accessor = laziness + caching
What are its applications?
Primarily, deferring expensive computations until needed and ensuring they are run only once.
Example: expensive database reporting query with further result processing in Ruby.
Let's have a look at the idiomatic way of handling that in Ruby ...
π‘ Ruby meta-programming idea: final classes can be easily implemented in Ruby
I've actually published a gem whose first feature is exactly that. More on that later though. Let's understand the concept of final classes first.
Ready? Set? Go!
What's a final class?
A final class is a class that cannot be inherited from. Any attempt to subclass it would result in an error (compile-time or runtime, depending on the language).
It's a foreign concept in Ruby land, so let's have a look at other languages.
In UIKit, Apple's UI framework, there's a view controller called UIAlertController for displaying all sorts of alerts.
Technically, it's NOT final, but the documentation says it should be used as-is and not subclassed.
π‘ Rails tip: as_json can be used to convert models into ... no, not JSON ... into hashes
It can be useful when building and working with APIs, so it's always a good idea to understand how it works. It's implemented by Active Model and is quite generic.
Let's dive in! π€Ώ π
Called without arguments it returns a hash including all columns in the model.
Is this a good idea? NO!
β οΈ Do that in a public API and it's guaranteed you'll leak sensitive data sooner or later. Therefore, you should use this rarely, if ever.
What's the alternative?
You can whitelist or blacklist columns (and wrap the output in a hash).
My recommendation: whitelist by default, unless you're sure blacklisting is better
You may think whitelisting and blacklisting are two sides of the same coin but they are NOT!