appydays 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: eab73741b9b38b5e71b173859d4a21da866a0ed0d6ac2f2d336c535b60772cad
+  data.tar.gz: c801ace1467194743e5c30c2a08b91f6f735fc61cde35cbc142cae35267eaef0
+SHA512:
+  metadata.gz: dad5bd7318ec9bfe7cf73011da874787a9b38dd60305944ea3024473bf3e4eca3aaba59ad0878b6bd37f9bd65c4ffb941e88219a3bfbbd029567d1edc33ebb2d
+  data.tar.gz: 8cfb4768365e9e1c5b1b0052be6b42246bfac6379e712903ef7ff76cf5e882e7d593c65757ac34673704f3b78b0800a25adc6dff578f5e64b75c2a37d6a0daa6

data/lib/appydays.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Appydays
+  VERSION = "0.1.0"
+end

data/lib/appydays/configurable.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "appydays/version"
+
+##
+# Define the configuration for a module or class.
+#
+# Usage:
+#     include Appydays::Configurable
+#     configurable(:myapp) do
+#       setting :log_level, 'debug', env: 'LOG_LEVEL'
+#       setting :app_url, 'http://localhost:3000'
+#       setting :workers, 4
+#     end
+#
+# The module or class that extends Configurable will get two singleton methods,
+# `log_level` and `app_url`.
+# The first will be be given a value of `ENV.fetch('LOG_LEVEL', 'debug')`,
+# because the env key is provided.
+#
+# The second will be given a value of `ENV.fetch('MYAPP_APP_URL', 'http:://localhost:3000')`,
+# because the env key is defaulted.
+#
+# The second will be given a value of `4.class(ENV.fetch('MYAPP_WORKERS', 4))`.
+# Note it will coerce the type of the env value to the type of the default.
+# Empty strings will be coerced to nil.
+#
+# The `setting` method has several other options;
+# see its documentation for more details.
+#
+# The target will also get a `reset_configuration` method that will restore defaults,
+# and `run_after_configured_hooks`. See their docs for more details.
+#
+module Appydays::Configurable
+  def self.included(target)
+    target.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def configurable(key, &block)
+      raise LocalJumpError unless block
+
+      installer = Installer.new(self, key)
+
+      self.define_singleton_method(:_configuration_installer) { installer }
+
+      installer.instance_eval(&block)
+      installer._run_after_configured
+    end
+
+    ##
+    # Restore all settings back to the values they were at config time.
+    # Ie, undoes any manual attribute writes.
+    def reset_configuration
+      self._configuration_installer._reset
+    end
+
+    ##
+    # Explicitly run after configuration hooks.
+    # This may need to be run explicitly after reset,
+    # if the `after_configured` hook involves side effects.
+    # Side effects are gnarly so we don't make assumptions.
+    def run_after_configured_hooks
+      self._configuration_installer._run_after_configured
+    end
+  end
+
+  class Installer
+    def initialize(target, group_key)
+      @target = target
+      @group_key = group_key
+      @settings = {}
+      @after_config_hooks = []
+    end
+
+    ##
+    # Define a setting for the receiver,
+    # which acts as an attribute accessor.
+    #
+    # Params:
+    #
+    # name: The name of the accessor/setting.
+    # default: The default value.
+    #   If `convert` is not supplied, this must be nil, or a string, int, float, or boolean,
+    #   so the parsed environment value can be converted/coerced into the same type as 'default'.
+    #   If convert is passed, that is used as the converter so the default value can be any type.
+    # key: The key to lookup the config value from the environment.
+    #   If nil, use an auto-generated combo of the configuration key and method name.
+    # convert: If provided, call it with the string value so it can be parsed.
+    #   For example, you can parse a string JSON value here.
+    #   Convert will not be called with the default value.
+    # side_effect: If this setting should have a side effect,
+    #   like configuring an external system, it should happen in this proc/lambda.
+    #   It is called with the parsed/processed config value.
+    #
+    # Note that only ONE conversion will happen, and
+    # - If converter is provided, it will be used with the environment value.
+    def setting(name, default, key: nil, convert: nil, side_effect: nil)
+      installer = self
+
+      @target.define_singleton_method(name) do
+        self.class_variable_get("@@#{name}")
+      end
+      @target.define_singleton_method("#{name}=".to_sym) do |v|
+        installer._set_value(name, v, side_effect)
+      end
+
+      key ||= "#{@group_key}_#{name}".upcase
+      env_value = ENV.fetch(key, nil)
+      converter = self._converter(default, convert)
+      value = env_value.nil? ? default : converter[env_value]
+      value = installer._set_value(name, value, side_effect)
+      @settings[name] = value
+    end
+
+    def _set_value(name, value, side_effect)
+      value = nil if value == ""
+      # rubocop:disable Style/ClassVars
+      self._target.class_variable_set("@@#{name}", value)
+      # rubocop:enable Style/ClassVars
+      self._target.instance_exec(value, &side_effect) if side_effect
+      return value
+    end
+
+    def after_configured(&block)
+      @after_config_hooks << block
+    end
+
+    def _converter(default, converter)
+      return converter if converter
+
+      return ->(v) { v.to_s } if default.nil? || default.is_a?(String)
+      return ->(v) { v.to_i } if default.is_a?(Integer)
+      return ->(v) { v.to_f } if default.is_a?(Float)
+      return ->(v) { v.casecmp("true").zero? } if [TrueClass, FalseClass].include?(default.class)
+      raise TypeError, "Uncoercable type %p" % [default.class]
+    end
+
+    def _target
+      return @target
+    end
+
+    def _group_key
+      return @group_key
+    end
+
+    def _run_after_configured
+      @after_config_hooks.each do |h|
+        @target.instance_eval(&h)
+      end
+    end
+
+    def _reset
+      @settings.each do |k, v|
+        @target.send("#{k}=".to_sym, v)
+      end
+      self._run_after_configured
+    end
+  end
+end

data/lib/appydays/dotenviable.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "dotenv"
+
+require "appydays/version"
+
+##
+# Wrapper over dotenv that will load the standard .env files for an environment
+# (by convention, .env.<env>.local, .env.<env>, and .env).
+#
+# It can be called multiple times for the same environment.
+#
+# NOTE: Foreman assigns the $PORT environment variable BEFORE we load config
+# (get to what is defined in worker, like puma.rb), so even if we have it in the .env files,
+# it won't get used, because .env files don't stomp what is already in the environment
+# (we don't want to use `overload`).
+# So we have some trickery to overwrite only PORT.
+module Appydays::Dotenviable
+  def self.load(rack_env: nil, default_rack_env: "development", env: ENV)
+    original_port = env.delete("PORT")
+    rack_env ||= env["RACK_ENV"] || default_rack_env
+    paths = [
+      ".env.#{rack_env}.local",
+      ".env.#{rack_env}",
+      ".env",
+    ]
+    Dotenv.load(*paths)
+    env["PORT"] ||= original_port
+  end
+end

data/lib/appydays/loggable.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "semantic_logger"
+
+require "appydays/version"
+
+##
+# Override SemanticLogger's keys for tags, named_tags, and payload.
+# It is emminently unhelpful to have three places the same data may be-
+# ie, in some cases, we may have a customer_id in a named tag,
+# sometimes in payload, etc. Callsite behavior should not vary
+# the shape/content of the log message.
+class SemanticLogger::Formatters::Raw
+  alias original_call call
+
+  def call(log, logger)
+    h = self.original_call(log, logger)
+    ctx = h[:context] ||= {}
+    ctx[:_tags] = h.delete(:tags) if h.key?(:tags)
+
+    [:named_tags, :payload].each do |hash_key|
+      next unless h.key?(hash_key)
+      h.delete(hash_key).each do |k, v|
+        ctx[k] = v
+      end
+    end
+
+    return h
+  end
+end
+
+##
+# Helpers for working with structured logging.
+# Use this instead of calling semantic_logger directly.
+# Generally you `include Appydays::Loggable`
+module Appydays::Loggable
+  def self.included(target)
+    target.include(SemanticLogger::Loggable)
+
+    target.extend(Methods)
+    target.include(Methods)
+  end
+
+  def self.default_level=(v)
+    self.set_default_level(v)
+  end
+
+  def self.set_default_level(v, warning: true)
+    return if v == SemanticLogger.default_level
+    self[self].warn "Overriding log level to %p" % v if warning
+    SemanticLogger.default_level = v
+  end
+
+  ##
+  # Return the logger for a key/object.
+  def self.[](key)
+    return key.logger if key.respond_to?(:logger)
+    (key = key.class) unless [Module, Class].include?(key.class)
+    return SemanticLogger[key]
+  end
+
+  ##
+  # Configure logging for 12 factor applications.
+  # Specifically, that means setting STDOUT to synchronous,
+  # using STDOUT as the log output,
+  # and also conveniently using color formatting if using a tty or json otherwise
+  # (ie, you want to use json logging on a server).
+  def self.configure_12factor(format: nil, application: nil)
+    format ||= $stdout.isatty ? :color : :json
+    $stdout.sync = true
+    SemanticLogger.application = application if application
+    SemanticLogger.add_appender(io: $stdout, formatter: format.to_sym)
+  end
+
+  def self.with_log_tags(tags, &block)
+    return SemanticLogger.named_tagged(tags, &block)
+  end
+
+  @stderr_appended = false
+
+  def self.ensure_stderr_appender
+    return if @stderr_appended
+    SemanticLogger.add_appender(io: $stderr)
+    @stderr_appended = true
+  end
+
+  module Methods
+    def with_log_tags(tags, &block)
+      return SemanticLogger.named_tagged(tags, &block)
+    end
+  end
+end

data/lib/appydays/loggable/request_logger.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "rack"
+require "securerandom"
+
+require "appydays/loggable"
+
+##
+# Rack middleware for request logging, to replace Rack::CommonLogger.
+# NOTE: To get additional log fields, you can subclass this and override `_request_tags`.
+# If you want authenticated user info, make sure you install the middleware
+# after your auth middleware.
+#
+# Params:
+#
+# error_code: If an unhandled exception reaches the request logger.
+#   or happens in the request logger, this status code will be used for easay identification.
+#   Generally unhandled exceptions in an application should be handled further downstream,
+#   and already be returning the right error code.
+# slow_request_seconds: Normally request_finished is logged at info.
+#   Requests that take >= this many seconds are logged at warn.
+# reraise: Reraise unhandled errors (after logging them).
+#   In some cases you may want this to be true, but in some it may bring down the whole process.
+class Appydays::Loggable::RequestLogger
+  include Appydays::Loggable
+
+  def initialize(app, error_code: 599, slow_request_seconds: 10, reraise: true)
+    @app = app
+    @error_code = error_code
+    @slow_request_seconds = slow_request_seconds
+    @reraise = reraise
+  end
+
+  def call(env)
+    began_at = Time.now
+    request_fields = self._request_tags(env, began_at)
+    status, header, body = SemanticLogger.named_tagged(request_fields) { @app.call(env) }
+    header = Rack::Utils::HeaderHash.new(header)
+    body = Rack::BodyProxy.new(body) { self.log_finished(request_fields, began_at, status, header) }
+    [status, header, body]
+  rescue StandardError => e
+    began_at ||= nil
+    request_fields ||= {}
+    self.log_finished(request_fields, began_at, 599, {}, e)
+    raise if @reraise
+  end
+
+  protected def _request_tags(env, began_at)
+    req_id = SecureRandom.uuid.to_s
+    env["HTTP_TRACE_ID"] ||= req_id
+    return {
+      remote_addr: env["HTTP_X_FORWARDED_FOR"] || env["REMOTE_ADDR"] || "-",
+      request_started_at: began_at.to_s,
+      request_method: env[Rack::REQUEST_METHOD],
+      request_path: env[Rack::PATH_INFO],
+      request_query: env.fetch(Rack::QUERY_STRING, "").empty? ? "" : "?#{env[Rack::QUERY_STRING]}",
+      request_id: req_id,
+      trace_id: env["HTTP_TRACE_ID"],
+    }.merge(self.request_tags(env))
+  end
+
+  def request_tags(_env)
+    return {}
+  end
+
+  protected def log_finished(request_tags, began_at, status, header, exc=nil)
+    elapsed = (Time.now - began_at).to_f
+
+    all_tags = request_tags.merge(
+      response_finished_at: Time.now.to_s,
+      response_status: status,
+      response_content_length: extract_content_length(header),
+      response_ms: elapsed * 1000,
+    )
+
+    level = if status >= 500
+              "error"
+    elsif elapsed >= @slow_request_seconds
+      "warn"
+    else
+      "info"
+    end
+
+    self.logger.tagged(all_tags) do
+      self.logger.send(level, "request_finished", exc)
+    end
+    SemanticLogger.flush
+  end
+
+  protected def extract_content_length(headers)
+    value = headers[Rack::CONTENT_LENGTH]
+    return !value || value.to_s == "0" ? "-" : value
+  end
+end

data/lib/appydays/loggable/sequel_logger.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Patch Sequel::Database logging methods for structured logging
+require "sequel/database/logging"
+
+class Sequel::Database
+  def log_exception(exception, message)
+    log_each(
+      :error,
+      proc { "#{exception.class}: #{exception.message.strip if exception.message}: #{message}" },
+      proc { ["sequel_exception", {sequel_message: message}, exception] },
+    )
+  end
+
+  # Log a message at level info to all loggers.
+  def log_info(message, args=nil)
+    log_each(
+      :info,
+      proc { args ? "#{message}; #{args.inspect}" : message },
+      proc { ["sequel_log", {message: message, args: args}] },
+    )
+  end
+
+  # Log message with message prefixed by duration at info level, or
+  # warn level if duration is greater than log_warn_duration.
+  def log_duration(duration, message)
+    lwd = log_warn_duration
+    log_each(
+      lwd && (duration >= lwd) ? :warn : sql_log_level,
+      proc { "(#{'%0.6fs' % duration}) #{message}" },
+      proc { ["sequel_query", {duration: duration, query: message}] },
+    )
+  end
+
+  def log_each(level, std, semantic)
+    @loggers.each do |logger|
+      if logger.is_a?(SemanticLogger::Base)
+        logger.public_send(level, *semantic.call)
+      else
+        logger.public_send(level, std.call)
+      end
+    end
+  end
+end

data/lib/appydays/loggable/spec_helpers.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "appydays/loggable"
+
+module Appydays::Loggable::SpecHelpers
+  def self.included(context)
+    # Appydays::Loggable.ensure_stderr_appender
+
+    context.around(:each) do |example|
+      override_level = (example.metadata[:log] || example.metadata[:logging])
+      if override_level
+        orig_level = SemanticLogger.default_level
+        SemanticLogger.default_level = override_level
+      end
+      example.run
+      SemanticLogger.default_level = orig_level if override_level
+    end
+
+    context.before(:all) do
+      Appydays::Loggable.set_default_level(:fatal, warning: false)
+    end
+
+    context.after(:all) do
+      Appydays::Loggable.set_default_level(:fatal, warning: false)
+    end
+
+    super
+  end
+
+  def capture_logs_from(loggers, level: "debug", formatter: nil)
+    (loggers = [loggers]) unless loggers.respond_to?(:to_ary)
+
+    existing_appenders_and_lvls = SemanticLogger.appenders.map { |app| [app, app.level] }
+    SemanticLogger.appenders.each { |app| app.level = :fatal }
+    original_levels_and_loggers = loggers.map { |log| [log, log.level] }
+    loggers.each { |log| log.level = level }
+
+    io = StringIO.new
+    appender = SemanticLogger.add_appender(io: io, level: level)
+    appender.formatter = formatter if formatter
+    begin
+      yield
+    ensure
+      SemanticLogger.flush
+      SemanticLogger.remove_appender(appender)
+      original_levels_and_loggers.each { |(log, lvl)| log.level = lvl }
+      existing_appenders_and_lvls.each { |(app, lvl)| app.level = lvl }
+    end
+    return io.string.lines
+  end
+end

data/lib/appydays/spec_helpers.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "appydays/version"
+
+RSpec::Matchers.define_negated_matcher(:exclude, :include)
+RSpec::Matchers.define_negated_matcher(:not_include, :include)
+RSpec::Matchers.define_negated_matcher(:not_change, :change)
+RSpec::Matchers.define_negated_matcher(:not_be_nil, :be_nil)
+RSpec::Matchers.define_negated_matcher(:not_be_empty, :be_empty)
+
+module Appydays::SpecHelpers
+  # Zero out nsecs to t can be compared to one from the database.
+  module_function def trunc_time(t)
+    return t.change(nsec: t.usec * 1000)
+  end
+
+  #
+  # :section: Matchers
+  #
+
+  class HaveALineMatching
+    def initialize(regexp)
+      @regexp = regexp
+    end
+
+    def matches?(target)
+      @target = target
+      return @target.find do |obj|
+        obj.to_s.match(@regexp)
+      end
+    end
+
+    def failure_message
+      return "expected %p to have at least one line matching %p" % [@target, @regexp]
+    end
+
+    alias failure_message_for_should failure_message
+
+    def failure_message_when_negated
+      return "expected %p not to have any lines matching %p, but it has at least one" % [@target, @regexp]
+    end
+
+    alias failure_message_for_should_not failure_message_when_negated
+  end
+
+  ### RSpec matcher -- set up the expectation that the lefthand side
+  ### is Enumerable, and that at least one of the objects yielded
+  ### while iterating matches +regexp+ when converted to a String.
+  module_function def have_a_line_matching(regexp)
+    return HaveALineMatching.new(regexp)
+  end
+
+  module_function def have_length(x)
+    return RSpec::Matchers::BuiltIn::HaveAttributes.new(length: x)
+  end
+
+  # Matcher that will compare a string or time expected against a string or time actual,
+  # within a tolerance (default to 1 millisecond).
+  #
+  #   expect(last_response).to have_json_body.that_includes(
+  #       closes_at: match_time('2025-12-01T00:00:00.000+00:00').within(1.second))
+  #
+  RSpec::Matchers.define(:match_time) do |expected|
+    match do |actual|
+      @tolerance ||= 0.001
+      RSpec::Matchers::BuiltIn::BeWithin.new(@tolerance).of(self.time(expected)).matches?(self.time(actual))
+    end
+
+    failure_message do |actual|
+      "expected ids %s to be within %s of %s" % [self.time(actual), @tolerance, self.time(expected)]
+    end
+
+    chain :within do |tolerance|
+      @tolerance = tolerance
+    end
+
+    def time(s)
+      return Time.parse(s) if s.is_a?(String)
+      return s.to_time
+    end
+  end
+
+  # Matcher that will compare a string or Money expected against a string or Money actual.
+  #
+  #   expect(order.total).to cost('$25')
+  #
+  RSpec::Matchers.define(:cost) do |expected|
+    match do |actual|
+      @base = RSpec::Matchers::BuiltIn::Eq.new(self.money(expected))
+      @base.matches?(self.money(actual))
+    end
+
+    failure_message do |_actual|
+      @base.failure_message
+    end
+
+    def money(s)
+      return Monetize.parse(s) if s.is_a?(String)
+      return s if s.is_a?(Money)
+      return Money.new(s) if s.is_a?(Integer)
+      return Money.new(s[:cents], s[:currency]) if s.respond_to?(:key?) && s.key?(:cents) && s.key?(:currency)
+      raise "#{s} type #{s.class.name} not convertable to Money (add support or use supported type)"
+    end
+  end
+end

data/lib/appydays/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Appydays
+  VERSION = "0.1.0"
+end

data/spec/appydays/configurable_spec.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+RSpec.describe Appydays::Configurable do
+  describe "configurable" do
+    it "raises if no block is given" do
+      expect do
+        Class.new do
+          include Appydays::Configurable
+          configurable(:hello)
+        end
+      end.to raise_error(LocalJumpError)
+    end
+
+    describe "setting" do
+      it "creates an attr accessor with the given name and default value" do
+        cls = Class.new do
+          include Appydays::Configurable
+          configurable(:hello) do
+            setting :knob, "zero"
+          end
+        end
+        expect(cls).to have_attributes(knob: "zero")
+      end
+
+      it "pulls the value from the environment" do
+        ENV["ENVTEST_KNOB"] = "one"
+        cls = Class.new do
+          include Appydays::Configurable
+          configurable(:envtest) do
+            setting :knob, "zero"
+          end
+        end
+        expect(cls).to have_attributes(knob: "one")
+      end
+
+      it "can use a custom environment key" do
+        ENV["OTHER_KNOB"] = "two"
+        cls = Class.new do
+          include Appydays::Configurable
+          configurable(:hello) do
+            setting :knob, "zero", key: "OTHER_KNOB"
+          end
+        end
+        expect(cls).to have_attributes(knob: "two")
+      end
+
+      it "can convert the value given the converter" do
+        ENV["CONVTEST_KNOB"] = "0"
+        cls = Class.new do
+          include Appydays::Configurable
+          configurable(:convtest) do
+            setting :knob, "", convert: ->(v) { v + v }
+          end
+        end
+        expect(cls).to have_attributes(knob: "00")
+      end
+
+      it "does not run the converter if the default is used" do
+        cls = Class.new do
+          include Appydays::Configurable
+          configurable(:hello) do
+            setting :knob, "0", convert: ->(v) { v + v }
+          end
+        end
+        expect(cls).to have_attributes(knob: "0")
+      end
+
+      it "can use a nil default" do
+        cls = Class.new do
+          include Appydays::Configurable
+          configurable(:hello) do
+            setting :knob, nil
+          end
+        end
+        expect(cls).to have_attributes(knob: nil)
+      end
+
+      it "converts strings to floats if the default is a float" do
+        ENV["FLOATTEST_KNOB"] = "3.2"
+        cls = Class.new do
+          include Appydays::Configurable
+          configurable(:floattest) do
+            setting :knob, 1.5
+          end
+        end
+        expect(cls).to have_attributes(knob: 3.2)
+      end
+
+      it "converts strings to integers if the default is an integer" do
+        ENV["INTTEST_KNOB"] = "5"
+        cls = Class.new do
+          include Appydays::Configurable
+          configurable(:inttest) do
+            setting :knob, 2
+          end
+        end
+        expect(cls).to have_attributes(knob: 5)
+      end
+
+      it "can coerce strings to booleans" do
+        ENV["BOOLTEST_KNOB"] = "TRue"
+        cls = Class.new do
+          include Appydays::Configurable
+          configurable(:booltest) do
+            setting :knob, false
+          end
+        end
+        expect(cls).to have_attributes(knob: true)
+      end
+
+      it "does not run the converter when using the accessor" do
+        cls = Class.new do
+          include Appydays::Configurable
+          configurable(:booltest) do
+            setting :knob, 5
+          end
+        end
+        cls.knob = "5"
+        expect(cls).to have_attributes(knob: "5")
+      end
+
+      it "coalesces an empty string to nil" do
+        cls = Class.new do
+          include Appydays::Configurable
+          configurable(:hello) do
+            setting :knob, ""
+          end
+        end
+        expect(cls).to have_attributes(knob: nil)
+      end
+
+      it "errors if the default value is not a supported type" do
+        expect do
+          Class.new do
+            include Appydays::Configurable
+            configurable(:hello) do
+              setting :knob, []
+            end
+          end
+        end.to raise_error(TypeError)
+      end
+
+      it "runs a side effect" do
+        side_effect = []
+        Class.new do
+          include Appydays::Configurable
+          configurable(:hello) do
+            setting :knob, "zero", side_effect: ->(s) { side_effect << s }
+          end
+        end
+        expect(side_effect).to contain_exactly("zero")
+      end
+    end
+
+    it "can reset settings" do
+      cls = Class.new do
+        include Appydays::Configurable
+        configurable(:hello) do
+          setting :knob, 1
+        end
+      end
+      cls.knob = 5
+      expect(cls).to have_attributes(knob: 5)
+      cls.reset_configuration
+      expect(cls).to have_attributes(knob: 1)
+    end
+
+    it "runs after_configure hooks after configuration" do
+      side_effect = []
+      Class.new do
+        include Appydays::Configurable
+        configurable(:hello) do
+          setting :knob, 1
+          after_configured do
+            side_effect << self.knob
+          end
+        end
+      end
+      expect(side_effect).to contain_exactly(1)
+    end
+
+    it "can run after_configured hooks explicitly" do
+      side_effect = []
+      cls = Class.new do
+        include Appydays::Configurable
+        configurable(:hello) do
+          setting :knob, 1
+          after_configured do
+            side_effect << self.knob
+          end
+        end
+      end
+      cls.run_after_configured_hooks
+      expect(side_effect).to contain_exactly(1, 1)
+    end
+  end
+end

data/spec/appydays/dotenviable_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+RSpec.describe Appydays::Dotenviable do
+  it "loads env files using RACK_ENV" do
+    expect(Dotenv).to receive(:load).with(".env.foo.local", ".env.foo", ".env")
+    described_class.load(env: {"RACK_ENV" => "foo"})
+  end
+
+  it "loads env files using the explicit env" do
+    expect(Dotenv).to receive(:load).with(".env.bar.local", ".env.bar", ".env")
+    described_class.load(rack_env: "bar")
+  end
+
+  it "loads env files with the given default env if no RACK_ENV is defined" do
+    expect(Dotenv).to receive(:load).with(".env.bar.local", ".env.bar", ".env")
+    described_class.load(default_rack_env: "bar", env: {})
+  end
+
+  it "loads env files with RACK_ENV rather than the default, if RACK_ENV is defined" do
+    expect(Dotenv).to receive(:load).with(".env.bar.local", ".env.bar", ".env")
+    described_class.load(default_rack_env: "foo", env: {"RACK_ENV" => "bar"})
+  end
+
+  it "reapplies the original port if one was not loaded" do
+    env = {"PORT" => "123"}
+    expect(Dotenv).to receive(:load)
+    described_class.load(env: env)
+    expect(env).to include("PORT" => "123")
+  end
+
+  it "does not reapply the original port if one was loaded" do
+    env = {"PORT" => "123"}
+    expect(Dotenv).to receive(:load) { env["PORT"] = "456" }
+    described_class.load(env: env)
+    expect(env).to include("PORT" => "456")
+  end
+end

data/spec/appydays/loggable_spec.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "appydays/loggable/request_logger"
+
+RSpec.describe Appydays::Loggable do
+  it "can set the default log level" do
+    expect(SemanticLogger).to receive(:default_level=).with("trace")
+    described_class.default_level = "trace"
+  end
+
+  it "can look up the logger for an object for a non-Loggable" do
+    cls = Class.new
+    cls_logger = described_class[cls]
+    inst_logger = described_class[cls.new]
+    expect(cls_logger).to be_a(SemanticLogger::Logger)
+    expect(inst_logger).to be_a(SemanticLogger::Logger)
+    expect(cls_logger.name).to eq(inst_logger.name)
+  end
+
+  it "can look up the logger for an object for a Loggable" do
+    cls = Class.new do
+      include Appydays::Loggable
+    end
+    cls_logger = described_class[cls]
+    inst = cls.new
+    inst_logger = described_class[inst]
+    expect(cls_logger).to be(inst_logger)
+    expect(cls.logger).to be(inst.logger)
+  end
+
+  it "adds logger methods" do
+    cls = Class.new do
+      include Appydays::Loggable
+    end
+    inst = cls.new
+    expect(cls.logger).to be_a(SemanticLogger::Logger)
+    expect(inst.logger).to be_a(SemanticLogger::Logger)
+  end
+
+  describe "custom formatting" do
+    it "combines :payload, :tags, and :named_tags into :context" do
+      logger1 = described_class["spec-helper-test"]
+
+      lines = capture_logs_from(logger1, formatter: :json) do
+        SemanticLogger.tagged("tag1", "tag2") do
+          SemanticLogger.named_tagged(nt1: 1, nt2: 2) do
+            logger1.error("hello", opt1: 1, opt2: 2)
+          end
+        end
+      end
+      j = JSON.parse(lines[0])
+      expect(j).to include("context")
+      expect(j["context"]).to eq(
+        "_tags" => ["tag1", "tag2"],
+        "nt1" => 1,
+        "nt2" => 2,
+        "opt1" => 1,
+        "opt2" => 2,
+      )
+    end
+  end
+
+  describe "spec helpers" do
+    logger1 = described_class["spec-helper-test"]
+
+    it "can capture log lines to a logger" do
+      lines = capture_logs_from(logger1) do
+        logger1.error("hello there")
+      end
+      expect(lines).to have_a_line_matching(/hello there/)
+    end
+
+    it "can capture log lines to multiple loggers" do
+      lines = capture_logs_from(logger1) do
+        logger1.error("hello there")
+      end
+      expect(lines).to have_a_line_matching(/hello there/)
+    end
+
+    it "can filter logs below a level" do
+      lines = capture_logs_from(logger1, level: :error) do
+        logger1.warn("hello there")
+      end
+      expect(lines).to be_empty
+    end
+
+    it "can specify the formatter" do
+      lines = capture_logs_from(logger1, formatter: :json) do
+        logger1.warn("hello there")
+      end
+      expect(lines).to have_a_line_matching(/"message":"hello there"/)
+
+      lines = capture_logs_from(logger1, formatter: :color) do
+        logger1.warn("hello there")
+      end
+      expect(lines).to have_a_line_matching(/-- hello there/)
+    end
+
+    it "sets and restores the level of all appenders" do
+      logger1.level = :info
+      other_appender = SemanticLogger.add_appender(io: StringIO.new, level: :trace)
+      capture_logs_from(logger1, level: :trace) do
+        expect(logger1.level).to eq(:trace)
+        expect(other_appender.level).to eq(:fatal)
+      end
+      expect(logger1.level).to eq(:info)
+      expect(other_appender.level).to eq(:trace)
+      SemanticLogger.remove_appender(other_appender)
+    end
+  end
+
+  describe Appydays::Loggable::RequestLogger do
+    def run_app(app, opts: {}, loggers: [], env: {}, cls: Appydays::Loggable::RequestLogger)
+      rl = cls.new(app, **opts.merge(reraise: false))
+      return capture_logs_from(loggers << rl.logger, formatter: :json) do
+        _, _, body = rl.call(env)
+        body&.close
+      end
+    end
+
+    it "logs info about the request" do
+      lines = run_app(proc { [200, {}, ""] })
+      expect(lines).to have_a_line_matching(/"message":"request_finished".*"response_status":200/)
+
+      lines = run_app(proc { [400, {}, ""] })
+      expect(lines).to have_a_line_matching(/"message":"request_finished".*"response_status":400/)
+    end
+
+    it "logs at 599 (or configured value) if something errors" do
+      lines = run_app(proc { raise "testing error" })
+      expect(lines).to have_a_line_matching(/"level":"error".*"response_status":599/)
+      expect(lines).to have_a_line_matching(/"message":"testing error"/)
+    end
+
+    it "logs slow queries at warn" do
+      lines = run_app(proc { [200, {}, ""] }, opts: {slow_request_seconds: 0})
+      expect(lines).to have_a_line_matching(/"level":"warn".*"response_status":200/)
+    end
+
+    it "logs errors at error" do
+      lines = run_app(proc { [504, {}, ""] }, opts: {slow_request_seconds: 0})
+      expect(lines).to have_a_line_matching(/"level":"error".*"response_status":504/)
+    end
+
+    it "adds tags around the execution of the request" do
+      logger = SemanticLogger["testlogger"]
+      lines = run_app(proc do
+                        logger.info("check for tags")
+                        [200, {}, ""]
+                      end,
+                      opts: {slow_request_seconds: 0}, loggers: [logger],)
+      expect(lines).to have_a_line_matching(/"message":"check for tags".*"request_method":/)
+    end
+
+    it "adds subclass tags" do
+      ReqLogger = Class.new(Appydays::Loggable::RequestLogger) do
+        def request_tags(env)
+          return {my_header_tag: env["HTTP_MY_HEADER"]}
+        end
+      end
+      lines = run_app(proc { [200, {}, ""] }, env: {"HTTP_MY_HEADER" => "myval"}, cls: ReqLogger)
+      expect(lines).to have_a_line_matching(/"my_header_tag":"myval"/)
+    end
+
+    it "adds a request id" do
+      lines = run_app(proc { [200, {}, ""] })
+      expect(lines).to have_a_line_matching(/"request_id":"[0-9a-z]{8}-/)
+    end
+
+    it "reads a trace id from headers" do
+      lines = run_app(proc { [200, {}, ""] }, env: {"HTTP_TRACE_ID" => "123xyz"})
+      expect(lines).to have_a_line_matching(/"trace_id":"123xyz"/)
+    end
+
+    it "sets the trace ID header if not set" do
+      env = {}
+      lines = run_app(proc do
+        expect(env).to(include("HTTP_TRACE_ID"))
+        [200, {}, ""]
+      end, env: env,)
+      expect(lines).to have_a_line_matching(/"trace_id":"[0-9a-z]{8}-/)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# See https://github.com/eliotsykes/rspec-rails-examples/blob/master/spec/spec_helper.rb
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+#
+require "appydays/dotenviable"
+Appydays::Dotenviable.load(default_rack_env: "test")
+
+require "rspec"
+require "rspec/json_expectations"
+require "appydays/loggable/spec_helpers"
+require "appydays/spec_helpers"
+require "appydays/configurable"
+
+RSpec.configure do |config|
+  # config.full_backtrace = true
+
+  RSpec::Support::ObjectFormatter.default_instance.max_formatted_output_length = 600
+
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.order = :random
+  Kernel.srand config.seed
+
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+  config.disable_monkey_patching!
+  config.default_formatter = "doc" if config.files_to_run.one?
+
+  config.include(Appydays::Loggable::SpecHelpers)
+  config.include(Appydays::SpecHelpers)
+end

metadata

@@ -0,0 +1,212 @@
+--- !ruby/object:Gem::Specification
+name: appydays
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Lithic Tech
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-03-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: semantic_logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-json_expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'appydays provides support for logging and handling environment variables
+
+  '
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/appydays.rb
+- lib/appydays/configurable.rb
+- lib/appydays/dotenviable.rb
+- lib/appydays/loggable.rb
+- lib/appydays/loggable/request_logger.rb
+- lib/appydays/loggable/sequel_logger.rb
+- lib/appydays/loggable/spec_helpers.rb
+- lib/appydays/spec_helpers.rb
+- lib/appydays/version.rb
+- spec/appydays/configurable_spec.rb
+- spec/appydays/dotenviable_spec.rb
+- spec/appydays/loggable_spec.rb
+- spec/spec_helper.rb
+homepage:
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: Provides support for development best practices
+test_files: []