mixboard 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0d0a1f66401e36fe1c9dfcac7514a27d9808a92b2416b8ca37a10bb738ab408f
+  data.tar.gz: 9b404a6b5b57186e759aa27314ed81a45d054f5cb3bb96fbfbd08ffa5118ed3a
+SHA512:
+  metadata.gz: 92128dccbba4f852a99662525589a38ac169e9ef14e3086570737f9e8e55bc109dba73c7200dab090b2fbfcb5809fb47835dff60c42a9a60b90629f646fee85f
+  data.tar.gz: a1c9d465c7259ca915c1d680ca8caa6f55fdf56fc3f1d0d2f4f0da82d60ec96ca020d6a40a7b2df13b912859d955e6847c64ca96ab8cbb1996c296603ae751ee

data/LICENSE.md

@@ -0,0 +1,25 @@
+The MIT License (MIT)
+=====================
+
+Copyright © `2020` `Braze, Inc.`
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the “Software”), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,180 @@
+# Mixboard
+
+Mixboard is a framework for routing signals from sources to sinks. Signals can be metrics,
+log messages, errors, or any other similar piece of information one might want to route
+from a source to a sink. Conditional routing is available via filters, and transformation
+of signals is possible via signal processors. A specific end-to-end route is called a channel.
+
+It's a common pattern to spend a non-trivial amount of time enabling and disabling
+logs, metrics, or other types of debugging information on a per-customer or a
+per-business-object basis. Instead, this framework provides the tooling to do this type of
+observability work ahead of time (i.e. inserting the proper signalling) and be able to
+enable/disable it selectively at runtime or via configuration.
+
+## Usage
+
+Mixboard is designed as a Rails Engine, so usage is straightforward. A simple example
+is below.
+
+### Signals
+
+A signal is a payload containing information that can be routed through the mixer.
+
+First, create a signal by extending `Mixboard::Signal` if you aren't using a generic
+signal type, like so:
+
+```ruby
+class DummySignal < Mixboard::Signal
+  attr_accessor :my_attribute
+end
+```
+
+#### Signal Levels
+
+Signals have levels associated with them, similar to log messages. Using levels,
+it's easy to subcategorize or delineate the granularity of signals. The provided
+levels are: `verbose`, `debug`, `info`, `warn`, and `error`, similar to most
+logging frameworks. These are often helpful when using filters.
+
+### Sources
+
+A source is anything that emits signals of a certain type.
+
+Create a source by extending `Mixboard::Source`, making sure the methods you
+plan on using on your source are calling the `emit` method with a signal instance,
+like so:
+
+```ruby
+class DummySource < Mixboard::Source
+  def signal_class
+    DummySignal
+  end
+
+  def my_logging_method
+    signal = DummySignal.new
+    signal.my_attribute = 'FizzBuzz'
+    emit(signal)
+  end
+end
+```
+
+### Sinks
+
+A sink is anything that accepts signals of a certain type.
+
+Create a sink by extending `Mixboard::Sink` if you aren't using a generic sink, 
+making sure to provide an `accept` method, like so:
+
+```ruby
+class DummySink < Mixboard::Sink
+  def signal_class
+    DummySignal
+  end
+
+  def accept(signal)
+    MyExternalLoggingService.post(signal.my_attribute) 
+  end
+end
+```
+
+### Configuration
+
+To statically configure channels, create a `mixboard.rb` initializer and
+configure a channel, like so:
+```ruby
+Mixboard::Mixer.configure do |c|
+  channel = Mixboard::Channel.new
+    .add_source(DummySource)
+    .add_sink(DummySink.new(any_config_options))
+
+  c.add_channel(channel)
+end
+```
+
+And you should be all set. You can instantiate your `DummySource` anywhere, use
+`my_logging_method`, and Mixboard will connect the two components!
+
+To dynamically configure channels... TODO!
+
+### Signal Processors
+
+Signal processors accept signals of a certain type and emit signals of a certain type.
+The are used for transforming signals from one type to another.
+
+Imagine wanting to send an error message to something like Sentry, but also wanting to 
+track it as a metric in StatsD. You would set up two channels:
+
+- Source: Logger; Sink: SentrySink
+- Source: Logger; Sink: StatsDCountMetricSink
+
+For the first channel, the signal types match (assuming they are both something simple,
+such as `MessageSignal`, so you don't need to associate a signal processor. For the 
+second channel, you have a source type of `MessageSignal`, and a sink type of `CountMetric`.
+You would need to add a signal processor that accepts `MessageSignal` (or a superclass),
+and emits `CountMetric`. Your channels would look like:
+
+- Source: Logger; Sink: SentrySink
+- Source: Logger; Sink: StatsDCountMetricSink, SignalProcessors: MessageSignalCounter
+
+Your signal processor might look like:
+
+```ruby
+class MessageSignalCounter < Mixboard::SignalProcessor
+  def initialize(metric_name:)
+    @metric_name = metric_name
+  end
+
+  def input_signal_class
+    MessageSignal
+  end
+
+  def output_signal_class
+    CountMetric
+  end
+
+  def transform(signal)
+    return CountMetric.new(@metric_name, 1)
+  end
+end
+```
+
+### Filters
+
+Filters interrupt the flow of signals through the system. You can add filters before or
+after channels and signal processors. Here's a simple example:
+
+```ruby
+class DummyFilter < Mixboard::Filter
+  def signal_class
+    DummySignal
+  end
+
+  def filter(signal)
+    signal
+  end
+end
+```
+
+Filters' `filter` method should only return the original signal to continue processing, or
+return nil to indicate to stop processing the signal further.
+
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mixboard'
+```
+
+Or install it yourself as:
+```bash
+$ gem install mixboard
+```
+
+To take advantage of the dynamic "mixing panel" to configure channels... TODO
+
+## Contributing
+Contribution directions go here. TODO
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Mixboard'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+
+  task default: :spec
+rescue LoadError
+  # no rspec available
+end

data/app/assets/config/mixboard_manifest.js

@@ -0,0 +1 @@
+//= link_directory ../stylesheets/mixboard .css

data/app/assets/stylesheets/mixboard/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/mixboard/application_controller.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Mixboard
+  # Probably will delete this
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+  end
+end

data/app/helpers/mixboard/application_helper.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Mixboard
+  # Probably will delete this
+  module ApplicationHelper
+  end
+end

data/app/jobs/mixboard/application_job.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Mixboard
+  # Probably will delete this
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mixer/mixboard/channel.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Mixboard
+  # A specific end-to-end route from a source to a sink.
+  class Channel
+    include Mixboard::Filterable
+    include Mixboard::UtilityFunctions
+
+    attr_reader :source_class
+
+    def add_source(source_class)
+      assert_non_nil_of_type(source_class, Class)
+      @source_class = source_class
+      self
+    end
+
+    def add_sink(sink)
+      assert_non_nil_of_type(sink, Sink)
+      @sink = sink
+      self
+    end
+
+    def add_signal_processor(signal_processor)
+      assert_non_nil_of_type(signal_processor, SignalProcessor)
+      signal_processors.append(signal_processor)
+      self
+    end
+
+    def accept(signal)
+      signal = with_filters(signal) do
+        signal_processors.reduce(signal) do |current_signal, signal_processor|
+          signal_processor.do_transform(current_signal)
+        end
+      end
+      @sink.do_accept(signal) unless signal.nil?
+    end
+
+    private
+
+    def signal_processors
+      @signal_processors ||= []
+    end
+  end
+end

data/app/mixer/mixboard/configuration.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Mixboard
+  # A mixer's configuration, usually set via an initializer
+  class Configuration
+    include Mixboard::UtilityFunctions
+
+    attr_reader :channel_map
+
+    def add_source(source_class)
+      assert_non_nil_of_type(source_class, Class)
+      sources.add(source_class)
+      self
+    end
+
+    def add_sink(sink)
+      assert_non_nil_of_type(sink, Mixboard::Sink)
+      sinks.add(sink)
+      self
+    end
+
+    def add_channel(channel)
+      assert_non_nil_of_type(channel, Channel)
+      channels.append(channel)
+      self
+    end
+
+    def dynamic_channel_store=(dynamic_channel_store)
+      assert_non_nil_of_type(dynamic_channel_store, Mixboard::DynamicChannelStore)
+      @dynamic_channel_store = dynamic_channel_store
+    end
+
+    def dynamic_channel_store
+      @dynamic_channel_store ||= Mixboard::InMemoryDynamicChannelStore.new
+    end
+
+    def setup_channel_map
+      @channel_map = {}
+      channels.each do |channel|
+        @channel_map[channel.source_class] ||= []
+        @channel_map[channel.source_class].append(channel)
+      end
+    end
+
+    private
+
+    def sources
+      @sources ||= Set.new
+    end
+
+    def sinks
+      @sinks ||= Set.new
+    end
+
+    # @return Array[Channel]
+    def channels
+      @channels ||= []
+    end
+  end
+end

data/app/mixer/mixboard/dynamic_channel_store.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Mixboard
+  # A DynamicChannelStore is an interface for a dynamically populated set of channels. The canonical implementation
+  # is InMemoryDynamicChannelStore, but you could implement this with another backing store, such as Redis or Memcached.
+  class DynamicChannelStore
+    include Mixboard::UtilityFunctions
+
+    def add_channel(_id, _channel, _expiry = nil)
+      declare_abstract_method_body
+    end
+
+    def remove_channel_by_id(_id)
+      declare_abstract_method_body
+    end
+
+    def channels
+      declare_abstract_method_body
+    end
+
+    def active_channel_map
+      map = {}
+      channels.each do |id, channel, expiry|
+        if !expiry.nil? && Time.now.to_i > expiry
+          remove_channel_by_id(id)
+          next
+        end
+        map[channel.source_class] ||= []
+        map[channel.source_class].append(channel)
+      end
+      map
+    end
+  end
+end

data/app/mixer/mixboard/errors/abstract_not_implemented_error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Mixboard
+  module Errors
+    # An error meant to indicate that a user tried to call a superclass method that the subclass did not implement.
+    class AbstractNotImplementedError < StandardError
+      def initialize(class_name:, entity_name:)
+        super("#{entity_name} not implemented in abstract class #{class_name}")
+        @class_name = class_name
+        @entity_name = entity_name
+      end
+    end
+  end
+end

data/app/mixer/mixboard/errors/type_mismatch_error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Mixboard
+  module Errors
+    # An error indicating that a signal was provided with an incorrect type.
+    class TypeMismatchError < StandardError
+      def initialize(expected_type:, given_type:)
+        super("Expected signal of type #{expected_type}, but given signal of type #{given_type}")
+        @expected_type = expected_type
+        @given_type = given_type
+      end
+    end
+  end
+end

data/app/mixer/mixboard/filter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Mixboard
+  # Filters interrupt the flow of signals through the system. You can add filters before or
+  # after channels and signal processors
+  class Filter
+    include Mixboard::UtilityFunctions
+
+    # @return [Class] the Signal subclass that this filter applies to
+    def signal_class
+      declare_abstract_method_body
+    end
+
+    # @param [Signal]
+    # @return [Signal,nil] the filtered signal or nil
+    def filter(_signal)
+      declare_abstract_method_body
+    end
+
+    def do_filter(signal)
+      assert_non_nil_of_type(signal, signal_class)
+      signal = filter(signal)
+      assert_type(signal, signal_class)
+      signal
+    end
+  end
+end

data/app/mixer/mixboard/filterable.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Mixboard
+  # A mixin for anything that can have a filter added before/after it.
+  module Filterable
+    include Mixboard::UtilityFunctions
+
+    def add_before_filter(filter)
+      before_filters.append(filter)
+      self
+    end
+
+    def add_after_filter(filter)
+      after_filters.append(filter)
+      self
+    end
+
+    def with_filters(signal, &block)
+      signal = run_filters(signal, before_filters)
+      return nil if signal.nil?
+
+      block.call(signal)
+      run_filters(signal, after_filters)
+    end
+
+    private
+
+    def run_filters(signal, filters)
+      filters.reduce(signal) do |current_signal, filter|
+        return nil if current_signal.nil?
+
+        assert_non_nil_of_type(current_signal, filter.signal_class)
+        filter.do_filter(current_signal)
+      end
+    end
+
+    def before_filters
+      @before_filters ||= []
+    end
+
+    def after_filters
+      @after_filters ||= []
+    end
+  end
+end

data/app/mixer/mixboard/in_memory_dynamic_channel_store.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Mixboard
+  # An in-memory store of dynamic channel assignments. You probably shouldn't use this because
+  # it won't work right with multiple processes. Consider implementing a DynamicChannelStore with
+  # a fast key-value store, like Redis or Memcached.
+  class InMemoryDynamicChannelStore < Mixboard::DynamicChannelStore
+    include Mixboard::UtilityFunctions
+
+    def add_channel(id, channel, expiry = nil)
+      assert_non_nil_of_type(channel, Mixboard::Channel)
+      assert_type(expiry, Integer)
+      channels_by_id[id] = [channel, expiry]
+    end
+
+    def remove_channel_by_id(id)
+      channels_by_id.delete(id)
+    end
+
+    def channels
+      channels_by_id.map do |id, tuple|
+        [id, tuple[0], tuple[1]]
+      end
+    end
+
+    private
+
+    def channels_by_id
+      @channels_by_id ||= {}
+    end
+  end
+end

data/app/mixer/mixboard/mixer.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Mixboard
+  # The Mixer is a singleton class that actually does the routing of signals.
+  class Mixer
+    include ::Singleton
+    include Mixboard::UtilityFunctions
+
+    CONFIGURATION_MUTEX = Mutex.new
+
+    attr_writer :map_refresh_timeout
+
+    # Accept a signal from a source to route it to the correct channels
+    # @param [Signal] signal
+    # @param [Source] source
+    def accept(signal, source)
+      assert_non_nil_of_type(signal, Signal)
+      assert_non_nil_of_type(source, Source)
+      (channel_map[source.class] || []).each do |channel|
+        channel.accept(signal)
+      end
+    end
+
+    def configure(&block)
+      CONFIGURATION_MUTEX.synchronize do
+        return unless @configuration.nil?
+
+        c = Mixboard::Configuration.new
+        block.call(c) if block_given?
+        c.setup_channel_map
+        @last_map_refresh = 0
+        @configuration = c
+      end
+    end
+
+    def clear_configuration
+      @configuration = nil
+    end
+
+    def map_refresh_timeout
+      @map_refresh_timeout ||= 30
+    end
+
+    def dynamic_channel_store
+      configuration.dynamic_channel_store
+    end
+
+    private
+
+    def channel_map
+      refresh_channel_map if Time.now.to_i > last_map_refresh + map_refresh_timeout
+      @channel_map
+    end
+
+    def refresh_channel_map
+      @last_map_refresh = Time.now.to_i
+      map = configuration.channel_map.dup
+
+      configuration.dynamic_channel_store.active_channel_map.each do |source, channels|
+        map[source] ||= []
+        map[source].concat(channels)
+      end
+
+      @channel_map = map
+    end
+
+    def last_map_refresh
+      @last_map_refresh ||= 0
+    end
+
+    def configuration
+      raise 'Mixer not configured yet!' if @configuration.nil?
+
+      @configuration
+    end
+  end
+end

data/app/mixer/mixboard/signal.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Mixboard
+  # A signal is a payload containing information that can be routed through the mixer.
+  class Signal
+  end
+end

data/app/mixer/mixboard/signal_processor.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Mixboard
+  # Signal processors accept signals of a certain type and emit signals of a certain type.
+  # The are used for transforming signals from one type to another.
+  class SignalProcessor
+    include Mixboard::Filterable
+    include Mixboard::UtilityFunctions
+
+    # @return [Class] the Signal subclass that this filter applies to
+    def input_signal_class
+      declare_abstract_method_body
+    end
+
+    # @return [Class] the Signal subclass that this filter applies to
+    def output_signal_class
+      declare_abstract_method_body
+    end
+
+    # @param [Signal]
+    # @return [Signal,nil] the filtered signal or nil
+    def transform(_signal)
+      declare_abstract_method_body
+    end
+
+    def do_transform(signal)
+      assert_non_nil_of_type(signal, input_signal_class)
+      signal = with_filters(signal) do
+        transform(signal)
+      end
+      assert_type(signal, output_signal_class)
+      signal
+    end
+  end
+end

data/app/mixer/mixboard/sink.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Mixboard
+  # A sink is anything that accepts signals of a certain type.
+  class Sink
+    include Mixboard::UtilityFunctions
+
+    def signal_class
+      declare_abstract_method_body
+    end
+
+    def accept(_signal)
+      declare_abstract_method_body
+    end
+
+    def do_accept(signal)
+      assert_non_nil_of_type(signal, signal_class)
+      accept(signal)
+    end
+  end
+end

data/app/mixer/mixboard/source.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Mixboard
+  # A source is anything that emits signals of a certain type.
+  class Source
+    include Mixboard::UtilityFunctions
+
+    def signal_class
+      declare_abstract_method_body
+    end
+
+    def emit(signal)
+      assert_non_nil_of_type(signal, signal_class)
+      Mixer.instance.accept(signal, self)
+    end
+  end
+end

data/app/mixer/mixboard/utility_functions.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Mixboard
+  # Various utility functions
+  module UtilityFunctions
+    def method_not_implemented_error(name)
+      Mixboard::Errors::AbstractNotImplementedError.new(
+        class_name: self.class.to_s, entity_name: "method: #{name}"
+      )
+    end
+
+    def declare_abstract_method_body
+      raise method_not_implemented_error(caller_locations(1, 1)[0].label)
+    end
+
+    def assert_type(obj, typ)
+      return unless !obj.nil? && !obj.is_a?(typ)
+
+      raise Mixboard::Errors::TypeMismatchError.new(expected_type: typ, given_type: obj.class)
+    end
+
+    def assert_non_nil_of_type(obj, typ)
+      raise Mixboard::Errors::TypeMismatchError.new(expected_type: typ, given_type: obj.class) if obj.nil?
+
+      assert_type(obj, typ)
+    end
+  end
+end

data/app/views/layouts/mixboard/application.html.erb

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Mixboard</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= stylesheet_link_tag    "mixboard/application", media: "all" %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+Mixboard::Engine.routes.draw do
+end

data/lib/mixboard.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'mixboard/engine'
+
+# code is in app/mixer/mixboard
+module Mixboard
+end

data/lib/mixboard/engine.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Mixboard
+  # The Rails engine for Mixboard
+  class Engine < ::Rails::Engine
+    isolate_namespace Mixboard
+
+    config.generators do |g|
+      g.test_framework :rspec
+      g.fixture_replacement :factory_bot
+      g.factory_bot dir: 'spec/factories'
+    end
+  end
+end

data/lib/mixboard/version.rb

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

data/lib/tasks/mixboard_tasks.rake

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+# desc "Explaining what the task does"
+# task :mixboard do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: mixboard
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Zach McCormick
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-11-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: factory_bot_rails
+  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-rails
+  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: sqlite3
+  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: |
+  Mixboard is a framework for routing signals from sources to sinks. Signals can be metrics,
+  log messages, errors, or any other similar piece of information one might want to route
+  from a source to a sink. Conditional routing is available via filters, and transformation
+  of signals is possible via signal processors.
+email:
+- zach.mccormick@braze.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- Rakefile
+- app/assets/config/mixboard_manifest.js
+- app/assets/stylesheets/mixboard/application.css
+- app/controllers/mixboard/application_controller.rb
+- app/helpers/mixboard/application_helper.rb
+- app/jobs/mixboard/application_job.rb
+- app/mixer/mixboard/channel.rb
+- app/mixer/mixboard/configuration.rb
+- app/mixer/mixboard/dynamic_channel_store.rb
+- app/mixer/mixboard/errors/abstract_not_implemented_error.rb
+- app/mixer/mixboard/errors/type_mismatch_error.rb
+- app/mixer/mixboard/filter.rb
+- app/mixer/mixboard/filterable.rb
+- app/mixer/mixboard/in_memory_dynamic_channel_store.rb
+- app/mixer/mixboard/mixer.rb
+- app/mixer/mixboard/signal.rb
+- app/mixer/mixboard/signal_processor.rb
+- app/mixer/mixboard/sink.rb
+- app/mixer/mixboard/source.rb
+- app/mixer/mixboard/utility_functions.rb
+- app/views/layouts/mixboard/application.html.erb
+- config/routes.rb
+- lib/mixboard.rb
+- lib/mixboard/engine.rb
+- lib/mixboard/version.rb
+- lib/tasks/mixboard_tasks.rake
+homepage: https://github.com/braze-inc/mixboard
+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.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Mixboard is a framework for routing signals from sources to sinks.
+test_files: []