google_cloud_run 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1978e88dc8a5bfb84eab657f11332750562931fc15d4ed9594e22ab0278b76f1
+  data.tar.gz: 45d40f141a603729fac0d75c54cfa4ebdde0c986500c357897db89a010ff18d1
+SHA512:
+  metadata.gz: 6eebceb1d26a294f9f990464e2ca611dabffa7a1a02fd8605d0756d5c4e5f884d988805f5e7cc58064af9b12aad52f0de05d63c1866f9b5bddeac6eb3db46524
+  data.tar.gz: e39fa2604dbc229083c43285ba066712a70df61733ccd21aec5ce62758a2520d486f5ebef8b99e36bca78e2c9f56c81351f939d99a85c7f2b132b07ffc8d499b

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright 2021 Matthias Kadenbach
+
+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,200 @@
+# Rails on Google Cloud Run 
+
+* Logging
+* Error Reporting
+* Active Job via [Cloud Tasks](https://cloud.google.com/tasks), including delayed jobs.
+* Minor patches for better compatibility
+* Works with Ruby 3 and Rails 6
+
+
+## Usage
+
+```ruby
+logger.info "Hello World"
+
+logger.info do
+  "Expensive logging operation, only run when logged"
+end
+
+logger.info "Labels work, too!", my_label: "works", another_one: "great"
+```
+
+All Google Cloud Logging Severities are supported:
+
+```
+logger.default (or logger.unknown) - The log entry has no assigned severity level.
+logger.debug                       - Debug or trace information. 
+logger.info                        - Routine information, such as ongoing status or performance.
+logger.notice                      - Normal but significant events, such as start up, shut down, or a configuration change.
+logger.warning (or logger.warn)    - Warning events might cause problems.
+logger.error                       - Error events are likely to cause problems.
+logger.critical (or logger.fatal)  - Critical events cause more severe problems or outages.
+logger.alert                       - A person must take an action immediately.
+logger.emergency                   - One or more systems are unusable.
+```
+
+
+## Installation
+
+Add the gem to your Gemfile and run `bundle install`.
+
+```ruby
+# Gemfile
+group :production do
+  gem 'google_cloud_run'
+end
+```
+
+
+In your production config:
+
+```ruby
+# config/environments/production.rb
+
+config.log_level = :g_notice
+config.logger = GoogleCloudRun::Logger.new
+
+config.active_job.queue_adapter = :google_cloudrun_tasks
+config.google_cloudrun.job_queue_default_region = "us-central1"
+config.google_cloudrun.job_callback_url = "https://your-domain.com/rails/google_cloudrun/job_callback"
+```
+
+Set the default queue:
+
+```ruby
+# app/jobs/application_job.rb
+queue_as "my-queue"
+
+# or if `config.google_cloudrun.job_queue_default_region` isn't set:
+queue_as "us-central1/my-queue"
+```
+
+---
+
+In the default production config, the logger is wrapped around 
+a `ENV["RAILS_LOG_TO_STDOUT"].present?` block. I usually just 
+remove this block so I don't have to actually set this ENV var.
+
+You can also remove `config.log_formatter` as we don't need it anymore.
+
+I recommend logging `:g_notice` and higher. Rails logs a lot of noise when logging
+`:info` and higher.
+
+
+## Configuration
+
+You can change more settings in `config/environments/production.rb`. See below
+for the default configuration.
+
+```ruby
+# Enable Google Cloud Logging
+config.google_cloudrun.logger = true
+
+# Set output (STDERR or STDOUT)
+config.google_cloudrun.out = STDERR
+
+# Add source location (file, line number, method) to each log 
+config.google_cloudrun.logger_source_location = true
+
+# Run Proc to assign current user as label to each log
+config.google_cloudrun.logger_user = nil
+
+
+# Enable Error Reporting
+config.google_cloudrun.error_reporting = true
+
+# Assign a default severity level to exceptions
+config.google_cloudrun.error_reporting_exception_severity = :critical
+
+# Run Proc to assign current user to Error Report
+config.google_cloudrun.error_reporting_user = nil
+
+# Turn logs into error reports for this severity and higher.
+# Set to nil to disable.
+config.google_cloudrun.error_reporting_level = :error
+
+# When log is turned into error report, discard the original
+# log and only report the error.
+# Set to false to log and report the error at the same time.
+config.google_cloudrun.error_reporting_discard_log = true
+
+
+# Don't log or error report the following exceptions,
+# because Cloud Run will create access logs for us already.
+config.google_cloudrun.silence_exceptions = [
+      ActionController::RoutingError,
+      ActionController::MethodNotAllowed,
+      ActionController::UnknownHttpMethod,
+      ActionController::NotImplemented,
+      ActionController::UnknownFormat,
+      ActionController::BadRequest,
+      ActionController::ParameterMissing,
+]
+
+
+# Set Rails' request id to the trace id from X-Cloud-Trace-Context header
+# as set by Cloud Run.
+config.google_cloudrun.patch_request_id = true
+
+
+# Enable Jobs via Cloud Tasks
+config.google_cloudrun.jobs = true
+
+# Set the default Google Cloud Task region, i.e. us-central1
+config.google_cloudrun.job_queue_default_region = nil
+
+# Google Cloud Tasks will call this url to execute the job
+config.google_cloudrun.job_callback_url = nil # required, see above
+
+# The default route for the callback url.
+config.google_cloudrun.job_callback_path = "/rails/google_cloudrun/job_callback"
+
+# Time for a job to run in seconds, default is 30min.
+# Use `timeout_after 5.minutes` to configure a job individually.
+config.google_cloudrun.job_timeout_sec = 1800 # (min 15s, max 30m)
+```
+
+---
+
+Both `error_reporting_user` and `logger_user` expect a Proc like this:
+
+```ruby
+config.google_cloudrun.logger_user = Proc.new do |request|
+  # extract and return user id from request, example:
+  request.try { cookie_jar.encrypted[:user_id] }
+end
+```
+
+---
+
+An example job:
+
+```ruby
+class MyJob < ApplicationJob
+  queue_as "us-central1/urgent"
+  timeout_after 1.minute # min 15s, max 30m, overrides config.google_cloudrun.job_timeout_sec
+
+  def perform(*args)
+    # Do something
+  end
+end
+```
+
+## Cloud Task considerations
+
+* Cloud Tasks are a better fit than Google Pub/Sub.
+  [Read more](https://cloud.google.com/pubsub/docs/choosing-pubsub-or-cloud-tasks#detailed-feature-comparison)
+* I'd recommend to create two different Cloud Run services.
+  One for HTTP requests (aka Heroku Dynos) and another service
+  for jobs (aka Heroku Workers). Set the `Request Timeout` for 
+  the request-bound service to something like `15s`, and for workers
+  to `1800s` or match `config.google_cloudrun.job_timeout_sec`.
+* Cloud Task execution calls are authenticated with a Google-issued
+  OIDC token. So even though `/rails/google_cloudrun/job_callback` is publicly
+  available, without a valid token, no job will be executed.
+* Cloud Task job processing is async. It supports multiple queues. Delayed jobs
+  are natively supported through Cloud Task. Priority jobs are not supported, use
+  different queues for that, i.e. "urgent", or "low-priority". Timeouts can be set
+  globally or per job-basis (min 15s, max 30m). 
+  Retries are natively supported by Cloud Tasks.
+

data/app/controllers/google_cloud_run/jobs_controller.rb

@@ -0,0 +1,32 @@
+module GoogleCloudRun
+  class JobsController < ActionController::Base
+    skip_before_action :verify_authenticity_token
+
+    def callback
+      # verify User-Agent and Content-Type
+      return head :bad_request unless request.user_agent == "Google-Cloud-Tasks"
+      return head :bad_request unless request.headers["Content-type"].include?("application/json")
+      return head :bad_request unless request.headers["Authorization"].start_with?("Bearer")
+
+      # verify Bearer token
+      begin
+        r = Google::Auth::IDTokens.verify_oidc request.headers["Authorization"]&.delete_prefix("Bearer")&.strip
+      rescue => e
+        Rails.logger.warning "Google Cloud Run Job callback failed: #{e.message}"
+        return head :bad_request
+      end
+
+      # parse JSON body
+      begin
+        body = JSON.parse(request.body.read)
+      rescue => e
+        raise "Google Cloud Run Job callback failed: Unable to parse JSON body: #{e.message}"
+      end
+
+      # execute the job
+      ActiveJob::Base.execute body
+
+      head :ok
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,3 @@
+Rails.application.routes.draw do
+  post Rails.application.config.google_cloudrun.job_callback_path => "google_cloud_run/jobs#callback", as: :rails_google_cloudrun_job_callback
+end

data/lib/google_cloud_run/engine.rb

@@ -0,0 +1,5 @@
+module GoogleCloudRun
+  class Engine < ::Rails::Engine
+    isolate_namespace GoogleCloudRun
+  end
+end

data/lib/google_cloud_run/entry.rb

@@ -0,0 +1,153 @@
+module GoogleCloudRun
+  class LogEntry
+    include ::Logger::Severity
+
+    attr_accessor :severity,
+                  :message,
+                  :labels,
+                  :timestamp,
+                  :request,
+                  :user,
+                  :location_path, :location_line, :location_method,
+                  :project_id
+
+    def initialize
+      @severity = G_DEFAULT
+      @timestamp = Time.now.utc
+      @insert_id = SecureRandom.uuid
+    end
+
+    def to_json
+      raise "labels must be hash" if !@labels.blank? && !@labels.is_a?(Hash)
+
+      labels["user"] = @user unless @user.blank?
+
+      j = {}
+
+      j["logging.googleapis.com/insertId"] = @insert_id
+      j["severity"] = Severity.to_s(Severity.mapping(@severity))
+      j["message"] = @message.is_a?(String) ? @message.strip : @message.inspect
+      j["timestampSeconds"] = @timestamp.to_i
+      j["timestampNanos"] = @timestamp.nsec
+      j["logging.googleapis.com/labels"] = @labels unless @labels.blank?
+
+      if @request
+        # https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#httprequest
+        j["httpRequest"] = {}
+        j["httpRequest"]["requestMethod"] = @request&.method.to_s
+        j["httpRequest"]["requestUrl"] = @request&.url.to_s
+        j["httpRequest"]["userAgent"] = @request&.headers["user-agent"].to_s unless @request&.headers["user-agent"].blank?
+        j["httpRequest"]["remoteIp"] = @request&.remote_ip.to_s
+        j["httpRequest"]["referer"] = @request&.headers["referer"].to_s unless @request&.headers["referer"].blank?
+
+        trace, span, sample = GoogleCloudRun.parse_trace_context(@request&.headers["X-Cloud-Trace-Context"])
+        j["logging.googleapis.com/trace"] = "projects/#{@project_id}/traces/#{trace}" unless trace.blank?
+        j["logging.googleapis.com/spanId"] = span unless span.blank?
+        j["logging.googleapis.com/trace_sampled"] = sample unless sample.nil?
+      end
+
+      if @location_path || @location_line || @location_method
+        j["logging.googleapis.com/sourceLocation"] = {}
+        j["logging.googleapis.com/sourceLocation"]["function"] = @location_method.to_s
+        j["logging.googleapis.com/sourceLocation"]["file"] = @location_path.to_s
+        j["logging.googleapis.com/sourceLocation"]["line"] = @location_line.to_i
+      end
+
+      j.to_json
+    end
+  end
+
+  # https://cloud.google.com/error-reporting/reference/rest/v1beta1/projects.events/report#ReportedErrorEvent
+  # https://cloud.google.com/error-reporting/docs/formatting-error-messages
+  class ErrorReportingEntry
+    include ::Logger::Severity
+
+    attr_accessor :severity,
+                  :exception,
+                  :project_id,
+                  :message,
+                  :labels,
+                  :timestamp,
+                  :request,
+                  :user,
+                  :location_path, :location_line, :location_method,
+                  :context_service, :context_version
+
+    def initialize
+      @severity = G_CRITICAL
+      @timestamp = Time.now.utc
+      @insert_id = SecureRandom.uuid
+    end
+
+    def to_json
+      raise "labels must be hash" if !@labels.blank? && !@labels.is_a?(Hash)
+
+      j = {}
+
+      j["@type"] = "type.googleapis.com/google.devtools.clouderrorreporting.v1beta1.ReportedErrorEvent"
+      j["logging.googleapis.com/insertId"] = @insert_id
+      j["severity"] = Severity.to_s(Severity.mapping(@severity))
+      j["eventTime"] = @timestamp.strftime("%FT%T.%9NZ")
+      j["logging.googleapis.com/labels"] = @labels unless @labels.blank?
+
+      if @context_service || @context_version
+        j["serviceContext"] = {}
+        j["serviceContext"]["service"] = @context_service.to_s
+        j["serviceContext"]["version"] = @context_version.to_s
+      end
+
+      if @request
+        # https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#httprequest
+        j["httpRequest"] = {}
+        j["httpRequest"]["requestMethod"] = @request&.method.to_s
+        j["httpRequest"]["requestUrl"] = @request&.url.to_s
+        j["httpRequest"]["userAgent"] = @request&.headers["user-agent"].to_s unless @request&.headers["user-agent"].blank?
+        j["httpRequest"]["remoteIp"] = @request&.remote_ip.to_s
+        j["httpRequest"]["referer"] = @request&.headers["referer"].to_s unless @request&.headers["referer"].blank?
+
+        trace, span, sample = GoogleCloudRun.parse_trace_context(@request&.headers["X-Cloud-Trace-Context"])
+        j["logging.googleapis.com/trace"] = "projects/#{@project_id}/traces/#{trace}" unless trace.blank?
+        j["logging.googleapis.com/spanId"] = span unless span.blank?
+        j["logging.googleapis.com/trace_sampled"] = sample unless sample.nil?
+      end
+
+      if @exception
+        j["message"] = @exception.class.to_s
+
+        e_message = @exception&.message.to_s.strip
+        unless e_message.blank?
+          j["message"] << ": " + e_message + "\n"
+        end
+
+        j["message"] << @exception&.backtrace.join("\n")
+      else
+        j["message"] = @message.is_a?(String) ? @message.strip : @message.inspect
+      end
+
+      j["context"] = {}
+
+      if @request
+        # https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#httprequest
+        j["context"]["httpRequest"] = {}
+        j["context"]["httpRequest"]["method"] = @request&.method
+        j["context"]["httpRequest"]["url"] = @request&.url
+        j["context"]["httpRequest"]["userAgent"] = @request&.headers["user-agent"] unless @request&.headers["user-agent"].blank?
+        j["context"]["httpRequest"]["remoteIp"] = @request&.remote_ip
+        j["context"]["httpRequest"]["referrer"] = @request&.headers["referer"] unless @request&.headers["referer"].blank?
+      end
+
+      if @user
+        j["context"]["user"] = @user
+      end
+
+      if @location_path || @location_line || @location_method
+        j["context"]["reportLocation"] = {}
+        j["context"]["reportLocation"]["filePath"] = @location_path.to_s
+        j["context"]["reportLocation"]["lineNumber"] = @location_line.to_i
+        j["context"]["reportLocation"]["functionName"] = @location_method.to_s
+      end
+
+      j.to_json
+    end
+  end
+end

data/lib/google_cloud_run/exceptions.rb

@@ -0,0 +1,32 @@
+module GoogleCloudRun
+  def self.exception_interceptor(request, exception)
+
+    # ref: https://cloud.google.com/error-reporting/reference/rest/v1beta1/projects.events/report#reportederrorevent
+
+    return false if Rails.application.config.google_cloudrun.silence_exceptions.any? { |e| exception.is_a?(e) }
+
+    l = ErrorReportingEntry.new
+    l.project_id = GoogleCloudRun.project_id
+    l.severity = Rails.application.config.google_cloudrun.error_reporting_exception_severity
+    l.exception = exception
+    l.request = request
+
+    l.context_service = GoogleCloudRun.k_service
+    l.context_version = GoogleCloudRun.k_revision
+
+    # attach user to entry
+    p = Rails.application.config.google_cloudrun.error_reporting_user
+    if p && p.is_a?(Proc)
+      begin
+        l.user = p.call(request)
+      rescue
+        # TODO ignore or log?
+      end
+    end
+
+    Rails.application.config.google_cloudrun.out.puts l.to_json
+    Rails.application.config.google_cloudrun.out.flush
+
+    return true
+  end
+end

data/lib/google_cloud_run/job_adapter.rb

@@ -0,0 +1,135 @@
+module ActiveJob
+  module QueueAdapters
+    class GoogleCloudrunTasksAdapter
+      def initialize
+        @client = Google::Cloud::Tasks.cloud_tasks
+        @project_id = GoogleCloudRun.project_id
+        @service_account_email = GoogleCloudRun.default_service_account_email
+        @default_job_timeout_sec = Rails.application.config.google_cloudrun.job_timeout_sec
+        @job_callback_url = Rails.application.config.google_cloudrun.job_callback_url
+        @queue_default_region = Rails.application.config.google_cloudrun.job_queue_default_region
+
+        if @job_callback_url.blank? || !@job_callback_url.end_with?(Rails.application.config.google_cloudrun.job_callback_path)
+          raise "Set config.google_cloudrun.job_callback_url to 'https://your-domain.com#{Rails.application.config.google_cloudrun.job_callback_path}'"
+        end
+
+        if !@job_callback_url.start_with?("https://")
+          raise "config.google_cloudrun.job_callback_url must start with https://"
+        end
+      end
+
+      def enqueue(job)
+        create_cloudtask(job.class,
+                         job.job_id,
+                         job.queue_name,
+                         local_timeout(job) || @default_job_timeout_sec,
+                         nil,
+                         job.serialize)
+      end
+
+      def enqueue_at(job, timestamp)
+        create_cloudtask(job.class,
+                         job.job_id,
+                         job.queue_name,
+                         local_timeout(job) || @default_job_timeout_sec,
+                         timestamp,
+                         job.serialize)
+      end
+
+      private
+
+      def create_cloudtask(job_name, job_id, full_queue_name, job_timeout, scheduled_at, job)
+        return if !Rails.application.config.google_cloudrun.jobs
+
+        region, queue_name = parse_full_queue_name(full_queue_name)
+        queue = @client.queue_path project: @project_id, location: region, queue: queue_name
+
+        task = build_task_request(
+          "projects/#{@project_id}/locations/#{region}/queues/#{queue_name}/tasks/#{job_id}",
+          @job_callback_url,
+          @service_account_email,
+          job.to_json,
+          job_timeout,
+          scheduled_at,
+        )
+
+        response = nil
+        begin
+          response = @client.create_task parent: queue, task: task
+        rescue => e
+          raise "Failed sending job #{job_name}(#{job_id}) to queue '#{region}/#{queue_name}'. #{e.message}"
+        end
+        if response.nil?
+          raise "Failed sending job #{job_name}(#{job_id}) to queue '#{region}/#{queue_name}'. Google didn't return a response."
+        end
+
+        Rails.logger&.notice "Job #{job_name}(#{job_id}) sent to queue '#{region}/#{queue_name}'"
+      end
+
+      def build_task_request(name, url, service_account_email, body, job_timeout, scheduled_at)
+        # ref: https://cloud.google.com/tasks/docs/reference/rest/v2/projects.locations.queues.tasks#Task
+        req = {
+          name: name,
+          http_request: {
+            oidc_token: { service_account_email: service_account_email },
+            headers: { "Content-Type": "application/json" },
+            http_method: "POST",
+            url: url,
+            body: body,
+          },
+        }
+
+        d = Google::Protobuf::Duration.new
+        d.seconds = job_timeout.to_i
+        req[:dispatch_deadline] = d
+
+        if scheduled_at
+          t = Google::Protobuf::Timestamp.new
+          t.seconds = Time.at(scheduled_at).utc.to_i
+          req[:schedule_time] = t
+        end
+
+        return req
+      end
+
+      def parse_full_queue_name(queue_name)
+        # config.active_job.queue_name_prefix will add an underscore,
+        # queue names can't have underscores. Let's turn it into a hyphen.
+        queue_name = queue_name.gsub("_", "-")
+
+        # see if we have something like this: region/queue
+        parts = queue_name.split("/")
+        if parts.size == 2
+          return parts[0], parts[1]
+        end
+
+        if @queue_default_region.blank?
+          raise "queue_as \"#{queue_name}\" needs region: \"region/#{queue_name}\" or set config.google_cloudrun.job_queue_default_region"
+        end
+
+        # use our default region
+        return @queue_default_region, queue_name
+      end
+
+      def local_timeout(job)
+        begin
+          job.class.class_variable_get(:@@google_cloudrun_job_timeout)
+        rescue
+          nil
+        end
+      end
+    end
+  end
+end
+
+module GoogleCloudRun
+  module TimeoutAfterExtension
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def timeout_after(t)
+        self.class_variable_set(:@@google_cloudrun_job_timeout, t)
+      end
+    end
+  end
+end

data/lib/google_cloud_run/logger.rb

@@ -0,0 +1,316 @@
+module GoogleCloudRun
+  class Logger
+    include ::Logger::Severity
+
+    def initialize
+      @level = G_INFO
+      @formatter = DummyFormatter.new
+      @out = Rails.application.config.google_cloudrun.out
+      @project_id = GoogleCloudRun.project_id
+    end
+
+    def level=(level)
+      @level = Severity.mapping(level)
+    end
+
+    def level?(level)
+      Severity.mapping(level) >= @level
+    end
+
+    def log(severity, msg = nil, progname = nil, **labels, &block)
+      labels["progname"] = progname unless progname.blank?
+      write(severity, msg, labels, &block)
+    end
+
+    def default(msg = nil, **labels, &block)
+      write(G_DEFAULT, msg, labels, &block)
+    end
+
+    def default?
+      self.level?(G_DEFAULT)
+    end
+
+    def default!
+      self.level = G_DEFAULT
+    end
+
+    def debug(msg = nil, **labels, &block)
+      write(G_DEBUG, msg, labels, &block)
+    end
+
+    def debug?
+      self.level?(G_DEBUG)
+    end
+
+    def debug!
+      self.level = G_DEBUG
+    end
+
+    def info(msg = nil, **labels, &block)
+      write(G_INFO, msg, labels, &block)
+    end
+
+    def info?
+      self.level?(G_INFO)
+    end
+
+    def info!
+      self.level = G_INFO
+    end
+
+    def notice(msg = nil, **labels, &block)
+      write(G_NOTICE, msg, labels, &block)
+    end
+
+    def notice?
+      self.level?(G_NOTICE)
+    end
+
+    def notice!
+      self.level = G_NOTICE
+    end
+
+    def warning(msg = nil, **labels, &block)
+      write(G_WARNING, msg, labels, &block)
+    end
+
+    def warning?
+      self.level?(G_WARNING)
+    end
+
+    def warning!
+      self.level = G_WARNING
+    end
+
+    def error(msg = nil, **labels, &block)
+      write(G_ERROR, msg, labels, &block)
+    end
+
+    def error?
+      self.level?(G_ERROR)
+    end
+
+    def error!
+      self.level = G_ERROR
+    end
+
+    def critical(msg = nil, **labels, &block)
+      write(G_CRITICAL, msg, labels, &block)
+    end
+
+    def critical?
+      self.level?(G_CRITICAL)
+    end
+
+    def critical!
+      self.level = G_CRITICAL
+    end
+
+    def alert(msg = nil, **labels, &block)
+      write(G_ALERT, msg, labels, &block)
+    end
+
+    def alert?
+      self.level?(G_ALERT)
+    end
+
+    def alert!
+      self.level = G_ALERT
+    end
+
+    def emergency(msg = nil, **labels, &block)
+      write(G_EMERGENCY, msg, labels, &block)
+    end
+
+    def emergency?
+      self.level?(G_EMERGENCY)
+    end
+
+    def emergency!
+      self.level = G_EMERGENCY
+    end
+
+    def <<(msg)
+      log(G_DEBUG, msg)
+    end
+
+    # called by LoggerMiddleware
+    def inject_request(request)
+      Thread.current[thread_key] = request
+    end
+
+    # called by ActiveSupport::LogSubscriber.flush_all!
+    def flush
+      Thread.current[thread_key] = nil
+      @out.flush
+    end
+
+    def datetime_format
+      "%FT%T.%9NZ" # RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits
+    end
+
+    def formatter
+      @formatter
+    end
+
+    # implement ::Logger interface, but do nothing
+    def close; end
+
+    def reopen(logdev = nil); end
+
+    def datetime_format=(format); end
+
+    def formatter=(formatter); end
+
+    alias_method :warn, :warning
+    alias_method :warn!, :warning!
+    alias_method :warn?, :warning?
+    alias_method :unknown, :default
+    alias_method :fatal, :critical
+    alias_method :fatal!, :critical!
+    alias_method :fatal?, :critical?
+    alias_method :add, :log
+    alias_method :sev_threshold, :level=
+
+    private
+
+    def should_log?(severity)
+      Rails.application.config.google_cloudrun.logger && self.level?(severity)
+    end
+
+    def should_error_report?(severity)
+      Rails.application.config.google_cloudrun.error_reporting &&
+        !Rails.application.config.google_cloudrun.error_reporting_level.nil? &&
+        Severity.mapping(severity) >= Severity.mapping(Rails.application.config.google_cloudrun.error_reporting_level)
+    end
+
+    def write(severity, msg, labels = {}, &block)
+      should_log = should_log?(severity)
+      should_error_report = should_error_report?(severity)
+      return false if !should_log && !should_error_report
+
+      # execute given block
+      msg = block.call if block
+
+      # write error report
+      if should_error_report
+        write_error_report(severity, msg, labels)
+
+        # return early if we don't want to log as well
+        return true if Rails.application.config.google_cloudrun.error_reporting_discard_log
+      end
+
+      # write log
+      if should_log
+        write_log(severity, msg, labels)
+      end
+
+      return true
+    end
+
+    def write_log(severity, msg, labels)
+      l = GoogleCloudRun::LogEntry.new
+      l.severity = severity
+      l.message = msg
+      l.labels = labels
+      l.request = current_request
+      l.project_id = @project_id
+
+      # set caller location
+      if Rails.application.config.google_cloudrun.logger_source_location
+        loc = caller_locations(3, 1)&.first
+        if loc
+          l.location_path = loc.path
+          l.location_line = loc.lineno
+          l.location_method = loc.label
+        end
+      end
+
+      # attach user to entry
+      p = Rails.application.config.google_cloudrun.logger_user
+      if p && p.is_a?(Proc)
+        begin
+          l.user = p.call(current_request)
+        rescue
+          raise
+          # TODO ignore or log?
+        end
+      end
+
+      @out.puts l.to_json
+    end
+
+    def write_error_report(severity, msg, labels)
+      l = ErrorReportingEntry.new
+      l.severity = severity
+      l.request = current_request
+      l.labels = labels
+      l.message = msg
+      l.project_id = @project_id
+
+      # set caller location
+      loc = caller_locations(3, 1)&.first
+      if loc
+        l.location_path = loc.path
+        l.location_line = loc.lineno
+        l.location_method = loc.label
+      end
+
+      # set context
+      l.context_service = GoogleCloudRun.k_service
+      l.context_version = GoogleCloudRun.k_revision
+
+      # attach user to entry
+      p = Rails.application.config.google_cloudrun.error_reporting_user
+      if p && p.is_a?(Proc)
+        begin
+          l.user = p.call(current_request)
+        rescue
+          # TODO ignore or log?
+        end
+      end
+
+      @out.puts l.to_json
+    end
+
+    def current_request
+      Thread.current[thread_key]
+    end
+
+    def thread_key
+      # We use our object ID here to avoid conflicting with other instances
+      thread_key = @thread_key ||= "google_cloudrun_logging_request:#{object_id}"
+    end
+  end
+
+  class LoggerMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    # A middleware which injects the request into the Rails.logger
+    def call(env)
+      request = ActionDispatch::Request.new(env)
+      Rails.logger.inject_request(request)
+      @app.call(env)
+    ensure
+      ActiveSupport::LogSubscriber.flush_all!
+    end
+  end
+
+  class DummyFormatter < ::Logger::Formatter
+    def call(severity, timestamp, progname, msg)
+      # we bypass all formatters
+    end
+  end
+
+  module SilenceExceptions
+    private
+
+    def log_error(_request, wrapper)
+      exception = wrapper.exception
+      return if Rails.application.config.google_cloudrun.silence_exceptions.any? { |e| exception.is_a?(e) }
+      super
+    end
+  end
+end

data/lib/google_cloud_run/railtie.rb

@@ -0,0 +1,60 @@
+module GoogleCloudRun
+  class Railtie < ::Rails::Railtie
+    config.google_cloudrun = ActiveSupport::OrderedOptions.new
+
+    config.google_cloudrun.out = STDERR
+
+    config.google_cloudrun.logger = true
+    config.google_cloudrun.logger_source_location = true
+    config.google_cloudrun.logger_user = nil
+
+    config.google_cloudrun.error_reporting = true
+    config.google_cloudrun.error_reporting_exception_severity = :critical
+    config.google_cloudrun.error_reporting_user = nil
+    config.google_cloudrun.error_reporting_level = :error
+    config.google_cloudrun.error_reporting_discard_log = true
+
+    config.google_cloudrun.silence_exceptions = [
+      ActionController::RoutingError,
+      ActionController::MethodNotAllowed,
+      ActionController::UnknownHttpMethod,
+      ActionController::NotImplemented,
+      ActionController::UnknownFormat,
+      ActionController::BadRequest,
+      ActionController::ParameterMissing,
+    ]
+
+    config.google_cloudrun.patch_request_id = true
+
+    config.google_cloudrun.jobs = true
+    config.google_cloudrun.job_queue_default_region = nil
+    config.google_cloudrun.job_callback_url = nil # required
+    config.google_cloudrun.job_callback_path = "/rails/google_cloudrun/job_callback"
+    config.google_cloudrun.job_timeout_sec = 1800 # 30 min (min 15s, max 30m)
+
+    # ref: https://guides.rubyonrails.org/rails_on_rack.html#internal-middleware-stack
+
+    initializer "google_cloud_run" do |app|
+      if app.config.google_cloudrun.error_reporting
+        ActionDispatch::DebugExceptions.register_interceptor GoogleCloudRun.method(:exception_interceptor)
+      end
+
+      if app.config.google_cloudrun.logger
+        app.config.middleware.insert_after Rails::Rack::Logger, GoogleCloudRun::LoggerMiddleware
+      end
+
+      if app.config.google_cloudrun.patch_request_id
+        app.config.middleware.insert_before ActionDispatch::RequestId, GoogleCloudRun::RequestId
+      end
+
+      # https://stackoverflow.com/a/52475865/2142441
+      if config.google_cloudrun.silence_exceptions.size > 0
+        ActiveSupport.on_load(:action_controller) do
+          ActionDispatch::DebugExceptions.prepend GoogleCloudRun::SilenceExceptions
+        end
+      end
+
+      ActiveJob::Base.send(:include, GoogleCloudRun::TimeoutAfterExtension)
+    end
+  end
+end

data/lib/google_cloud_run/request_id.rb

@@ -0,0 +1,16 @@
+module GoogleCloudRun
+  class RequestId
+    def initialize(app)
+      @app = app
+    end
+
+    # A middleware to replace X-Request-Id with X-Cloud-Trace-Context's Trace ID
+    # ref: https://github.com/rails/rails/blob/6-1-stable/actionpack/lib/action_dispatch/middleware/request_id.rb
+    # ref: https://github.com/Octo-Labs/heroku-request-id/blob/master/lib/heroku-request-id/railtie.rb
+    def call(env)
+      req = ActionDispatch::Request.new env
+      trace, _, _ = GoogleCloudRun.parse_trace_context(req.headers["X-Cloud-Trace-Context"])
+      @app.call(env).tap { |_status, headers, _body| headers["X-Request-Id"] = trace }
+    end
+  end
+end

data/lib/google_cloud_run/severity.rb

@@ -0,0 +1,124 @@
+class Logger
+  module Severity
+    # Ruby/Rails default severities:
+    # Low-level information, mostly for developers.
+    # DEBUG = 0
+    # Generic (useful) information about system operation.
+    # INFO = 1
+    # A warning.
+    # WARN = 2
+    # A handleable error condition.
+    # ERROR = 3
+    # An unhandleable error that results in a program crash.
+    # FATAL = 4
+    # An unknown message that should always be logged.
+    # UNKNOWN = 5
+
+    # Google Cloud severities:
+    # The log entry has no assigned severity level.
+    G_DEFAULT = 0
+
+    # Debug or trace information.
+    G_DEBUG = 100
+
+    # Routine information, such as ongoing status or performance.
+    G_INFO = 200
+
+    # Normal but significant events, such as start up, shut down, or a configuration change.
+    G_NOTICE = 300
+
+    # Warning events might cause problems.
+    G_WARNING = 400
+
+    # Error events are likely to cause problems.
+    G_ERROR = 500
+
+    # Critical events cause more severe problems or outages.
+    G_CRITICAL = 600
+
+    # A person must take an action immediately.
+    G_ALERT = 700
+
+    # One or more systems are unusable.
+    G_EMERGENCY = 800
+  end
+end
+
+module GoogleCloudRun
+  module Severity
+    include ::Logger::Severity
+
+    def self.to_s(severity)
+      case mapping(severity)
+      when G_DEFAULT; return "DEFAULT"
+      when G_DEBUG; return "DEBUG"
+      when G_INFO; return "INFO"
+      when G_NOTICE; return "NOTICE"
+      when G_WARNING; return "WARNING"
+      when G_ERROR; return "ERROR"
+      when G_CRITICAL; return "CRITICAL"
+      when G_ALERT; return "ALERT"
+      when G_EMERGENCY; return "EMERGENCY"
+      end
+    end
+
+    def self.mapping(severity)
+      case severity
+      when nil; return G_DEFAULT
+      when G_DEFAULT, G_DEBUG, G_INFO, G_NOTICE, G_WARNING, G_ERROR, G_CRITICAL, G_ALERT, G_EMERGENCY; return severity
+      when DEBUG; return G_DEBUG
+      when INFO; return G_INFO
+      when WARN; return G_WARNING
+      when ERROR; return G_ERROR
+      when FATAL; return G_CRITICAL
+      when UNKNOWN; return G_DEFAULT
+      when 0; return G_DEFAULT
+      when 1; return G_INFO
+      when 2; return G_WARNING
+      when 3; return G_ERROR
+      when 4; return G_CRITICAL
+      when 5; return G_DEFAULT
+      when 100; return G_DEBUG
+      when 200; return G_INFO
+      when 300; return G_NOTICE
+      when 400; return G_WARNING
+      when 500; return G_ERROR
+      when 600; return G_CRITICAL
+      when 700; return G_ALERT
+      when 800; return G_EMERGENCY
+      when "G_DEFAULT"; return G_DEFAULT
+      when "G_DEBUG"; return G_DEBUG
+      when "G_INFO"; return G_INFO
+      when "G_NOTICE"; return G_NOTICE
+      when "G_WARNING"; return G_WARNING
+      when "G_ERROR"; return G_ERROR
+      when "G_CRITICAL"; return G_CRITICAL
+      when "G_ALERT"; return G_ALERT
+      when "G_EMERGENCY"; return G_EMERGENCY
+      when :g_default; return G_DEFAULT
+      when :g_debug; return G_DEBUG
+      when :g_info; return G_INFO
+      when :g_notice; return G_NOTICE
+      when :g_warning; return G_WARNING
+      when :g_error; return G_ERROR
+      when :g_critical; return G_CRITICAL
+      when :g_alert; return G_ALERT
+      when :g_emergency; return G_EMERGENCY
+      when :debug; return G_DEBUG
+      when :info; return G_INFO
+      when :warn; return G_WARNING
+      when :error; return G_ERROR
+      when :fatal; return G_CRITICAL
+      when :unknown; return G_DEFAULT
+      when :default; return G_DEFAULT
+      when :notice; return G_NOTICE
+      when :warning; return G_WARNING
+      when :critical; return G_CRITICAL
+      when :alert; return G_ALERT
+      when :emergency; return G_EMERGENCY
+      else
+        raise "unknown severity '#{severity.inspect}'"
+      end
+    end
+  end
+end

data/lib/google_cloud_run/util.rb

@@ -0,0 +1,103 @@
+require "net/http"
+require "uri"
+
+module GoogleCloudRun
+  def self.k_service
+    @k_service ||= begin
+        ENV.fetch("K_SERVICE", "")
+      end
+  end
+
+  def self.k_revision
+    @k_revision ||= begin
+        revision = ENV.fetch("K_REVISION", "")
+        service = ENV.fetch("K_SERVICE", "")
+        revision.delete_prefix(service + "-")
+      end
+  end
+
+  # parse_trace_context parses header
+  # X-Cloud-Trace-Context: TRACE_ID/SPAN_ID;o=TRACE_TRUE
+  def self.parse_trace_context(raw)
+    raw&.strip!
+    return nil, nil, nil if raw.blank?
+
+    trace = nil
+    span = nil
+    sample = nil
+
+    first = raw.split("/")
+    if first.size > 0
+      trace = first[0]
+    end
+
+    if first.size > 1
+      second = first[1].split(";")
+
+      if second.size > 0
+        span = second[0]
+      end
+
+      if second.size > 1
+        case second[1].delete_prefix("o=")
+        when "1"; sample = true
+        when "0"; sample = false
+        end
+      end
+    end
+
+    return trace, span, sample
+  end
+
+  # project_id returns the current Google project id from the
+  # metadata server
+  def self.project_id
+    return "dummy-project" if Rails.env.test?
+
+    @project_id ||= begin
+        uri = URI.parse("http://metadata.google.internal/computeMetadata/v1/project/project-id")
+        request = Net::HTTP::Get.new(uri)
+        request["Metadata-Flavor"] = "Google"
+
+        req_options = {
+          open_timeout: 5,
+          read_timeout: 5,
+          max_retries: 2,
+        }
+
+        response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
+          http.request(request)
+        end
+
+        raise "unknown google cloud project" if response.code.to_i != 200
+
+        response.body.strip
+      end
+  end
+  #
+  # default_service_account_email returns the default service account's email from the
+  # metadata server
+  def self.default_service_account_email
+    return "123456789-compute@developer.gserviceaccount.com" if Rails.env.test?
+
+    @default_service_account_email ||= begin
+        uri = URI.parse("http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/email")
+        request = Net::HTTP::Get.new(uri)
+        request["Metadata-Flavor"] = "Google"
+
+        req_options = {
+          open_timeout: 5,
+          read_timeout: 5,
+          max_retries: 2,
+        }
+
+        response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
+          http.request(request)
+        end
+
+        raise "unknown google default service account" if response.code.to_i != 200
+
+        response.body.strip
+      end
+  end
+end

data/lib/google_cloud_run/version.rb

@@ -0,0 +1,3 @@
+module GoogleCloudRun
+  VERSION = "0.2.0"
+end

data/lib/google_cloud_run.rb

@@ -0,0 +1,9 @@
+require "google_cloud_run/severity"
+require "google_cloud_run/util"
+require "google_cloud_run/entry"
+require "google_cloud_run/logger"
+require "google_cloud_run/exceptions"
+require "google_cloud_run/request_id"
+require "google_cloud_run/engine"
+require "google_cloud_run/job_adapter"
+require "google_cloud_run/railtie"

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: google_cloud_run
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Matt Kadenbach
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-02-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: google-cloud-tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: googleauth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.15'
+description: Opinionated Logging, Error Reporting and minor patches for Rails on Google
+  Cloud Run.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- app/controllers/google_cloud_run/jobs_controller.rb
+- config/routes.rb
+- lib/google_cloud_run.rb
+- lib/google_cloud_run/engine.rb
+- lib/google_cloud_run/entry.rb
+- lib/google_cloud_run/exceptions.rb
+- lib/google_cloud_run/job_adapter.rb
+- lib/google_cloud_run/logger.rb
+- lib/google_cloud_run/railtie.rb
+- lib/google_cloud_run/request_id.rb
+- lib/google_cloud_run/severity.rb
+- lib/google_cloud_run/util.rb
+- lib/google_cloud_run/version.rb
+homepage: https://github.com/mattes/google_cloud_run
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/mattes/google_cloud_run
+  source_code_uri: https://github.com/mattes/google_cloud_run
+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.2.3
+signing_key: 
+specification_version: 4
+summary: Rails on Google Cloud Run
+test_files: []