honeycomb-beeline 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc4528a9aaab86b940cc602a90134618ff588f88d25d8eaa8408edcc294ea987
-  data.tar.gz: f7fb9cafa295258ad9e96fe3116e8e81f8f4a27a3affa29db9eec63207cbf6a9
+  metadata.gz: 0e5338862ac2eed88b9a4c9712bf47d63652531c0a6c9c06d8e2e4f0f62c2650
+  data.tar.gz: 7e70234ac75d0361578905460c92625744f70fae73a050db386ab5b0614870e7
 SHA512:
-  metadata.gz: '08e93b50154976fc28a3408df22a4b4e347d2236cf18673a4adef9092a4d739ff083772260e96a1d058efa6674b9afc24cc2b7d7c6156078dfd7d2847edec2c4'
-  data.tar.gz: 78287f73733f6cce17d28fb5c58afdd8e99a4bcf8c56cc7af01c97b03a3e8aab7d7947e68e9ee6afef201fb38c0541e08ed34c912994907a09a6bfc3d9a1c27c
+  metadata.gz: 3730b7e2add547932ce15ed3ec4a18ab52a65c20c65542547fa8c8a6a15e19aa0a2aff498d85b8237a5603099cbca3824e5dc3e4a9ba9d260dc26ec0cf3f2d62
+  data.tar.gz: ac42934a9679810c693d673d88aa656ca36f7c17cbccc66cca1cd4cadb3ce0969f50926efdb4a4716913a728235b6368bef20264ebc9d7aa374ce55cdb618f8f

data/README.md

@@ -6,217 +6,31 @@
 This package makes it easy to instrument your Ruby web app to send useful events to [Honeycomb](https://www.honeycomb.io), a service for debugging your software in production.
 - [Usage and Examples](https://docs.honeycomb.io/getting-data-in/beelines/ruby-beeline/)
 
-Requires Ruby 2.2 or later. Sign up for a [Honeycomb
+Sign up for a [Honeycomb
 trial](https://ui.honeycomb.io/signup) to obtain an API key before starting.
 
-## Installation
+## Compatible with
 
-Add `honeycomb-beeline` to your Gemfile:
+Requires Ruby version 2.2 or later
 
-```ruby
-gem 'honeycomb-beeline'
-```
-Now run `bundle install` to install the gem.
+Built in instrumentation for:
 
-## Setup
+- Active Record 4 or later
+- Rails 4 or later
+- Faraday 0.8 or later
+- Sequel
+- Rack 1 or greater
 
-In your app's startup script - e.g. config.ru or app.rb - add the following
-code:
+## Get in touch
 
-```ruby
-require 'honeycomb-beeline'
+Please reach out to [support@honeycomb.io](mailto:support@honeycomb.io) or ping
+us with the chat bubble on [our website](https://www.honeycomb.io) for any
+assistance. We also welcome [bug reports](https://github.com/honeycombio/beeline-ruby/issues).
 
-Honeycomb.init # pulls configuration from the environment - see below
-```
+## Contributions
 
-## Configuration
+Features, bug fixes and other changes to `beeline-ruby` are gladly accepted. Please
+open issues or a pull request with your change. Remember to add your name to the
+CONTRIBUTORS file!
 
-You'll need to configure your Honeycomb API key so that your app can
-identify itself to Honeycomb. You can find your API key on [your Account
-page](https://ui.honeycomb.io/account).
-
-You'll also need to configure the name of a dataset in your Honeycomb account to
-send events to. The name of your app is a good choice.
-
-You can specify the configuration either via environment variables, or by
-passing arguments to `Honeycomb.init`:
-
-### Configuration via environment variables
-
- * `HONEYCOMB_WRITEKEY` - specifies the API key (aka "write key")
- * `HONEYCOMB_DATASET` - specifies the dataset
- * `HONEYCOMB_SERVICE` - specifies the name of your app (defaults to the dataset
-   name)
-
-### Configuration via code
-
-```ruby
-Honeycomb.init(
-  writekey: '<MY HONEYCOMB API KEY>',
-  dataset: 'my-app',
-  service_name: 'my-app'
-)
-```
-
-Note that Honeycomb API keys have the ability to create and delete data, and
-should be managed in the same way as your other application secrets. For example
-you might prefer to configure production API keys via environment variables,
-rather than checking them into version control.
-
-## Example questions
-
-Now your app is instrumented and sending events, try using Honeycomb to ask
-these questions:
-
- * Which of my app's routes are the slowest?
-```
-BREAKDOWN: request.path
-CALCULATE: P99(duration_ms)
-FILTER: type == http_server
-ORDER BY: P99(duration_ms) DESC
-```
- * Where's my app spending the most time?
-```
-BREAKDOWN: type
-CALCULATE: SUM(duration_ms)
-ORDER BY: SUM(duration_ms) DESC
-```
- * Which users are using the endpoint that I'd like to deprecate? First add a
-   [custom field](#adding-additional-context) `user.email`, then try:
-```
-BREAKDOWN: app.user.email
-CALCULATE: COUNT
-FILTER: request.path == /my/deprecated/endpoint
-```
-
-## Example event
-
-Here is an example of an `http_server` event (recording that your web app
-processed an incoming HTTP request) emitted by the Beeline:
-
-```json
-{
-  "meta.beeline_version": "0.2.0",
-  "meta.local_hostname": "killerbee",
-  "service_name": "my-test-app",
-  "meta.package": "rack",
-  "meta.package_version": "1.3",
-  "type": "http_server",
-  "name": "GET /dashboard",
-  "request.method": "GET",
-  "request.path": "/dashboard",
-  "request.protocol": "https",
-  "request.http_version": "HTTP/1.1",
-  "request.host": "my-test-app.example.com",
-  "request.remote_addr": "172.217.1.238",
-  "request.header.user_agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36",
-  "trace.trace_id": "b694512a-833f-4b35-be5f-6c742ba18e12",
-  "trace.span_id": "c35cc326-ed90-4881-a4a8-68526d252f2e",
-  "response.status_code": 200,
-  "duration_ms": 303.057396
-}
-```
-
-## Adding additional context
-
-The Beeline will automatically instrument your incoming HTTP requests, database
-queries and outbound HTTP requests to send events to Honeycomb. However, it can
-be very helpful to extend these events with additional context specific to your
-app.  You can add your own fields by calling `Rack::Honeycomb.add_field`. For
-example, this snippet shows how to associate the currently logged-in user with
-each `http_server` event:
-
-```ruby
-get '/hello' do
-  user = authenticate_user()
-
-  # this will add a custom field 'app.user.email' to the http_server event
-  Rack::Honeycomb.add_field(env, 'user.email', user.email)
-
-  "Hello, #{user.name}!"
-end
-```
-
-## Instrumented packages
-
-The Beeline will automatically send the following events if you are using one of
-the listed packages:
-
-### `http_server` (incoming HTTP requests)
-
-* [Sinatra](http://sinatrarb.com) - via [rack-honeycomb](https://github.com/honeycombio/rack-honeycomb)
-* Any other [Rack](https://rack.github.io)-based web app - via [rack-honeycomb](https://github.com/honeycombio/rack-honeycomb) (requires manually adding the middleware)
-
-### `db` (database queries)
-
-* [ActiveRecord](https://rubygems.org/gems/activerecord) - via
-  [activerecord-honeycomb](https://github.com/honeycombio/activerecord-honeycomb)
-* [Sequel](https://sequel.jeremyevans.net/) - via
-  [sequel-honeycomb](https://github.com/honeycombio/sequel-honeycomb)
-
-### `http_client` (outbound HTTP requests)
-
-* [Faraday](https://github.com/lostisland/faraday) - via
-  [faraday-honeycomb](https://github.com/honeycombio/faraday-honeycomb)
-
-## Known limitations
-
- * The Beeline will try to autodetect your web framework and automatically
-   install its middleware. Currently this only works for Sinatra apps, and
-   also fails in some more exotic configurations of Sinatra. If you find you
-   aren't seeing any events for processing web requests, you can install the
-   [middleware](https://www.rubydoc.info/gems/rack-honeycomb) manually: e.g.
-   `use Rack::Honeycomb::Middleware`.
- * Rails apps should work after installing the middleware as above, but are
-   currently better supported by our dedicated [Rails
-   integration](https://github.com/honeycombio/honeycomb-rails).
- * Alternative concurrency models such as EventMachine or Celluloid are not
-   currently supported.
-
-If support for one of these scenarios is important to you, please [let us
-know](#get-in-touch)!
-
-## Troubleshooting
-
-If you've setup the Beeline as above but you aren't seeing data for your app in
-Honeycomb, or you're seeing errors on startup, here are a few things to try:
-
-### Debug mode
-
-To verify the Beeline is working as expected, try running it in debug mode:
-
-```ruby
-Honeycomb.init(debug: true)
-```
-
-Alternatively, you can also enable debug mode with no code changes by setting
-`HONEYCOMB_DEBUG=true` in your environment.
-
-In debug mode, the Beeline will not send any events to Honeycomb, but will
-instead print them to your app's standard error. It will also log startup
-messages to standard error.
-
-### Logging
-
-By default the Beeline will log errors but otherwise keep quiet. To see more
-detail about what it's doing, you can pass a logger object (compliant with the
-[stdlib Logger API](https://ruby-doc.org/stdlib-2.4.1/libdoc/logger/rdoc/)) to
-`Honeycomb.init`:
-
-```ruby
-require 'logger'
-logger = Logger.new($stderr)
-logger.level = Logger::INFO           # determine how much detail you want to see
-Honeycomb.init(logger: logger)
-```
-
-A level of `Logger::DEBUG` will show you detail about each library being instrumented,
-whereas a level of `Logger::INFO` will just print a few progress messages.
-
-### Get in touch
-
-This beeline is still young, so please reach out to
-[support@honeycomb.io](mailto:support@honeycomb.io) or ping us with the chat
-bubble on [our website](https://www.honeycomb.io) for assistance.  We also
-welcome [bug reports](https://github.com/honeycombio/beeline-ruby/issues) and
-[contributions](https://github.com/honeycombio/beeline-ruby/blob/master/CONTRIBUTING.md).
+All contributions will be released under the Apache License 2.0.

data/lib/honeycomb/beeline/version.rb

@@ -1,6 +1,6 @@
 module Honeycomb
   module Beeline
     GEM_NAME = 'honeycomb-beeline'
-    VERSION = '0.5.0'
+    VERSION = '0.6.0'
   end
 end

data/lib/honeycomb/client.rb

@@ -72,7 +72,7 @@ module Honeycomb
       @client = new_client(options)
 
       after_init_hooks.each do |label, block|
-        @logger.debug "Running hook '#{label}' after Honeycomb.init" if @logger
+        debug "Running hook '#{label}' after Honeycomb.init"
         run_hook(label, block)
       end
 
@@ -106,6 +106,16 @@ module Honeycomb
     end
 
     private
+    def debug(msg)
+      logger.debug msg if logger
+    end
+    def info(msg)
+      logger.info msg if logger
+    end
+    def warn(msg)
+      logger.warn msg if logger
+    end
+
     def after_init_hooks
       @after_init_hooks ||= []
     end
@@ -116,13 +126,13 @@ module Honeycomb
       options = {user_agent_addition: USER_AGENT_SUFFIX}.merge(options)
       if @debug
         raise ArgumentError, "can't specify both client and debug options", caller if client
-        @logger.info 'logging events to standard error instead of sending to Honeycomb' if @logger
+        info 'logging events to standard error instead of sending to Honeycomb'
         client = Libhoney::LogClient.new(verbose: true, **options)
       else
         client ||= if options[:writekey] && options[:dataset]
           Libhoney::Client.new(options)
         else
-          @logger.warn "#{self.name}: no #{options[:writekey] ? 'dataset' : 'writekey'} configured, disabling sending events" if @logger
+          warn "#{self.name}: no #{options[:writekey] ? 'dataset' : 'writekey'} configured, disabling sending events"
           Libhoney::NullClient.new(options)
         end
       end
@@ -146,7 +156,7 @@ module Honeycomb
              end
 
       if defined?(@initialized)
-        @logger.debug "Running hook '#{label}' as Honeycomb already initialized" if @logger
+        debug "Running hook '#{label}' as Honeycomb already initialized"
         run_hook(label, hook)
       else
         after_init_hooks << [label, hook]
@@ -155,12 +165,12 @@ module Honeycomb
 
     def run_hook(label, block)
       if @without.include?(label)
-        @logger.debug "Skipping hook '#{label}' due to opt-out" if @logger
+        debug "Skipping hook '#{label}' due to opt-out"
       else
         block.call @client, @logger
       end
     rescue => e
-      @logger.warn "Honeycomb.init hook '#{label}' raised #{e.class}: #{e}" if @logger
+      warn "Honeycomb.init hook '#{label}' raised #{e.class}: #{e}"
     end
   end
 

data/lib/honeycomb/span.rb

@@ -1,42 +1,50 @@
+require 'base64'
+require 'json'
 require 'securerandom'
 
 module Honeycomb
   class << self
-    # @api private
-    def with_trace_id(trace_id = SecureRandom.uuid)
-      Thread.current[:honeycomb_trace_id] = trace_id
-      yield trace_id
-    ensure
-      Thread.current[:honeycomb_trace_id] = nil
-    end
+    # Start a new trace. Calling {.span} will automatically start a new trace if
+    # one is not already active, so you do not need to call this explicitly
+    # unless you want to specify the trace id or parent span id (e.g. to
+    # propagate a trace id received from upstream).
+    def trace(trace_id: nil, parent_span_id: nil, context: {}, **extra_context)
+      context = context.merge(extra_context)
 
-    # @api private
-    def trace_id
-      Thread.current[:honeycomb_trace_id]
+      with_trace trace_id: trace_id, parent_span_id: parent_span_id, context: context do
+        yield
+      end
     end
 
-    # @api private
-    def with_span_id(span_id)
-      parent_span_id = Thread.current[:honeycomb_span_id]
-      Thread.current[:honeycomb_span_id] = span_id
-      yield parent_span_id
-    ensure
-      Thread.current[:honeycomb_span_id] = parent_span_id
+    # Continue a trace from a serialized trace context, e.g. propagated from
+    # another process.
+    def trace_from_encoded_context(encoded_context = nil, additional_context: {})
+      trace_context = decode_trace_context(encoded_context) || {}
+      trace_id = trace_context[:trace_id]
+      parent_span_id = trace_context[:parent_span_id]
+      context = trace_context[:context] || {}
+
+      trace(trace_id: trace_id, parent_span_id: parent_span_id, context: context.merge(additional_context)) do
+        yield
+      end
     end
 
-    # @api private
-    def span(service_name:, name:, span_id: SecureRandom.uuid)
+    # Start a new span, and send it at the end of the supplied code block. This
+    # will start a new trace if one is not already active.
+    def span(name = nil, type: 'app', fields: {}, **extra_fields)
+      fields = fields.merge(extra_fields)
+
+      start = nil
+
       event = client.event
+      span_for_existing_event(event, name: name, type: type) do |span_id, trace_id|
+        fields.each do |field, value|
+          event.add_field "app.#{field}", value
+        end
 
-      event.add_field 'trace.trace_id', trace_id if trace_id
-      event.add_field 'service_name', service_name
-      event.add_field 'name', name
-      event.add_field 'trace.span_id', span_id
+        start = Time.now
 
-      start = Time.now
-      with_span_id(span_id) do |parent_span_id|
-        event.add_field 'trace.parent_id', parent_span_id if parent_span_id
-        yield
+        yield span_id, trace_id
       end
     rescue Exception => e
       if event
@@ -53,5 +61,235 @@ module Honeycomb
         event.send
       end
     end
+
+    # Start a new span, and annotate an existing {Libhoney::Event} with its
+    # tracing fields. Most users should call {.span} instead, since it has
+    # simpler semantics (e.g. it will time the execution of the code block for
+    # you, record any exceptions that were thrown, and send the event at the end
+    # of the code block). This method is mainly useful if you are writing a
+    # library instrumentation which needs to also work independently of the
+    # Beeline, and which therefore needs to implement those semantics itself; or
+    # which needs custom error handling, e.g. adding custom fields in case of
+    # error.
+    def span_for_existing_event(event, name:, type:)
+      with_trace do |trace_id, context|
+        with_span do |parent_span_id, span_id|
+          event.add_field 'trace.trace_id', trace_id
+          event.add_field 'trace.parent_id', parent_span_id if parent_span_id
+          event.add_field 'trace.span_id', span_id
+          event.add_field 'name', name if name
+          event.add_field 'type', type
+
+          context.each do |field, value|
+            event.add_field "app.#{field}", value
+          end
+
+          yield span_id, trace_id
+        end
+      end
+    end
+
+    # Add a trace field, which will get added to all spans sent after this call.
+    def add_trace_field(name, value)
+      self.active_trace_context[name] = value
+      # TODO right now this will only add the field to all spans *started* after
+      # this call, which unfortunately excludes the actual active span when the
+      # call was made. One way to fix this is to change .span_for_existing_event
+      # to add fields from .active_trace_context _after_ the yield (in a
+      # begin/ensure block) instead of before.
+    end
+
+    def decode_trace_context(encoded_context)
+      return nil unless encoded_context
+      version, payload = encoded_context.split(';', 2)
+      case version
+      when '1'
+        decode_payload_v1(payload)
+      else
+        warn "#{self}.decode_trace_context: unrecognized trace context version #{version.inspect}"
+        nil
+      end
+    end
+
+    def encode_trace_context_v1(trace_id, parent_span_id, context)
+      version = 1
+
+      encoded_payload = encode_payload_v1(
+        trace_id: trace_id,
+        parent_id: parent_span_id,
+        context: context,
+      )
+
+      "#{version};#{encoded_payload}"
+    end
+    alias encode_trace_context encode_trace_context_v1
+
+    def active_trace_id
+      Thread.current[:honeycomb_trace_id]
+    end
+    def active_trace_id=(trace_id)
+      Thread.current[:honeycomb_trace_id] = trace_id
+    end
+
+    def active_parent_span_id
+      Thread.current[:honeycomb_parent_span_id]
+    end
+    def active_parent_span_id=(parent_span_id)
+      Thread.current[:honeycomb_parent_span_id] = parent_span_id
+    end
+
+    def active_trace_context
+      Thread.current[:honeycomb_trace_context]
+    end
+    def active_trace_context=(trace_context)
+      Thread.current[:honeycomb_trace_context] = trace_context
+    end
+
+    private
+    def with_trace(trace_id: nil, parent_span_id: nil, context: nil)
+      if self.active_trace_id
+        if trace_id
+          warn "#{self}.with_trace called while another trace is already active; ignoring supplied trace_id and preserving existing one"
+        end
+        yield self.active_trace_id, self.active_trace_context
+      else
+        begin
+          trace_id, context = start_trace!(trace_id: trace_id, parent_span_id: parent_span_id, context: context)
+
+          yield trace_id, context
+        ensure
+          finish_trace!
+        end
+      end
+    end
+
+    def start_trace!(trace_id: nil, parent_span_id: nil, context: nil)
+      raise "#{self}.start_trace! called while another trace is already active" if self.active_trace_id
+
+      trace_id ||= SecureRandom.uuid
+      self.active_trace_id = trace_id
+
+      self.active_parent_span_id = parent_span_id if parent_span_id
+
+      context ||= {}
+      self.active_trace_context = context
+
+      [trace_id, context]
+    end
+
+    def finish_trace!
+      self.active_trace_id = nil
+      self.active_parent_span_id = nil
+      self.active_trace_context = nil
+    end
+
+    def with_span
+      parent_span_id, span_id = start_span!
+
+      yield parent_span_id, span_id
+    ensure
+      finish_span!(parent_span_id)
+    end
+
+    def start_span!
+      span_id = SecureRandom.uuid
+
+      parent_span_id = self.active_parent_span_id
+      self.active_parent_span_id = span_id
+
+      return parent_span_id, span_id
+    end
+
+    def finish_span!(parent_span_id)
+      self.active_parent_span_id = parent_span_id
+    end
+
+    def decode_payload_v1(encoded_payload)
+      trace_id, parent_span_id, context = nil
+
+      encoded_payload.split(',').each do |entry|
+        k, v = entry.split('=', 2)
+        case k
+        when 'trace_id'
+          trace_id = v
+        when 'parent_id'
+          parent_span_id = v
+        when 'context'
+          context = decode_payload_context_v1(v)
+        else
+          debug "#{self}.decode_payload_v1: unrecognized payload key #{k.inspect}"
+        end
+      end
+
+      if trace_id.nil?
+        warn "#{self}.decode_payload_v1: no trace_id in context"
+        return nil
+      elsif parent_span_id.nil?
+        warn "#{self}.decode_payload_v1: no parent_id in context"
+        return nil
+      end
+
+      payload = {
+        trace_id: trace_id,
+        parent_span_id: parent_span_id,
+      }
+      payload[:context] = context if context
+      payload
+    rescue StandardError => e
+      warn "#{self}.decode_payload_v1: encountered #{e.class} decoding payload: #{e}"
+      nil
+    end
+
+    def decode_payload_context_v1(encoded_payload_context)
+      return {} if encoded_payload_context.empty?
+      json = Base64.decode64(encoded_payload_context)
+      JSON.parse(json)
+    end
+
+    def encode_payload_v1(payload_parts)
+      payload_parts.map do |k, v|
+        encoded_part = encode_payload_part_v1(k, v)
+        encoded_part ? "#{k}=#{encoded_part}" : nil
+      end
+        .compact # strip out parts that failed to encode
+        .join(',')
+    end
+
+    def encode_payload_part_v1(param, value)
+      case param
+      when :trace_id, :parent_id
+        encode_payload_id_v1(value)
+      when :context
+        encode_payload_context_v1(value)
+      end
+    end
+
+    def encode_payload_id_v1(id)
+      case id
+      when nil
+        nil
+      when String, Symbol
+        id = id.to_s
+        if id.include? ','
+          raise ArgumentError, "can't include ','"
+        end
+        id
+      when Numeric
+        id.to_s
+      else
+        raise ArgumentError, "invalid type #{id.class}"
+      end
+    end
+
+    def encode_payload_context_v1(context)
+      case context
+      when nil
+        nil
+      when Hash
+        Base64.urlsafe_encode64(JSON.generate(context)).strip
+      else
+        raise ArgumentError, "invalid type #{context.class}"
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: honeycomb-beeline
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Sam Stokes
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-19 00:00:00.000000000 Z
+date: 2018-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: libhoney
@@ -30,56 +30,56 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.4.0
 - !ruby/object:Gem::Dependency
   name: rack-honeycomb
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.4.0
 - !ruby/object:Gem::Dependency
   name: faraday-honeycomb
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.3.0
 - !ruby/object:Gem::Dependency
   name: sequel-honeycomb
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.4.0
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement