laravel-cloud-rails 0.1.1

data/lib/laravel_cloud/queue/worker.rb

@@ -0,0 +1,338 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module LaravelCloud
+  module Queue
+    # Runs managed-queue jobs (`laravel-cloud queue:work`). Receives one message
+    # at a time — from the Cloud agent, or straight from SQS without one — and
+    # reports exactly one outcome per message:
+    #
+    #   - success / discard        → delete              ("processed")
+    #   - `retry_on` retrying      → visibility reset    ("released")
+    #   - an exception, tries left → visibility reset    ("released")
+    #   - an exception, no tries   → delete + failed job ("failed")
+    #
+    # `tries` / `backoff` are Laravel's `queue:work` options; the default of one
+    # try keeps Active Job's behaviour (an escaping exception is terminal).
+    # `tries` also caps deliveries, so a job that crashes the worker can't come
+    # back forever; a job's `retry_on` attempts raise its cap (RetryAttempts).
+    class Worker
+      # The message has been delivered more times than its job may be attempted.
+      class MaxAttemptsExceeded < LaravelCloud::Error; end
+
+      # Raised into the worker thread to abandon a long-poll or an overrunning
+      # job at shutdown. Not a StandardError, so `retry_on` and a job's own
+      # `rescue` don't treat it as a failure.
+      class Shutdown < Exception; end # rubocop:disable Lint/InheritException
+
+      SIGNALS = %w[TERM INT].freeze
+
+      # `queues` only applies without the agent, which is pinned to one queue.
+      # `shutdown_timeout` is how long a running job gets after a stop request
+      # before it's abandoned and released.
+      def initialize(queues: [], tries: 1, backoff: 0, max_jobs: nil, max_time: nil, shutdown_timeout: 15,
+                     stop_when_empty: false, runtime: Queue.runtime, logger: nil)
+        @queues = queues
+        @tries = [tries.to_i, 1].max
+        @backoff = backoff.to_i.clamp(0, Dispatcher::MAX_VISIBILITY_SECONDS)
+        @max_jobs = max_jobs
+        @max_time = max_time
+        @shutdown_timeout = shutdown_timeout
+        @stop_when_empty = stop_when_empty
+        @runtime = runtime
+        @logger = logger || ActiveJob::Base.logger || Logger.new($stdout)
+        @stop_requested_at = nil
+        @polling = false
+        @executing = false
+        @processed = 0
+      end
+
+      def run
+        @thread = Thread.current
+        @started_at = monotonic
+        previous_handlers = trap_signals
+        watchdog = start_watchdog
+
+        @logger.info("[LaravelCloud] Processing managed queue jobs #{source_description}")
+
+        until stopping? || limit_reached?
+          delivery = poll
+
+          if delivery.nil?
+            break if @stop_when_empty
+
+            next
+          end
+
+          process(delivery)
+          @processed += 1
+        end
+      rescue Shutdown
+        # Shut down mid-poll; nothing was taken.
+      ensure
+        watchdog&.kill
+        restore_signals(previous_handlers) if previous_handlers
+        @logger.info("[LaravelCloud] Stopped processing managed queue jobs")
+      end
+
+      # Finish the current job, then exit. An idle long-poll (up to ~55s) is
+      # abandoned so shutdown isn't held up; a message received at that exact
+      # moment is redelivered by SQS after its visibility timeout.
+      def stop
+        @stop_requested_at ||= monotonic
+        @thread.raise(Shutdown) if @polling && @thread
+      end
+
+      def stopping?
+        !@stop_requested_at.nil?
+      end
+
+      def process(delivery)
+        job_data = begin
+          Message.decode(delivery.body, receive_count: delivery.receive_count)
+        rescue Message::Undecodable => e
+          # Drop the poison message so it isn't redelivered forever.
+          @logger.error("[LaravelCloud] Deleting undecodable managed queue message #{delivery.message_id}: #{e.message}")
+          acknowledge(delivery)
+          return
+        end
+
+        delivery.bind(job_data)
+
+        started_at = observer.now
+        observer.started(delivery.queue, started_at)
+
+        begin
+          job_class = JobClass.resolve(job_data["job_class"], allowed: @runtime.settings.allowed_job_classes)
+          enforce_max_attempts!(delivery, job_class)
+          execute(delivery, job_data)
+        rescue Shutdown
+          # Release now so another worker can take it immediately. As with a
+          # killed Laravel job, this counts as an attempt.
+          @logger.warn("[LaravelCloud] Shutdown timeout exceeded; releasing #{job_data['job_class']} (#{delivery.message_id}) for redelivery")
+          release(delivery, 0)
+          observer.released(delivery.queue, started_at, observer.now)
+          return
+        rescue StandardError => e
+          handle_failure(delivery, job_data, e, started_at)
+          return
+        end
+
+        if delivery.released?
+          release(delivery, delivery.release_delay)
+          observer.released(delivery.queue, started_at, observer.now)
+        else
+          acknowledge(delivery)
+
+          if delivery.retried?
+            observer.released(delivery.queue, started_at, observer.now)
+          else
+            observer.processed(delivery.queue, started_at, observer.now)
+          end
+        end
+      end
+
+      private
+
+      def config
+        @runtime.config
+      end
+
+      def observer
+        @runtime.observer
+      end
+
+      # The watchdog only interrupts while @executing, so the interrupt lands in
+      # the job, not the outcome reporting. A job finishing at that same instant
+      # may run again; SQS is at-least-once anyway.
+      def execute(delivery, job_data)
+        @executing = true
+        Delivery.within(delivery) { ActiveJob::Base.execute(job_data) }
+      ensure
+        @executing = false
+      end
+
+      def enforce_max_attempts!(delivery, job_class)
+        limit = [@tries, job_class.cloud_retry_attempts].max
+
+        return if delivery.receive_count <= limit
+
+        raise MaxAttemptsExceeded, "#{job_class.name} has been attempted too many times (#{delivery.receive_count} deliveries, limit #{limit})."
+      end
+
+      def handle_failure(delivery, job_data, error, started_at)
+        if retryable?(error) && delivery.receive_count < @tries
+          release(delivery, @backoff)
+          observer.released(delivery.queue, started_at, observer.now)
+          return
+        end
+
+        # Terminal: delete it (the agent has no "failed" outcome) and report the
+        # failure through observability.
+        @logger.error("[LaravelCloud] #{job_data['job_class']} (#{delivery.message_id}) failed: #{error.class}: #{error.message}")
+        acknowledge(delivery)
+        observer.failed(delivery, error, started_at, observer.now)
+        notify_failure(error, job_data)
+      end
+
+      # Whether another delivery could turn out differently.
+      def retryable?(error)
+        !error.is_a?(JobClass::Unrunnable) && !error.is_a?(MaxAttemptsExceeded)
+      end
+
+      def notify_failure(error, job_data)
+        @runtime.settings.on_failure&.call(error, job_data)
+      rescue StandardError => e
+        @logger.error("[LaravelCloud] The on_failure handler raised #{e.class}: #{e.message}")
+      end
+
+      def poll
+        @polling = true
+        config.agent_available? ? receive_from_agent : receive_from_sqs
+      ensure
+        @polling = false
+      end
+
+      def receive_from_agent
+        data = @runtime.agent.next_message
+        return nil if data.nil?
+
+        message_id = data["messageId"]
+        return nil unless message_id.is_a?(String) && !message_id.empty?
+
+        # The queue the message actually came from, for metrics.
+        queue_url = data["queueUrl"].is_a?(String) && !data["queueUrl"].empty? ? data["queueUrl"] : config.queue_url
+        attributes = data["attributes"].is_a?(Hash) ? data["attributes"] : {}
+
+        Delivery.new(
+          message_id: message_id,
+          receipt_handle: data["receiptHandle"].is_a?(String) ? data["receiptHandle"] : nil,
+          queue_url: queue_url,
+          queue: config.normalize_queue(queue_url),
+          body: data["body"].to_s,
+          receive_count: attributes["ApproximateReceiveCount"] || 1,
+          from_agent: true,
+        )
+      end
+
+      # Polls each queue in turn and takes the first message found.
+      def receive_from_sqs
+        queue_names.each do |name|
+          queue_url = config.queue_url_for(name)
+          raise NotConfigured, "No Laravel Cloud managed queue is configured (LARAVEL_CLOUD_MANAGED_QUEUES_CONFIG is missing)." if queue_url.nil?
+
+          message = @runtime.sqs.receive_message(
+            queue_url: queue_url,
+            max_number_of_messages: 1,
+            wait_time_seconds: 20,
+            message_attribute_names: ["All"],
+            # The attempt counter (see Message.decode).
+            message_system_attribute_names: ["ApproximateReceiveCount"],
+          ).messages.first
+
+          next if message.nil?
+
+          return Delivery.new(
+            message_id: message.message_id,
+            receipt_handle: message.receipt_handle,
+            queue_url: queue_url,
+            queue: config.normalize_queue(queue_url),
+            body: message.body.to_s,
+            receive_count: message.attributes&.fetch("ApproximateReceiveCount", nil) || 1,
+            from_agent: false,
+          )
+        end
+
+        nil
+      end
+
+      def queue_names
+        @queues.empty? ? [config.queue] : @queues
+      end
+
+      def acknowledge(delivery)
+        if delivery.from_agent?
+          report(delivery, "processed")
+        elsif delivery.receipt_handle
+          @runtime.sqs.delete_message(queue_url: delivery.queue_url, receipt_handle: delivery.receipt_handle)
+        end
+      end
+
+      # Have SQS redeliver the original message after `delay` seconds.
+      def release(delivery, delay)
+        if delivery.from_agent?
+          report(delivery, "released", delay: delay)
+        elsif delivery.receipt_handle
+          @runtime.sqs.change_message_visibility(
+            queue_url: delivery.queue_url,
+            receipt_handle: delivery.receipt_handle,
+            visibility_timeout: delay,
+          )
+        end
+      end
+
+      # An unavailable agent ends the worker (it only recovers on restart); a
+      # rejected outcome only concerns this message, so it's just logged.
+      def report(delivery, status, delay: nil)
+        @runtime.agent.report(delivery.message_id, delivery.receipt_handle, status, delay: delay)
+      rescue AgentClient::Rejected => e
+        @logger.error("[LaravelCloud] #{e.message} (message #{delivery.message_id}, outcome #{status})")
+      end
+
+      def limit_reached?
+        if @max_jobs && @processed >= @max_jobs
+          @logger.info("[LaravelCloud] Processed #{@processed} jobs; stopping (max jobs)")
+          return true
+        end
+
+        if @max_time && monotonic - @started_at >= @max_time
+          @logger.info("[LaravelCloud] Ran for #{@max_time}s; stopping (max time)")
+          return true
+        end
+
+        false
+      end
+
+      # Enforces the shutdown timeout: signal handlers can't wait or lock, so
+      # they only note the stop time and this thread watches the clock.
+      def start_watchdog
+        return nil if @shutdown_timeout.nil?
+
+        Thread.new do
+          loop do
+            sleep 0.25
+
+            next unless stopping? && @executing && monotonic - @stop_requested_at >= @shutdown_timeout
+
+            @thread.raise(Shutdown)
+            break
+          end
+        end
+      end
+
+      def monotonic
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def source_description
+        if config.agent_available?
+          "from the Laravel Cloud agent"
+        else
+          "directly from SQS (#{queue_names.join(', ')})"
+        end
+      end
+
+      def trap_signals
+        SIGNALS.to_h { |signal| [signal, Signal.trap(signal) { stop }] }
+      rescue ArgumentError
+        # Not on the main thread (e.g. in tests).
+        nil
+      end
+
+      def restore_signals(handlers)
+        handlers.each { |signal, handler| Signal.trap(signal, handler || "DEFAULT") }
+      end
+    end
+  end
+end

data/lib/laravel_cloud/queue.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "aws-sdk-sqs"
+
+module LaravelCloud
+  # Laravel Cloud Managed Queues for Active Job. Jobs are pushed straight to
+  # SQS, and received through the Cloud agent or, without one, from SQS.
+  module Queue
+    # LARAVEL_CLOUD_MANAGED_QUEUES_CONFIG is missing.
+    class NotConfigured < LaravelCloud::Error; end
+
+    # A dispatch the queue can't honour, raised rather than silently degraded.
+    class InvalidDispatch < LaravelCloud::Error; end
+
+    # What the adapter and worker share. Built lazily, so an app boots without
+    # a managed queue; injectable for tests.
+    class Runtime
+      attr_reader :settings
+
+      def initialize(config: nil, sqs: nil, agent: nil, events: nil, settings: Settings.new)
+        @config = config
+        @sqs = sqs
+        @agent = agent
+        @events = events
+        @settings = settings
+      end
+
+      def config
+        @config ||= ManagedQueueConfig.from_env
+      end
+
+      def sqs
+        @sqs ||= build_sqs_client
+      end
+
+      def agent
+        @agent ||= AgentClient.new(config.agent_socket)
+      end
+
+      def observer
+        @observer ||= Observer.new(@events || LaravelCloud.events)
+      end
+
+      def dispatcher
+        @dispatcher ||= Dispatcher.new(self)
+      end
+
+      private
+
+      def build_sqs_client
+        args = { region: config.region || "us-east-1" }
+
+        # "ecs" means the container credential provider; otherwise the SDK's
+        # default chain.
+        args[:credentials] = Aws::ECSCredentials.new if config.ecs_credentials?
+
+        Aws::SQS::Client.new(**args)
+      end
+    end
+
+    class << self
+      def runtime
+        @runtime ||= Runtime.new
+      end
+
+      attr_writer :runtime
+
+      def configure
+        yield runtime.settings
+      end
+    end
+  end
+end
+
+require_relative "queue/settings"
+require_relative "queue/retry_attempts"
+require_relative "queue/job_class"
+require_relative "queue/managed_queue_config"
+require_relative "queue/agent_client"
+require_relative "queue/delivery"
+require_relative "queue/message"
+require_relative "queue/observer"
+require_relative "queue/dispatcher"
+require_relative "queue/message_attributes"
+require_relative "queue/worker"

data/lib/laravel_cloud/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module LaravelCloud
+  # A placeholder: the release workflow sets this from the release's tag.
+  VERSION = "0.1.1"
+end

data/lib/laravel_cloud/websockets/client.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module LaravelCloud
+  module Websockets
+    # A server-side Pusher protocol connection, subscribed to private channels
+    # it signs itself. Calls on_failure once the connection is lost.
+    class Client
+      def initialize(logger: nil, &on_failure)
+        @logger = logger
+        @failure = on_failure
+        @monitor = Monitor.new
+        @changed = @monitor.new_cond
+        @subscriptions = {}
+        @joined = {}
+        @closed = false
+        @last_received = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        @executor = Concurrent::ThreadPoolExecutor.new(min_threads: 1, max_threads: 8, max_queue: 1024, fallback_policy: :abort)
+        @thread = Thread.new { run }
+        @thread.name = "laravel-cloud-rails-reverb"
+      end
+
+      def url
+        config = Websockets.settings
+        scheme = config[:scheme] == "https" ? "wss" : "ws"
+        "#{scheme}://#{config[:host]}:#{config[:port]}/app/#{URI.encode_www_form_component(config[:key])}?protocol=7&client=laravel-cloud-rails&version=1"
+      end
+
+      def write(bytes)
+        @socket.write(bytes)
+      end
+
+      def subscribe(channel, callback, success = nil)
+        @monitor.synchronize do
+          wait_until { @socket_id }
+          if !@subscriptions.key?(channel)
+            @subscriptions[channel] = []
+            send_event(event: "pusher:subscribe", data: { channel: channel, auth: Websockets.authorize(@socket_id, channel) })
+          end
+          @subscriptions[channel] << callback
+          wait_until { @joined[channel] }
+        end
+        success&.call
+      end
+
+      def unsubscribe(channel, callback)
+        @monitor.synchronize do
+          callbacks = @subscriptions[channel]
+          return unless callbacks
+          callbacks.delete(callback)
+          if callbacks.empty?
+            @subscriptions.delete(channel)
+            @joined.delete(channel)
+            send_event(event: "pusher:unsubscribe", data: { channel: channel }) unless @closed
+          end
+        end
+      end
+
+      def ping
+        @monitor.synchronize do
+          raise Unavailable, "Backend heartbeat timed out" if @closed || Process.clock_gettime(Process::CLOCK_MONOTONIC) - @last_received > 12
+          send_event(event: "pusher:ping", data: {})
+        end
+      end
+
+      def close
+        @monitor.synchronize do
+          return if @closed
+          @closed = true
+          @changed.broadcast
+          @socket&.close
+        end
+        @executor.shutdown
+      end
+
+      private
+
+      def wait_until
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 5
+        until yield
+          raise Unavailable, "WebSocket backend connection closed" if @closed
+          remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          raise Unavailable, "WebSocket backend subscription timed out" if remaining <= 0
+          @changed.wait(remaining)
+        end
+      end
+
+      def application_origin
+        uri = URI.parse(ENV["APP_URL"].to_s)
+        return unless uri.is_a?(URI::HTTP) && uri.host
+        port = uri.port unless uri.port == uri.default_port
+        URI::Generic.build(scheme: uri.scheme, host: uri.host, port: port).to_s
+      end
+
+      def run
+        config = Websockets.settings
+        tcp = Socket.tcp(config[:host], config[:port], connect_timeout: 3)
+        @socket = tcp
+        if config[:scheme] == "https"
+          context = OpenSSL::SSL::SSLContext.new
+          context.set_params
+          tls = OpenSSL::SSL::SSLSocket.new(tcp, context)
+          tls.hostname = config[:host]
+          tls.sync_close = true
+          @socket = tls
+          Timeout.timeout(3, Unavailable, "Backend TLS handshake timed out") do
+            tls.connect
+            tls.post_connection_check(config[:host])
+          end
+        end
+        @driver = WebSocket::Driver.client(self, max_length: 1_000_000)
+        origin = application_origin
+        @driver.set_header("Origin", origin) if origin
+        @driver.on(:message) { |event| receive(JSON.parse(event.data)) }
+        @driver.on(:error) { |event| raise Unavailable, event.message }
+        @driver.on(:close) { raise Unavailable, "Backend WebSocket closed" }
+        @monitor.synchronize { @driver.start }
+        loop do
+          data = @socket.readpartial(16384)
+          @monitor.synchronize { @driver.parse(data) }
+        end
+      rescue StandardError => error
+        # Only our own messages are logged; they may quote the backend (e.g. "Origin not allowed").
+        detail = error.is_a?(Unavailable) ? error.message : error.class
+        @logger&.warn("laravel-cloud-rails: backend connection lost (#{detail})") unless @closed
+      ensure
+        close
+        @failure.call
+      end
+
+      def send_event(event)
+        @driver.text(JSON.generate(event))
+      end
+
+      def receive(frame)
+        @last_received = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        data = frame["data"].is_a?(String) ? JSON.parse(frame["data"]) : frame["data"]
+        case frame["event"]
+        when "pusher:connection_established"
+          @socket_id = data.fetch("socket_id")
+          @changed.broadcast
+        when "pusher_internal:subscription_succeeded"
+          @joined[frame.fetch("channel")] = true
+          @changed.broadcast
+        when "pusher:ping"
+          send_event(event: "pusher:pong", data: {})
+        when "pusher:error", "pusher:subscription_error"
+          raise Unavailable, "Backend error: #{data.is_a?(Hash) ? data["message"] : data}"
+        else
+          @subscriptions.fetch(frame["channel"], []).dup.each do |callback|
+            @executor.post { callback.call(frame["event"], data) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/laravel_cloud/websockets.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "openssl"
+require "digest"
+require "json"
+require "monitor"
+require "socket"
+require "concurrent"
+require "websocket/driver"
+
+module LaravelCloud
+  # Laravel Cloud managed WebSockets: a Pusher-compatible (Reverb) server whose
+  # connection settings Cloud injects as PUSHER_* variables.
+  module Websockets
+    class Error < LaravelCloud::Error; end
+
+    # The PUSHER_* variables are missing.
+    class NotConfigured < Error; end
+
+    # The server can't be reached, or refused the request or connection.
+    class Unavailable < Error; end
+
+    # An event too large for the server to accept.
+    class PayloadTooLarge < Error; end
+
+    VARIABLES = %w[PUSHER_APP_ID PUSHER_APP_KEY PUSHER_APP_SECRET PUSHER_HOST PUSHER_PORT PUSHER_SCHEME].freeze
+
+    def self.enabled?
+      VARIABLES.all? { |key| ENV[key] && !ENV[key].empty? }
+    end
+
+    def self.settings
+      raise NotConfigured, "Laravel Cloud WebSockets need #{VARIABLES.join(', ')}" unless enabled?
+      scheme = ENV.fetch("PUSHER_SCHEME")
+      raise Error, "PUSHER_SCHEME must be http or https" unless %w[http https].include?(scheme)
+      port = Integer(ENV.fetch("PUSHER_PORT"))
+      raise Error, "Invalid PUSHER_PORT" unless (1..65535).cover?(port)
+      { host: ENV.fetch("PUSHER_HOST"), port: port, scheme: scheme, key: ENV.fetch("PUSHER_APP_KEY") }
+    end
+
+    # Signs a socket's subscription to a private channel.
+    def self.authorize(socket_id, channel)
+      "#{ENV.fetch('PUSHER_APP_KEY')}:#{sign("#{socket_id}:#{channel}")}"
+    end
+
+    def self.sign(value)
+      OpenSSL::HMAC.hexdigest("SHA256", ENV.fetch("PUSHER_APP_SECRET"), value)
+    end
+
+    # Triggers an event through the server's HTTP API.
+    def self.publish(channel, event, data)
+      body = JSON.generate(name: event, channels: [channel], data: JSON.generate(data))
+      # Reverb refuses HTTP requests over 10 KB (max_request_size), headers
+      # included; the auth query and headers take roughly 350 bytes.
+      raise PayloadTooLarge, "Message exceeds the backend payload limit" if body.bytesize > 9500
+      path = "/apps/#{ENV.fetch('PUSHER_APP_ID')}/events"
+      parameters = { "auth_key" => ENV.fetch("PUSHER_APP_KEY"), "auth_timestamp" => Time.now.to_i.to_s, "auth_version" => "1.0", "body_md5" => Digest::MD5.hexdigest(body) }
+      query = URI.encode_www_form(parameters.sort)
+      config = settings
+      klass = config[:scheme] == "https" ? URI::HTTPS : URI::HTTP
+      uri = klass.build(host: config[:host], port: config[:port], path: path, query: "#{query}&auth_signature=#{sign("POST\n#{path}\n#{query}")}")
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https", open_timeout: 2, read_timeout: 3) do |http|
+        http.post(uri.request_uri, body, { "Content-Type" => "application/json" })
+      end
+      raise Unavailable, "WebSocket backend returned HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+      true
+    rescue IOError, SystemCallError, Timeout::Error, OpenSSL::SSL::SSLError => error
+      raise Unavailable, "WebSocket backend unavailable (#{error.class})"
+    end
+  end
+end
+
+require_relative "websockets/client"

data/lib/laravel_cloud.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "active_job"
+
+require_relative "laravel_cloud/version"
+
+# Laravel Cloud features for Rails. This module holds what features share (the
+# dashboard event socket); each feature lives in its own namespace, starting
+# with Managed Queues (LaravelCloud::Queue).
+module LaravelCloud
+  # Laravel's default too; LARAVEL_CLOUD_LOG_SOCKET overrides it.
+  DEFAULT_LOG_SOCKET = "unix:///tmp/cloud-init.sock"
+
+  class Error < StandardError; end
+
+  class << self
+    # The one dashboard event channel per process, shared by every feature.
+    def events
+      @events ||= Events.new(ENV.fetch("LARAVEL_CLOUD_LOG_SOCKET", DEFAULT_LOG_SOCKET))
+    end
+
+    attr_writer :events
+  end
+end
+
+require_relative "laravel_cloud/events"
+require_relative "laravel_cloud/queue"
+require_relative "active_job/queue_adapters/cloud_adapter"
+
+# Loaded up front so its Railtie can install the browser transport. Only for
+# Rails apps that load Action Cable; the gem doesn't depend on it.
+require_relative "action_cable/subscription_adapter/cloud" if defined?(Rails::Railtie) && defined?(ActionCable::Engine)