changebase 0.1 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dcaf7190bcd66bca83640222cc52f2bae125b65b9008c26c9e8dac4c88c35226
-  data.tar.gz: '099666dc5717843cf99230a8a22c51fed5568ef93b4aa550928621a29d8a3e72'
+  metadata.gz: cb5026dc3675467dc638006f5953c5ba3a1ec4f486e63ecd4066fd2a027356f2
+  data.tar.gz: e4d58239417908fec5572dfe5e99bfb6d48db046679c39621d632cdcba8951fc
 SHA512:
-  metadata.gz: 0b3dc117e4516d95e353b2e4e4ad076020815e37c88a6c256bb40ca1633ff5a487b692ac49331a203e8c6f519c46523c20e231e1cee768078c007666dea23d35
-  data.tar.gz: f0915103e19c8966675d21d40b7091d62eb4eb97f686b92fc98087fe8277e3ef94ace4a3524ded170ead1cbd4f6d06395a03b6737fd937ca20edf4365a3225c3
+  metadata.gz: 5ed3fa5539602e0417635ff5333ec804a749930db38802a6f56636363b91a9896b1aa7acb18c0665471e9f66863e54e391a644d34e016014dda5090247eed488
+  data.tar.gz: 0cae8f40c3bc961c6381c0e4b9773b19d408e3602cbf47340d77479cc34c0bbb7827726f030b5929d3e466c944372b8f16d1792c0390f3f7696508ed88a53dd4

data/README.md

@@ -47,27 +47,27 @@ Below are several diffent way of including metadata:
 
 ```ruby
   class ApplicationController < ActionController::Base
-    
+
     # Just a block returning a hash of metadata.
     changebase do
         { my: data }
     end
-    
+
     # Sets `release` in the metadata to the string RELEASE_SHA
     changebase :release, RELEASE_SHA
-    
+
     # Sets `request_id` in the metadata to the value returned from the `Proc`
     changebase :request_id, -> { request.uuid }
-    
+
     # Sets `user.id` in the metadata to the value returned from the
     # `current_user_id` function
     changebase :user, :id, :current_user_id
-    
+
     # Sets `user.name` in the metadata to the value returned from the block
     changebase :user, :name do
       current_user.name
     end
-    
+
     def current_user_id
       current_user.id
     end
@@ -99,8 +99,15 @@ To include metadata when creating or modifying data with ActiveRecord:
 
 ### Configuration
 
-To configure the metadata table that Changebase writes to create a initializer
-at `config/initializers/changebase.rb` with the following:
+#### Replication Mode
+
+The default mode for the `changebase` gem is `replication`. In this mode
+Changebase is setup to replicate your database and record events via the
+replication stream.
+
+The default configuration `changebase` will write metadata to the
+`"changebase_metadata"` table. To configure the metadata table create an
+initializer at `config/initializers/changebase.rb` with the following:
 
 ```ruby
 Rails.application.config.tap do |config|
@@ -112,9 +119,67 @@ If you are not using Rails you can configure Changebase directly via:
 
 ```ruby
 Changebase.metadata_table = "my_very_cool_custom_metadata_table"
+
+# Or
+
+Changebase.configure(metadata_table: "my_very_cool_custom_metadata_table")
+```
+
+#### Inline Mode
+
+If you are unable to setup database replication you can use inline mode. Events
+will be sent to through the Changebase API. You will collect roughly the same
+information, but potentionally to miss events and changes in your database
+if you are not careful, or if another application accesses the database directly.
+
+##### Limitations
+
+- Any changes made to the database by ActiveRecord that does not first
+  instantiate the records will not be caputred. These methods include:
+  - [ActiveRecord::ConnectionAdapters::DatabaseStatements#execute](https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/DatabaseStatements.html#method-i-execute)
+  - [ActiveRecord::ConnectionAdapters::DatabaseStatements#exec_query](https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/DatabaseStatements.html#method-i-exec_query)
+  - [ActiveRecord::ConnectionAdapters::DatabaseStatements#exec_update](https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/DatabaseStatements.html#method-i-exec_update)
+  - [ActiveRecord::ConnectionAdapters::DatabaseStatements#exec_insert](https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/DatabaseStatements.html#method-i-exec_insert)
+  - [ActiveRecord::ConnectionAdapters::DatabaseStatements#exec_delete](https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/DatabaseStatements.html#method-i-exec_delete)
+  - [ActiveRecord::Persistence#delete](https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-delete)
+  - [ActiveRecord::Persistence#update_column](https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-update_column)
+  - [ActiveRecord::Persistence#update_columns](https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-update_columns)
+  - [ActiveRecord::Relation#touch_all](https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-touch_all)
+  - [ActiveRecord::Relation#update_all](https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-update_all)
+  - [ActiveRecord::Relation#delete_all](https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-delete_all)
+  - [ActiveRecord::Relation#delete_by](https://api.rubyonrails.org/classes/ActiveRecord/Relation.html#method-i-delete_by)
+- Any changes made to the database outside of the Rails application will not be
+  captured.
+- Ordering of events will not be guaranteed. The timestamp will be used as the
+  LSN, which may not be in the same order of transactions / events in the database.
+
+To configure Changebase in the `"inline"` mode create a initializer at
+`config/initializers/changebase.rb` with the following:
+
+```ruby
+Rails.application.config.tap do |config|
+  config.changebase.mode = "inline"
+  config.changebase.connection = "https://#{ ENV.fetch('CHANGEBASE_API_KEY') }@changebase.io"
+end
+```
+
+If you are not using Rails you can configure Changebase directly via:
+
+```ruby
+Changebase.configure do |config|
+  config.changebase.mode = "inline"
+  config.changebase.connection = "https://#{ ENV.fetch('CHANGEBASE_API_KEY') }@changebase.io"
+end
+
+# Or
+
+Changebase.configure(
+    mode: "inline",
+    connection: "https://API_KEY@chanbase.io"
+)
 ```
 
 ## Bugs
 
-If you think you found a bug, please file a ticket on the [issue 
+If you think you found a bug, please file a ticket on the [issue
 tracker](https://github.com/changebase-io/ruby-gem/issues).

data/lib/changebase/action_controller.rb

@@ -4,7 +4,7 @@ module Changebase::ActionController
   included do
     prepend_around_action :changebase_metadata_wrapper
   end
-  
+
   module ClassMethods
     def changebase(*keys, &block)
       method = if block
@@ -14,18 +14,18 @@ module Changebase::ActionController
       else
         keys.first
       end
-      
+
       @changebase_metadata ||= []
       @changebase_metadata << [keys, method]
     end
-    
+
     def changebase_metadata
       klass_metadata = if instance_variable_defined?(:@changebase_metadata)
         @changebase_metadata
       else
         []
       end
-      
+
       if self.superclass.respond_to?(:changebase_metadata)
         klass_metadata + self.superclass.changebase_metadata
       else
@@ -33,21 +33,21 @@ module Changebase::ActionController
       end
     end
   end
-  
+
   def changebase_metadata
     self.class.changebase_metadata
   end
-    
+
   def changebase_metadata_wrapper(&block)
     metadata = {}
-    
+
     changebase_metadata.each do |keys, value|
       data = metadata
       keys[0...-1].each do |key|
         data[key] ||= {}
         data = data[key]
       end
-      
+
       value = case value
       when Symbol
         self.send(value)
@@ -56,7 +56,7 @@ module Changebase::ActionController
       else
         value
       end
-      
+
       if keys.last
         data[keys.last] ||= value
       else
@@ -66,7 +66,7 @@ module Changebase::ActionController
 
     ActiveRecord::Base.with_metadata(metadata, &block)
   end
-  
+
 end
 
-ActionController::Base.include(Changebase::ActionController)
+ActionController::Base.include(Changebase::ActionController)

data/lib/changebase/active_record.rb

@@ -1,106 +1,23 @@
 module Changebase::ActiveRecord
   extend ActiveSupport::Concern
-  
-  module ClassMethods
+
+  class_methods do
     def with_metadata(metadata, &block)
       connection.with_metadata(metadata, &block)
     end
   end
-  
-  def with_metadata(metadata, &block)
-    self.class.with_metadata(metadata, &block)
-  end
-end
-
-module Changebase::ActiveRecord::Connection
 
   def with_metadata(metadata, &block)
-    @changebase_metadata = metadata
-    yield
-  ensure
-    @changebase_metadata = nil
-  end
-  
-end
-
-module Changebase::ActiveRecord::PostgreSQLAdapter
-
-  def initialize(*args, **margs)
-    @without_changebase = false
-    @changebase_metadata = nil
-    super
-  end
-  
-  def without_changebase
-    @without_changebase = true
-    yield
-  ensure
-    @without_changebase = false
-  end
-  
-  def drop_database(name) # :nodoc:
-    without_changebase { super }
-  end
-
-  def drop_table(table_name, **options) # :nodoc:
-    without_changebase { super }
-  end
-
-  def create_database(name, options = {})
-    without_changebase { super }
-  end
-  
-  def recreate_database(name, options = {}) # :nodoc:
-    without_changebase { super }
-  end
-  
-  def execute(sql, name = nil)
-    if !@without_changebase && !current_transaction.open? && write_query?(sql)
-      transaction { super }
-    else
-      super
-    end
-  end
-  
-  def exec_query(sql, name = "SQL", binds = [], prepare: false)
-    if !@without_changebase && !current_transaction.open? && write_query?(sql)
-      transaction { super }
-    else
-      super
-    end
-  end
-  
-  def exec_delete(sql, name = nil, binds = []) # :nodoc:
-    if !@without_changebase && !current_transaction.open? && write_query?(sql)
-      transaction { super }
-    else
-      super
-    end
+    self.class.with_metadata(metadata, &block)
   end
 
-  def commit_db_transaction
-    if !@without_changebase && @changebase_metadata && !@changebase_metadata.empty?
-      sql = ActiveRecord::Base.send(:replace_named_bind_variables, <<~SQL, {version: 1, metadata: ActiveSupport::JSON.encode(@changebase_metadata)})
-        INSERT INTO #{quote_table_name(Changebase.metadata_table)} ( version, data )
-        VALUES ( :version, :metadata )
-        ON CONFLICT ( version )
-        DO UPDATE SET version = :version, data = :metadata;
-      SQL
-      
-      log(sql, "CHANGEBASE") do
-        ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-          @connection.async_exec(sql)
-        end
-      end
+  module Connection
+    def with_metadata(metadata, &block)
+      @changebase_metadata = metadata
+      yield
+    ensure
+      @changebase_metadata = nil
     end
-    super
   end
   
-end
-
-require 'active_record'
-ActiveRecord::Base.include(Changebase::ActiveRecord)
-ActiveRecord::ConnectionAdapters::AbstractAdapter.include(Changebase::ActiveRecord::Connection)
-
-require 'active_record/connection_adapters/postgresql_adapter'
-ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.include(Changebase::ActiveRecord::PostgreSQLAdapter)
+end

data/lib/changebase/connection.rb

@@ -0,0 +1,399 @@
+require 'net/https'
+
+module Changebase
+  
+  class ServerError < ::RuntimeError
+  end
+
+  # RuntimeErrors don't get translated by Rails into
+  # ActiveRecord::StatementInvalid which StandardError do. Would rather
+  # use StandardError, but it's usefull with Changebase to know when something
+  # raises a Changebase::Exception::NotFound or Forbidden
+  class Exception < ::RuntimeError
+    
+    class UnexpectedResponse < Changebase::Exception
+    end
+
+    class BadRequest < Changebase::Exception
+    end
+
+    class Unauthorized < Changebase::Exception
+    end
+
+    class Forbidden < Changebase::Exception
+    end
+
+    class NotFound < Changebase::Exception
+    end
+
+    class Gone < Changebase::Exception
+    end
+
+    class MovedPermanently < Changebase::Exception
+    end
+    
+    class BadGateway < Changebase::Exception
+    end
+
+    class ApiVersionUnsupported < Changebase::Exception
+    end
+
+    class ServiceUnavailable < Changebase::Exception
+    end
+
+  end
+  
+end
+
+
+# _Changebase::Connection_ is a low-level API. It provides basic HTTP #get,
+# #post, #put, and #delete calls to the an HTTP(S) Server. It can also provides 
+# basic error checking of responses.
+class Changebase::Connection
+
+  attr_reader :api_key, :host, :port, :use_ssl
+
+  # Initialize a connection Changebase.
+  #
+  # Options:
+  #
+  # * <tt>:url</tt> - An optional url used to set the protocol, host, port,
+  #   and api_key
+  # * <tt>:host</tt> - The default is to connect to 127.0.0.1.
+  # * <tt>:port</tt> - Defaults to 80.
+  # * <tt>:use_ssl</tt> - Defaults to true.
+  # * <tt>:api_key</tt> - An optional token to send in the `Api-Key` header
+  # * <tt>:user_agent</tt> - An optional string. Will be joined with other
+  #                          User-Agent info.
+  def initialize(config)
+    if config[:url]
+      uri = URI.parse(config.delete(:url))
+      config[:api_key] ||= (uri.user ? CGI.unescape(uri.user) : nil)
+      config[:host]    ||= uri.host
+      config[:port]    ||= uri.port
+      config[:use_ssl] ||= (uri.scheme == 'https')
+    end
+
+    [:api_key, :host, :port, :use_ssl, :user_agent].each do |key|
+      self.instance_variable_set(:"@#{key}", config[key])
+    end
+
+    @connection = Net::HTTP.new(host, port)
+    @connection.max_retries         = 0
+    @connection.open_timeout        = 5
+    @connection.read_timeout        = 30
+    @connection.write_timeout       = 5
+    @connection.ssl_timeout         = 5
+    @connection.keep_alive_timeout  = 30
+    @connection.use_ssl = use_ssl
+    true
+  end
+
+  def connect!
+    @connection.start
+  end
+
+  def active?
+    @connection.active?
+  end
+
+  def reconnect!
+    disconnect!
+    connect!
+  end
+
+  def disconnect!
+    @connection.finish if @connection.active?
+  end
+
+  # Returns the User-Agent of the client. Defaults to:
+  # "Rubygems/changebase@GEM_VERSION Ruby@RUBY_VERSION-pPATCH_LEVEL RUBY_PLATFORM"
+  def user_agent
+    [
+      @user_agent,
+      "Rubygems/changebase@#{Changebase::VERSION}",
+      "Ruby@#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}",
+      RUBY_PLATFORM
+    ].compact.join(' ')
+  end
+
+  # Sends a Net::HTTPRequest to the server. The headers returned from
+  # Connection#request_headers are automatically added to the request.
+  # The appropriate error is raised if the response is not in the 200..299
+  # range.
+  #
+  # Paramaters::
+  #
+  # * +request+ - A Net::HTTPRequest to send to the server
+  # * +body+ - Optional, a String, IO Object, or a Ruby object which is
+  #            converted into JSON and sent as the body
+  # * +block+ - An optional block to call with the +Net::HTTPResponse+ object.
+  #
+  # Return Value::
+  #
+  #  Returns the return value of the <tt>&block</tt> if given, otherwise the
+  #  response object (a Net::HTTPResponse)
+  #
+  # Examples:
+  #
+  #  #!ruby
+  #  connection.send_request(#<Net::HTTP::Get>) # => #<Net::HTTP::Response>
+  #
+  #  connection.send_request(#<Net::HTTP::Get @path="/404">) # => raises Changebase::Exception::NotFound
+  #
+  #  # this will still raise an exception if the response_code is not valid
+  #  # and the block will not be called
+  #  connection.send_request(#<Net::HTTP::Get>) do |response|
+  #    # ...
+  #  end
+  #
+  #  # The following example shows how to stream a response:
+  #  connection.send_request(#<Net::HTTP::Get>) do |response|
+  #    response.read_body do |chunk|
+  #      io.write(chunk)
+  #    end
+  #  end
+  def send_request(request, body=nil, &block)
+    request_headers.each { |k, v| request[k] = v }
+    request['Content-Type'] ||= 'application/json'
+  
+    if body.is_a?(IO)
+      request['Transfer-Encoding'] = 'chunked'
+      request.body_stream =  body
+    elsif body.is_a?(String)
+      request.body = body
+    elsif body
+      request.body = JSON.generate(body)
+    end
+
+    return_value = nil
+    begin
+      close_connection = false
+      @connection.request(request) do |response|
+        # if response['Deprecation-Notice']
+        #   ActiveSupport::Deprecation.warn(response['Deprecation-Notice'])
+        # end
+
+        validate_response_code(response)
+
+        # Get the cookies
+        response.each_header do |key, value|
+          case key.downcase
+          when 'connection'
+            close_connection = (value == 'close')
+          end
+        end
+
+        if block_given?
+          return_value = yield(response)
+        else
+          return_value = response
+        end
+      end
+      @connection.finish if close_connection
+    end
+
+    return_value
+  end
+
+  # Send a GET request to +path+ via +Connection#send_request+.
+  # See +Connection#send_request+ for more details on how the response is
+  # handled.
+  #
+  # Paramaters::
+  #
+  # * +path+ - The +path+ on the server to GET to.
+  # * +params+ - Either a String, Hash, or Ruby Object that responds to
+  #              #to_param. Appended on the URL as query params
+  # * +block+ - An optional block to call with the +Net::HTTPResponse+ object.
+  #
+  # Return Value::
+  #
+  #  See +Connection#send_request+
+  #
+  # Examples:
+  #
+  #  #!ruby
+  #  connection.get('/example') # => #<Net::HTTP::Response>
+  #
+  #  connection.get('/example', 'query=stuff') # => #<Net::HTTP::Response>
+  #
+  #  connection.get('/example', {:query => 'stuff'}) # => #<Net::HTTP::Response>
+  #
+  #  connection.get('/404') # => raises Changebase::Exception::NotFound
+  #
+  #  connection.get('/act') do |response|
+  #    # ...
+  #  end
+  def get(path, params='', &block)
+    params ||= ''
+    request = Net::HTTP::Get.new(path + '?' + params.to_param)
+
+    send_request(request, nil, &block)
+  end
+
+  # Send a POST request to +path+ via +Connection#send_request+.
+  # See +Connection#send_request+ for more details on how the response is
+  # handled.
+  #
+  # Paramaters::
+  #
+  # * +path+ - The +path+ on the server to POST to.
+  # * +body+ - Optional, See +Connection#send_request+.
+  # * +block+ - Optional, See +Connection#send_request+
+  #
+  # Return Value::
+  #
+  #  See +Connection#send_request+
+  #
+  # Examples:
+  #
+  #  #!ruby
+  #  connection.post('/example') # => #<Net::HTTP::Response>
+  #
+  #  connection.post('/example', 'body') # => #<Net::HTTP::Response>
+  #
+  #  connection.post('/example', #<IO Object>) # => #<Net::HTTP::Response>
+  #
+  #  connection.post('/example', {:example => 'data'}) # => #<Net::HTTP::Response>
+  #
+  #  connection.post('/404') # => raises Changebase::Exception::NotFound
+  #
+  #  connection.post('/act') do |response|
+  #    # ...
+  #  end
+  def post(path, body=nil, &block)
+    request = Net::HTTP::Post.new(path)
+
+    send_request(request, body, &block)
+  end
+
+  # Send a PUT request to +path+ via +Connection#send_request+.
+  # See +Connection#send_request+ for more details on how the response is
+  # handled.
+  #
+  # Paramaters::
+  #
+  # * +path+ - The +path+ on the server to POST to.
+  # * +body+ - Optional, See +Connection#send_request+.
+  # * +block+ - Optional, See +Connection#send_request+
+  #
+  # Return Value::
+  #
+  #  See +Connection#send_request+
+  #
+  # Examples:
+  #
+  #  #!ruby
+  #  connection.put('/example') # => #<Net::HTTP::Response>
+  #
+  #  connection.put('/example', 'body') # => #<Net::HTTP::Response>
+  #
+  #  connection.put('/example', #<IO Object>) # => #<Net::HTTP::Response>
+  #
+  #  connection.put('/example', {:example => 'data'}) # => #<Net::HTTP::Response>
+  #
+  #  connection.put('/404') # => raises Changebase::Exception::NotFound
+  #
+  #  connection.put('/act') do |response|
+  #    # ...
+  #  end
+  def put(path, body=nil, *valid_response_codes, &block)
+    request = Net::HTTP::Put.new(path)
+
+    send_request(request, body, &block)
+  end
+
+  # Send a DELETE request to +path+ via +Connection#send_request+.
+  # See +Connection#send_request+ for more details on how the response is
+  # handled
+  #
+  # Paramaters::
+  #
+  # * +path+ - The +path+ on the server to POST to.
+  # * +block+ - Optional, See +Connection#send_request+
+  #
+  # Return Value::
+  #
+  #  See +Connection#send_request+
+  #
+  # Examples:
+  #
+  #  #!ruby
+  #  connection.delete('/example') # => #<Net::HTTP::Response>
+  #
+  #  connection.delete('/404') # => raises Changebase::Exception::NotFound
+  #
+  #  connection.delete('/act') do |response|
+  #    # ...
+  #  end
+  def delete(path, &block)
+    request = Net::HTTP::Delete.new(path)
+
+    send_request(request, nil, &block)
+  end
+
+  private
+
+  def request_headers
+    headers = {}
+  
+    headers['Accept'] = 'application/json'
+    headers['User-Agent'] = user_agent
+    headers['Api-Version'] = '0.2.0'
+    headers['Connection'] = 'keep-alive'
+    headers['Api-Key'] = api_key if api_key
+  
+    headers
+  end
+
+  # Raise an Changebase::Exception based on the response_code, unless the
+  # response_code is include in the valid_response_codes Array
+  #
+  # Paramaters::
+  #
+  # * +response+ - The Net::HTTP::Response object
+  #
+  # Return Value::
+  #
+  #  If an exception is not raised the +response+ is returned
+  #
+  # Examples:
+  #
+  #  #!ruby
+  #  connection.validate_response_code(<Net::HTTP::Response @code=200>) # => <Net::HTTP::Response @code=200>
+  #
+  #  connection.validate_response_code(<Net::HTTP::Response @code=404>) # => raises Changebase::Exception::NotFound
+  #
+  #  connection.validate_response_code(<Net::HTTP::Response @code=500>) # => raises Changebase::Exception
+  def validate_response_code(response)
+    code = response.code.to_i
+
+    if !(200..299).include?(code)
+      case code
+      when 400
+        raise Changebase::Exception::BadRequest, response.body
+      when 401
+        raise Changebase::Exception::Unauthorized, response.body
+      when 403
+        raise Changebase::Exception::Forbidden, response.body
+      when 404
+        raise Changebase::Exception::NotFound, response.body
+      when 410
+        raise Changebase::Exception::Gone, response.body
+      when 422
+        raise Changebase::Exception::ApiVersionUnsupported, response.body
+      when 503
+        raise Changebase::Exception::ServiceUnavailable, response.body
+      when 301
+        raise Changebase::Exception::MovedPermanently, response.body
+      when 502
+        raise Changebase::Exception::BadGateway, response.body
+      when 500..599
+        raise Changebase::ServerError, response.body
+      else
+        raise Changebase::Exception, response.body
+      end
+    end
+  end
+end

data/lib/changebase/inline/active_record.rb

@@ -0,0 +1,161 @@
+require 'securerandom'
+
+module Changebase::Inline
+
+  module Through
+    extend ActiveSupport::Concern
+
+    def delete_records(records, method)
+      x = super
+
+      if method != :destroy
+        records.each do |record|
+          through_model = source_reflection.active_record
+
+          columns = through_model.columns.each_with_index.reduce([]) do |acc, (column, index)|
+            attr_type = through_model.type_for_attribute(column.name)
+            previous_value = attr_type.serialize(column.name == source_reflection.foreign_key ? record.id : owner.id)
+            acc << {
+              index: index,
+              identity: true,
+              name: column.name,
+              type: column.sql_type,
+              value: nil,
+              previous_value: previous_value
+            }
+            acc
+          end
+
+          transaction = through_model.connection.changebase_transaction || Changebase::Inline::Transaction.new(
+            timestamp: Time.current,
+            metadata: through_model.connection.instance_variable_get(:@changebase_metadata)
+          )
+
+          transaction.event!({
+            schema: columns[0].try(:[], :schema) || through_model.connection.current_schema,
+            table: through_model.table_name,
+            type: :delete,
+            columns: columns,
+            timestamp: Time.current
+          })
+
+          # Save the Changebase::Transaction if we are not in a transaction.
+          transaction.save! if !through_model.connection.changebase_transaction
+        end
+      end
+
+      x
+    end
+  end
+
+  module HasMany
+    
+    def delete_or_nullify_all_records(method)
+      x = super
+      if method == :delete_all
+        target.each { |record| record.changebase_track(:delete) }
+      end
+      x
+    end
+    
+  end
+
+  module ActiveRecord
+
+    module PostgreSQLAdapter
+      
+      attr_reader :changebase_transaction
+      
+      # Begins a transaction.
+      def begin_db_transaction
+        super
+        @changebase_transaction = Changebase::Inline::Transaction.new(
+          timestamp: Time.current,
+          metadata: @changebase_metadata
+        )
+      end
+
+      # Aborts a transaction.
+      def exec_rollback_db_transaction
+        super
+      ensure
+        @changebase_transaction = nil
+      end
+
+      # Commits a transaction.
+      def commit_db_transaction
+        @changebase_transaction&.save!
+        @changebase_transaction = nil
+        super
+      end
+    end
+
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def self.extended(other)
+        other.after_create      { changebase_track(:insert) }
+        other.after_update      { changebase_track(:update) }
+        other.after_destroy     { changebase_track(:delete) }
+      end
+
+    end
+
+    def changebase_tracking
+      if Changebase.configured?# && self.class.instance_variable_defined?(:@changebase)
+        # self.class.instance_variable_get(:@changebase)
+        {exclude: []}
+      end
+    end
+
+    def changebase_transaction
+      self.class.connection.changebase_transaction
+    end
+
+    def changebase_track(type)
+      return if !changebase_tracking
+      return if type == :update && self.previous_changes.empty?
+
+      # Go through each of the Model#attributes and grab the type from the
+      # Model#type_for_attribute(attr) to do the serialization, grab the
+      # column definition using Model#column_for_attribute(attr) to write the
+      # type, and use Model.columns.index(col) to grab the index of the column
+      # in the database.
+      columns = self.class.columns.each_with_index.reduce([]) do |acc, (column, index)|
+        identity = self.class.primary_key ? self.class.primary_key == column.name : true
+
+        attr_type = self.type_for_attribute(column.name)
+        value = self.attributes[column.name]
+        previous_value = self.previous_changes[column.name].try(:[], 0)
+
+        case type
+        when :update
+          previous_value ||= value
+        when :delete
+          previous_value ||= value
+          value = nil
+        end
+
+        acc << {
+          index: index,
+          identity: identity,
+          name: column.name,
+          type: column.sql_type,
+          value: attr_type.serialize(value),
+          previous_value: attr_type.serialize(previous_value)
+        }
+        acc
+      end
+
+      # Emit the event
+      changebase_transaction.event!({
+        schema: columns[0].try(:[], :schema) || self.class.connection.current_schema,
+        table: self.class.table_name,
+        type: type,
+        columns: columns,
+        timestamp: Time.current
+      })
+    end
+
+  end
+end

data/lib/changebase/inline/event.rb

@@ -0,0 +1,25 @@
+class Changebase::Inline::Event
+
+  attr_accessor :id, :database_id, :transaction_id, :type, :schema,
+                :table, :timestamp, :created_at, :columns
+
+  def initialize(attrs)
+    attrs.each { |k,v| self.send("#{k}=", v) }
+
+    self.columns ||= {}
+  end
+
+  def as_json
+    {
+      id:                 id,
+      transaction_id:     transaction_id,
+      lsn:                timestamp.utc.iso8601(3),
+      type:               type,
+      schema:             schema,
+      table:              table,
+      timestamp:          timestamp.utc.iso8601(3),
+      columns:            columns.as_json
+    }.compact
+  end
+
+end

data/lib/changebase/inline/transaction.rb

@@ -0,0 +1,71 @@
+require 'securerandom'
+
+class Changebase::Inline::Transaction
+
+  attr_accessor :id, :metadata, :timestamp, :events
+
+  def initialize(attrs={})
+    attrs.each { |k,v| self.send("#{k}=", v) }
+
+    if id
+      @persisted = true
+    else
+      @persisted = false
+      @id ||= SecureRandom.uuid
+    end
+
+    @events ||= []
+    @timestamp ||= Time.now
+    @metadata ||= {}
+  end
+
+  def persisted?
+    @persisted
+  end
+
+  def event!(event_attributes)
+    event = Changebase::Inline::Event.new(event_attributes)
+    @events << event
+    event
+  end
+
+  def self.create!(attrs={})
+    transaction = self.new(attrs)
+    transaction.save!
+    transaction
+  end
+
+  def save!
+    persisted? ? _update : _create
+  end
+
+  def _update
+    return if events.empty?
+    events.delete_if { |a| a.diff.empty? }
+    payload = JSON.generate({events: events.as_json.map{ |json| json[:transaction_id] = id; json }})
+    Changebase.logger.debug("[Changebase] POST /events WITH #{payload}")
+    Changebase.connection.post('/events', payload)
+    @events = []
+  end
+
+  def _create
+    events.delete_if { |a| a.columns.empty? }
+    payload = JSON.generate({transaction: self.as_json})
+    Changebase.logger.debug("[Changebase] POST /transactions WITH #{payload}")
+    Changebase.connection.post('/transactions', payload)
+    @events = []
+    @persisted = true
+  end
+
+  def as_json
+    result = {
+      id:                   id,
+      lsn:                  timestamp.utc.iso8601(3),
+      timestamp:            timestamp.utc.iso8601(3),
+      events:               events.as_json
+    }
+    result[:metadata] = metadata.as_json if !metadata.empty?
+    result
+  end
+
+end

data/lib/changebase/inline.rb

@@ -0,0 +1,32 @@
+require 'changebase'
+Changebase.mode = 'inline'
+
+module Changebase::Inline
+
+  autoload :Event, 'changebase/inline/event'
+  autoload :Transaction, 'changebase/inline/transaction'
+
+  def self.load!
+    require 'active_record'
+    require 'changebase/active_record'
+
+    ::ActiveRecord::Base.include(Changebase::ActiveRecord)
+    ::ActiveRecord::ConnectionAdapters::AbstractAdapter.include(Changebase::ActiveRecord::Connection)
+
+    require 'active_record/connection_adapters/postgresql_adapter'
+    require 'changebase/inline/active_record'
+    ::ActiveRecord::Base.include(Changebase::Inline::ActiveRecord)
+    ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.include(Changebase::Inline::ActiveRecord::PostgreSQLAdapter)
+    ::ActiveRecord::Associations::HasManyThroughAssociation.prepend(Changebase::Inline::Through)
+    ::ActiveRecord::Associations::HasManyAssociation.prepend(Changebase::Inline::HasMany)
+
+    @loaded = true
+  end
+
+  def self.loaded?
+    @loaded
+  end
+
+end
+
+Changebase::Inline.load!

data/lib/changebase/railtie.rb

@@ -1,23 +1,31 @@
 class Changebase::Engine < ::Rails::Engine
 
   config.changebase = ActiveSupport::OrderedOptions.new
+  # config.changebase.mode = nil
   config.changebase.metadata_table = "changebase_metadata"
-  
+
   initializer :changebase do |app|
     migration_paths = config.paths['db/migrate'].expanded
-    
+
     ActiveSupport.on_load(:active_record) do
-      require 'changebase/active_record'
-      migration_paths.each do |path|
-        ActiveRecord::Tasks::DatabaseTasks.migrations_paths << path
+      Changebase.logger = ActiveRecord::Base.logger
+
+      case Changebase.mode
+      when 'replication'
+        Changebase::Replication.load! if !Changebase::Replication.loaded?
+        migration_paths.each do |path|
+          ActiveRecord::Tasks::DatabaseTasks.migrations_paths << path
+        end
+      when 'inline'
+        Changebase::Inline.load! if !Changebase::Inline.loaded?
       end
     end
-    
+
     ActiveSupport.on_load(:action_controller) do
       require 'changebase/action_controller'
     end
-    
-    Changebase.metadata_table = app.config.changebase.metadata_table
+
+    Changebase.configure(**app.config.changebase.to_h)
   end
-  
-end
+
+end

data/lib/changebase/replication/active_record.rb

@@ -0,0 +1,96 @@
+module Changebase::Replication
+  module ActiveRecord
+    module PostgreSQLAdapter
+
+      def initialize(*args, **margs)
+        @without_changebase = false
+        @changebase_metadata = nil
+        super
+      end
+
+      def without_changebase
+        @without_changebase = true
+        yield
+      ensure
+        @without_changebase = false
+      end
+
+      def drop_database(name) # :nodoc:
+        without_changebase { super }
+      end
+
+      def drop_table(table_name, **options) # :nodoc:
+        without_changebase { super }
+      end
+
+      def create_database(name, options = {})
+        without_changebase { super }
+      end
+
+      def recreate_database(name, options = {}) # :nodoc:
+        without_changebase { super }
+      end
+
+      def execute(sql, name = nil)
+        if !@without_changebase && !current_transaction.open? && write_query?(sql)
+          transaction { super }
+        else
+          super
+        end
+      end
+
+      def exec_query(sql, name = "SQL", binds = [], prepare: false)
+        if !@without_changebase && !current_transaction.open? && write_query?(sql)
+          transaction { super }
+        else
+          super
+        end
+      end
+
+      def exec_delete(sql, name = nil, binds = []) # :nodoc:
+        if !@without_changebase && !current_transaction.open? && write_query?(sql)
+          transaction { super }
+        else
+          super
+        end
+      end
+
+      def commit_db_transaction
+        if !@without_changebase && @changebase_metadata && !@changebase_metadata.empty?
+          sql = ::ActiveRecord::Base.send(:replace_named_bind_variables, <<~SQL, {version: 1, metadata: ActiveSupport::JSON.encode(@changebase_metadata)})
+            INSERT INTO #{quote_table_name(Changebase.metadata_table)} ( version, data )
+            VALUES ( :version, :metadata )
+            ON CONFLICT ( version )
+            DO UPDATE SET version = :version, data = :metadata;
+          SQL
+
+          log(sql, "CHANGEBASE") do
+            ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+              @connection.async_exec(sql)
+            end
+          end
+        end
+        super
+      end
+
+      if ::ActiveRecord.gem_version < ::Gem::Version.new("6.0.0")
+        CHANGEBASE_COMMENT_REGEX = %r{(?:--.*\n)|/\*(?:[^*]|\*[^/])*\*/}m
+        def self.changebase_build_read_query_regexp(*parts) # :nodoc:
+          parts += [:begin, :commit, :explain, :release, :rollback, :savepoint, :select, :with]
+          parts = parts.map { |part| /#{part}/i }
+          /\A(?:[(\s]|#{CHANGEBASE_COMMENT_REGEX})*#{Regexp.union(*parts)}/
+        end
+              
+        CHANGEBASE_READ_QUERY = changebase_build_read_query_regexp(
+          :close, :declare, :fetch, :move, :set, :show
+        )
+        def write_query?(sql)
+          !CHANGEBASE_READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !CHANGEBASE_READ_QUERY.match?(sql.b)
+        end
+      end
+
+    end
+  end
+end

data/lib/changebase/replication.rb

@@ -0,0 +1,24 @@
+require 'changebase'
+Changebase.mode = 'replication'
+
+module Changebase::Replication
+  def self.load!
+    require 'active_record'
+
+    ::ActiveRecord::Base.include(Changebase::ActiveRecord)
+    ::ActiveRecord::ConnectionAdapters::AbstractAdapter.include(Changebase::ActiveRecord::Connection)
+    
+    require 'active_record/connection_adapters/postgresql_adapter'
+    require 'changebase/replication/active_record'
+    ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.include(Changebase::Replication::ActiveRecord::PostgreSQLAdapter)
+    
+    @loaded = true
+  end
+  
+  def self.loaded?
+    @loaded
+  end
+  
+end
+
+Changebase::Replication.load!

data/lib/changebase/version.rb

@@ -1,3 +1,3 @@
 module Changebase
-  VERSION = '0.1'
+  VERSION = '0.2'
 end

data/lib/changebase.rb

@@ -1,16 +1,67 @@
 module Changebase
+
+  autoload :VERSION, 'changebase/version'
+  autoload :Connection, 'changebase/connection'
+  autoload :Inline, 'changebase/inline'
+  autoload :Replication, 'changebase/replication'
   autoload :ActiveRecord, 'changebase/active_record'
   autoload :ActionController, 'changebase/action_controller'
-  
-  @metadata_table = "changebase_metadata"
-  
+
+  @config = {
+    mode: "replication",
+    metadata_table: "changebase_metadata"
+  }
+
   def self.metadata_table=(value)
-    @metadata_table = value
+    @config[:metadata_table] = value
   end
-  
+
   def self.metadata_table
-    @metadata_table
+    @config[:metadata_table]
+  end
+
+  def self.mode=(value)
+    @config[:mode] = value
+  end
+
+  def self.mode
+    @config[:mode]
+  end
+
+  def self.connection=(value)
+    @config[:connection] = value
+  end
+
+  def self.connection
+    Thread.current[:changebase_connection] ||= Changebase::Connection.new({
+      url: @config[:connection]
+    })
+  end
+
+  def self.configure(**config)
+    @config.merge!(config)
+    self.logger = @config[:logger] if @config[:logger]
   end
+
+  def self.configured?
+    case @config[:mode]
+    when 'inline'
+      !!@config[:connection]
+    else
+      true
+    end
+  end
+
+  def self.logger
+    return @logger if defined?(@logger)
+
+    @logger = Logger.new(STDOUT)
+  end
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+
 end
 
-require 'changebase/railtie' if defined?(Rails)
+require 'changebase/railtie' if defined?(Rails)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: changebase
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.2'
 platform: ruby
 authors:
 - Jon Bracy
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-17 00:00:00.000000000 Z
+date: 2022-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -17,7 +17,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '5.2'
     - - "<"
       - !ruby/object:Gem::Version
         version: '8'
@@ -27,7 +27,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '5.2'
     - - "<"
       - !ruby/object:Gem::Version
         version: '8'
@@ -37,7 +37,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '5.2'
     - - "<"
       - !ruby/object:Gem::Version
         version: '8'
@@ -47,7 +47,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '5.2'
     - - "<"
       - !ruby/object:Gem::Version
         version: '8'
@@ -57,7 +57,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '5.2'
     - - "<"
       - !ruby/object:Gem::Version
         version: '8'
@@ -67,7 +67,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '5.2'
     - - "<"
       - !ruby/object:Gem::Version
         version: '8'
@@ -141,6 +141,20 @@ dependencies:
     - - ">="
       - !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: mocha
   requirement: !ruby/object:Gem::Requirement
@@ -225,7 +239,14 @@ files:
 - lib/changebase.rb
 - lib/changebase/action_controller.rb
 - lib/changebase/active_record.rb
+- lib/changebase/connection.rb
+- lib/changebase/inline.rb
+- lib/changebase/inline/active_record.rb
+- lib/changebase/inline/event.rb
+- lib/changebase/inline/transaction.rb
 - lib/changebase/railtie.rb
+- lib/changebase/replication.rb
+- lib/changebase/replication/active_record.rb
 - lib/changebase/version.rb
 homepage: https://changebase.io
 licenses: []