google-cloud-pubsub 1.9.0

data/TROUBLESHOOTING.md

@@ -0,0 +1,31 @@
+# Troubleshooting
+
+## Where can I get more help?
+
+### Ask the Community
+
+If you have a question about how to use a Google Cloud client library in your
+project or are stuck in the Developer's console and don't know where to turn,
+it's possible your questions have already been addressed by the community.
+
+First, check out the appropriate tags on StackOverflow:
+  - [`google-cloud-platform+ruby+pubsub`][so-ruby]
+
+Next, try searching through the issues on GitHub:
+
+  - [`api:pubsub` issues][gh-search-ruby]
+
+Still nothing?
+
+### Ask the Developers
+
+If you're experiencing a bug with the code, or have an idea for how it can be
+improved, *please* create a new issue on GitHub so we can talk about it.
+
+  - [New issue][gh-ruby]
+
+[so-ruby]: http://stackoverflow.com/questions/tagged/google-cloud-platform+ruby+pubsub
+
+[gh-search-ruby]: https://github.com/googleapis/google-cloud-ruby/issues?q=label%3A%22api%3A+pubsub%22
+
+[gh-ruby]: https://github.com/googleapis/google-cloud-ruby/issues/new

data/lib/google-cloud-pubsub.rb

@@ -0,0 +1,139 @@
+# Copyright 2016 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+##
+# This file is here to be autorequired by bundler, so that the
+# Google::Cloud.pubsub and Google::Cloud#pubsub methods can be available, but
+# the library and all dependencies won't be loaded until required and used.
+
+
+gem "google-cloud-core"
+require "google/cloud" unless defined? Google::Cloud.new
+require "google/cloud/config"
+require "googleauth"
+
+module Google
+  module Cloud
+    ##
+    # Creates a new object for connecting to the Pub/Sub service.
+    # Each call creates a new connection.
+    #
+    # For more information on connecting to Google Cloud see the
+    # {file:AUTHENTICATION.md Authentication Guide}.
+    #
+    # @param [String, Array<String>] scope The OAuth 2.0 scopes controlling the
+    #   set of resources and operations that the connection can access. See
+    #   [Using OAuth 2.0 to Access Google
+    #   APIs](https://developers.google.com/identity/protocols/OAuth2).
+    #
+    #   The default scope is:
+    #
+    #   * `https://www.googleapis.com/auth/pubsub`
+    # @param [Integer] timeout Default timeout to use in requests. Optional.
+    # @param [Hash] client_config A hash of values to override the default
+    #   behavior of the API client. Optional.
+    #
+    # @return [Google::Cloud::PubSub::Project]
+    #
+    # @example
+    #   require "google/cloud"
+    #
+    #   gcloud = Google::Cloud.new
+    #   pubsub = gcloud.pubsub
+    #   topic = pubsub.topic "my-topic"
+    #   topic.publish "task completed"
+    #
+    # @example The default scope can be overridden with the `scope` option:
+    #   require "google/cloud"
+    #
+    #   gcloud  = Google::Cloud.new
+    #   platform_scope = "https://www.googleapis.com/auth/cloud-platform"
+    #   pubsub = gcloud.pubsub scope: platform_scope
+    #
+    def pubsub scope: nil, timeout: nil, client_config: nil
+      timeout ||= @timeout
+      Google::Cloud.pubsub @project, @keyfile, scope: scope, timeout: timeout, client_config: client_config
+    end
+
+    ##
+    # Creates a new object for connecting to the Pub/Sub service.
+    # Each call creates a new connection.
+    #
+    # For more information on connecting to Google Cloud see the
+    # {file:AUTHENTICATION.md Authentication Guide}.
+    #
+    # @param [String] project_id Project identifier for the Pub/Sub service you
+    #   are connecting to. If not present, the default project for the
+    #   credentials is used.
+    # @param [String, Hash, Google::Auth::Credentials] credentials The path to
+    #   the keyfile as a String, the contents of the keyfile as a Hash, or a
+    #   Google::Auth::Credentials object.
+    #   (See {Google::Cloud::PubSub::Credentials})
+    # @param [String, Array<String>] scope The OAuth 2.0 scopes controlling the
+    #   set of resources and operations that the connection can access. See
+    #   [Using OAuth 2.0 to Access Google
+    #   APIs](https://developers.google.com/identity/protocols/OAuth2).
+    #
+    #   The default scope is:
+    #
+    #   * `https://www.googleapis.com/auth/pubsub`
+    # @param [Integer] timeout Default timeout to use in requests. Optional.
+    # @param [Hash] client_config A hash of values to override the default
+    #   behavior of the API client. Optional.
+    #
+    # @return [Google::Cloud::PubSub::Project]
+    #
+    # @example
+    #   require "google/cloud"
+    #
+    #   pubsub = Google::Cloud.pubsub
+    #
+    #   topic = pubsub.topic "my-topic"
+    #   topic.publish "task completed"
+    #
+    def self.pubsub project_id = nil, credentials = nil, scope: nil,
+                    timeout: nil, client_config: nil
+      require "google/cloud/pubsub"
+      Google::Cloud::PubSub.new project_id: project_id, credentials: credentials,
+                                scope: scope, timeout: timeout, client_config: client_config
+    end
+  end
+end
+
+# Set the default pubsub configuration
+Google::Cloud.configure.add_config! :pubsub do |config|
+  default_project = Google::Cloud::Config.deferred do
+    ENV["PUBSUB_PROJECT"]
+  end
+  default_creds = Google::Cloud::Config.deferred do
+    Google::Cloud::Config.credentials_from_env(
+      "PUBSUB_CREDENTIALS", "PUBSUB_CREDENTIALS_JSON", "PUBSUB_KEYFILE", "PUBSUB_KEYFILE_JSON"
+    )
+  end
+  default_emulator = Google::Cloud::Config.deferred do
+    ENV["PUBSUB_EMULATOR_HOST"]
+  end
+
+  config.add_field! :project_id, default_project, match: String, allow_nil: true
+  config.add_alias! :project, :project_id
+  config.add_field! :credentials, default_creds, match: [String, Hash, Google::Auth::Credentials], allow_nil: true
+  config.add_alias! :keyfile, :credentials
+  config.add_field! :scope, nil, match: [String, Array]
+  config.add_field! :timeout, nil, match: Integer
+  config.add_field! :client_config, nil, match: Hash
+  config.add_field! :emulator_host, default_emulator, match: String, allow_nil: true
+  config.add_field! :on_error, nil, match: Proc
+  config.add_field! :endpoint, nil, match: String
+end

data/lib/google/cloud/pubsub.rb

@@ -0,0 +1,173 @@
+# Copyright 2015 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require "google-cloud-pubsub"
+require "google/cloud/pubsub/project"
+require "google/cloud/config"
+require "google/cloud/env"
+
+module Google
+  module Cloud
+    ##
+    # # Google Cloud Pub/Sub
+    #
+    # Google Cloud Pub/Sub is designed to provide reliable, many-to-many,
+    # asynchronous messaging between applications. Publisher applications can
+    # send messages to a "topic" and other applications can subscribe to that
+    # topic to receive the messages. By decoupling senders and receivers, Google
+    # Cloud Pub/Sub allows developers to communicate between independently
+    # written applications.
+    #
+    # See {file:OVERVIEW.md Google Cloud Pub/Sub Overview}.
+    #
+    module PubSub
+      # rubocop:disable Metrics/AbcSize
+
+      ##
+      # Creates a new object for connecting to the Pub/Sub service.
+      # Each call creates a new connection.
+      #
+      # For more information on connecting to Google Cloud see the
+      # {file:AUTHENTICATION.md Authentication Guide}.
+      #
+      # @param [String] project_id Project identifier for the Pub/Sub service
+      #   you are connecting to. If not present, the default project for the
+      #   credentials is used.
+      # @param [String, Hash, Google::Auth::Credentials] credentials The path to
+      #   the keyfile as a String, the contents of the keyfile as a Hash, or a
+      #   Google::Auth::Credentials object. (See {PubSub::Credentials})
+      # @param [String, Array<String>] scope The OAuth 2.0 scopes controlling
+      #   the set of resources and operations that the connection can access.
+      #   See [Using OAuth 2.0 to Access Google
+      #   APIs](https://developers.google.com/identity/protocols/OAuth2).
+      #
+      #   The default scope is:
+      #
+      #   * `https://www.googleapis.com/auth/pubsub`
+      # @param [Integer] timeout Default timeout to use in requests. Optional.
+      # @param [Hash] client_config A hash of values to override the default
+      #   behavior of the API client. Optional.
+      # @param [String] endpoint Override of the endpoint host name. Optional.
+      #   If the param is nil, uses the default endpoint.
+      # @param [String] emulator_host Pub/Sub emulator host. Optional.
+      #   If the param is nil, uses the value of the `emulator_host` config.
+      # @param [String] project Alias for the `project_id` argument. Deprecated.
+      # @param [String] keyfile Alias for the `credentials` argument.
+      #   Deprecated.
+      #
+      # @return [Google::Cloud::PubSub::Project]
+      #
+      # @example
+      #   require "google/cloud/pubsub"
+      #
+      #   pubsub = Google::Cloud::PubSub.new
+      #
+      #   topic = pubsub.topic "my-topic"
+      #   topic.publish "task completed"
+      #
+      def self.new project_id: nil, credentials: nil, scope: nil, timeout: nil, client_config: nil, endpoint: nil,
+                   emulator_host: nil, project: nil, keyfile: nil
+        project_id    ||= (project || default_project_id)
+        scope         ||= configure.scope
+        timeout       ||= configure.timeout
+        client_config ||= configure.client_config
+        endpoint      ||= configure.endpoint
+        emulator_host ||= configure.emulator_host
+
+        if emulator_host
+          project_id = project_id.to_s # Always cast to a string
+          raise ArgumentError, "project_id is missing" if project_id.empty?
+
+          return PubSub::Project.new(
+            PubSub::Service.new(
+              project_id, :this_channel_is_insecure, host: emulator_host, timeout: timeout, client_config: client_config
+            )
+          )
+        end
+
+        credentials ||= (keyfile || default_credentials(scope: scope))
+        unless credentials.is_a? Google::Auth::Credentials
+          credentials = PubSub::Credentials.new credentials, scope: scope
+        end
+
+        project_id ||= credentials.project_id if credentials.respond_to? :project_id
+        project_id = project_id.to_s # Always cast to a string
+        raise ArgumentError, "project_id is missing" if project_id.empty?
+
+        PubSub::Project.new(
+          PubSub::Service.new(
+            project_id, credentials, timeout: timeout, host: endpoint, client_config: client_config
+          )
+        )
+      end
+
+      # rubocop:enable Metrics/AbcSize
+
+      ##
+      # Configure the Google Cloud PubSub library.
+      #
+      # The following PubSub configuration parameters are supported:
+      #
+      # * `project_id` - (String) Identifier for a PubSub project. (The
+      #   parameter `project` is considered deprecated, but may also be used.)
+      # * `credentials` - (String, Hash, Google::Auth::Credentials) The path to
+      #   the keyfile as a String, the contents of the keyfile as a Hash, or a
+      #   Google::Auth::Credentials object. (See {PubSub::Credentials}) (The
+      #   parameter `keyfile` is considered deprecated, but may also be used.)
+      # * `scope` - (String, Array<String>) The OAuth 2.0 scopes controlling
+      #   the set of resources and operations that the connection can access.
+      # * `retries` - (Integer) Number of times to retry requests on server
+      #   error.
+      # * `timeout` - (Integer) Default timeout to use in requests.
+      # * `client_config` - (Hash) A hash of values to override the default
+      #   behavior of the API client.
+      # * `endpoint` - (String) Override of the endpoint host name, or `nil`
+      #   to use the default endpoint.
+      # * `emulator_host` - (String) Host name of the emulator. Defaults to
+      #   `ENV["PUBSUB_EMULATOR_HOST"]`
+      # * `on_error` - (Proc) A Proc to be run when an error is encountered
+      #   on a background thread. The Proc must take the error object as the
+      #   single argument. (See {Subscriber.on_error}.)
+      #
+      # @return [Google::Cloud::Config] The configuration object the
+      #   Google::Cloud::PubSub library uses.
+      #
+      def self.configure
+        yield Google::Cloud.configure.pubsub if block_given?
+
+        Google::Cloud.configure.pubsub
+      end
+
+      ##
+      # @private Default project.
+      def self.default_project_id
+        Google::Cloud.configure.pubsub.project_id ||
+          Google::Cloud.configure.project_id ||
+          Google::Cloud.env.project_id
+      end
+
+      ##
+      # @private Default credentials.
+      def self.default_credentials scope: nil
+        Google::Cloud.configure.pubsub.credentials ||
+          Google::Cloud.configure.credentials ||
+          PubSub::Credentials.default(scope: scope)
+      end
+    end
+
+    ## Legacy namespace
+    Pubsub = PubSub unless const_defined? :Pubsub
+  end
+end

data/lib/google/cloud/pubsub/async_publisher.rb

@@ -0,0 +1,399 @@
+# Copyright 2017 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require "monitor"
+require "concurrent"
+require "google/cloud/pubsub/errors"
+require "google/cloud/pubsub/async_publisher/batch"
+require "google/cloud/pubsub/publish_result"
+require "google/cloud/pubsub/service"
+require "google/cloud/pubsub/convert"
+
+module Google
+  module Cloud
+    module PubSub
+      ##
+      # Used to publish multiple messages in batches to a topic. See
+      # {Google::Cloud::PubSub::Topic#async_publisher}
+      #
+      # @example
+      #   require "google/cloud/pubsub"
+      #
+      #   pubsub = Google::Cloud::PubSub.new
+      #
+      #   topic = pubsub.topic "my-topic"
+      #   topic.publish_async "task completed" do |result|
+      #     if result.succeeded?
+      #       log_publish_success result.data
+      #     else
+      #       log_publish_failure result.data, result.error
+      #     end
+      #   end
+      #
+      #   topic.async_publisher.stop.wait!
+      #
+      # @attr_reader [String] topic_name The name of the topic the messages are published to. In the form of
+      #   "/projects/project-identifier/topics/topic-name".
+      # @attr_reader [Integer] max_bytes The maximum size of messages to be collected before the batch is published.
+      #   Default is 1,000,000 (1MB).
+      # @attr_reader [Integer] max_messages The maximum number of messages to be collected before the batch is
+      #   published. Default is 100.
+      # @attr_reader [Numeric] interval The number of seconds to collect messages before the batch is published. Default
+      #   is 0.01.
+      # @attr_reader [Numeric] publish_threads The number of threads used to publish messages. Default is 2.
+      # @attr_reader [Numeric] callback_threads The number of threads to handle the published messages' callbacks.
+      #   Default is 4.
+      #
+      class AsyncPublisher
+        include MonitorMixin
+
+        attr_reader :topic_name, :max_bytes, :max_messages, :interval,
+                    :publish_threads, :callback_threads
+        ##
+        # @private Implementation accessors
+        attr_reader :service, :batch, :publish_thread_pool,
+                    :callback_thread_pool
+
+        ##
+        # @private Create a new instance of the object.
+        def initialize topic_name, service, max_bytes: 1_000_000, max_messages: 100, interval: 0.01, threads: {}
+          # init MonitorMixin
+          super()
+          @topic_name = service.topic_path topic_name
+          @service    = service
+
+          @max_bytes        = max_bytes
+          @max_messages     = max_messages
+          @interval         = interval
+          @publish_threads  = (threads[:publish] || 2).to_i
+          @callback_threads = (threads[:callback] || 4).to_i
+
+          @published_at = nil
+          @publish_thread_pool = Concurrent::ThreadPoolExecutor.new max_threads: @publish_threads
+          @callback_thread_pool = Concurrent::ThreadPoolExecutor.new max_threads: @callback_threads
+
+          @ordered = false
+          @batches = {}
+          @cond = new_cond
+
+          @thread = Thread.new { run_background }
+        end
+
+        ##
+        # Add a message to the async publisher to be published to the topic.
+        # Messages will be collected in batches and published together.
+        # See {Google::Cloud::PubSub::Topic#publish_async}
+        #
+        # @param [String, File] data The message payload. This will be converted
+        #   to bytes encoded as ASCII-8BIT.
+        # @param [Hash] attributes Optional attributes for the message.
+        # @param [String] ordering_key Identifies related messages for which
+        #   publish order should be respected.
+        # @yield [result] the callback for when the message has been published
+        # @yieldparam [PublishResult] result the result of the asynchronous
+        #   publish
+        # @raise [Google::Cloud::PubSub::AsyncPublisherStopped] when the
+        #   publisher is stopped. (See {#stop} and {#stopped?}.)
+        # @raise [Google::Cloud::PubSub::OrderedMessagesDisabled] when
+        #   publishing a message with an `ordering_key` but ordered messages are
+        #   not enabled. (See {#message_ordering?} and
+        #   {#enable_message_ordering!}.)
+        # @raise [Google::Cloud::PubSub::OrderingKeyError] when publishing a
+        #   message with an `ordering_key` that has already failed when
+        #   publishing. Use {#resume_publish} to allow this `ordering_key` to be
+        #   published again.
+        #
+        def publish data = nil, attributes = nil, ordering_key: nil, **extra_attrs, &callback
+          msg = Convert.pubsub_message data, attributes, ordering_key, extra_attrs
+
+          synchronize do
+            raise AsyncPublisherStopped if @stopped
+            raise OrderedMessagesDisabled if !@ordered && !msg.ordering_key.empty? # default is empty string
+
+            batch = resolve_batch_for_message msg
+            raise OrderingKeyError, batch.ordering_key if batch.canceled?
+            batch_action = batch.add msg, callback
+            if batch_action == :full
+              publish_batches!
+            elsif @published_at.nil?
+              # Set initial time to now to start the background counter
+              @published_at = Time.now
+            end
+            @cond.signal
+          end
+
+          nil
+        end
+
+        ##
+        # Begins the process of stopping the publisher. Messages already in
+        # the queue will be published, but no new messages can be added. Use
+        # {#wait!} to block until the publisher is fully stopped and all
+        # pending messages have been published.
+        #
+        # @return [AsyncPublisher] returns self so calls can be chained.
+        def stop
+          synchronize do
+            break if @stopped
+
+            @stopped = true
+            publish_batches! stop: true
+            @cond.signal
+            @publish_thread_pool.shutdown
+          end
+
+          self
+        end
+
+        ##
+        # Blocks until the publisher is fully stopped, all pending messages have
+        # been published, and all callbacks have completed, or until `timeout`
+        # seconds have passed.
+        #
+        # Does not stop the publisher. To stop the publisher, first call {#stop}
+        # and then call {#wait!} to block until the publisher is stopped
+        #
+        # @param [Number, nil] timeout The number of seconds to block until the
+        #   publisher is fully stopped. Default will block indefinitely.
+        #
+        # @return [AsyncPublisher] returns self so calls can be chained.
+        def wait! timeout = nil
+          synchronize do
+            @publish_thread_pool.wait_for_termination timeout
+
+            @callback_thread_pool.shutdown
+            @callback_thread_pool.wait_for_termination timeout
+          end
+
+          self
+        end
+
+        ##
+        # Stop this publisher and block until the publisher is fully stopped,
+        # all pending messages have been published, and all callbacks have
+        # completed, or until `timeout` seconds have passed.
+        #
+        # The same as calling {#stop} and {#wait!}.
+        #
+        # @param [Number, nil] timeout The number of seconds to block until the
+        #   publisher is fully stopped. Default will block indefinitely.
+        #
+        # @return [AsyncPublisher] returns self so calls can be chained.
+        def stop! timeout = nil
+          stop
+          wait! timeout
+        end
+
+        ##
+        # Forces all messages in the current batch to be published
+        # immediately.
+        #
+        # @return [AsyncPublisher] returns self so calls can be chained.
+        def flush
+          synchronize do
+            publish_batches!
+            @cond.signal
+          end
+
+          self
+        end
+
+        ##
+        # Whether the publisher has been started.
+        #
+        # @return [boolean] `true` when started, `false` otherwise.
+        def started?
+          !stopped?
+        end
+
+        ##
+        # Whether the publisher has been stopped.
+        #
+        # @return [boolean] `true` when stopped, `false` otherwise.
+        def stopped?
+          synchronize { @stopped }
+        end
+
+        ##
+        # Enables message ordering for messages with ordering keys. When
+        # enabled, messages published with the same `ordering_key` will be
+        # delivered in the order they were published.
+        #
+        # See {#message_ordering?}. See {Topic#publish_async},
+        # {Subscription#listen}, and {Message#ordering_key}.
+        #
+        def enable_message_ordering!
+          synchronize { @ordered = true }
+        end
+
+        ##
+        # Whether message ordering for messages with ordering keys has been
+        # enabled. When enabled, messages published with the same `ordering_key`
+        # will be delivered in the order they were published. When disabled,
+        # messages may be delivered in any order.
+        #
+        # See {#enable_message_ordering!}. See {Topic#publish_async},
+        # {Subscription#listen}, and {Message#ordering_key}.
+        #
+        # @return [Boolean]
+        #
+        def message_ordering?
+          synchronize { @ordered }
+        end
+
+        ##
+        # Resume publishing ordered messages for the provided ordering key.
+        #
+        # @param [String] ordering_key Identifies related messages for which
+        #   publish order should be respected.
+        #
+        # @return [boolean] `true` when resumed, `false` otherwise.
+        #
+        def resume_publish ordering_key
+          synchronize do
+            batch = resolve_batch_for_ordering_key ordering_key
+            return if batch.nil?
+            batch.resume!
+          end
+        end
+
+        protected
+
+        def run_background
+          synchronize do
+            until @stopped
+              if @published_at.nil?
+                @cond.wait
+                next
+              end
+
+              time_since_first_publish = Time.now - @published_at
+              if time_since_first_publish > @interval
+                # interval met, flush the batches...
+                publish_batches!
+                @cond.wait
+              else
+                # still waiting for the interval to publish the batch...
+                timeout = @interval - time_since_first_publish
+                @cond.wait timeout
+              end
+            end
+          end
+        end
+
+        def resolve_batch_for_message msg
+          @batches[msg.ordering_key] ||= Batch.new self, msg.ordering_key
+        end
+
+        def resolve_batch_for_ordering_key ordering_key
+          @batches[ordering_key]
+        end
+
+        def publish_batches! stop: nil
+          @batches.reject! { |_ordering_key, batch| batch.empty? }
+          @batches.values.each do |batch|
+            ready = batch.publish! stop: stop
+            publish_batch_async @topic_name, batch if ready
+          end
+          # Set published_at to nil to wait indefinitely
+          @published_at = nil
+        end
+
+        def publish_batch_async topic_name, batch
+          # TODO: raise unless @publish_thread_pool.running?
+          return unless @publish_thread_pool.running?
+
+          Concurrent::Promises.future_on(
+            @publish_thread_pool, topic_name, batch
+          ) { |t, b| publish_batch_sync t, b }
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength
+
+        def publish_batch_sync topic_name, batch
+          # The only batch methods that are safe to call from the loop are
+          # rebalance! and reset! because they are the only methods that are
+          # synchronized.
+          loop do
+            items = batch.rebalance!
+
+            unless items.empty?
+              grpc = @service.publish topic_name, items.map(&:msg)
+              items.zip Array(grpc.message_ids) do |item, id|
+                next unless item.callback
+
+                item.msg.message_id = id
+                publish_result = PublishResult.from_grpc item.msg
+                execute_callback_async item.callback, publish_result
+              end
+            end
+
+            break unless batch.reset!
+          end
+        rescue StandardError => e
+          items = batch.items
+
+          unless batch.ordering_key.empty?
+            retry if publish_batch_error_retryable? e
+            # Cancel the batch if the error is not to be retried.
+            begin
+              raise OrderingKeyError, batch.ordering_key
+            rescue OrderingKeyError => e
+              # The existing e variable is not set to OrderingKeyError
+              # Get all unsent messages for the callback
+              items = batch.cancel!
+            end
+          end
+
+          items.each do |item|
+            next unless item.callback
+
+            publish_result = PublishResult.from_error item.msg, e
+            execute_callback_async item.callback, publish_result
+          end
+
+          # publish will retry indefinitely, as long as there are unsent items.
+          retry if batch.reset!
+        end
+
+        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/MethodLength
+
+        PUBLISH_RETRY_ERRORS = [
+          GRPC::Cancelled, GRPC::DeadlineExceeded, GRPC::Internal,
+          GRPC::ResourceExhausted, GRPC::Unauthenticated, GRPC::Unavailable,
+          GRPC::Core::CallError
+        ].freeze
+
+        def publish_batch_error_retryable? error
+          PUBLISH_RETRY_ERRORS.any? { |klass| error.is_a? klass }
+        end
+
+        def execute_callback_async callback, publish_result
+          return unless @callback_thread_pool.running?
+
+          Concurrent::Promises.future_on(
+            @callback_thread_pool, callback, publish_result
+          ) do |cback, p_result|
+            cback.call p_result
+          end
+        end
+      end
+    end
+
+    Pubsub = PubSub unless const_defined? :Pubsub
+  end
+end