pg_audit_log 0.0.1

data/.gitignore

@@ -0,0 +1,9 @@
+*.gem
+*~
+.DS_Store
+.bundle
+.idea
+Gemfile.lock
+doc
+pkg/*
+tags

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.2-p136@pg_audit_log

data/Gemfile

@@ -0,0 +1,7 @@
+source :rubygems
+
+# Specify your gem's dependencies the .gemspec
+gemspec
+
+gem "pg"
+gem "ZenTest"

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009-11 Case Commons, LLC
+
+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.rdoc

@@ -0,0 +1,64 @@
+= pg_audit_log
+
+* http://github.com/casecommons/pg_audit_log/
+
+== DESCRIPTION
+
+PostgreSQL only database-level audit logging of all databases changes using a completely transparent stored procedure and triggers.
+Comes with specs for your project and a rake task to generate the reverse SQL to undo changes logged}
+
+All SQL INSERTs, UPDATEs, and DELETEs will be captured. Record columns that do not change do not generate an audit log entry.
+
+== INSTALL
+
+=== Enable custom variables in your postgresql instance
+
+  To enable auditing you need to set a variable in your postgresql.conf file:
+
+  For macports: /opt/local/var/db/postgresql84/defaultdb/postgresql.conf
+  For homebrew: /usr/local/var/postgres/postgresql.conf
+  For linux: it varies from distro to distro.
+
+  At the bottom of the file add the following:
+
+    custom_variable_classes = 'audit'
+
+  Then restart your PostgreSQL server
+
+=== Rails 3
+
+  $ rails generate pg_audit_log:install
+
+=== Installing the PostgreSQL function and triggers for your project
+
+  $ rake pg_audit_log:install
+
+== Using on your project
+
+The PgAuditLog::Entry ActiveRecord model represents a single entry in the audit log table. Each entry represents a single change to a single field of a record in a table. So if you change 3 columns of a record, that will generate 3 corresponding PgAuditLog::Entry records.
+
+=== Migrations
+
+TODO
+
+=== schema.rb and development_structure.sql
+
+Since schema.rb cannot represent TRIGGERs or FUNCTIONs you will need to set your environment to generate SQL instead of ruby for your database schema and structure. In your application environment put the following:
+
+  config.active_record.schema_format = :sql
+
+And you can generate this sql using:
+
+  $ rake db:structure:dump
+
+=== Uninstalling
+
+  $ rake pg_audit_log:uninstall
+
+== REQUIREMENTS
+
+* ActiveRecord
+
+== LICENSE
+
+MIT

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :autotest do
+  sh "bundle update && autotest -s rspec2"
+end

data/init.rb

@@ -0,0 +1 @@
+require "pg_audit_log"

data/lib/generators/pg_audit_log/install_generator.rb

@@ -0,0 +1,11 @@
+module PgAuditLog
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+
+      def install
+        directory "lib/tasks"
+      end
+    end
+  end
+end

data/lib/generators/pg_audit_log/rspec_generator.rb

@@ -0,0 +1,12 @@
+module PgAuditLog
+  module Generators
+    class RSpecGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+
+      def install
+        directory "spec/models"
+        copy_file "spec/models/pg_audit_log_spec.rb", "spec/models/pg_audit_log_spec.rb"
+      end
+    end
+  end
+end

data/lib/generators/pg_audit_log/templates/lib/tasks/pg_audit_log.rake

@@ -0,0 +1,76 @@
+namespace :pg_audit_log do
+  IGNORED_TABLES = ["plugin_schema_migrations", "sessions", "schema_migrations"]
+
+  desc "Install audit_log triggers on all tables"
+  task :install => :environment do
+    unless all_tables.include?(PgAuditLog::Entry.table_name)
+      puts "Creating #{PgAuditLog::Entry.table_name} table..."
+      sql = File.read(File.join(sql_path, "create_audit_log_table.sql"))
+      connection.execute_without_auditing(sql)
+    end
+    puts "Installing audit_changes() function..."
+    sql = File.read(File.join(sql_path, "create_audit_changes.sql"))
+    connection.execute_without_auditing(sql)
+
+    puts "Installing all audit log triggers... "
+    run_on(audit_log_tables) do |table|
+      <<-SQL
+        CREATE TRIGGER audit_#{table}
+        AFTER INSERT OR UPDATE OR DELETE
+        ON #{table}
+        FOR EACH ROW
+          EXECUTE PROCEDURE audit_changes()
+      SQL
+    end
+    puts "Exporting development_structure.sql..."
+    Rake::Task["db:structure:dump"].reenable
+    Rake::Task["db:structure:dump"].invoke
+  end
+
+  desc "Uninstall audit log triggers on all tables"
+  task :uninstall => :environment do
+    puts "Dropping all audit_log triggers... "
+    run_on(audit_log_tables) do |table|
+      "DROP TRIGGER audit_#{table} ON #{table};"
+    end
+    puts "Uninstalling audit_changes() function..."
+    sql = File.read(File.join(sql_path, "uninstall_audit_changes.sql"))
+    connection.execute_without_auditing(sql)
+
+    puts "Exporting development_structure.sql..."
+    Rake::Task["db:structure:dump"].reenable
+    Rake::Task["db:structure:dump"].invoke
+  end
+
+  private
+
+  def connection
+    ActiveRecord::Base.connection
+  end
+
+  def all_tables
+    connection.tables
+  end
+
+  def audit_log_tables
+    all_tables - (IGNORED_TABLES + [PgAuditLog::Entry.table_name])
+  end
+
+  def sql_path
+    Rails.root.join("lib/tasks/pg_audit_log")
+  end
+
+  def run_on(tables, &block)
+    tables.sort.each do |table|
+      puts "* #{table}"
+      sql = yield(table)
+      begin
+        connection.execute_without_auditing(sql)
+      rescue => e
+        puts e.to_s
+        connection.reconnect!
+      end
+    end
+  end
+
+end

data/lib/generators/pg_audit_log/templates/lib/tasks/pg_audit_log/create_audit_changes.sql

@@ -0,0 +1,72 @@
+CREATE OR REPLACE PROCEDURAL LANGUAGE plpgsql;
+CREATE OR REPLACE FUNCTION audit_changes() RETURNS trigger
+    LANGUAGE plpgsql
+    AS $_$
+            DECLARE
+              col information_schema.columns %ROWTYPE;
+              new_value text;
+              old_value text;
+              primary_key_column varchar;
+              primary_key_value varchar;
+              user_identifier integer;
+              unique_name varchar;
+              column_name varchar;
+            BEGIN
+              FOR col IN SELECT * FROM information_schema.columns WHERE table_name = TG_RELNAME LOOP
+                new_value := NULL;
+                old_value := NULL;
+                primary_key_column := NULL;
+                primary_key_value := NULL;
+                user_identifier := current_setting('audit.user_id');
+                unique_name := current_setting('audit.user_unique_name');
+                column_name := col.column_name;
+
+                EXECUTE 'SELECT pg_attribute.attname
+                         FROM pg_index, pg_class, pg_attribute
+                         WHERE pg_class.oid = $1::regclass
+                         AND indrelid = pg_class.oid
+                         AND pg_attribute.attrelid = pg_class.oid
+                         AND pg_attribute.attnum = any(pg_index.indkey)
+                         AND indisprimary'
+                INTO primary_key_column USING TG_RELNAME;
+
+                IF TG_OP = 'INSERT' OR TG_OP = 'UPDATE' THEN
+                  EXECUTE 'SELECT CAST($1 . '|| column_name ||' AS TEXT)' INTO new_value USING NEW;
+                  IF primary_key_column IS NOT NULL THEN
+                    EXECUTE 'SELECT CAST($1 . '|| primary_key_column ||' AS VARCHAR)' INTO primary_key_value USING NEW;
+                  END IF;
+                END IF;
+                IF TG_OP = 'DELETE' OR TG_OP = 'UPDATE' THEN
+                  EXECUTE 'SELECT CAST($1 . '|| column_name ||' AS TEXT)' INTO old_value USING OLD;
+                  EXECUTE 'SELECT CAST($1 . '|| primary_key_column ||' AS VARCHAR)' INTO primary_key_value USING OLD;
+                END IF;
+
+                IF TG_RELNAME = 'users' AND column_name = 'last_accessed_at' THEN
+                  NULL;
+                ELSE
+                  IF TG_OP != 'UPDATE' OR new_value != old_value OR (TG_OP = 'UPDATE' AND ( (new_value IS NULL AND old_value IS NOT NULL) OR (new_value IS NOT NULL AND old_value IS NULL))) THEN
+                    INSERT INTO audit_log("operation",
+                                          "table_name",
+                                          "primary_key",
+                                          "field_name",
+                                          "field_value_old",
+                                          "field_value_new",
+                                          "user_id",
+                                          "user_unique_name",
+                                          "occurred_at"
+                                         )
+                    VALUES(TG_OP,
+                          TG_RELNAME,
+                          primary_key_value,
+                          column_name,
+                          old_value,
+                          new_value,
+                          user_identifier,
+                          unique_name,
+                          current_timestamp);
+                  END IF;
+                END IF;
+              END LOOP;
+              RETURN NULL;
+            END
+            $_$;

data/lib/generators/pg_audit_log/templates/lib/tasks/pg_audit_log/create_audit_log_table.sql

@@ -0,0 +1,18 @@
+CREATE SEQUENCE audit_log_id_seq
+    START WITH 1
+    INCREMENT BY 1;
+
+CREATE TABLE audit_log (
+    id integer PRIMARY KEY DEFAULT nextval('audit_log_id_seq'),
+    user_id integer,
+    user_unique_name character varying(255),
+    operation character varying(255),
+    table_name character varying(255),
+    field_name character varying(255),
+    field_value_new text,
+    field_value_old text,
+    occurred_at timestamp without time zone,
+    primary_key character varying(255)
+);
+
+ALTER SEQUENCE audit_log_id_seq OWNED BY audit_log.id;

data/lib/generators/pg_audit_log/templates/lib/tasks/pg_audit_log/uninstall_audit_changes.sql

@@ -0,0 +1 @@
+DROP FUNCTION audit_changes();

data/lib/generators/pg_audit_log/templates/spec/models/pg_audit_log_spec.rb

@@ -0,0 +1,71 @@
+require File.join(File.dirname(__FILE), "pg_audit_log_spec_helper")
+
+describe PgAuditLog do
+  include PgAuditLogSpecHelper
+
+  describe "logging for all models" do
+    get_all_klasses.each do |klass|
+      it "logs inserts for #{klass} (#{klass.table_name})" do
+        object, columns = create_object_for_klass(klass)
+
+        log_entries = PgAuditLog::Entry.find :all, :conditions => {:table_name => klass.table_name, :operation => "INSERT"}
+        columns.each do |column|
+          selected_entries = log_entries.select {|entry| entry.field_name == column.name}
+
+          selected_entries.size.should >= 1
+
+          entry = selected_entries.detect {|entry| entry.primary_key == object.id.to_s}
+          entry.field_value_old.should be_nil
+          entry.field_value_new.should == get_data(column, true).to_s
+        end
+
+        log_entries.map(&:field_name).uniq.should =~ columns.map(&:name)
+      end
+
+      it "logs updates for #{klass}" do
+        klass.delete_all
+        klass.count.should == 0
+        object, columns = create_object_for_klass(klass, [klass.primary_key, "type", "updated_at", "deleted_at"])
+        object.reload # needed for Rails bug around create_without_callbacks + boolean value going from true to false
+        columns.each do |column|
+          object.send("#{column.name}=", get_diff_data(column))
+        end
+
+        object.send(:update_without_callbacks)
+        log_entries = PgAuditLog::Entry.find :all, :conditions => ["table_name = ? AND operation = ? AND field_name != ?",  klass.table_name, "UPDATE", "updated_at"]
+        columns.each do |column|
+          selected_entries = log_entries.select {|entry| entry.field_name == column.name}
+
+          selected_entries.size.should equal(1), "Expected to find entry for #{column.name} (#{column.type}) but found none!"
+
+          entry = selected_entries.first
+          entry.field_value_old.should == get_data(column, true).to_s
+          entry.field_value_new.should == get_diff_data(column, true).to_s
+        end
+
+        log_entries.map(&:field_name).should =~ columns.map(&:name)
+      end
+
+      it "logs deletes for #{klass}" do
+        object, columns = create_object_for_klass(klass)
+
+        ActiveRecord::Base.connection.execute("DELETE FROM #{klass.quoted_table_name} WHERE #{klass.primary_key} = #{object.id}")
+
+        log_entries = PgAuditLog::Entry.find :all, :conditions => {:table_name => klass.table_name, :operation => "DELETE"}
+        columns.each do |column|
+          next if column.name == "update_at"
+          selected_entries = log_entries.select {|entry| entry.field_name == column.name}
+          selected_entries.size.should equal(1), "Expected to find entry for #{column.name} (#{column.type}) but found none!"
+
+          entry = selected_entries.first
+          entry.field_value_old.should == get_data(column, true).to_s
+          entry.field_value_new.should be_nil
+        end
+
+        log_entries.map(&:field_name).should =~ columns.map(&:name)
+      end
+
+    end
+
+  end
+end

data/lib/generators/pg_audit_log/templates/spec/models/pg_audit_log_spec_helper.rb

@@ -0,0 +1,105 @@
+module PgAuditLogSpecHelper
+  EXCLUDED_CLASSES = [ActiveRecord::Base, PgAuditLog::Entry]
+  EXCLUDED_COLUMNS = ["last_accessed_at"]
+
+  def included(base)
+    base.include(InstanceMethods)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def self.find_all_constants(constant)
+      constant.constants.find_all.select do |constant|
+        klass = constant.is_a?(String) ? constant.constantize : constant
+        klass.respond_to?(:ancestors) &&
+        klass.ancestors.include?(ActiveRecord::Base) &&
+        !klass.abstract_class? &&
+        !EXCLUDED_CLASSES.include?(klass)
+      end.sort
+    end
+
+    def self.get_all_klasses
+      return @all_klasses if @all_klasses
+      @all_klasses ||= find_all_constants(Module).map(&:constantize)
+    end
+  end
+
+  module InstanceMethods
+    def get_data(column, format_without_timezone = false)
+      case column.type
+      when :boolean
+        true
+      when :date
+        Date.parse("1/1/2000")
+      when :datetime
+        if format_without_timezone
+          DateTime.parse("1/1/2000 1pm").utc.strftime("%Y-%m-%d %H:%M:%S")
+        else
+          DateTime.parse("1/1/2000 1pm").utc.to_s
+        end
+      when :integer
+        7
+      when :decimal
+        "7.1234567891"
+      when :float
+        7.1234
+      when :string
+        if column.name == "type"
+          "Object"
+        else
+          "Happy"
+        end
+
+      when :text
+        "Happy text"
+      else
+        raise "I don't know how to make data for '#{column.type}'!"
+      end
+    end
+
+    def get_diff_data(column, format_without_timezone = false)
+      case column.type
+      when :boolean
+        false
+      when :date
+        Date.parse("12/1/2000")
+      when :datetime
+        if format_without_timezone
+          DateTime.parse("12/1/2000 1pm").utc.strftime("%Y-%m-%d %H:%M:%S")
+        else
+          DateTime.parse("12/1/2000 1pm").utc.to_s
+        end
+      when :integer
+        9
+      when :decimal
+        "9.1234567891"
+      when :float
+        9.1234
+      when :string
+        if column.name == "type"
+          "Object"
+        else
+          "Sad"
+        end
+      when :text
+        "Sad text"
+      else
+        raise "I don't know how to make data for '#{column.type}'!"
+      end
+    end
+
+    def create_object_for_klass(klass, exclude_columns = [])
+      exclude_columns = exclude_columns | EXCLUDED_COLUMNS
+
+      object = klass.new
+      columns = klass.columns.reject {|column| exclude_columns.include? column.name }
+      columns.each do |column|
+        object.send("#{column.name}=", get_data(column))
+      end
+
+      object.send(:create_without_callbacks)
+      [object, columns]
+    end
+  end
+
+end

data/lib/pg_audit_log.rb

@@ -0,0 +1,8 @@
+module PgAuditLog
+end
+
+require "active_record"
+require "pg_audit_log/version"
+require "pg_audit_log/extensions/postgresql_adapter.rb"
+require "pg_audit_log/entry"
+

data/lib/pg_audit_log/entry.rb

@@ -0,0 +1,23 @@
+class PgAuditLog::Entry < ActiveRecord::Base
+  class CannotDeleteError < StandardError
+    def message
+      "Audit Logs cannot be deleted!"
+    end
+  end
+  set_table_name :audit_log
+
+  before_destroy do
+    raise CannotDeleteError
+  end
+
+  class << self
+    def delete(id)
+      raise CannotDeleteError
+    end
+
+    def delete_all
+      raise CannotDeleteError
+    end
+  end
+
+end

data/lib/pg_audit_log/extensions/postgresql_adapter.rb

@@ -0,0 +1,54 @@
+require "active_record/connection_adapters/postgresql_adapter"
+
+# Did not want to reopen the class but sending an include seemingly is not working.
+class ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+  def execute_with_auditing(sql, name = nil)
+    current_user = Thread.current[:current_user]
+    user_unique_name = current_user.try(:unique_name) || "UNKNOWN"
+
+    log_user_id = %[SET audit.user_id = #{current_user.try(:id) || "-1"}]
+    log_user_unique_name = %[SET audit.user_unique_name = "#{user_unique_name}"]
+
+    log([log_user_id, log_user_unique_name, sql].join("; "), name) do
+      if @async
+        @connection.async_exec(log_user_id)
+        @connection.async_exec(log_user_unique_name)
+        @connection.async_exec(sql)
+      else
+        @connection.exec(log_user_id)
+        @connection.exec(log_user_unique_name)
+        @connection.exec(sql)
+      end
+    end
+  end
+
+  alias_method_chain :execute, :auditing
+
+  def begin_db_transaction
+    execute_without_auditing "BEGIN"
+  end
+
+  # Commits a transaction.
+  def commit_db_transaction
+    execute_without_auditing "COMMIT"
+  end
+
+  # Aborts a transaction.
+  def rollback_db_transaction
+    execute_without_auditing "ROLLBACK"
+  end
+
+  def create_savepoint
+    execute_without_auditing("SAVEPOINT #{current_savepoint_name}")
+  end
+
+  def rollback_to_savepoint
+    execute_without_auditing("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")
+  end
+
+  def release_savepoint
+    execute_without_auditing("RELEASE SAVEPOINT #{current_savepoint_name}")
+  end
+
+end
+

data/lib/pg_audit_log/version.rb

@@ -0,0 +1,3 @@
+module PgAuditLog
+  VERSION = "0.0.1"
+end

data/pg_audit_log.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "pg_audit_log/version"
+
+Gem::Specification.new do |s|
+  s.name        = "pg_audit_log"
+  s.version     = PgAuditLog::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Case Commons, LLC"]
+  s.email       = ["casecommons-dev@googlegroups.com"]
+  s.homepage    = "https://github.com/Casecommons/pg_audit_log"
+  s.summary     = %q{postgresql only database-level audit logging of all databases changes}
+  s.description = %q{A completely transparent audit logging component for your application using a stored procedure and triggers. Comes with specs for your project and a rake task to generate the reverse SQL to undo changes logged}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency("rails", ">=2.3")
+  s.add_development_dependency('rspec')
+  s.add_development_dependency('with_model')
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "the PostgreSQL database" do
+  after do
+    ActiveRecord::Base.connection.reconnect!
+  end
+
+  it "allows custom class variables for audit" do
+    lambda {
+      ActiveRecord::Base.connection.execute('SET audit.test = 1')
+    }.should_not raise_error(ActiveRecord::StatementInvalid), "Your postgres is not configured for auditing. See README.rdoc"
+  end
+
+  it "has an audit log table" do
+    ActiveRecord::Base.connection.table_exists?("audit_log").should be_true
+  end
+
+end

data/spec/connection_adapter_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "the connection adapter" do
+  subject { ActiveRecord::Base.connection }
+
+  it { should respond_to(:execute_without_auditing) }
+
+  it "should work for both execute and execute_without_auditing" do
+    subject.execute("SELECT 1 = 1")
+    subject.execute_without_auditing("SELECT 1 = 1")
+  end
+
+end

data/spec/model_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe PgAuditLog::Entry do
+
+  subject { PgAuditLog::Entry.create! }
+
+  describe ".delete" do
+    it "blows up because deleting audit logs is not allowed" do
+      proc { PgAuditLog::Entry.delete(subject.id) }.should raise_error(PgAuditLog::Entry::CannotDeleteError)
+    end
+  end
+
+  describe ".delete_all" do
+    it "blows up because deleting audit logs is not allowed" do
+      proc { PgAuditLog::Entry.delete_all }.should raise_error(PgAuditLog::Entry::CannotDeleteError)
+    end
+  end
+
+  describe "#destroy" do
+    it "blows up because deleting audit logs is not allowed" do
+      proc { subject.destroy }.should raise_error(PgAuditLog::Entry::CannotDeleteError)
+    end
+  end
+end

data/spec/pg_audit_log_spec.rb

@@ -0,0 +1,185 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe PgAuditLog do
+  describe "a model that is audited" do
+    with_model :audited_model do
+      table do |t|
+        t.string :str
+        t.text :txt
+        t.integer :int
+        t.date :date
+        t.datetime :dt
+        t.boolean :bool
+      end
+    end
+
+    before do
+      AuditedModel.connection.execute(<<-SQL)
+            CREATE TRIGGER audit_audited_models
+            AFTER INSERT OR UPDATE OR DELETE
+            ON #{AuditedModel.quoted_table_name}
+            FOR EACH ROW
+              EXECUTE PROCEDURE audit_changes()
+          SQL
+    end
+
+    after do
+      AuditedModel.connection.execute("DROP TRIGGER audit_audited_models ON #{AuditedModel.quoted_table_name};")
+      PgAuditLog::Entry.connection.execute("TRUNCATE #{PgAuditLog::Entry.quoted_table_name}")
+    end
+
+    let(:attributes) { { :str => "foo", :txt => "bar", :int => 5, :date => Date.today, :dt => Time.now.midnight } }
+
+    context "on create" do
+
+      before do
+        AuditedModel.create!(attributes)
+      end
+
+      describe "the audit log record" do
+        subject { PgAuditLog::Entry.last(:conditions => { :field_name => "str" }) }
+
+        it { should be }
+        its(:occurred_at) { should be }
+        its(:table_name) { should == AuditedModel.table_name }
+        its(:field_name) { should == "str" }
+        its(:primary_key) { should == AuditedModel.last.id.to_s }
+        its(:operation) { should == "INSERT" }
+
+        context "when a user is present" do
+          before do
+            Thread.current[:current_user] = stub(:id => 1, :unique_name => "my current user")
+            AuditedModel.create!
+          end
+
+          after { Thread.current[:current_user] = nil }
+
+          its(:user_id) { should == 1 }
+          its(:user_unique_name) { should == "my current user" }
+        end
+
+        context "when no user is present" do
+          its(:user_id) { should == -1 }
+          its(:user_unique_name) { should == "UNKNOWN" }
+        end
+
+        it "captures all new values for all fields" do
+          attributes.each do |field_name, value|
+            if field_name == :dt
+              PgAuditLog::Entry.last(:conditions => { :field_name => field_name }).field_value_new.should == value.strftime("%Y-%m-%d %H:%M:%S")
+            else
+              PgAuditLog::Entry.last(:conditions => { :field_name => field_name }).field_value_new.should == value.to_s
+            end
+            PgAuditLog::Entry.last(:conditions => { :field_name => field_name }).field_value_old.should be_nil
+          end
+        end
+
+      end
+    end
+
+    context "on update" do
+      before do
+        @model = AuditedModel.create!(attributes)
+      end
+
+      context "when going from a value to a another value" do
+        before { @model.update_attributes!(:str => "bar") }
+        subject { PgAuditLog::Entry.last(:conditions => { :field_name => "str" }) }
+
+        its(:operation) { should == "UPDATE" }
+        its(:field_value_new) { should == "bar" }
+        its(:field_value_old) { should == "foo" }
+      end
+
+      context "when going from nil to a value" do
+        let(:attributes) { {:txt => nil} }
+        before { @model.update_attributes!(:txt => "baz") }
+        subject { PgAuditLog::Entry.last(:conditions => { :field_name => "txt" }) }
+
+        its(:field_value_new) { should == "baz" }
+        its(:field_value_old) { should be_nil }
+      end
+
+      context "when going from a value to nil" do
+        before { @model.update_attributes!(:str => nil) }
+        subject { PgAuditLog::Entry.last(:conditions => { :field_name => "str" }) }
+
+        its(:field_value_new) { should be_nil }
+        its(:field_value_old) { should == "foo" }
+      end
+
+      context "when the value does not change" do
+        before { @model.update_attributes!(:str => "foo") }
+        subject { PgAuditLog::Entry.last(:conditions => { :field_name => "str", :operation => "UPDATE" }) }
+
+        it { should_not be }
+      end
+
+      context "when the value is nil and does not change" do
+        let(:attributes) { {:txt => nil} }
+        before { @model.update_attributes!(:txt => nil) }
+        subject { PgAuditLog::Entry.last(:conditions => { :field_name => "txt", :operation => "UPDATE" }) }
+
+        it { should_not be }
+      end
+
+      context "when the value is a boolean" do
+
+        context "going from nil -> true" do
+          before { @model.update_attributes!(:bool => true) }
+          subject { PgAuditLog::Entry.last(:conditions => { :field_name => "bool", :operation => "UPDATE" }) }
+
+          its(:field_value_new) { should == "true" }
+          its(:field_value_old) { should be_nil }
+        end
+
+        context "going from false -> true" do
+          let(:attributes) { {:bool => false} }
+          before do
+            @model.update_attributes!(:bool => true)
+          end
+          subject { PgAuditLog::Entry.last(:conditions => { :field_name => "bool", :operation => "UPDATE" }) }
+
+          its(:field_value_new) { should == "true" }
+          its(:field_value_old) { should == "false" }
+        end
+
+        context "going from true -> false" do
+          let(:attributes) { {:bool => true} }
+
+          before do
+            @model.update_attributes!(:bool => false)
+          end
+          subject { PgAuditLog::Entry.last(:conditions => { :field_name => "bool", :operation => "UPDATE" }) }
+
+          its(:field_value_new) { should == "false" }
+          its(:field_value_old) { should == "true" }
+        end
+
+      end
+    end
+
+    context "on delete" do
+      before do
+        @model = AuditedModel.create!(attributes)
+        @model.delete
+      end
+
+      subject { PgAuditLog::Entry.last(:conditions => { :field_name => "str" }) }
+
+      its(:operation) { should == "DELETE" }
+
+      it "captures all new values for all fields" do
+        attributes.each do |field_name, value|
+          if field_name == :dt
+            PgAuditLog::Entry.last(:conditions => { :field_name => field_name }).field_value_old.should == value.strftime("%Y-%m-%d %H:%M:%S")
+          else
+            PgAuditLog::Entry.last(:conditions => { :field_name => field_name }).field_value_old.should == value.to_s
+          end
+          PgAuditLog::Entry.last(:conditions => { :field_name => field_name }).field_value_new.should be_nil
+        end
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,43 @@
+require "bundler/setup"
+require "pg_audit_log"
+require "with_model"
+
+connection = nil
+begin
+  ActiveRecord::Base.establish_connection(:adapter  => 'postgresql',
+                                          :database => 'pg_audit_log_test',
+                                          :min_messages => 'warning')
+  connection = ActiveRecord::Base.connection
+  connection.execute("SELECT 1")
+rescue PGError => e
+  puts "-" * 80
+  puts "Unable to connect to database.  Please run:"
+  puts
+  puts "    createdb pg_audit_log_test"
+  puts "-" * 80
+  raise e
+end
+
+connection.execute("DROP TABLE IF EXISTS audit_log")
+
+sql_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib", "generators", "pg_audit_log", "templates", "lib", "tasks", "pg_audit_log"))
+
+["create_audit_changes.sql", "create_audit_log_table.sql"].each do |sql_file|
+  begin
+    connection.execute File.read(File.join(sql_path, sql_file))
+  rescue => e
+    puts "-" * 80
+    puts "Unable to install #{sql_file}"
+    puts "-" * 80
+    raise e
+  end
+end
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+  config.extend WithModel
+
+  config.after(:each) do
+    ActiveRecord::Base.connection.reconnect!
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification 
+name: pg_audit_log
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Case Commons, LLC
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-28 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "2.3"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: with_model
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: A completely transparent audit logging component for your application using a stored procedure and triggers. Comes with specs for your project and a rake task to generate the reverse SQL to undo changes logged
+email: 
+- casecommons-dev@googlegroups.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- LICENSE
+- README.rdoc
+- Rakefile
+- init.rb
+- lib/generators/pg_audit_log/install_generator.rb
+- lib/generators/pg_audit_log/rspec_generator.rb
+- lib/generators/pg_audit_log/templates/lib/tasks/pg_audit_log.rake
+- lib/generators/pg_audit_log/templates/lib/tasks/pg_audit_log/create_audit_changes.sql
+- lib/generators/pg_audit_log/templates/lib/tasks/pg_audit_log/create_audit_log_table.sql
+- lib/generators/pg_audit_log/templates/lib/tasks/pg_audit_log/uninstall_audit_changes.sql
+- lib/generators/pg_audit_log/templates/spec/models/pg_audit_log_spec.rb
+- lib/generators/pg_audit_log/templates/spec/models/pg_audit_log_spec_helper.rb
+- lib/pg_audit_log.rb
+- lib/pg_audit_log/entry.rb
+- lib/pg_audit_log/extensions/postgresql_adapter.rb
+- lib/pg_audit_log/version.rb
+- pg_audit_log.gemspec
+- spec/configuration_spec.rb
+- spec/connection_adapter_spec.rb
+- spec/model_spec.rb
+- spec/pg_audit_log_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/Casecommons/pg_audit_log
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: postgresql only database-level audit logging of all databases changes
+test_files: 
+- spec/configuration_spec.rb
+- spec/connection_adapter_spec.rb
+- spec/model_spec.rb
+- spec/pg_audit_log_spec.rb
+- spec/spec_helper.rb