feature-flag-monitor 0.5.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5e773ef74c79cae366fa0b71a9e098bc3415cfa099fc1dd6189fdf607ad1b8ad
+  data.tar.gz: 43d43aa07978605dcbff6558427417f208b40e473dbe1fe22c57f896cf7b9bbf
+SHA512:
+  metadata.gz: a5313c13aaf5a3b937179aea4b6c80dbf646790275ee2e36f61d33117feda60d76d0f0075519de0523d38748365d97b3003bfa2e061d01d58c59910907b1c15c
+  data.tar.gz: 969331464add408e28b500eba3ee7545edb7e60f52272a85be7d49d27f4fdf864a3552d582c8f7eb52c857f13b559f102ff239a58d5ae823ab012f9c0de232d6

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+--format documentation

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in feature-flag-monitor.gemspec
+gemspec

data/README.md

@@ -0,0 +1,35 @@
+# Feature Flag Monitor Gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/feature_flag_monitor`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'feature_flag_monitor'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install feature_flag_monitor
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/feature_flag_monitor.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "feature_flag_monitor"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+FFM = FeatureFlagMonitor
+FeatureFlagMonitor.configure do |config|
+  config.consul_uri = 'http://localhost:8500'
+  config.feature_flag_monitor_uri = 'http://localhost:1255'
+end
+
+def authorization
+  { 'Authorization' => "Basic #{Base64.encode64("#{ENV['SUPERADMIN_USER']}:#{ENV['SUPERADMIN_PASS']}")}" }
+end
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/feature-flag-monitor.gemspec

@@ -0,0 +1,44 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "feature_flag_monitor/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "feature-flag-monitor"
+  spec.version       = FeatureFlagMonitor::VERSION
+  spec.authors       = ["Michael Chui"]
+  spec.email         = ["michael.chui@socrata.com"]
+
+  spec.summary       = 'Summary'
+  #spec.description   = %q{TODO: Write a longer description or delete this line.}
+  #spec.homepage      = "TODO: Put your gem's website or public repo URL here."
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    #spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "byebug", "~> 11.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'simplecov-cobertura'
+  spec.add_development_dependency 'webmock'
+
+  spec.add_runtime_dependency "activesupport", ">= 5.2", "< 8.0"
+  spec.add_runtime_dependency "diplomat", ">= 0"
+  spec.add_runtime_dependency "httparty", "~> 0.13"
+  spec.add_runtime_dependency "request_store", ">= 1.3"
+
+end

data/lib/feature_flag_monitor/configuration.rb

@@ -0,0 +1,17 @@
+module FeatureFlagMonitor
+  module Configuration
+    class << self
+      attr_accessor :consul_uri, :feature_flag_monitor_uri
+
+      def done?
+        @done
+      end
+
+      def done!
+        @done = true
+      end
+    end
+
+    class Error < StandardError; end
+  end
+end

data/lib/feature_flag_monitor/consul_key.rb

@@ -0,0 +1,27 @@
+module FeatureFlagMonitor
+  class ConsulKey
+    def self.by_id(id)
+      self.new(:i, id)
+    end
+
+    def self.by_cname(cname)
+      self.new(:n, cname)
+    end
+
+    def self.for_types
+      self.new(:m, 'types').to_key
+    end
+
+    def initialize(key_type, identifier)
+      @key_parts = ['ffm', key_type, identifier]
+    end
+
+    def for_domain
+      to_key
+    end
+
+    def to_key
+      @key_parts.join('/') << '?stale'
+    end
+  end
+end

data/lib/feature_flag_monitor/refinements/attemptable.rb

@@ -0,0 +1,19 @@
+module FeatureFlagMonitor::Refinements::Attemptable
+  refine Object do
+    def attempt(message, *args, &block)
+      (respond_to?(message) && public_send(message, *args, &block)) || self
+    end
+
+    def blank?
+      nil? || (respond_to?(:empty?) && empty?)
+    end
+
+    def present?
+      !blank?
+    end
+
+    def property_present?(message)
+      respond_to?(message) && public_send(message).present?
+    end
+  end
+end

data/lib/feature_flag_monitor/refinements/hash_extensions.rb

@@ -0,0 +1,15 @@
+module FeatureFlagMonitor::Refinements::HashExtensions
+  refine Hash do
+    def slice(*keys)
+      keys.each_with_object({}) { |key, hash| hash[key] = self[key] }
+    end
+
+    def compact
+      reject { |_, value| value.nil? }
+    end
+
+    def map_values(&block)
+      keys.zip(values.map(&block)).to_h
+    end
+  end
+end

data/lib/feature_flag_monitor/refinements/yield_self.rb

@@ -0,0 +1,10 @@
+module FeatureFlagMonitor::Refinements::YieldSelf
+  refine Object do
+    # Please can we upgrade to Ruby 2.5 yet?
+    unless method_defined?(:yield_self)
+      def yield_self
+        yield self
+      end
+    end
+  end
+end

data/lib/feature_flag_monitor/refinements.rb

@@ -0,0 +1,8 @@
+module FeatureFlagMonitor
+  module Refinements
+  end
+end
+
+require_relative 'refinements/attemptable'
+require_relative 'refinements/hash_extensions'
+require_relative 'refinements/yield_self'

data/lib/feature_flag_monitor/test/helpers.rb

@@ -0,0 +1,26 @@
+require_relative '../utils/restricted_hash'
+
+module FeatureFlagMonitor
+  module Test
+    module Helpers
+    end
+  end
+end
+
+module FeatureFlagMonitor::Test::Helpers
+  class << self
+    attr_accessor :defaults, :wrapper_class
+  end
+  @defaults = {}
+
+  def stub_feature_flags(flags = {})
+    flags = FeatureFlagMonitor::Utils.wrapper_class.new(FeatureFlagMonitor::Test::Helpers.defaults.merge(flags))
+
+    allow(FeatureFlagMonitor).to receive(:list).
+      and_return(flags.transform_values { { description: '' } })
+    allow(FeatureFlagMonitor).to receive(:type_data).
+      and_return(flags.transform_values { %w(boolean integer string) }) # don't try to be smart; presume all types are acceptable
+    allow(FeatureFlagMonitor).to receive(:flag) { |name:, on_domain:| flags[name] }
+    allow(FeatureFlagMonitor).to receive(:flags_on).and_return(flags)
+  end
+end

data/lib/feature_flag_monitor/utils/restricted_hash.rb

@@ -0,0 +1,81 @@
+# A restricted hash is an immutable Hash that only comprehends the keys that it already knows.
+# If a key it does not know is requested, it will raise FeatureFlagMonitor::FlagNotFound, as this
+# exists in the context of the FeatureFlagMonitor gem.
+#
+# It bears some similarities with https://github.com/intridea/hashie#dash but is pointedly
+# much less flexible.
+#
+# There is an additional goal of having full compatibility (to the extent immutability
+# allows) with ActiveSupport core extensions, i.e. monkeypatches. I won't guarantee complete
+# support with the first iteration; it is a moving target, and we don't use all of it
+# anyways.
+#
+# #compact, #deep_merge, #except, and #slice should all work.
+
+require 'active_support/hash_with_indifferent_access'
+
+module FeatureFlagMonitor
+  module Utils
+    class RestrictedHash < ActiveSupport::HashWithIndifferentAccess
+
+      class MutationNotAllowed < NoMethodError; end
+
+      # There are more, but I am lazy.
+      MUTATION_METHODS = %i([]= compact! delete merge! reject! replace select! store update)
+
+      def initialize(hash = {}, when_not_found = FeatureFlagMonitor::FlagNotFound)
+        super()
+        merge!(hash)
+
+        @key_not_found = when_not_found
+
+        each_key do |flag|
+          singleton_class.class_eval do
+            define_method(flag) { fetch(flag) }
+          end
+        end
+
+        singleton_class.class_eval do
+          MUTATION_METHODS.each do |_method|
+            define_method(_method) { |*args, &block| raise MutationNotAllowed }
+          end
+        end
+      end
+
+      def [](key)
+        raise @key_not_found.new(key) unless key?(key)
+        super
+      end
+      
+      def fetch(key, *args, &block)
+        begin
+          super
+        rescue KeyError
+          raise @key_not_found.new(key)
+        end
+      end
+
+      def method_missing(id, *args, &block)
+        raise @key_not_found.new(id)
+      end
+
+      # Methods for compatibility.
+
+      # Many non-mutation methods work by creating a duplicate version first, so
+      # implementing this fixes them all nicely.
+      def dup
+        self.class.superclass.new(self)
+      end
+
+      # Necessary because the ActiveSupport implementation relies on self.class.new.
+      #
+      # Stolen from: https://github.com/rails/rails/blob/ac717d65a31d05458588b78ea7719b79f8ea69e5/activesupport/lib/active_support/core_ext/hash/slice.rb#L23-L26
+      def slice(*keys)
+        keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
+        keys.each_with_object(self.class.superclass.new) do |k, hash|
+          hash[k] = self[k] if has_key?(k)
+        end
+      end
+    end
+  end
+end

data/lib/feature_flag_monitor/utils.rb

@@ -0,0 +1,75 @@
+require_relative 'utils/restricted_hash'
+
+module FeatureFlagMonitor
+  module Utils
+    using Refinements::YieldSelf
+
+    class << self
+      def derive(*sources, specs: FeatureFlagMonitor.type_data, processor: method(:process_value))
+        sources.compact.inject({}) do |memo, source|
+          merge(memo, source, specs: specs, processor: processor)
+        end.yield_self(&wrapper_class.method(:new))
+      end
+
+      def merge(base, other,
+                specs: FeatureFlagMonitor.type_data, processor: method(:process_value))
+        specs.each_with_object({}) do |(flag, spec), flags|
+          flags[flag] = processor.call(
+            if valid_value?(other[flag], spec) then other[flag]
+            else base[flag]
+            end)
+        end.yield_self(&wrapper_class.method(:new))
+      end
+
+      def valid_value?(unprocessed_value, spec)
+        value = process_value(unprocessed_value)
+        valid_classes = []
+        valid_values = []
+
+        boolean = [TrueClass, FalseClass]
+        parse_classes = lambda do |parseable_spec|
+          valid_classes.concat(boolean) if parseable_spec.include?('boolean')
+          valid_classes << Numeric if parseable_spec.include?('integer')
+          valid_classes << String if parseable_spec.include?('string')
+        end
+
+        case spec
+          # No type defined. Therefore boolean.
+        when NilClass then valid_classes.concat(boolean)
+        when Array, String
+          parseable_spec = spec.kind_of?(String) ? spec.split(/\s+/).reject(&:empty?) : spec
+          valid_values = parseable_spec - %w(boolean string integer)
+          valid_values = valid_values.first if valid_values.first.is_a?(Array)
+          parse_classes.call(parseable_spec)
+        when Hash
+          parse_classes.call(spec['anyOf']) if spec.key?('anyOf')
+          valid_classes.any?(&value.method(:kind_of?))
+        end
+
+        unless valid_values.nil? || valid_values.empty?
+          return true if valid_values.include?(value)
+          return false if valid_classes.empty?
+        end
+        valid_classes.any?(&value.method(:kind_of?))
+      end
+
+      def process_value(value)
+        return nil if value.nil?
+
+        begin
+          JSON.parse("{\"valueString\": #{value}}")['valueString']
+        rescue JSON::ParserError # This means it's a string!
+          value
+        end
+      end
+
+      # This is a helper function to allow frontend to wrap in a Hashie::Mash instead,
+      # entirely so that I can be lazy and not deal with all the tests that expect an
+      # unrestricted hash.
+      attr_writer :wrapper_class
+      def wrapper_class
+        @wrapper_class ||= RestrictedHash
+      end
+    end
+  end
+end

data/lib/feature_flag_monitor/version.rb

@@ -0,0 +1,3 @@
+module FeatureFlagMonitor
+  VERSION = "0.5.4"
+end

data/lib/feature_flag_monitor.rb

@@ -0,0 +1,188 @@
+require 'diplomat'
+require 'httparty'
+require 'request_store'
+
+require 'feature_flag_monitor/configuration'
+require 'feature_flag_monitor/consul_key'
+require 'feature_flag_monitor/refinements'
+require "feature_flag_monitor/utils"
+require "feature_flag_monitor/version"
+
+module FeatureFlagMonitor
+  using Refinements::Attemptable
+  using Refinements::HashExtensions
+
+  class FlagNotFound < StandardError; end
+  class GenericError < StandardError; end
+  class << self; attr_accessor :request_id; end
+
+  def self.configure
+    return if Configuration.done?
+    yield(Configuration) if block_given?
+
+    error_msg = lambda do |type|
+      lambda do |uri|
+        raise Configuration::Error.new("#{type} URI not configured") if uri.nil?
+      end
+    end
+
+    const_set(:FFM,
+      Configuration.feature_flag_monitor_uri.tap(&error_msg.call('Feature Flag Monitor')))
+    Diplomat.configure do |config|
+      config.url = Configuration.consul_uri.tap(&error_msg.call('Consul'))
+    end
+
+    Configuration.done!
+  end
+
+  IS_A_CNAME = [String, ->(domain) { domain.property_present?(:cname) }]
+  IS_AN_ID =  [Numeric, ->(domain) { domain.property_present?(:id) }]
+
+  def self.list(with_descriptions: false)
+    request_store[:"list_#{with_descriptions}"] ||=
+      case with_descriptions
+      when TrueClass
+        headers = { 'X-Socrata-RequestId' => request_id }.compact
+        JSON.parse(HTTParty.get(URI.join(FFM, 'describe.json'), headers: headers).body)
+      when FalseClass
+        type_data.map_values { |type| { 'type' => type } }
+      end.map_values do |config|
+        # Entirely for backwards compatibility with Signaller's config format.
+        config['disableTrueFalse'] = true unless config['type'].include?('boolean')
+        (config['type'] - [ 'boolean', 'integer', 'string' ]).tap do |expected_values|
+          config['expectedValues'] = expected_values.join(' ') unless expected_values.empty?
+        end
+        config
+      end
+  end
+
+  def self.domains
+    headers = { 'X-Socrata-RequestId' => request_id }.compact
+    endpoint = 'domains.json'
+    request_store[:domains] ||=
+      JSON.parse(HTTParty.get(URI.join(FFM, endpoint), headers: headers).body)
+  end
+
+  def self.type_data
+    request_store[:type_data] ||= fetch(ConsulKey.for_types)
+  end
+
+  def self.flags_on(domain:)
+    request_store[:"flags_on_#{domain}"] ||=
+      fetch(
+        case domain
+        when *IS_A_CNAME then ConsulKey.by_cname(domain.attempt(:cname))
+        when *IS_AN_ID   then ConsulKey.by_id(domain.attempt(:id))
+        end.for_domain
+      )
+  end
+
+  def self.flag(name:, on_domain:)
+    flags_on(domain: on_domain)[name.to_s]
+  end
+
+  def self.report(for_flag:)
+    headers = { 'X-Socrata-RequestId' => request_id }.compact
+    endpoint = [ 'report', for_flag ].join('/') << '.json'
+    request_store[:"report_#{for_flag}"] ||=
+      JSON.parse(HTTParty.get(URI.join(FFM, endpoint), headers: headers).body)
+  end
+
+  def self.set(flag:, value:, domain: nil, authorization:)
+    domain = extract_cname(domain)
+    headers = {
+      'X-Socrata-Host' => domain,
+      'X-Socrata-RequestId' => request_id,
+      'Content-Type' => 'application/json',
+    }.merge(authorization).compact
+
+    endpoint = flag_endpoint(flag, domain)
+    HTTParty.put(URI.join(FFM, endpoint), body: value.to_json, headers: headers).
+      tap(&method(:raise_errors_on_non_success))
+  end
+
+  def self.set_multiple(flags:, domain: nil, authorization:)
+    domain = extract_cname(domain)
+    headers = {
+      'X-Socrata-Host' => domain,
+      'X-Socrata-RequestId' => request_id,
+      'Content-Type' => 'application/json',
+    }.merge(authorization).compact
+
+    endpoint = domain_endpoint(domain)
+    HTTParty.send(:patch, URI.join(FFM, endpoint), body: flags.to_json, headers: headers).
+      tap(&method(:raise_errors_on_non_success))
+  end
+
+  def self.bulk_write(flags:, domains: nil, cohort: nil, exceptions: {}, authorization:)
+    raise ArgumentError, 'Must provide either domains or cohort.' if domains.nil? && cohort.nil?
+
+    headers = {
+      'X-Socrata-RequestId' => request_id,
+      'Content-Type' => 'application/json',
+    }.merge(authorization).compact
+
+    payload = {
+      flags: flags,
+      domains: domains,
+      cohort: cohort,
+      except: exceptions
+    }
+    HTTParty.send(:patch, URI.join(FFM, bulk_endpoint), body: payload.to_json, headers: headers).
+      tap(&method(:raise_errors_on_non_success))
+  end
+
+  def self.reset(flag:, domain: nil, authorization:)
+    domain = extract_cname(domain)
+    headers = {
+      'X-Socrata-Host' => domain,
+      'X-Socrata-RequestId' => request_id,
+      'Content-Type' => 'application/json',
+    }.merge(authorization).compact
+
+    endpoint = flag_endpoint(flag, domain)
+    HTTParty.delete(URI.join(FFM, endpoint), headers: headers).
+      tap(&method(:raise_errors_on_non_success))
+  end
+
+  private
+  def self.fetch(key)
+    begin
+      Diplomat::Kv.get(key, http_addr: Configuration.consul_uri)
+    rescue Diplomat::KeyNotFound
+      Diplomat::Kv.get(key, http_addr: Configuration.feature_flag_monitor_uri)
+    end.yield_self(&JSON.method(:parse))
+  end
+
+  def self.flag_endpoint(flag, domain)
+    if domain.nil? then [ 'env_state', flag ]
+    else [ 'flag', flag, domain ]
+    end.join('/') << '.json'
+  end
+
+  def self.domain_endpoint(domain)
+    if domain.nil? then [ 'env_state' ]
+    else [ 'domain', domain ]
+    end.join('/') << '.json'
+  end
+
+  def self.bulk_endpoint
+    'bulk.json'
+  end
+
+  def self.extract_cname(domain)
+    domain.attempt(:cname)
+  end
+
+  def self.request_store
+    RequestStore[:feature_flag_monitor] ||= {}
+  end
+
+  def self.raise_errors_on_non_success(response)
+    return if (200..299).include?(response.code)
+    message = response.parsed_response['message']
+    message << '. '
+    message << response.parsed_response['data'].to_json
+    raise GenericError.new(message)
+  end
+end

metadata

@@ -0,0 +1,207 @@
+--- !ruby/object:Gem::Specification
+name: feature-flag-monitor
+version: !ruby/object:Gem::Version
+  version: 0.5.4
+platform: ruby
+authors:
+- Michael Chui
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-11-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: simplecov-cobertura
+  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: webmock
+  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: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: diplomat
+  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: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+- !ruby/object:Gem::Dependency
+  name: request_store
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description:
+email:
+- michael.chui@socrata.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- feature-flag-monitor.gemspec
+- lib/feature_flag_monitor.rb
+- lib/feature_flag_monitor/configuration.rb
+- lib/feature_flag_monitor/consul_key.rb
+- lib/feature_flag_monitor/refinements.rb
+- lib/feature_flag_monitor/refinements/attemptable.rb
+- lib/feature_flag_monitor/refinements/hash_extensions.rb
+- lib/feature_flag_monitor/refinements/yield_self.rb
+- lib/feature_flag_monitor/test/helpers.rb
+- lib/feature_flag_monitor/utils.rb
+- lib/feature_flag_monitor/utils/restricted_hash.rb
+- lib/feature_flag_monitor/version.rb
+homepage:
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: Summary
+test_files: []