pgdice 0.4.3 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e580b9c81c5f8881771e2728e23a012703d15ce1196ef3395f32e40bbe8bfa0b
-  data.tar.gz: 0ab69e25f7d15d8fef14bfaeba53cccc2cd7e212e80d8fdaa36629c030410a28
+  metadata.gz: aa5557cff6f9f2ef5c8f73d925d6dc21d99df9300d368b05172a699893b97c22
+  data.tar.gz: 563dc93f6915247e5ff7d5b6500d1cfdcbcb38247a871d787d0d76bfad50fffc
 SHA512:
-  metadata.gz: cbf8ecffdeb93605197217c6aba201611672d92ed56598b3580807e482c86ca4e740425b17ee25ac4161c7445b25c277484d71b1c58750f2dac55ba90db1abed
-  data.tar.gz: 2358edafb9391d37df00982c1ef05cd490c44730ed8c45bc854c4e4eeaba433979c03a5a141a3032a81eb9b2753e47164cd967201abeb5c9c31980c6a2917488
+  metadata.gz: e7dbe79ec3584a45e054827acf2993d6aa02ccdae42335418cd4113c385c36a460d21c6c6cd68cbc2ced9044cfed38ff6e952735791a54a8587c65a905e0aa13
+  data.tar.gz: fe0e0ccb8f503b7bfed31f1baf6bb1b986566f26324b35550f8c39408ae013df25439bfd6b57f268f0883e827211a13dc5332711e296612f90c8f2cd0a1a8efa

data/.codeclimate.yml

@@ -2,4 +2,7 @@ version: "2"
 checks:
   argument-count:
     config:
-      threshold: 5
+      threshold: 5
+
+exclude_patterns:
+  - "examples/**/*"

data/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,27 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: needs investigation
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Please include this information**
+ - Postgres Version: [e.g. 10.6]
+ - PgDice Version [e.g. 0.14.3]
+
+**Additional context**
+Add any other context about the problem here.

data/.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: needs investigation
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

data/.github/workflows/gempush.yml

@@ -0,0 +1,41 @@
+name: Ruby Gem
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    name: Build + Publish
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@master
+    - name: Set up Ruby 2.6
+      uses: actions/setup-ruby@v1
+      with:
+        version: 2.6.x
+
+#     - name: Publish to GPR
+#       run: |
+#         mkdir -p $HOME/.gem
+#         touch $HOME/.gem/credentials
+#         chmod 0600 $HOME/.gem/credentials
+#         printf -- "---\n:github: Bearer ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
+#         gem build *.gemspec
+#         gem push --KEY github --host https://rubygems.pkg.github.com/${OWNER} *.gem
+#       env:
+#         GEM_HOST_API_KEY: ${{secrets.GPR_AUTH_TOKEN}}
+#         OWNER: username
+
+    - name: Publish to RubyGems
+      run: |
+        mkdir -p $HOME/.gem
+        touch $HOME/.gem/credentials
+        chmod 0600 $HOME/.gem/credentials
+        printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
+        gem build *.gemspec
+        gem push *.gem
+      env:
+        GEM_HOST_API_KEY: ${{secrets.RUBYGEMS_AUTH_TOKEN}}

data/.rubocop.yml

@@ -8,4 +8,8 @@ Metrics/BlockLength:
 # TODO: Evaluate if this is an acceptable parameter list. It's a constructor after all.
 Metrics/ParameterLists:
   Exclude:
-    - lib/pgdice/table.rb
+    - lib/pgdice/table.rb
+
+AllCops:
+  Exclude:
+    - 'examples/**/*'

data/README.md

@@ -13,18 +13,6 @@ PgDice is intended to be used by scheduled background jobs in frameworks like [S
 where logging and clear exception messages are crucial.
 
 
-## Disclaimer
-
-There are some features in this gem which allow you to drop database tables. 
-
-If you choose to use this software without a __tested and working__ backup and restore strategy in place then you 
-are a fool and will pay the price for your negligence. THIS SOFTWARE IS PROVIDED "AS IS",
-WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. By using this software you agree that the creator, 
-maintainers and any affiliated parties CANNOT BE HELD LIABLE FOR DATA LOSS OR LOSSES OF ANY KIND.
-
-See the [LICENSE](LICENSE) for more information.
-
-
 # Installation
 
 Add this line to your application's Gemfile:
@@ -279,6 +267,12 @@ PgDice.list_droppable_partitions('comments', past: 60)
 ```
 This example would use `60` instead of the configured value of `90` from the `comments` table we configured above.
 
+# Examples
+
+1. [Here's an example on how to use PgDice in AWS](examples/aws) and the [README](examples/aws/README.md) which will guide
+you through what is going on.
+
+1. [Here's an example on how to write a config.yml for PgDice](examples/config.yml)
 
 # FAQ
 
@@ -292,7 +286,7 @@ This example would use `60` instead of the configured value of `90` from the `co
   password = config[Rails.env]["password"]
 
   "postgres://#{username}:#{password}@#{host}/#{database}"
-end
+ end
 ```
 
 1. I'm seeing off-by-one errors for my `assert_tables` calls?
@@ -305,6 +299,8 @@ end
 1. Non time-range based partitioning. [PgParty](https://github.com/rkrage/pg_party) might be a good option!
 
 
+
+
 # Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. 
@@ -336,6 +332,16 @@ to be a safe, welcoming space for collaboration, and contributors are expected t
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
+# Disclaimer
+
+There are some features in this gem which allow you to drop database tables. 
+
+If you choose to use this software without a __tested and working__ backup and restore strategy in place then you 
+are a fool and will pay the price for your negligence. THIS SOFTWARE IS PROVIDED "AS IS",
+WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. By using this software you agree that the creator, 
+maintainers and any affiliated parties CANNOT BE HELD LIABLE FOR DATA LOSS OR LOSSES OF ANY KIND.
+
+See the [LICENSE](LICENSE) for more information.
 
 # Code of Conduct
 

data/examples/aws/README.md

@@ -0,0 +1,28 @@
+# How can I use PgDice in production?
+
+This collection of files is how I use PgDice in production. I'll describe the architecture here so you'll have a place
+to start.
+
+1. `tasks/poll_sqs.rake` is run using some sort of process manager like systemd on the ec2 instance. I like to run
+the poll_sqs stuff on my Sidekiq instances because they are the ones who eventually handle the work anyway.
+
+1. `lib/sqs_poller.rb` is used to handle the looping logic for the rake task. It invokes `lib/sqs_listener.rb` for each 
+iteration.
+
+1. `lib/sqs_listener.rb` calls AWS SQS to receive messages and then passes each one into the `lib/sqs_listener/sqs_event_router.rb` 
+to be routed to the correct message handler.
+
+1. Inside `lib/sqs_listener/sqs_event_router.rb` the message is parsed and passed through a case statement. 
+This could be abstracted better but for now if the message has a field of `event_type` and a value of `"task"` then
+the router will send it off to the `TaskEventHandler` which in this case is 
+`lib/sqs_listener/typed_event_handler/task_event_handler.rb`
+
+1. In the `TaskEventHandler` the task is sent to a handler which responds to the task specified in the message body field `task`.
+
+1. The handler for the task (in this case, `DatabaseTasks`) handles the parameters for invoking the Sidekiq worker: `PgDiceWorker`
+
+1. Finally, the `PgDiceWorker` is called and handles invoking `PgDice` based on the parameters passed in.
+
+
+Hopefully that wasn't too confusing. There's a lot of steps in here because the system that uses PgDice handles lots
+of different types of SQS events and needs to be as resilient as possible.

data/examples/aws/cloudformation/scheduled_events.json

@@ -0,0 +1,59 @@
+{
+  "Description": "Deployment stack",
+  "Parameters": {
+    "PgDiceEnabled": {
+      "Type": "String",
+      "Description": "The ENABLED/DISABLED state of the cloudwatch scheduled events for PgDice."
+    }
+  },
+  "Resources": {
+    "PgDiceDailyAddPartitions": {
+      "DependsOn": "IncomingSQS",
+      "Type": "AWS::Events::Rule",
+      "Properties": {
+        "State":{
+          "Ref": "PgDiceEnabled"
+        },
+        "Description": " PgDice daily add partitions",
+        "Name": "PgDiceDailyAddPartitions",
+        "ScheduleExpression": "rate(1 day)",
+        "Targets": [
+          {
+            "Arn": {
+              "Fn::GetAtt": [
+                "IncomingSQS",
+                "Arn"
+              ]
+            },
+            "Id": "PgDiceDailyAddPartitionsId",
+            "Input": "{\"event_type\":\"task\",\"task\":\"add_new_partitions\"}"
+          }
+        ]
+      }
+    },
+    "PgDiceDailyDropPartitions": {
+      "DependsOn": "IncomingSQS",
+      "Type": "AWS::Events::Rule",
+      "Properties": {
+        "State":{
+          "Ref": "PgDiceEnabled"
+        },
+        "Description": " PgDice daily drop partitions",
+        "Name": "PgDiceDailyDropPartitions",
+        "ScheduleExpression": "rate(1 day)",
+        "Targets": [
+          {
+            "Arn": {
+              "Fn::GetAtt": [
+                "IncomingSQS",
+                "Arn"
+              ]
+            },
+            "Id": "PgDiceDailyDropPartitionsId",
+            "Input": "{\"event_type\":\"task\",\"task\":\"drop_old_partitions\"}"
+          }
+        ]
+      }
+    }
+  }
+}

data/examples/aws/lib/sqs_listener.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-sqs'
+
+# READ_ONLY_SQS can be set to ensure we don't delete good messages
+class SqsListener
+  DEFAULT_VISIBILITY_TIMEOUT ||= 600
+  attr_reader :logger, :queue_url, :visibility_timeout
+
+  def initialize(opts = {})
+    @logger = opts[:logger] ||= Sidekiq.logger
+    @queue_url = opts[:queue_url] ||= ENV['SqsQueueUrl']
+    @sqs_client = opts[:sqs_client] ||= Aws::SQS::Client.new
+    @sqs_event_router = opts[:sqs_event_router] ||= SqsEventRouter.new(logger: logger)
+    increase_timeout_resolver = opts[:increase_timeout_resolver] ||= -> { ENV['READ_ONLY_SQS'].to_s == 'true' }
+    @visibility_timeout = calculate_visibility_timeout(increase_timeout_resolver.call)
+
+    logger.debug { "Running in environment: #{ENV['RAILS_ENV']} and using sqs queue: #{queue_url}" }
+  end
+
+  # http://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/sqs-example-get-messages-with-long-polling.html
+  def call
+    # This uses long polling to retrieve sqs events so we can process them
+    response = @sqs_client.receive_message(queue_url: queue_url,
+                                           max_number_of_messages: 10,
+                                           wait_time_seconds: 20,
+                                           visibility_timeout: visibility_timeout)
+
+    if response.messages&.size&.positive?
+      logger.debug { "The number of messages received from the queue was: #{response.messages&.size}" }
+    end
+
+    # Iterate over all the messages in the response (Response is a Struct which acts like an object with methods)
+    response.messages&.each do |message|
+      @sqs_event_router.handle_message(message)
+    end
+  end
+
+  private
+
+  def calculate_visibility_timeout(increase_timeout)
+    visibility_timeout = increase_timeout ? DEFAULT_VISIBILITY_TIMEOUT * 4 : DEFAULT_VISIBILITY_TIMEOUT
+
+    logger.info { "Visibility timeout set to: #{visibility_timeout} seconds" }
+    visibility_timeout
+  end
+end

data/examples/aws/lib/sqs_listener/default_event_handler.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class DefaultEventHandler
+  attr_reader :logger
+
+  def initialize(opts = {})
+    @logger = opts[:logger] ||= Sidekiq.logger
+    @fallthrough_event_handler = opts[:fallthrough_event_handler] ||= FallthroughEventHandler.new(logger: logger)
+  end
+
+  def handle_message(message)
+    # Since 'message' is a JSON formatted string, parse the JSON and then get the values under the 'Records' key
+    # When JSON parses a string it returns a Ruby Hash (just like a Java HashMap)
+    records = JSON.parse(message.body)['Records']
+    if records
+      process_records(records, message)
+    else
+      # If the message body doesn't have any entries under the 'Records' key then we don't know what to do.
+      @fallthrough_event_handler.call(message)
+    end
+  rescue StandardError => e
+    # If any errors are raised processing this message then call the fallthrough because something went wrong.
+    logger.error { "Caught error while handling incoming message. Calling fallthrough_event_handler. Error: #{e}" }
+    @fallthrough_event_handler.call(message)
+  end
+
+  private
+
+  def process_records(records, message)
+    # Process default event
+  end
+end

data/examples/aws/lib/sqs_listener/exceptions/unknown_task_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class UnknownTaskError < StandardError
+end

data/examples/aws/lib/sqs_listener/fallthrough_event_handler.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class FallthroughEventHandler
+  attr_reader :logger
+
+  def initialize(opts = {})
+    @logger = opts[:logger] ||= Sidekiq.logger
+    @sqs_message_deleter = opts[:sqs_message_deleter] ||= SqsMessageDeleter.new(logger: logger)
+  end
+
+  def call(message)
+    logger.warn do
+      "Received sqs message we don't know how to process. Message: #{message}"
+    end
+
+    @sqs_message_deleter.call(message.receipt_handle)
+  end
+end

data/examples/aws/lib/sqs_listener/sqs_event_router.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Responsible for routing incoming SQS events to the correct handler
+class SqsEventRouter
+  attr_reader :logger
+
+  def initialize(opts = {})
+    @logger = opts[:logger] ||= Sidekiq.logger
+    @task_event_handler = opts[:task_event_handler] ||= TaskEventHandler.new(logger: logger)
+    @default_event_handler = opts[:default_event_handler] ||= DefaultEventHandler.new(logger: logger)
+    @sqs_message_deleter = opts[:sqs_message_deleter] ||= SqsMessageDeleter.new(logger: logger)
+  end
+
+  # Handles incoming sqs event, looking for a field of 'event_type'
+  # See scheduled_events.json for details on how to create task events from cloudwatch
+  def handle_message(message)
+    message_body = JSON.parse(message.body).with_indifferent_access
+    event_type = message_body[:event_type]
+
+    logger.tagged(message.receipt_handle) do
+      logger.debug { "The received message was: #{message}" }
+
+      case event_type
+      when 'task'
+        @task_event_handler.run_task(message_body)
+        @sqs_message_deleter.call(message.receipt_handle)
+      else
+        @default_event_handler.handle_message(message)
+      end
+    end
+  end
+end

data/examples/aws/lib/sqs_listener/typed_event_handler/task_event_handler.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class TaskEventHandler
+  attr_reader :logger
+
+  def initialize(opts = {})
+    @logger = opts[:logger] ||= Sidekiq.logger
+    @task_handlers = [opts[:task_handlers] ||= initialize_default_handlers].flatten.compact
+  end
+
+  def run_task(message_body_hash)
+    task = message_body_hash.fetch(:task).to_sym
+    logger.debug { "Running task: #{task}. Searching for task in: #{@task_handlers}" }
+
+    task_handlers = resolve_task_handlers(task)
+
+    if task_handlers.blank?
+      raise UnknownTaskError, "Could not find task: #{task} in any of the available task_handlers: #{@task_handlers}"
+    end
+
+    invoke_task_handler(task_handlers.first, task, message_body_hash.fetch(:parameters, {}))
+  end
+
+  private
+
+  def resolve_task_handlers(task)
+    task_handlers = @task_handlers.select { |task_handler| task_handler.respond_to?(task) }
+
+    task_handlers.each do |task_handler|
+      logger.debug { "Found task handler: #{task_handler.class} that can handle task: #{task}" }
+    end
+    task_handlers
+  end
+
+  def invoke_task_handler(task_handler, task, params)
+    logger.debug { "Invoking handler: #{task_handler.class}##{task} with params: #{params}" }
+    task_handler.public_send(task, params)
+  end
+
+  def initialize_default_handlers
+    [
+      DatabaseTasks.new
+      # Other tasks go here
+    ]
+  end
+end

data/examples/aws/lib/sqs_listener/typed_event_handler/tasks/database_tasks.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Tasks that we can use to maintain partitioned tables over time
+# You can override the default params hash by passing it in to the method calls.
+# The default params are defined inside each method.
+#
+# Also, as far as the string keys for hashes go:
+# https://github.com/mperham/sidekiq/wiki/Best-Practices
+# Sidekiq job parameters must be JSON serializable. That means Ruby symbols are
+# lost when they are sent through JSON!
+class DatabaseTasks
+  def initialize(opts = {})
+    @pgdice = opts[:pgdice] ||= PgDice
+    @task_runner = opts[:task_runner] ||= ->(method, params) { PgdiceWorker.perform_async(method, params) }
+  end
+
+  def add_new_partitions(params = {})
+    all_params = { 'table_names' => table_names, 'only' => 'future', 'validate' => true }.merge(params)
+    @task_runner.call('add_new_partitions', all_params)
+  end
+
+  def drop_old_partitions(params = {})
+    all_params = { 'table_names' => table_names, 'only' => 'past', 'validate' => true }.merge(params)
+    @task_runner.call('drop_old_partitions', all_params)
+  end
+
+  def assert_tables(params = {})
+    all_params = { 'table_names' => table_names, 'validate' => false }.merge(params)
+    @task_runner.call('assert_tables', all_params)
+  end
+
+  private
+
+  def table_names
+    @pgdice.approved_tables.map(&:name)
+  end
+end

data/examples/aws/lib/sqs_message_deleter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-sqs'
+
+class SqsMessageDeleter
+  attr_reader :logger
+
+  def initialize(opts = {})
+    @logger = opts[:logger] ||= Sidekiq.logger
+    @queue_url = opts[:queue_url] ||= ENV['SqsQueueUrl']
+    @sqs_client = opts[:sqs_client] ||= Aws::SQS::Client.new
+    @skip_delete_predicate = opts[:skip_delete_predicate] ||= proc do
+      Rails.env != 'production' || ENV['READ_ONLY_SQS'].to_s == 'true'
+    end
+  end
+
+  def call(sqs_message_receipt_handle)
+    if @skip_delete_predicate.call
+      logger.info { "Not destroying sqs message because environment is not prod or READ_ONLY_SQS was set to 'true'" }
+      return false
+    end
+
+    logger.debug { "Destroying sqs message with handle: #{sqs_message_receipt_handle}" }
+
+    response = @sqs_client.delete_message(queue_url: @queue_url, receipt_handle: sqs_message_receipt_handle)
+    unless response.successful?
+      raise "Attempt to delete SQS message: #{sqs_message_receipt_handle} was not successful. Response: #{response}"
+    end
+
+    true
+  end
+end

data/examples/aws/lib/sqs_poller.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-sqs'
+
+class SqsPoller
+  attr_reader :logger, :queue_url
+
+  MAX_RETRIES ||= 3
+  DEFAULT_WAIT_TIME ||= 5
+
+  def initialize(opts = {})
+    @logger = opts[:logger] ||= ActiveSupport::TaggedLogging.new(Logger.new(ENV['POLL_SQS_LOG_OUTPUT'] || STDOUT))
+    @max_retries = opts[:max_retries] ||= MAX_RETRIES
+    @sleep_seconds = opts[:sleep_seconds] ||= DEFAULT_WAIT_TIME
+    @error_sleep_seconds = opts[:error_sleep_seconds] ||= @sleep_seconds * 2
+    @sqs_listener = opts[:sqs_listener] ||= SqsListener.new(logger: logger)
+  end
+
+  def poll(iterations = Float::INFINITY)
+    logger.info { "Starting loop to #{iterations}, press Ctrl-C to exit" }
+
+    retries = 0
+    i = 0
+
+    while i < iterations
+      begin
+        i += 1
+        execute_loop
+      rescue StandardError => e
+        if retries < MAX_RETRIES
+          retries = handle_retry(retries, e)
+          retry
+        else
+          die(e)
+        end
+      rescue Exception => e
+        die(e)
+      end
+    end
+  end
+
+  private
+
+  def execute_loop
+    @sqs_listener.call
+    sleep @sleep_seconds
+  end
+
+  def handle_retry(retries, error)
+    logger.error do
+      "Polling loop encountered an error. Will retry in #{@error_sleep_seconds} seconds. "\
+        "Error: #{error}. Retries: #{retries}"
+    end
+    retries += 1
+
+    # Handle error with error tracking service
+    # @error_handler.call(error)
+
+    sleep @error_sleep_seconds
+    retries
+  end
+
+  def die(error)
+    logger.fatal { "Polling loop is stopping due to exception: #{error}" }
+    raise error
+  end
+end

data/examples/aws/tasks/poll_sqs.rake

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# You can set READ_ONLY_SQS=true if you don't want to delete messages
+
+desc 'Poll SQS for any new test executions'
+task poll_sqs: :environment do
+  SqsPoller.new.poll
+end

data/examples/aws/workers/pg_dice_worker.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# https://github.com/mperham/sidekiq/wiki/Best-Practices
+# Sidekiq job parameters must be JSON serializable. That means Ruby symbols are
+# lost when they are sent through JSON!
+class PgdiceWorker
+  include Sidekiq::Worker
+  attr_reader :logger
+  sidekiq_options queue: :default, backtrace: true, retry: 5
+
+  def initialize(opts = {})
+    @pgdice = opts[:pgdice] ||= PgDice
+    @logger = opts[:logger] ||= Sidekiq.logger
+    @validator = opts[:validator] ||= lambda do |table_name, params|
+      @pgdice.public_send(:assert_tables, table_name, params)
+    end
+  end
+
+  def perform(method, params)
+    table_names = params.delete('table_names')
+    validate = params.delete('validate').present?
+    # Don't pass in params to PgDice if the hash is empty. PgDice will behave differently when params are passed.
+    pgdice_params = params.keys.size.zero? ? nil : handle_pgdice_params(params)
+
+    logger.debug { "PgdiceWorker called with method: #{method} and table_names: #{table_names}. Validate: #{validate}" }
+
+    [table_names].flatten.compact.each do |table_name|
+      @pgdice.public_send(method, table_name, pgdice_params)
+      @validator.call(table_name, pgdice_params) if validate
+    end
+  end
+
+  private
+
+  def handle_pgdice_params(pgdice_params)
+    convert_pgdice_param_values(pgdice_known_symbol_keys(pgdice_params))
+  end
+
+  def pgdice_known_symbol_keys(params)
+    convertable_keys = ['only']
+    params.keys.each do |key|
+      params[key.to_sym] = params.delete(key) if convertable_keys.include?(key)
+    end
+    params
+  end
+
+  def convert_pgdice_param_values(params)
+    symbolize_values_for_keys = [:only]
+    params.each do |key, value|
+      params[key] = value.to_sym if symbolize_values_for_keys.include?(key)
+    end
+    params
+  end
+end

data/lib/pgdice/partition_helper.rb

@@ -40,8 +40,8 @@ module PgDice
 
     def undo_partitioning(table_name)
       undo_partitioning!(table_name)
-    rescue PgDice::PgSliceError => error
-      logger.error { "Rescued PgSliceError: #{error}" }
+    rescue PgDice::PgSliceError => e
+      logger.error { "Rescued PgSliceError: #{e}" }
       false
     end
 

data/lib/pgdice/pg_slice_manager.rb

@@ -73,8 +73,8 @@ module PgDice
       table_name = params.fetch(:table_name)
 
       run_pgslice("unprep #{table_name}", params[:dry_run])
-    rescue PgSliceError => error
-      logger.error { "Rescued PgSliceError: #{error}" }
+    rescue PgSliceError => e
+      logger.error { "Rescued PgSliceError: #{e}" }
       false
     end
 
@@ -82,8 +82,8 @@ module PgDice
       table_name = params.fetch(:table_name)
 
       run_pgslice("unswap #{table_name}", params[:dry_run])
-    rescue PgSliceError => error
-      logger.error { "Rescued PgSliceError: #{error}" }
+    rescue PgSliceError => e
+      logger.error { "Rescued PgSliceError: #{e}" }
       false
     end
 

data/lib/pgdice/query_executor.rb

@@ -13,8 +13,8 @@ module PgDice
 
     def call(query)
       @connection_supplier.call.exec(query)
-    rescue PG::Error => error
-      logger.error { "Caught error: #{error}. Going to reset connection and try again" }
+    rescue PG::Error => e
+      logger.error { "Caught error: #{e}. Going to reset connection and try again" }
       @connection_supplier.call.reset
       @connection_supplier.call.exec(query)
     end

data/lib/pgdice/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgDice
-  VERSION = '0.4.3'
+  VERSION = '1.0.1'
 end

data/pgdice.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   # Locked because we depend on internal behavior for table commenting
-  spec.add_runtime_dependency 'pg', '~> 1.1.0', '>= 1.1.0'
+  spec.add_runtime_dependency 'pg', '~> 1.2.2', '>= 1.1.0'
   spec.add_runtime_dependency 'pgslice', '0.4.5'
 
   spec.add_development_dependency 'bundler', '~> 1.16', '>= 1.16'
@@ -38,6 +38,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'minitest-ci', '~> 3.4.0', '>= 3.4.0'
   spec.add_development_dependency 'minitest-reporters', '~> 1.3.4', '>= 1.3.4'
   spec.add_development_dependency 'rake', '~> 10.0', '>= 10.0'
-  spec.add_development_dependency 'rubocop', '0.59'
+  spec.add_development_dependency 'rubocop', '0.71'
   spec.add_development_dependency 'simplecov', '~> 0.16.1', '>= 0.16.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pgdice
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 1.0.1
 platform: ruby
 authors:
 - Andrew Newell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-04-23 00:00:00.000000000 Z
+date: 2020-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -19,7 +19,7 @@ dependencies:
         version: 1.1.0
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.2.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +29,7 @@ dependencies:
         version: 1.1.0
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.2.2
 - !ruby/object:Gem::Dependency
   name: pgslice
   requirement: !ruby/object:Gem::Requirement
@@ -250,14 +250,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '0.59'
+        version: '0.71'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '0.59'
+        version: '0.71'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -288,6 +288,9 @@ files:
 - ".circleci/config.yml"
 - ".codeclimate.yml"
 - ".coveralls.yml"
+- ".github/ISSUE_TEMPLATE/bug_report.md"
+- ".github/ISSUE_TEMPLATE/feature_request.md"
+- ".github/workflows/gempush.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - ".ruby-gemset"
@@ -303,6 +306,19 @@ files:
 - bin/console
 - bin/guard
 - bin/setup
+- examples/aws/README.md
+- examples/aws/cloudformation/scheduled_events.json
+- examples/aws/lib/sqs_listener.rb
+- examples/aws/lib/sqs_listener/default_event_handler.rb
+- examples/aws/lib/sqs_listener/exceptions/unknown_task_error.rb
+- examples/aws/lib/sqs_listener/fallthrough_event_handler.rb
+- examples/aws/lib/sqs_listener/sqs_event_router.rb
+- examples/aws/lib/sqs_listener/typed_event_handler/task_event_handler.rb
+- examples/aws/lib/sqs_listener/typed_event_handler/tasks/database_tasks.rb
+- examples/aws/lib/sqs_message_deleter.rb
+- examples/aws/lib/sqs_poller.rb
+- examples/aws/tasks/poll_sqs.rake
+- examples/aws/workers/pg_dice_worker.rb
 - examples/config.yml
 - lib/pgdice.rb
 - lib/pgdice/approved_tables.rb
@@ -352,8 +368,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.9
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Postgres table partitioning with a Ruby API!