heroku_error_pages 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dcbc58c8c09a48ecfc080524888410620dd4c0e56e35cb37efb29398e814d7d4
-  data.tar.gz: dc633286704481c7a6c1b111f0c2b0231c6528b35ed2f32574ecedb6fdc096a1
+  metadata.gz: 1b985d20291623223aec9fe97d81b3171aa432257116cd01c841383a03a3bf11
+  data.tar.gz: b61f8ef5c37a87f836d9aa338cdb167d1e1066dd476446ee4578189071e5fad9
 SHA512:
-  metadata.gz: e718a4161a2ebc3d01596981fe636abc1fa7d1a49124593fac8a1d3fe1460eb70fde2a764e4f5c5a6dcfca2d754fa80b2609c558fbc1fea3fe72809619afa4ea
-  data.tar.gz: bd8a9ac179af8087514b18fee7fced133a79c4eed86afbfcb16669cce4b6c53266452f15b42bcf7f9ba30e37c78adda387bb313cf0861be78bb4dc7b26387574
+  metadata.gz: 95ceb34bb2908d5a5e65cc0b386de1531ca92c9f59e4cf6c400443e68315bf9b1fe351ff3e0abf97ecad35fd004156e1d71f9d0f8d94f5b628f0c0d338e82146
+  data.tar.gz: 8570c4cf61a9820ce034df71ab183e760f8910a8cdf640342f0169bd3f238aadd956276026a8d40262b7ea829b3614ca28b7063e793a3f53ca258a1f7b308ef8

data/.rubocop.yml

@@ -22,3 +22,6 @@ Metrics/AbcSize:
 
 Metrics/MethodLength:
   Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false

data/README.md

@@ -1,10 +1,15 @@
 # HerokuErrorPages
 
-Heroku allows you to configure custom error pages for application/launch errors and maintenance mode. https://devcenter.heroku.com/articles/error-pages#customize-pages
+Heroku allows you to configure [custom error pages](https://devcenter.heroku.com/articles/error-pages#customize-pages) for application errors and maintenance mode.
 
-This gem allows you to easily generate one or both of these pages during your Heroku deployment and store the static HTML on Amazon S3. This means your custom error pages are always using your latest stylesheets. You simply supply the template and S3 configuration variables.
+This gem allows you to developer the pages in your Rails application, generate the pages during Heroku deployments, and store the static HTML on Amazon S3. This means your custom error pages are always kept up-to-date.
 
-## Installation
+There are 3 areas of configuration:
+- Gem Installation and Configuration
+- AWS Configuration
+- Heroku Configuration
+
+## Gem Installation
 
 Install the gem and add to the application's Gemfile by executing:
 
@@ -14,9 +19,9 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
     $ gem install heroku_error_pages
 
-## Usage
+## Gem Configuration
 
-Configure the error and/or maintenance pages. For a rails application, create a file like `config/initializers/heroku_error_pages.rb`.
+Configure the error and/or maintenance pages via an initializer in `config/initializers/heroku_error_pages.rb`.
 
 Sample configuration:
 
@@ -32,12 +37,11 @@ HerokuErrorPages.configure do |config|
 
   # at least one page must be configured
   config.configure_error_page(
-    s3_path: 'application_error.html', # where the html will be stored in your S3 bucket
     template: 'errors/show', # the Rails template to render
     assigns: { # optional, any variables to assign to the template
       status: :internal_server_error
     },
-    controller: ErrorsController # optional, defaults to ActionController::Base
+    layout: 'public' # optional, defaults to 'application'
   )
 
   config.configure_maintenance_page(
@@ -46,20 +50,55 @@ HerokuErrorPages.configure do |config|
 end
 ```
 
-Add this to your `Procfile` to configure Heroku to deploy your custom pages as part of deployments:
+## AWS Configuration
+
+The AWS user specified in the configuration must have `s3:PutObject` permissions for the specified AWS S3 bucket. The gem does not specify any ACLs for the uploaded files, so the bucket policy must allow public access to the files.
+
+The gem prefixes all files with `heroku_error_pages/` to avoid conflicts with other files in the bucket. You can therefore apply a single bucket policy to allow public access to only the files with this prefix.
+
+This example policy will allow public access to all files with the prefix `heroku_error_pages/` (make sure you replace `YOUR_BUCKET_NAME_HERE` with your actual bucket name):
+
+```
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Sid": "AllowPublicReadForHerokuErrorPages",
+            "Effect": "Allow",
+            "Principal": "*",
+            "Action": "s3:GetObject",
+            "Resource": "arn:aws:s3:::YOUR_BUCKET_NAME_HERE/heroku_error_pages/*"
+        }
+    ]
+```
+
+In order to use a policy for allowing public access, configure your bucket like this:
+
+- ☑️ Block public access to buckets and objects granted through new access control lists (ACLs)
+- ☑️ Block public access to buckets and objects granted through any access control lists (ACLs)
+- ⬜ Block public access to buckets and objects granted through new public bucket or access point policies
+- ⬜ Block public and cross-account access to buckets and objects through any public bucket or access point policies
+
+## Heroku Configuration
+
+Configure the Heroku `Procfile` to deploy your custom pages as part of deployments:
 
 ```
 release: bundle exec rake heroku_error_pages:deploy
 ```
 
-You can verify that your error pages are being served correctly out of S3 by navigating there in your browser, eg. `https://your-s3-bucket.s3.amazonaws.com/application_error.html`. Once you are satisfied you can configure Heroku to use your custom error pages:
+This rake task will generate `error_page.html` and/or `maintenance_page.html` and upload all the relevant assets (CSS, JS, images) to the S3 bucket in the `heroku_error_pages/` folder/prefix. This should ensure that the custom error pages have all assets referenced correctly via relative paths.
+
+You can verify that your error pages have the necessary permissions and are being served correctly out of S3 by navigating there in your browser, i.e. `https://your-s3-bucket.s3.amazonaws.com/heroku_error_pages/error_page.html` or `https://your-s3-bucket.s3.amazonaws.com/heroku_error_pages/maintenance_page.html`. Once you are satisfied you can configure Heroku to use your custom error pages:
 
 ```
 heroku config:set \
-  ERROR_PAGE_URL=//your-s3-bucket.s3.amazonaws.com/application_error.html \
-  MAINTENANCE_PAGE_URL=//your-s3-bucket.s3.amazonaws.com/your_maintenance_page.html
+  ERROR_PAGE_URL=//your-s3-bucket.s3.amazonaws.com/heroku_error_pages/error_page.html \
+  MAINTENANCE_PAGE_URL=//your-s3-bucket.s3.amazonaws.com/heroku_error_pages/maintenance_page.html
 ```
 
+The pages will be refreshed automatically as part of every deployment, which ensures that any style changes are automatically applied.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/heroku_error_pages/config.rb

@@ -11,21 +11,19 @@ module HerokuErrorPages
       @aws_region = "us-east-1"
     end
 
-    def configure_error_page(s3_path:, template:, assigns: nil, controller: nil)
+    def configure_error_page(template:, assigns: nil, layout: nil)
       @error_page = PageConfig.new(
-        s3_path: s3_path,
         template: template,
         assigns: assigns,
-        controller: controller
+        layout: layout
       )
     end
 
-    def config_maintenance_page(s3_path:, template:, assigns: nil, controller: nil)
+    def configure_maintenance_page(template:, assigns: nil, layout: nil)
       @maintenance_page = PageConfig.new(
-        s3_path: s3_path,
         template: template,
         assigns: assigns,
-        controller: controller
+        layout: layout
       )
     end
   end

data/lib/heroku_error_pages/page_config.rb

@@ -2,13 +2,12 @@
 
 module HerokuErrorPages
   class PageConfig
-    attr_accessor :s3_path, :template, :assigns, :controller
+    attr_accessor :template, :assigns, :layout
 
-    def initialize(s3_path:, template:, assigns:, controller:)
-      @s3_path = s3_path
+    def initialize(template:, assigns:, layout:)
       @template = template
       @assigns = assigns || {}
-      @controller = controller || ActionController::Base
+      @layout = layout || "application"
     end
   end
 end

data/lib/heroku_error_pages/renderer.rb

@@ -4,14 +4,14 @@ module HerokuErrorPages
   class Renderer
     class << self
       def render_html(page_config)
-        new(page_config.template, page_config.assigns, page_config.controller).html
+        new(page_config.template, page_config.assigns, page_config.layout).html
       end
     end
 
-    def initialize(template, assigns, controller)
+    def initialize(template, assigns, layout)
       @template = template
       @assigns = assigns
-      @controller = controller
+      @layout = layout
     end
 
     def html
@@ -20,14 +20,15 @@ module HerokuErrorPages
 
     private
 
-    attr_reader :template, :assigns, :controller
+    attr_reader :template, :assigns, :layout
 
     def generate_html
-      controller = Class.new(controller) do
+      controller = Class.new(ActionController::Base) do
         self.asset_host = nil
+        self.relative_url_root = "/#{HerokuErrorPages::S3_PREFIX}"
       end
 
-      controller.render(template: template, assigns: assigns)
+      controller.render(template: template, assigns: assigns, layout: layout)
     end
   end
 end

data/lib/heroku_error_pages/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HerokuErrorPages
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/heroku_error_pages.rb

@@ -6,8 +6,13 @@ require_relative "heroku_error_pages/page_config"
 require_relative "heroku_error_pages/railtie"
 require_relative "heroku_error_pages/renderer"
 require_relative "heroku_error_pages/public_asset"
+require "aws-sdk-s3"
 
 module HerokuErrorPages
+  S3_PREFIX = "heroku_error_pages"
+  ERROR_PAGE = "error_page.html"
+  MAINTENANCE_PAGE = "maintenance_page.html"
+
   class << self
     def config
       @config ||= Config.new
@@ -28,19 +33,22 @@ module HerokuErrorPages
         region: config.aws_region
       )
 
-      deploy_page(config.error_page, s3_client)
-      deploy_page(config.maintenance_page, s3_client)
+      deploy_page(config.error_page, s3_client, "error_page.html")
+      deploy_page(config.maintenance_page, s3_client, "maintenance_page.html")
       deploy_public_assets(s3_client)
     end
 
     private
 
-    def deploy_page(page_config, s3_client)
+    def deploy_page(page_config, s3_client, page_name)
       return if page_config.nil?
 
-      s3_object = Aws::S3::Object.new(config.s3_bucket_name, page_config.s3_path, client: s3_client)
+      s3_object = Aws::S3::Object.new(
+        config.s3_bucket_name,
+        "#{S3_PREFIX}/#{page_name}",
+        client: s3_client
+      )
       s3_object.put(
-        acl: "public-read",
         body: Renderer.render_html(page_config),
         content_type: "text/html"
       )
@@ -48,13 +56,16 @@ module HerokuErrorPages
 
     def deploy_public_assets(s3_client)
       PublicAsset.all.each do |public_asset|
-        s3_absolute_path = "#{config.s3_bucket_name}/#{public_asset.relative_path}"
+        s3_absolute_path = "#{config.s3_bucket_name}/#{S3_PREFIX}/#{public_asset.relative_path}"
         Rails.logger.info "Uploading #{public_asset.absolute_path} to #{s3_absolute_path}"
 
-        s3_object = Aws::S3::Object.new(config.s3_bucket_name, public_asset.relative_path, client: s3_client)
+        s3_object = Aws::S3::Object.new(
+          config.s3_bucket_name,
+          "#{S3_PREFIX}/#{public_asset.relative_path}",
+          client: s3_client
+        )
         s3_object.upload_file(
           public_asset.absolute_path,
-          acl: "public-read",
           content_type: public_asset.mime_type
         )
       end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: heroku_error_pages
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Jaco Pretorius
 bindir: exe
 cert_chain: []
-date: 2025-04-18 00:00:00.000000000 Z
+date: 2025-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-s3