postburner 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b86343f81143907f3df739be458355fd5ac083cc83c6785a8eb3c45b4f2d2e3c
+  data.tar.gz: 2db76cad93eeb4e5fa551ca7b7a5a9734c81b1d50c64acdbba7e5f71d75cc579
+SHA512:
+  metadata.gz: 167fd6de8a0e985d09baa86ef49e63c9a7d5e642732e10cc6812dcc2bc562a6e1fc95a3910691a18450dd84ff6440ec69a884cd53f8fb236e12fb032e6fe5a97
+  data.tar.gz: 2fb90a8b7a4ad78a8b8c5163bbf9585552fc0e72522d19d0c7779b1706e084899f347932bc5e70741ad64dad83a8bc5a31dae7e07ef8028e20adc4503f778c95

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## v0.2.0 - 2021-04-25
+
+### Added
+- add migration generator.
+- move subclasses to app/jobs.
+- fix/expand views. add lag stat.
+- initial commit with concept.
+
+### Fixed
+- update README.

data/MIT-LICENSE

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

data/README.md

@@ -0,0 +1,116 @@
+# Postburner
+An ActiveRecord layer on top of Backburner for inspecting and auditing the
+queue, especially for delayed jobs. It isn't meant to be fast, but safe.
+
+It is meant to be complementary to Backburner. Use Backburner as the default
+ActiveJob processor for mailers, active storage, and the like. Use a
+`Postburner::Job` for things that you want to track.
+
+Comes with a mountable interface that can be password protected with whatever
+authentication you use in your project.
+
+Also meant to be a replacement/upgrade for [Que](https://github.com/que-rb/que).
+If you need something faster, but backed with ACID compliance, check out Que.
+There are some additional features in Postburner such as retained jobs
+after processing, stats, per job logging, etc.
+
+Compared to plain [Backburner](https://github.com/nesquena/backburner),
+Postburner adds:
+- Database Jobs for inspection, linking, auditing, removal (and deletion)
+- Direct access to associated [Beanstalk](https://beanstalkd.github.io/) (via [beaneater](https://github.com/beanstalkd/beaneater))
+- Job Statistics (lag, attempts, logs, tracked errors)
+- Convenience methods to clear tubes, stats, and connections for Beanstalk.
+
+Otherwise, Postburner tries to be a super simple layer on `Backburner::Queue`
+and `ActiveRecord`. Every tool with either of those are avilabel in
+`Postburner::Job`s.
+
+## Usage
+
+```ruby
+class RunDonation < Postburner::Job
+  queue 'critical'
+  queue_priority 0 # 0 is highest priority
+  queue_max_job_retries 0 # don't retry
+
+  def process(args)
+    # do long tasks here
+    # also have access to self.args
+  end
+end
+
+RunDonation.create!(args: {donation_id: 123}).queue!
+=> {:status=>"INSERTED", :id=>"1139"}
+RunDonation.create!(args: {donation_id: 123}).queue! at: Time.zone.now + 2.days
+=> {:status=>"INSERTED", :id=>"1140"}
+
+# `delay` takes priority over `at`
+RunDonation.create!(args: {donation_id: 123}).queue! delay: 1.hour
+=> {:status=>"INSERTED", :id=>"1141"}
+```
+
+## Installation
+
+```ruby
+# in Gemfile
+gem 'postburner'
+```
+
+```bash
+$ bundle
+
+# install migration, possible to edit and add attributes or indexes as needed.
+$ bundle exec rails g postburner:install
+```
+
+Add a `config/initializers/backburner.rb` with option found [here](https://github.com/nesquena/backburner#configuration).
+
+Set `Backburner` for `ActiveJob`
+```
+# config/application.rb
+config.active_job.queue_adapter = :backburner
+```
+
+Postburner may later provide an adapter, but we recommend using `Postburner::Job` classes
+directyly.
+
+Add jobs to `app/jobs/`. There currently is no generator.
+```ruby
+# app/jobs/run_donation.rb
+
+class RunDonation < Postburner::Job
+  queue 'critical'
+  queue_priority 0 # 0 is highest priority
+  queue_max_job_retries 0 # don't retry
+
+  def process(args)
+    # do long tasks here
+    # also have access to self.args
+  end
+end
+
+## Contributing
+Submit a pull request. Follow conventions of the project. Be nice.
+
+### V1 TODO
+- Basic tests
+- Add Authentication modules for engine mount.
+
+### V1+ TODO
+- Install generator
+  - Sub to backburner
+- Job generator
+  - Build file in app/jobs
+  - Inherit from Postburner::Job
+- Job generator
+- Add before/after/around hooks
+- Add destroy, and remove actions on show page
+- Clear tubes.
+- Document how/when to use activerecord hooks
+- Document how/when to use backburner hooks
+- Document how/when to use postburner hooks
+- Add logging with Job.args in backburner logs
+- MAYBE - ActiveJob adapter
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/assets/config/postburner_manifest.js

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

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

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

data/app/controllers/postburner/application_controller.rb

@@ -0,0 +1,4 @@
+module Postburner
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/controllers/postburner/jobs_controller.rb

@@ -0,0 +1,13 @@
+require_dependency "postburner/application_controller"
+
+module Postburner
+  class JobsController < ApplicationController
+    def index
+      @jobs = Job.order(queued_at: :desc, created_at: :desc)
+    end
+
+    def show
+      @job = Job.find(params[:id])
+    end
+  end
+end

data/app/controllers/postburner/static_controller.rb

@@ -0,0 +1,9 @@
+require_dependency "postburner/application_controller"
+
+module Postburner
+  class StaticController < ApplicationController
+    def root
+      redirect_to postburner.jobs_url
+    end
+  end
+end

data/app/helpers/postburner/application_helper.rb

@@ -0,0 +1,4 @@
+module Postburner
+  module ApplicationHelper
+  end
+end

data/app/jobs/postburner/application_job.rb

@@ -0,0 +1,4 @@
+module Postburner
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/postburner/application_mailer.rb

@@ -0,0 +1,6 @@
+module Postburner
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/postburner/application_record.rb

@@ -0,0 +1,5 @@
+module Postburner
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/postburner/job.rb

@@ -0,0 +1,196 @@
+module Postburner
+  class Job < ApplicationRecord
+    include Backburner::Queue
+
+    LOG_LEVELS = [
+      :debug,
+      :info,
+      :warning,
+      :error
+    ].freeze
+
+    before_validation :ensure_sid!
+    before_destroy :delete!
+
+    validates :sid, presence: {strict: true}
+
+    def queue!(options={})
+      return if self.queued_at.present? && self.bkid.present?
+
+      case
+      when options[:at].present?
+        # this is rudimentary, add error handling
+        options[:delay] ||= options[:at].to_i - Time.zone.now.to_i
+        update_column :run_at, options[:at]
+        options.delete(:at)
+      when options[:delay].present?
+        update_column :run_at, Time.zone.now + options[:delay].seconds
+      end
+
+      insert!(options)
+    end
+
+    # tube: backburner.worker.queue.backburner-jobs
+    #
+    def self.perform(id, _={})
+      begin
+        job = self.find(id)
+        job.perform!(job.args)
+      rescue ActiveRecord::RecordNotFound => e
+        Rails.logger.warning <<-MSG
+[Postburner::Job] [#{id}] Not Found.
+        MSG
+      end
+    end
+
+    def perform!(args={})
+      self.attempting
+
+      self.update_columns(
+        attempting_at:  self.attempting_at,
+        attempts:       self.attempts,
+        attempt_count:  self.attempts.length,
+        lag:            self.lag,
+        processing_at:  Time.zone.now,
+      )
+
+      begin
+        if self.removed_at.present?
+          self.log "Removed", level: :error
+          update_column :logs, self.logs
+          return
+        end
+
+        if self.run_at && self.run_at > Time.zone.now
+          response = self.insert! delay: self.run_at - Time.zone.now
+          self.log "PREMATURE; RE-INSERTED: #{response}"
+          update_column :logs, self.logs
+          return
+        end
+
+        self.log('START')
+
+        self.perform(args)
+
+        self.log('DONE')
+
+      rescue Exception => e
+        self.log_exception(e)
+      end
+
+      begin
+        now = Time.zone.now
+        _duration =  (now - self.processing_at) * 1000 rescue nil
+        self.update_columns(
+          processed_at: now,
+          duration:     _duration,
+          errata:       self.errata,
+          error_count:  self.errata.length,
+          logs:         self.logs,
+          log_count:    self.logs.length,
+        )
+      rescue Exception => e
+        raise e if Rails.env.development? || Rails.env.production?
+        self.log_exception(e)
+        update_column :errata, self.errata
+      end
+    end
+
+    def delete!
+      return unless self.beanstalk_job
+      begin
+        self.beanstalk_job.delete
+      rescue Beaneater::NotConnected => e
+        self.beanstalk_job!.delete
+      end
+    end
+
+    def kick!
+      return unless self.beanstalk_job
+      begin
+        self.beanstalk_job.kick
+      rescue Beaneater::NotConnected => e
+        self.beanstalk_job!.kick
+      end
+    end
+
+    def remove!
+      return false if self.attempts.any?
+      self.delete!
+      self.update_column(removed_at: Time.zone.now)
+    end
+
+    def beanstalk_job
+      return unless self.bkid.present?
+      return @_beanstalk_job if @_beanstalk_job
+
+      @_beanstalk_job = Postburner.connection.beanstalk.jobs.find(self.bkid)
+
+      @_beanstalk_job
+    end
+
+    def beanstalk_job!
+      @_beanstalk_job = nil
+      self.beanstalk_job
+    end
+
+    def log_exception(exception)
+      self.errata << [
+        Time.zone.now,
+        {
+          class:      exception.class,
+          message:    exception.message,
+          backtrace:  exception.backtrace,
+        }
+      ]
+    end
+
+    def log(message, options={})
+      options[:level] ||= :info
+      options[:level] = :error unless LOG_LEVELS.member?(options[:level])
+
+      self.logs << [
+        Time.zone.now,
+        options[:level],
+        message,
+      ]
+    end
+
+    private
+
+    def insert!(options={})
+      response = Backburner::Worker.enqueue(Postburner::Job, self.id, options)
+
+      self.log("QUEUED: #{response}")
+
+      update_columns(
+        queued_at:  Time.zone.now,
+        bkid:       response[:id],
+        logs:       self.logs,
+      )
+
+      response
+    end
+
+    def attempting
+      now = Time.zone.now
+      self.attempts << now
+      self.attempting_at ||= now
+      self.lag ||= (self.attempting_at - self.intended_at) * 1000
+      now
+    end
+
+    def intended_at
+      self.run_at ? self.run_at : self.queued_at
+    end
+
+    def ensure_sid!
+      self.sid ||= SecureRandom.uuid
+    end
+
+    def message
+      "Job: #{self.id}"
+    end
+
+  end
+end

data/app/views/layouts/postburner/application.html.haml

@@ -0,0 +1,10 @@
+!!!
+%html
+  %head
+    %meta{:content => "text/html; charset=UTF-8", "http-equiv" => "Content-Type"}/
+    %title Postburner
+    = csrf_meta_tags
+    = csp_meta_tag
+    = stylesheet_link_tag    "postburner/application", media: "all"
+  %body
+    = yield

data/app/views/postburner/jobs/index.html.haml

@@ -0,0 +1,34 @@
+%h1 Jobs
+
+%table
+  %thead
+    %tr
+      %th ID
+      %th Beanstalk
+      %th Type
+      %th Arguments
+      %th Run
+      %th Attempted
+      %th Completed
+      %th Attempts
+      %th Errors
+      %th Logs
+      %th Lag
+      %th Duration
+  %tbody
+    - @jobs.each do |job|
+      %tr
+        %td
+          = link_to postburner.job_path(job) do
+            %span{title: job.sid}= job.id
+        %td= job.bkid
+        %td= job.type
+        %td= job.args.inspect
+        %td= job.run_at
+        %td= job.attempting_at
+        %td= job.processed_at
+        %td= job.attempt_count
+        %td= job.error_count
+        %td= job.log_count
+        %td= job.lag
+        %td= job.duration

data/app/views/postburner/jobs/show.html.haml

@@ -0,0 +1,13 @@
+%h1 Job #{@job.id} / #{@job.bkid} / #{@job.sid}
+
+- if @job.run_at && @job.run_at > Time.zone.now
+  Running in
+  = distance_of_time_in_words Time.zone.now, @job.run_at
+  (#{@job.run_at.to_i - Time.zone.now.to_i} seconds)
+
+%h3 Stats
+- if @job.beanstalk_job
+  %pre= JSON.pretty_generate @job.beanstalk_job.stats.as_json
+
+%h3 Job
+%pre= JSON.pretty_generate @job.as_json

data/config/routes.rb

@@ -0,0 +1,6 @@
+Postburner::Engine.routes.draw do
+  root 'static#root'
+  resources :jobs, only: %w(index show destroy) do
+    patch :remove, on: :member
+  end
+end

data/lib/generators/postburner/install/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Explain the generator
+
+Example:
+    bin/rails generate install Thing
+
+    This will create:
+        what/will/it/create

data/lib/generators/postburner/install/install_generator.rb

@@ -0,0 +1,47 @@
+class Postburner::InstallGenerator < Rails::Generators::Base
+  source_root File.expand_path('templates', __dir__)
+  include Rails::Generators::Migration
+
+  def install_migrations
+    install_migration! 'create_postburner_jobs'
+  end
+
+  def self.next_migration_number(dirname)
+    timestamp = Time.now.utc.strftime("%Y%m%d%H%M%S")
+    stem = timestamp[0..-3]
+    regexp = Regexp.new("^(#{stem})(\\d\\d)_")
+    timestamps = Dir[File.join(dirname, '*.rb')].map { |name|
+      match = regexp.match(File.basename(name, File.extname(name)))
+      match ? match[2].to_i : nil
+    }.reject(&:nil?)
+    _max = timestamps.max || timestamp[-2..-1].to_i
+    _next = _max + 1
+    raise "MISSING NEXT" if _next.blank?
+    migration_number = "#{stem}#{_next}"
+    if migration_number.length != 14
+      raise "INCORRECT LENGTH stem=#{stem} _next=#{_next} _max=#{_max}"
+    end
+    migration_number
+  end
+
+  private
+
+  def install_migration!(filename)
+    migrate_path = File.join(Rails.root, "db/migrate")
+
+    if self.class.migration_exists?(migrate_path, "#{filename}")
+      say_status "skipped", "#{filename}.rb migration already exists"
+    else
+      migration_template(
+        "migrations/#{filename}.rb.erb",
+        File.join(migrate_path, "#{filename}.rb"),
+        migration_version: migration_version,
+      )
+    end
+  end
+
+  def migration_version
+    "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+  end
+
+end

data/lib/generators/postburner/install/templates/migrations/create_postburner_jobs.rb.erb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+#
+class CreatePostburnerJobs < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :postburner_jobs do |t|
+      t.bigint :bkid
+      t.string :sid, null: false
+      t.string :type
+      t.jsonb :args, default: {}
+      t.datetime :run_at
+      t.datetime :queued_at
+      t.datetime :attempting_at
+      t.datetime :processing_at
+      t.datetime :processed_at
+      t.datetime :removed_at
+      t.integer :lag
+      t.integer :duration
+      t.integer :attempt_count
+      t.integer :error_count
+      t.integer :log_count
+      t.datetime :attempts, array: true, default: []
+      t.jsonb :errata, default: []
+      t.jsonb :logs, default: []
+
+      t.timestamps
+
+      t.index [ :bkid ]
+      t.index [ :sid ], unique: true
+      t.index [ :type ]
+      t.index [ :args ], using: :gin
+      t.index [ :run_at ]
+      t.index [ :queued_at ]
+      t.index [ :removed_at ]
+      t.index [ :lag ]
+      t.index [ :duration ]
+      t.index [ :attempt_count ]
+      t.index [ :error_count ]
+      t.index [ :log_count ]
+
+      # Add these or more depending on what you want to search for.
+      #t.index [ :attempts ], using: :gin
+      #t.index [ :errata ], using: :gin
+      #t.index [ :logs ], using: :gin
+    end
+  end
+end

data/lib/postburner.rb

@@ -0,0 +1,31 @@
+require "postburner/version"
+require "postburner/engine"
+
+module Postburner
+
+  def self.connection
+    @_connection ||= Backburner::Connection.new(
+      Backburner.configuration.beanstalk_url
+    )
+    @_connection.reconnect! unless @_connection.connected?
+    @_connection
+  end
+
+  def self.connected
+    if block_given?
+      begin
+        yield connection
+      ensure
+        connection.close if connection
+      end
+    else
+      connection
+    end
+  end
+
+  def self.remove_all!(confirm)
+    return unless confirm == "CONFIRM"
+
+    # TODO
+  end
+end

data/lib/postburner/engine.rb

@@ -0,0 +1,17 @@
+require 'backburner'
+require 'haml-rails'
+
+module Postburner
+  class Engine < ::Rails::Engine
+    isolate_namespace Postburner
+
+    config.generators do |g|
+      g.template_engine :haml
+      g.helper false
+      g.fixture false
+      g.assets false
+      g.skip_routes true
+    end
+
+  end
+end

data/lib/postburner/version.rb

@@ -0,0 +1,3 @@
+module Postburner
+  VERSION = '0.2.2'
+end

data/lib/tasks/postburner_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :postburner do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: postburner
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+platform: ruby
+authors:
+- Matt Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-05-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.1.3
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.1.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.1.3
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.1.3.1
+- !ruby/object:Gem::Dependency
+  name: backburner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.3
+- !ruby/object:Gem::Dependency
+  name: haml-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+description: Queue background jobs, inspect them, and audit them afterwards.
+email:
+- matt@nearapogee.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/config/postburner_manifest.js
+- app/assets/stylesheets/postburner/application.css
+- app/controllers/postburner/application_controller.rb
+- app/controllers/postburner/jobs_controller.rb
+- app/controllers/postburner/static_controller.rb
+- app/helpers/postburner/application_helper.rb
+- app/jobs/postburner/application_job.rb
+- app/mailers/postburner/application_mailer.rb
+- app/models/postburner/application_record.rb
+- app/models/postburner/job.rb
+- app/views/layouts/postburner/application.html.haml
+- app/views/postburner/jobs/index.html.haml
+- app/views/postburner/jobs/show.html.haml
+- config/environment.rb
+- config/routes.rb
+- lib/generators/postburner/install/USAGE
+- lib/generators/postburner/install/install_generator.rb
+- lib/generators/postburner/install/templates/migrations/create_postburner_jobs.rb.erb
+- lib/postburner.rb
+- lib/postburner/engine.rb
+- lib/postburner/version.rb
+- lib/tasks/postburner_tasks.rake
+homepage: https://gitlab.nearapogee.com/opensource/postburner
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://gitlab.nearapogee.com/opensource/postburner
+  source_code_uri: https://gitlab.nearapogee.com/opensource/postburner
+  changelog_uri: https://gitlab.nearapogee.com/opensource/postburner/-/blob/master/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: Postgres backed beanstalkd queue via backburner
+test_files: []