devbench 0.5.0 → 0.7.0

data/lib/devbench/logs.rb

@@ -0,0 +1,413 @@
+# frozen_string_literal: true
+
+require 'logger'
+require_relative 'current'
+
+module Devbench
+  # In-process log capture (docs/SERVER_SDK_SPEC.md, "In-process log capture
+  # (direct mode)"; DECISIONS #161): recent log lines kept in memory, keyed
+  # by the trace that was current when each was written, so triage can be
+  # handed the server lines of one user action without a sidecar.
+  #
+  # Two ways in, both installed by the Railtie in direct mode only:
+  #
+  #   * Rails 7.1+ (Rails.logger is an ActiveSupport::BroadcastLogger):
+  #     broadcast_to a CaptureLogger — Rails' own public API for "also send
+  #     these lines there". It writes nothing anywhere; it only remembers.
+  #   * Any other ::Logger (Rails < 7.1, Sidekiq.logger, a plain Logger):
+  #     a Tee prepended to that one logger object. It calls the logger's own
+  #     #add first, unchanged, and remembers the line afterwards; a block
+  #     message is evaluated once, by the logger, and its value reused.
+  #
+  # Never harms the host: what the app's logger writes is untouched; a line
+  # with no current trace costs one thread-local read; the buffer lock is
+  # held for an Array push, never across I/O or redaction; nothing raises
+  # out of a logging call. Fork-safe: a child starts with an empty buffer.
+  module Logs
+    MAX_LINES = 10_000
+    MAX_BYTES = 4 * 1024 * 1024
+    MAX_AGE = 15 * 60
+    MAX_LINE_BYTES = 4096
+    # Lines held from one multi-line message (an exception and its
+    # backtrace): the top of it, so one framework backtrace cannot push the
+    # rest of the request out of a 200-line slice.
+    MAX_MESSAGE_LINES = 50
+
+    SEVERITY = %w[DEBUG INFO WARN ERROR FATAL].freeze
+    # The last line captured on this thread, and by which hook: see #capture.
+    LAST = :__devbench_last_log
+
+    # Bounded, thread-safe, per-trace store of recent lines. Oldest evicted
+    # first, by count, bytes and age.
+    class Buffer
+      Entry = Struct.new(:key, :at, :text)
+
+      def initialize(max_lines: MAX_LINES, max_bytes: MAX_BYTES, max_age: MAX_AGE,
+                     clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
+        @max_lines = max_lines
+        @max_bytes = max_bytes
+        @max_age = max_age
+        @clock = clock
+        @lock = Mutex.new
+        reset
+      end
+
+      # Keeps one line under a trace key.
+      def push(key, text)
+        now = @clock.call
+        entry = Entry.new(key, now, text)
+        @lock.synchronize do
+          reset if @pid != Process.pid
+          @entries << entry
+          (@by_key[key] ||= []) << entry
+          @bytes += text.bytesize
+          evict(now)
+        end
+        nil
+      end
+
+      # The lines held for a key, oldest first, at most `limit` (the most
+      # recent ones when there are more). A copy: the caller redacts it
+      # outside the lock.
+      def lookup(key, limit)
+        @lock.synchronize do
+          reset if @pid != Process.pid
+          evict(@clock.call)
+          list = @by_key[key]
+          return [] if list.nil?
+
+          (list.length > limit ? list.last(limit) : list).map(&:text)
+        end
+      end
+
+      def size
+        @lock.synchronize { @entries.length }
+      end
+
+      # Whether any line younger than the age bound is held (by this
+      # process).
+      def any?
+        @lock.synchronize do
+          reset if @pid != Process.pid
+          evict(@clock.call)
+          !@entries.empty?
+        end
+      end
+
+      def bytes
+        @lock.synchronize { @bytes }
+      end
+
+      def clear
+        @lock.synchronize { reset }
+      end
+
+      private
+
+      def reset
+        @pid = Process.pid
+        @entries = []
+        @by_key = {}
+        @bytes = 0
+      end
+
+      # Every entry is the oldest of its own key when it is the oldest
+      # overall, so removing it from its key's list is a shift.
+      def evict(now)
+        cutoff = now - @max_age
+        while (oldest = @entries.first) &&
+              (@entries.length > @max_lines || @bytes > @max_bytes || oldest.at < cutoff)
+          @entries.shift
+          list = @by_key[oldest.key]
+          list.shift
+          @by_key.delete(oldest.key) if list.empty?
+          @bytes -= oldest.text.bytesize
+        end
+      end
+    end
+
+    # Rails 7.1+: the logger handed to BroadcastLogger#broadcast_to. Its
+    # level mirrors the app's other loggers, so adding it never turns on a
+    # level the app has off (BroadcastLogger#level is the minimum of its
+    # loggers, and #debug? asks whether any is at debug). It has no #tagged:
+    # BroadcastLogger would run a tagged block once per logger that has one.
+    module CaptureLogger
+      attr_accessor :devbench_broadcast
+
+      def level
+        own = super
+        others = devbench_broadcast&.broadcasts&.reject { |l| l.equal?(self) }
+        return own if others.nil? || others.empty?
+
+        mirrored = others.map(&:level).min
+        local = respond_to?(:local_level) ? local_level : nil
+        local.nil? ? mirrored : [local, mirrored].max
+      rescue StandardError, SystemStackError
+        ::Logger::FATAL
+      end
+
+      def add(severity, message = nil, progname = nil)
+        severity ||= ::Logger::UNKNOWN
+        return true if severity < level || Current.trace.nil?
+
+        if message.nil?
+          message = block_given? ? yield : progname
+        end
+        Logs.capture(severity, message, :broadcast, Logs.broadcast_tags(devbench_broadcast, self))
+        true
+      rescue StandardError, SystemStackError
+        true
+      end
+      alias log add
+
+      def <<(message)
+        Logs.capture(nil, message, :broadcast, Logs.broadcast_tags(devbench_broadcast, self)) unless Current.trace.nil?
+        self
+      rescue StandardError, SystemStackError
+        self
+      end
+    end
+
+    # Every other ::Logger: prepended to the one logger object's singleton
+    # class. The logger's own #add runs first, exactly as before; only then
+    # is the line remembered.
+    module Tee
+      def add(severity, message = nil, progname = nil, &block)
+        return super if Current.trace.nil? || !Logs.active?
+
+        yielded = false
+        value = nil
+        if block
+          original = block
+          block = proc do
+            value = original.call
+            yielded = true
+            value
+          end
+        end
+        result = super(severity, message, progname, &block)
+        Logs.tee(self, severity, message, progname, !block.nil?, yielded, value)
+        result
+      end
+      alias log add
+    end
+
+    class << self
+      def buffer
+        @buffer ||= Buffer.new
+      end
+
+      # For tests: a buffer with other bounds or a controllable clock.
+      attr_writer :buffer
+
+      # Whether capture is on: direct mode, after install. Hooks stay in
+      # place when it is turned off, and do nothing.
+      def active?
+        @active ? true : false
+      end
+
+      # A new transport (Devbench.configure) must be started again by the
+      # next line held, so both reset the per-process start.
+      def activate!
+        @polling_pid = nil
+        @active = true
+      end
+
+      # Whether any logger was hooked in this process.
+      def hooked?
+        @hooked ? true : false
+      end
+
+      def deactivate!
+        @polling_pid = nil
+        @active = false
+      end
+
+      # Hooks one logger. Returns :broadcast, :tee, or nil (not a logger we
+      # can hook — left alone). Idempotent.
+      def install(logger)
+        return nil if logger.nil?
+
+        if logger.respond_to?(:broadcast_to) && logger.respond_to?(:broadcasts)
+          return :broadcast if logger.broadcasts.any? { |l| l.is_a?(CaptureLogger) }
+
+          capture = capture_logger_class.new(nil)
+          capture.level = logger.level
+          capture.devbench_broadcast = logger
+          logger.broadcast_to(capture)
+          @hooked = true
+          :broadcast
+        elsif logger.is_a?(::Logger)
+          logger.singleton_class.prepend(Tee) unless logger.singleton_class.include?(Tee)
+          @hooked = true
+          :tee
+        end
+      rescue StandardError, SystemStackError
+        nil
+      end
+
+      # Whether this process holds any traced line: the transport polls
+      # ingest for log requests only then.
+      def holding?
+        buffer.any?
+      rescue StandardError, SystemStackError
+        false
+      end
+
+      # The lines held for one trace key (session/intent), oldest first.
+      def lookup(key, limit)
+        buffer.lookup(key, limit)
+      rescue StandardError, SystemStackError
+        []
+      end
+
+      # The tag prefixes of the app's loggers in a broadcast (not ours): the
+      # one Rails wrote after each newline of a multi-line message is the
+      # first broadcast's, but which logger is first is the app's choice.
+      # A Proc, so a single-line message never computes it.
+      def broadcast_tags(broadcast, own)
+        lambda do
+          loggers = broadcast&.broadcasts || []
+          loggers.reject { |l| l.equal?(own) }.filter_map { |l| tags_of(l) }
+        end
+      end
+
+      # Called by Tee after the logger's own #add returned.
+      def tee(logger, severity, message, progname, had_block, yielded, value)
+        severity ||= ::Logger::UNKNOWN
+        return if severity < logger.level
+
+        if message.nil?
+          return if had_block && !yielded
+
+          message = had_block ? value : progname
+        end
+        capture(severity, message, :tee, -> { tags_of(logger) })
+      rescue StandardError, SystemStackError
+        nil
+      end
+
+      # Keeps one message under the current trace — one entry per line of
+      # it (see #lines_for). Never raises. `tags` is the tag prefix of the
+      # logger written to (an Array of candidates, or a Proc giving one),
+      # needed only for a multi-line message.
+      #
+      # One line can reach both hooks: in a Sidekiq process Rails.logger may
+      # broadcast to Sidekiq.logger. Both run on this thread, one right
+      # after the other, so a line equal to the one just captured *by the
+      # other hook* is that same write and is skipped. The same hook
+      # repeating a line is a real repeat and is kept.
+      def capture(severity, message, source, tags = nil)
+        return nil unless active?
+
+        trace = Current.trace
+        return nil if trace.nil?
+
+        lines = lines_for(trace, severity, message, tags)
+        return nil if lines.empty?
+
+        written = lines.join("\n")
+        last = Thread.current[LAST]
+        if last && last[0] != source && last[1] == written
+          Thread.current[LAST] = nil
+          return nil
+        end
+        Thread.current[LAST] = [source, written]
+        lines.each { |line| buffer.push(trace.key, line) }
+        start_polling if @polling_pid != Process.pid
+        nil
+      rescue StandardError, SystemStackError, ThreadError
+        nil
+      end
+
+      private
+
+      # The first line this process holds starts the transport's flush
+      # thread, so a process with nothing to report still polls for log
+      # requests (a forked worker included: the PID is per process).
+      def start_polling
+        @polling_pid = Process.pid
+        transport = Devbench.transport
+        transport.start if transport.respond_to?(:start)
+      end
+
+      # "[a] [b] " — what ActiveSupport::TaggedLogging puts before a line,
+      # and what ActionDispatch::DebugExceptions puts after every newline of
+      # the exception it logs as one message. nil when the logger has none.
+      def tags_of(logger)
+        formatter = logger.respond_to?(:formatter) ? logger.formatter : nil
+        return nil unless formatter.respond_to?(:tags_text)
+
+        text = formatter.tags_text.to_s
+        text.empty? ? nil : text
+      end
+
+      # "[v1/s/i/h] INFO message", at most MAX_LINE_BYTES, valid UTF-8 —
+      # one per line of the message. A multi-line message (Rails logs an
+      # exception and its backtrace as one) is split so each line reaches
+      # triage on its own, with the logger's tags removed from the start of
+      # continuation lines (the trace frames each line once) and blank
+      # lines dropped. At most MAX_MESSAGE_LINES; when more, the last says
+      # how many were left out.
+      def lines_for(trace, severity, message, tags)
+        label = severity.is_a?(Integer) ? SEVERITY[severity] : nil
+        prefix = label ? "[#{trace}] #{label} " : "[#{trace}] "
+        text = message_text(message)
+        text = text.dup.force_encoding(Encoding::UTF_8) unless text.encoding == Encoding::UTF_8
+        text = text.scrub('') unless text.valid_encoding?
+        return [bound_line(prefix + text)] unless text.include?("\n")
+
+        prefixes = tag_prefixes(tags)
+        parts = text.split("\n").each_with_index.filter_map do |part, i|
+          part = untag(part, prefixes) if i.positive?
+          part = part.chomp("\r")
+          part unless part.strip.empty?
+        end
+        return [] if parts.empty?
+
+        if parts.length > MAX_MESSAGE_LINES
+          omitted = parts.length - (MAX_MESSAGE_LINES - 1)
+          parts = parts.first(MAX_MESSAGE_LINES - 1) << "... (#{omitted} more lines)"
+        end
+        parts.map { |part| bound_line(prefix + part) }
+      end
+
+      # A logger whose formatter fails to give its tags costs the untagging,
+      # never the line.
+      def tag_prefixes(tags)
+        Array(tags.respond_to?(:call) ? tags.call : tags).select { |t| t.is_a?(::String) && !t.empty? }
+      rescue StandardError, SystemStackError
+        []
+      end
+
+      def untag(part, prefixes)
+        found = prefixes.find { |p| part.start_with?(p) }
+        found ? part[found.length..] : part
+      end
+
+      def bound_line(line)
+        line = line.byteslice(0, MAX_LINE_BYTES) if line.bytesize > MAX_LINE_BYTES
+        line = line.dup.force_encoding(Encoding::UTF_8) unless line.encoding == Encoding::UTF_8
+        line.valid_encoding? ? line : line.scrub('')
+      end
+
+      # As ::Logger::Formatter#msg2str.
+      def message_text(message)
+        text = case message
+               when ::String then message
+               when ::Exception
+                 "#{message.message} (#{message.class})\n#{(message.backtrace || []).join("\n")}"
+               else message.inspect
+               end
+        text.end_with?("\n") ? text.chomp : text
+      end
+
+      def capture_logger_class
+        @capture_logger_class ||= begin
+          base = defined?(::ActiveSupport::Logger) ? ::ActiveSupport::Logger : ::Logger
+          Class.new(base) { include CaptureLogger }
+        end
+      end
+    end
+  end
+end

data/lib/devbench/railtie.rb

@@ -3,6 +3,7 @@
 require_relative 'middleware'
 require_relative 'rails_hooks'
 require_relative 'sidekiq_hooks'
+require_relative 'view_helper'
 
 module Devbench
   # Hooks Dev Bench into Rails at boot. Loaded by lib/devbench.rb only when
@@ -40,6 +41,11 @@ module Devbench
       nil
     end
 
+    # <%= devbench_script_tag %> in any view or layout.
+    initializer 'devbench.view_helper' do
+      ActiveSupport.on_load(:action_view) { include Devbench::ViewHelper }
+    end
+
     # rake devbench:test — check the DSN without waiting for a flush.
     rake_tasks do
       namespace :devbench do
@@ -62,12 +68,27 @@ module Devbench
         # Native Sidekiq jobs never reach the ActiveJob hook. after_initialize
         # runs after every gem is required, so Gemfile order does not matter.
         Devbench::SidekiqHooks.install if defined?(::Sidekiq)
+
+        # Server log lines for triage, kept in-process (direct mode only).
+        # After the app's initializers, so the logger they configured is the
+        # one hooked.
+        Devbench::Railtie.capture_logs
       rescue StandardError, SystemStackError
         nil
       end
     end
 
     class << self
+      # Rails.logger, plus Sidekiq's logger when Sidekiq is loaded. A no-op
+      # unless reporting is direct.
+      def capture_logs
+        loggers = [::Rails.logger]
+        loggers << ::Sidekiq.logger if defined?(::Sidekiq) && ::Sidekiq.respond_to?(:logger)
+        Devbench.capture_logs(loggers.compact)
+      rescue StandardError, SystemStackError
+        false
+      end
+
       # Records the conditional insert on a MiddlewareStackProxy. Returns
       # true when recorded.
       def auto_insert(proxy)

data/lib/devbench/scrub.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'fingerprint'
+require_relative 'egress_policy'
 
 module Devbench
   # A port of the sidecar's strict egress (internal/scrub and
@@ -109,25 +110,62 @@ module Devbench
       end
 
       # The sidecar's forEgress in strict mode, for one line: any trace kept
-      # as is, the rest templated, scrubbed and prose-masked.
-      def egress(line)
+      # as is, the rest templated, scrubbed and prose-masked — then the
+      # learned rules (an EgressPolicy), exactly as Sidecar.redactBody
+      # applies them:
+      #
+      #   shape 'none'   the content never leaves: <withheld:shape:<fp12>>
+      #   shape 'full'   lifts only the prose heuristic, never base redaction
+      #   shape 'masked' prose heuristic (already on in strict mode)
+      #   field / term   masked afterwards, whatever the shape rule says
+      #
+      # Shape rules are keyed by the line's shape fingerprint, as the sidecar
+      # computes it (log_template / sidecar / service / the trace-stripped
+      # line).
+      def egress(line, policy = nil, service = '')
         line = utf8(line)
         match = TRACE.match(line)
         body = match ? line.gsub(TRACE, '<trace>') : line
-        redacted = strict(body)
+        fp, rule = shape_rule(policy, service, body)
+        redacted = if rule == EgressPolicy::NONE
+                     withheld(fp)
+                   else
+                     redact_body(body, rule, policy)
+                   end
         match ? "[#{match[0]}] #{redacted}" : redacted
       end
 
       # A bundle's template text: as the sidecar's answerEvidenceRequests
-      # does, strict redaction and then a second shape pass.
-      def template_text(text)
-        self.text(strict(utf8(text)))
+      # does, the shape's own rule (by the signal's fingerprint), strict
+      # redaction, and then a second shape pass. Empty when the shape's
+      # content never leaves.
+      def template_text(text, policy = nil, fp = nil)
+        rule = policy && fp ? policy.rule_for(fp) : nil
+        return '' if rule == EgressPolicy::NONE
+
+        self.text(redact_body(utf8(text), rule, policy))
+      end
+
+      # What stands in for a line whose shape is marked 'none'.
+      def withheld(fp)
+        "<withheld:shape:#{fp.to_s[0, 12]}>"
       end
 
       private
 
-      def strict(body)
-        prose(text(Fingerprint.template(body)))
+      # Base redaction (template + scrub), the prose heuristic unless the
+      # shape is marked 'full', then field and term rules.
+      def redact_body(body, rule, policy)
+        redacted = text(Fingerprint.template(body))
+        redacted = prose(redacted) unless rule == EgressPolicy::FULL
+        policy ? policy.mask(redacted) : redacted
+      end
+
+      def shape_rule(policy, service, body)
+        return [nil, nil] if policy.nil? || !policy.shapes?
+
+        fp = Fingerprint.compute(kind: 'log_template', source: 'sidecar', service: service.to_s, message: body)
+        fp ? [fp, policy.rule_for(fp)] : [nil, nil]
       end
 
       def proper_noun?(token)

data/lib/devbench/sidekiq_hooks.rb

@@ -101,6 +101,10 @@ module Devbench
 
         handlers = config.error_handlers
         handlers << ERROR_HANDLER unless handlers.any? { |h| h.equal?(ERROR_HANDLER) }
+
+        # The job's own log lines (Sidekiq::Job#logger), kept under the
+        # job's trace — direct mode only, a no-op otherwise.
+        Devbench.capture_logs(config.logger) if config.respond_to?(:logger)
         true
       rescue StandardError, SystemStackError
         false

data/lib/devbench/transport.rb

@@ -3,6 +3,7 @@
 require_relative 'config'
 require_relative 'sidecar_transport'
 require_relative 'direct'
+require_relative 'logs'
 
 # Configuration and transport selection (docs/SERVER_SDK_SPEC.md,
 # "Transports: direct (default) or sidecar (optional)").
@@ -17,8 +18,6 @@ require_relative 'direct'
 # Never both: a sidecar on the same host still reads logs, but writing to
 # its socket as well would count every report twice.
 module Devbench
-  # Raised (and rescued) by Devbench.test! to make its synthetic report.
-  class TestException < StandardError; end
 
   TRANSPORT_LOCK = Mutex.new
   CONFIG_LOCK = Mutex.new
@@ -42,6 +41,9 @@ module Devbench
     def configure
       yield config if block_given?
       reset_transport!
+      # Hooks already in place follow the new configuration: on in direct
+      # mode, inert otherwise.
+      Logs.hooked? && direct? ? Logs.activate! : Logs.deactivate!
       nil
     rescue StandardError, SystemStackError => e
       warn_once(:configure, "Devbench.configure raised #{e.class}; reporting is unchanged")
@@ -60,6 +62,64 @@ module Devbench
       @transport || TRANSPORT_LOCK.synchronize { @transport ||= build_transport }
     end
 
+    # The DSN the browser sensor may hold — https://<public>@host — derived
+    # from DEVBENCH_DSN, so a page needs no setting of its own. Nil when the
+    # DSN has no public part (a 0.5 single-key DSN: that key is a server
+    # secret), does not parse, or reporting is disabled. Never raises, and
+    # never returns anything carrying the secret.
+    def browser_dsn
+      cfg = config
+      return nil unless cfg.enabled?
+
+      raw = cfg.dsn.to_s
+      cached = @browser_dsn
+      return cached[1] if cached && cached[0] == raw
+
+      value = raw.strip.empty? ? nil : DSN.parse(raw).browser_dsn
+      @browser_dsn = [raw, value]
+      value
+    rescue StandardError, SystemStackError
+      nil
+    end
+
+    # Where the browser sensor connects, for the app's CSP connect_src:
+    # the ingest host from DEVBENCH_DSN and evidence storage. Read when the
+    # CSP initializer runs, so the policy follows the DSN instead of a host
+    # frozen at generate time; empty when there is no usable DSN, so an app
+    # without Dev Bench configured (e.g. production) keeps its policy as is.
+    # `bin/rails generate devbench` adds `*Devbench.csp_connect_sources`.
+    STORAGE_SOURCE = 'https://*.storage.supabase.co'
+
+    def csp_connect_sources
+      return [] if browser_dsn.nil?
+
+      [DSN.parse(config.dsn.to_s).base, STORAGE_SOURCE]
+    rescue StandardError, SystemStackError
+      []
+    end
+
+    # True when this process reports straight to Dev Bench (a DSN is set
+    # and parses). Builds the transport if it was not built yet.
+    def direct?
+      transport.is_a?(DirectTransport)
+    rescue StandardError, SystemStackError
+      false
+    end
+
+    # Keeps recent lines from these loggers, per trace, for triage to ask
+    # for (direct mode only; elsewhere a no-op). The Railtie does this for
+    # Rails.logger and Sidekiq.logger; a Rack app without Rails calls it
+    # itself. Returns true when capture is on. Never raises.
+    def capture_logs(*loggers)
+      return false unless enabled? && direct?
+
+      hooked = loggers.flatten.map { |l| Logs.install(l) }.compact
+      Logs.activate! unless hooked.empty?
+      Logs.active?
+    rescue StandardError, SystemStackError
+      false
+    end
+
     # Sends whatever direct mode has counted, now, waiting at most `timeout`
     # seconds. A no-op in sidecar mode. Returns true when nothing is left
     # unsent. Never raises.
@@ -81,7 +141,7 @@ module Devbench
       end
       if cfg.dsn.nil? || cfg.dsn.strip.empty?
         io.puts 'DEVBENCH_DSN is not set. Set it to the DSN Dev Bench gave you for this ' \
-                'environment (https://<key>@<host>), or call Devbench.configure { |c| c.dsn = ... }.'
+                'environment (https://<public>:<secret>@<host>, from `adt dsn create`), or call Devbench.configure { |c| c.dsn = ... }.'
         return false
       end
 
@@ -92,14 +152,8 @@ module Devbench
         return false
       end
 
-      error = begin
-        raise TestException, 'Dev Bench test exception: if you can read this, the DSN works'
-      rescue TestException => e
-        e
-      end
-      payload = Reporter.report_for(error, context: 'explicit', handled: true, symbol: 'devbench:test')
       client = DirectTransport.new(dsn: dsn, service: cfg.resolved_service, release: cfg.resolved_release)
-      client.self_test(payload, io)
+      client.self_test(io)
     rescue StandardError, SystemStackError => e
       io.puts "Dev Bench test failed: #{e.class}: #{e.message}"
       false
@@ -110,6 +164,7 @@ module Devbench
     # Devbench.configure.
     def reset!
       reset_transport!
+      Logs.deactivate!
       CONFIG_LOCK.synchronize { @config = nil }
       nil
     end

data/lib/devbench/version.rb

@@ -6,5 +6,5 @@ module Devbench
   # The wire format this speaks — the trace header, the handled header, the
   # control-socket message shapes — is what a customer's deployment depends
   # on. See docs/SERVER_SDK_SPEC.md.
-  VERSION = '0.5.0'
+  VERSION = '0.7.0'
 end