google-cloud-pubsub 3.4.0 → 3.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2706c0520b9cd5aba014d233fddf25b3c5265cc35a30b65719ed91647a271bef
-  data.tar.gz: d6f9a3e8c9b74a08bd344582ce7c7e9b5a4bc03cebe0243ffb09ac17cdcc0afd
+  metadata.gz: 5694017436fe99de18ba1d45e73ecdb0941b0183e115c3d02cad10085dcaae2c
+  data.tar.gz: b4a7a35193d6b9e75614474dc6510d1c978bbaa49fc2973123da33ea38b33116
 SHA512:
-  metadata.gz: 426ac33d83d07732c22854216b673def03cf2b5813718a5e57428546f0e5499178d6848e75473da2e71169b79d76246879663d94f1ce8415758737efe6f5817a
-  data.tar.gz: b5def0275205fa9bd13ea1f463ce50992903ba2c423817f22401675ecfc1eb55e1ef57f9e97178d83659ee40fdc1e87a21075aa4180dfed177526e487d043327
+  metadata.gz: f49b732799a033333beef767ac6667d603d066ff5bc5f7207b7c05ab127a4996e95f472a9377826ac2fc5898f6b31f710d2408473f611b1114815968edd91f95
+  data.tar.gz: 3cb7429db18f8d79c4ff6d1b0a1e488ebf090268fcb9e7ad35f19f4dced3e77c1616c89a8b6d070a9e9e4fc9fd57a3db0cdff2fb44cfc4f8432e57fe6c8719d2

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Release History
 
+### 3.5.0 (2026-09-14)
+
+#### Features
+
+* Support subscriber shutdown options ([#36480](https://github.com/googleapis/google-cloud-ruby/issues/36480)) 
+#### Documentation
+
+* Add subscriber shutdown documentation and examples ([#36482](https://github.com/googleapis/google-cloud-ruby/issues/36482)) 
+
+### 3.4.1 (2026-08-24)
+
+#### Bug Fixes
+
+* Propagate logger to v1 admin and schema clients ([#32440](https://github.com/googleapis/google-cloud-ruby/issues/32440)) ([#36298](https://github.com/googleapis/google-cloud-ruby/issues/36298)) 
+
 ### 3.4.0 (2026-07-29)
 
 #### Features

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

@@ -379,7 +379,7 @@ module Google
               grpc = @service.publish topic_name,
                                       items.map(&:msg),
                                       compress: compress && batch.total_message_bytes >= compression_bytes_threshold
-              service.logger.log_batch "publish-batch", reason, "publish", items.count, items.sum(&:bytesize)
+              service.internal_logger.log_batch "publish-batch", reason, "publish", items.count, items.sum(&:bytesize)
               items.zip Array(grpc.message_ids) do |item, id|
                 @flow_controller.release item.bytesize
                 next unless item.callback

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

@@ -122,7 +122,7 @@ module Google
           grpc = service.publish topic_name,
                                  messages,
                                  compress: compress && total_message_bytes >= compression_bytes_threshold
-          service.logger.log_batch "publish-batch", reason, "publish", messages.count, @total_message_bytes
+          service.internal_logger.log_batch "publish-batch", reason, "publish", messages.count, @total_message_bytes
           to_gcloud_messages Array(grpc.message_ids)
         end
       end

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

@@ -31,7 +31,7 @@ module Google
         def log level, subtag, &message_block
           return unless VALID_LOG_LEVELS.include?(level) && block_given?
           # Only log if the logger is explicitly tagged for 'pubsub'.
-          return unless @logger && @logger.progname == LOG_NAME
+          return unless @logger.respond_to?(:progname) && @logger.progname == LOG_NAME
 
           @logger.public_send(level, "#{LOG_NAME}:#{subtag}", &message_block)
         end

data/lib/google/cloud/pubsub/message_listener/inventory.rb

@@ -50,7 +50,7 @@ module Google
           end
 
           def ack_ids
-            @inventory.keys
+            synchronize { @inventory.keys }
           end
 
           def add *rec_msgs
@@ -86,7 +86,7 @@ module Google
               extension_time = Time.new - extension
               expired, keep = @inventory.partition { |_ack_id, item| item.pulled_at < extension_time }
               @inventory = keep.to_h
-              stream.subscriber.service.logger.log_expiry expired
+              stream.subscriber.service.internal_logger.log_expiry expired
               @wait_cond.broadcast
             end
           end
@@ -109,6 +109,31 @@ module Google
             end
           end
 
+          ##
+          # @private
+          # Blocks until the inventory is empty or until timeout expires.
+          #
+          # @param [Numeric, nil] timeout Maximum time in seconds to wait, or nil to wait indefinitely.
+          # @return [Boolean] true if inventory became empty, false if timed out.
+          def wait_until_empty timeout = nil
+            synchronize do
+              return true if @inventory.empty?
+
+              if timeout
+                target_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+                while !@inventory.empty? && !@stopped
+                  remaining = target_time - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+                  break if remaining <= 0
+
+                  @wait_cond.wait remaining
+                end
+              else
+                @wait_cond.wait_while { !@inventory.empty? && !@stopped }
+              end
+              @inventory.empty?
+            end
+          end
+
           def start
             @background_thread ||= Thread.new { background_run }
 

data/lib/google/cloud/pubsub/message_listener/stream.rb

@@ -111,11 +111,16 @@ module Google
             self
           end
 
+          ##
+          # @private
+          # Stops pulling messages from the subscription.
+          #
+          # @return [Stream] self for chaining.
           def stop
             synchronize do
               break if @stopped
 
-              subscriber.service.logger.log :info, "subscriber-streams" do
+              subscriber.service.internal_logger.log :info, "subscriber-streams" do
                 "stopping stream for subscription #{@subscriber.subscription_name}"
               end
               # Close the stream by pushing the sentinel value.
@@ -129,22 +134,45 @@ module Google
 
               @keepalive_monitor.stop
 
-              # Now that the reception thread is stopped, immediately stop the
-              # callback thread pool. All queued callbacks will see the stream
-              # is stopped and perform a noop.
-              @callback_thread_pool.shutdown
-
-              # Once all the callbacks are stopped, we can stop the inventory.
-              @inventory.stop
+              # When :nack_immediately, release all queued messages immediately and shut down callback pool.
+              if nack_immediately?
+                nack_unprocessed_messages!
+                @callback_thread_pool.shutdown
+              end
             end
 
             self
           end
 
+          ##
+          # @private
+          # Nacks all messages currently held in inventory.
+          def nack_unprocessed_messages!
+            synchronize do
+              ack_ids = @inventory.ack_ids
+              return if ack_ids.empty?
+
+              @subscriber.buffer.modify_ack_deadline 0, ack_ids
+              @subscriber.buffer.flush!
+              @inventory.remove ack_ids
+            end
+          end
+
           def stopped?
             synchronize { @stopped }
           end
 
+          ##
+          # @private
+          # Returns whether the subscriber is stopped and configured to nack unprocessed messages immediately.
+          #
+          # @return [Boolean]
+          def nack_immediately?
+            return false unless @stopped
+
+            @subscriber.shutdown_behavior == :nack_immediately
+          end
+
           def stream_open?
             synchronize { @stream_open }
           end
@@ -157,14 +185,26 @@ module Google
             !stopped?
           end
 
+          ##
+          # @private
+          # Blocks until all received messages are processed, or until timeout expires.
+          #
+          # @param [Numeric, nil] timeout The maximum seconds to wait, or nil to wait indefinitely.
+          # @return [Stream] self for chaining.
           def wait! timeout = nil
-            # Wait for all queued callbacks to be processed.
-            @callback_thread_pool.wait_for_termination timeout
+            deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout if timeout
+            emptied = @inventory.wait_until_empty timeout
+            nack_unprocessed_messages! unless emptied
 
+            @callback_thread_pool.shutdown
+            pool_timeout = [deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC), 0].max if deadline
+            @callback_thread_pool.wait_for_termination pool_timeout
+
+            # Once all callbacks are finished and inventory is clear, stop the inventory.
+            @inventory.stop
             self
           end
 
-
           def request_queue_active?
             !@request_queue.nil?
           end
@@ -185,13 +225,13 @@ module Google
           end
 
           def log_info msg
-            subscriber.service.logger.log :info, "subscriber-streams" do
+            subscriber.service.internal_logger.log :info, "subscriber-streams" do
               msg
             end
           end
 
           def log_error msg
-            subscriber.service.logger.log :error, "subscriber-streams" do
+            subscriber.service.internal_logger.log :error, "subscriber-streams" do
               msg
             end
           end
@@ -289,7 +329,7 @@ module Google
             synchronize do
               # Don't allow a stream to restart if already stopped
               if @stopped
-                subscriber.service.logger.log :debug, "subscriber-streams" do
+                subscriber.service.internal_logger.log :debug, "subscriber-streams" do
                   "not filling stream for subscription #{@subscriber.subscription_name} because stream is already" \
                   " stopped"
                 end
@@ -319,7 +359,7 @@ module Google
               @stream_open = false
             end
             enum = @subscriber.service.streaming_pull @request_queue.each, options
-            subscriber.service.logger.log :info, "subscriber-streams" do
+            subscriber.service.internal_logger.log :info, "subscriber-streams" do
               "rpc: streamingPull, subscription: #{@subscriber.subscription_name}, stream opened"
             end
 
@@ -396,7 +436,7 @@ module Google
                  GRPC::ResourceExhausted, GRPC::Unauthenticated,
                  GRPC::Unavailable => e
             status_code = e.respond_to?(:code) ? e.code : e.class.name
-            subscriber.service.logger.log :error, "subscriber-streams" do
+            subscriber.service.internal_logger.log :error, "subscriber-streams" do
               "Subscriber stream for subscription #{@subscriber.subscription_name} has ended with status " \
               "#{status_code}; will be retried."
             end
@@ -404,13 +444,13 @@ module Google
             backoff_and_wait!
             retry
           rescue RestartStream
-            subscriber.service.logger.log :info, "subscriber-streams" do
+            subscriber.service.internal_logger.log :info, "subscriber-streams" do
               "Subscriber stream for subscription #{@subscriber.subscription_name} has ended; will be retried."
             end
             backoff_and_wait!
             retry
           rescue StandardError => e
-            subscriber.service.logger.log :error, "subscriber-streams" do
+            subscriber.service.internal_logger.log :error, "subscriber-streams" do
               "error on stream for subscription #{@subscriber.subscription_name}: #{e.inspect}"
             end
             @subscriber.error! e
@@ -463,19 +503,19 @@ module Google
           end
 
           def perform_callback_sync rec_msg
-            subscriber.service.logger.log :info, "callback-delivery" do
+            subscriber.service.internal_logger.log :info, "callback-delivery" do
               "message (ID #{rec_msg.message_id}, ackID #{rec_msg.ack_id}) delivery to user callbacks"
             end
-            @subscriber.callback.call rec_msg unless stopped?
+            @subscriber.callback.call rec_msg unless nack_immediately?
           rescue StandardError => e
-            subscriber.service.logger.log :info, "callback-exceptions" do
+            subscriber.service.internal_logger.log :info, "callback-exceptions" do
               "message (ID #{rec_msg.message_id}, ackID #{rec_msg.ack_id}) caused a user callback exception: " \
                 "#{e.inspect}"
             end
             @subscriber.error! e
           ensure
             release rec_msg
-            if @sequencer && running?
+            if @sequencer && !nack_immediately?
               begin
                 @sequencer.next rec_msg
               rescue OrderedMessageDeliveryError => e
@@ -498,7 +538,7 @@ module Google
             return unless pause_streaming?
 
             @paused = true
-            subscriber.service.logger.log :info, "subscriber-flow-control" do
+            subscriber.service.internal_logger.log :info, "subscriber-flow-control" do
               "subscriber for #{@subscriber.subscription_name} is client-side flow control blocked"
             end
           end
@@ -519,7 +559,7 @@ module Google
               # leaving last_pong_at stale. Updating timestamp guarantees the monitor thread will not trigger an immediate
               # false-positive restart while the reader thread wakes up to drain buffered frames.
               @keepalive_monitor.record_pong!
-              subscriber.service.logger.log :info, "subscriber-flow-control" do
+              subscriber.service.internal_logger.log :info, "subscriber-flow-control" do
                 "subscriber for #{@subscriber.subscription_name} is unblocking client-side flow control"
               end
               # Signal to the background thread that we are unpaused

data/lib/google/cloud/pubsub/message_listener/timed_unary_buffer.rb

@@ -320,7 +320,9 @@ module Google
                              reason
                            end
               requests[:acknowledge].each do |req|
-                @subscriber.service.logger.log_batch "ack-batch", new_reason, "ack", req.ack_ids.length, req.to_proto.bytesize
+                @subscriber.service.internal_logger.log_batch(
+                  "ack-batch", new_reason, "ack", req.ack_ids.length, req.to_proto.bytesize
+                )
               end
             end
             requests[:modify_ack_deadline] =
@@ -329,7 +331,9 @@ module Google
                 type = mod_deadline.zero? ? "nack" : "modack"
                 new_reason = mod_ack_reqs.length > 1 ? "#{reason} and partitioned for exceeding max bytes" : reason
                 mod_ack_reqs.each do |req|
-                  @subscriber.service.logger.log_batch "ack-batch", new_reason, type, req.ack_ids.length, req.to_proto.bytesize
+                  @subscriber.service.internal_logger.log_batch(
+                    "ack-batch", new_reason, type, req.ack_ids.length, req.to_proto.bytesize
+                  )
                 end
                 mod_ack_reqs
               end.flatten

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

@@ -60,6 +60,12 @@ module Google
       #   acknowledgement ({ReceivedMessage#ack!}) and delay messages
       #   ({ReceivedMessage#nack!}, {ReceivedMessage#modify_ack_deadline!}).
       #   Default is 4.
+      # @attr_reader [Symbol] shutdown_behavior The strategy used to handle
+      #   unprocessed messages when stopping the subscriber (`:wait_for_processing`
+      #   or `:nack_immediately`). Default is `:wait_for_processing`.
+      # @attr_reader [Numeric, nil] shutdown_timeout The maximum number of
+      #   seconds to wait during shutdown before forcing remaining messages
+      #   to be nacked. Default is `nil`.
       #
       class MessageListener
         include MonitorMixin
@@ -71,6 +77,8 @@ module Google
         attr_reader :message_ordering
         attr_reader :callback_threads
         attr_reader :push_threads
+        attr_reader :shutdown_behavior
+        attr_reader :shutdown_timeout
 
         ##
         # @private Implementation attributes.
@@ -83,7 +91,7 @@ module Google
         ##
         # @private Create an empty {MessageListener} object.
         def initialize subscription_name, callback, deadline: nil, message_ordering: nil, streams: nil, inventory: nil,
-                       threads: {}, service: nil
+                       threads: {}, shutdown_behavior: :wait_for_processing, shutdown_timeout: nil, service: nil
           super() # to init MonitorMixin
 
           @callback = callback
@@ -91,6 +99,16 @@ module Google
           @subscription_name = subscription_name
           @deadline = deadline || 60
           @streams = streams || 1
+          @shutdown_behavior = shutdown_behavior || :wait_for_processing
+          @shutdown_timeout = shutdown_timeout
+
+          unless [:wait_for_processing, :nack_immediately].include? @shutdown_behavior
+            raise ArgumentError, "Invalid shutdown_behavior: #{@shutdown_behavior.inspect}"
+          end
+          if @shutdown_timeout && (!@shutdown_timeout.is_a?(Numeric) || @shutdown_timeout.negative?)
+            raise ArgumentError, "Invalid shutdown_timeout: #{@shutdown_timeout.inspect}"
+          end
+
           coerce_inventory inventory
           @message_ordering = message_ordering
           @callback_threads = Integer(threads[:callback] || 8)
@@ -145,7 +163,7 @@ module Google
             @started = false
             @stopped = true
             @stream_pool.map(&:stop)
-            wait_stop_buffer_thread!
+            wait_stop_buffer_thread! @shutdown_timeout
             self
           end
         end
@@ -160,12 +178,14 @@ module Google
         # stopped.
         #
         # @param [Number, nil] timeout The number of seconds to block until the
-        #   subscriber is fully stopped. Default will block indefinitely.
+        #   subscriber is fully stopped. Default will block indefinitely or use
+        #   configured `shutdown_timeout`.
         #
         # @return [MessageListener] returns self so calls can be chained.
         #
         def wait! timeout = nil
-          wait_stop_buffer_thread!
+          timeout ||= @shutdown_timeout
+          wait_stop_buffer_thread! timeout
           @wait_stop_buffer_thread.join timeout
           self
         end
@@ -178,11 +198,13 @@ module Google
         # The same as calling {#stop} and {#wait!}.
         #
         # @param [Number, nil] timeout The number of seconds to block until the
-        #   listener is fully stopped. Default will block indefinitely.
+        #   listener is fully stopped. Default will block indefinitely or use
+        #   configured `shutdown_timeout`.
         #
         # @return [MessageListener] returns self so calls can be chained.
         #
         def stop! timeout = nil
+          timeout ||= @shutdown_timeout
           stop
           wait! timeout
         end
@@ -365,10 +387,10 @@ module Google
 
         ##
         # Starts a new thread to call wait! (blocking) on each Stream and then stop the TimedUnaryBuffer.
-        def wait_stop_buffer_thread!
+        def wait_stop_buffer_thread! timeout = nil
           synchronize do
             @wait_stop_buffer_thread ||= Thread.new do
-              @stream_pool.map(&:wait!)
+              @stream_pool.each { |s| s.wait! timeout }
               # Shutdown the buffer TimerTask (and flush the buffer) after the streams are all stopped.
               @buffer.stop
             end

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

@@ -43,7 +43,7 @@ module Google
 
         ##
         # @private The InternalLogger object.
-        attr_reader :logger
+        attr_reader :internal_logger
 
         ##
         # Creates a new Service instance.
@@ -55,6 +55,7 @@ module Google
           @client_id = SecureRandom.uuid.freeze
           @universe_domain = universe_domain || ENV["GOOGLE_CLOUD_UNIVERSE_DOMAIN"] || "googleapis.com"
           @logger = logger
+          @internal_logger = InternalLogger.new logger
         end
 
         def subscription_admin
@@ -67,6 +68,7 @@ module Google
             config.lib_name = "gccl"
             config.lib_version = Google::Cloud::PubSub::VERSION
             config.metadata = { "google-cloud-resource-prefix": "projects/#{@project}" }
+            config.logger = @logger if @logger
           end
         end
         attr_accessor :mocked_subscription_admin
@@ -81,6 +83,7 @@ module Google
             config.lib_name = "gccl"
             config.lib_version = Google::Cloud::PubSub::VERSION
             config.metadata = { "google-cloud-resource-prefix": "projects/#{@project}" }
+            config.logger = @logger if @logger
           end
         end
         attr_accessor :mocked_topic_admin
@@ -94,6 +97,7 @@ module Google
               config.lib_name = "gccl"
               config.lib_version = Google::Cloud::PubSub::VERSION
               config.metadata = { "google-cloud-resource-prefix": "projects/#{@project}" }
+              config.logger = @logger if @logger
             end
             iam
           end
@@ -110,6 +114,7 @@ module Google
             config.lib_name = "gccl"
             config.lib_version = Google::Cloud::PubSub::VERSION
             config.metadata = { "google-cloud-resource-prefix": "projects/#{@project}" }
+            config.logger = @logger if @logger
           end
         end
         attr_accessor :mocked_schemas
@@ -147,7 +152,7 @@ module Google
         ##
         # Acknowledges receipt of a message.
         def acknowledge subscription, *ack_ids
-          logger.log_ack_nack ack_ids, "ack"
+          internal_logger.log_ack_nack ack_ids, "ack"
           subscription_admin.acknowledge_internal subscription: subscription_path(subscription),
                                                   ack_ids: ack_ids
         end
@@ -156,7 +161,7 @@ module Google
         # Modifies the ack deadline for a specific message.
         def modify_ack_deadline subscription, ids, deadline
           if deadline.zero?
-            logger.log_ack_nack Array(ids), "nack"
+            internal_logger.log_ack_nack Array(ids), "nack"
           end
           subscription_admin.modify_ack_deadline_internal subscription: subscription_path(subscription),
                                                           ack_ids: Array(ids),
@@ -203,7 +208,6 @@ module Google
             rpc.timeout = timeout if rpc.respond_to? :timeout=
           end
         end
-
       end
     end
     Pubsub = PubSub unless const_defined? :Pubsub

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

@@ -324,6 +324,16 @@ module Google
         #       acknowledgement ({ReceivedMessage#ack!}) and modify ack deadline
         #       messages ({ReceivedMessage#nack!},
         #       {ReceivedMessage#modify_ack_deadline!}). Default is 4.
+        # @param [Symbol] shutdown_behavior The strategy used to handle
+        #   unprocessed messages when stopping the subscriber.
+        #   Supported values:
+        #   * `:wait_for_processing` (default) - Waits for in-flight callbacks
+        #     to complete and acknowledge or nack messages.
+        #   * `:nack_immediately` - Immediately nacks all unprocessed messages
+        #     back to Pub/Sub for rapid redelivery to other subscribers.
+        # @param [Numeric, nil] shutdown_timeout The maximum number of seconds
+        #   to wait during shutdown before forcing remaining in-flight messages
+        #   to be nacked. Default is `nil` (blocks indefinitely until callbacks finish).
         #
         # @yield [received_message] a block for processing new messages
         # @yieldparam [ReceivedMessage] received_message the newly received
@@ -408,13 +418,52 @@ module Google
         #   # Shut down the subscriber when ready to stop receiving messages.
         #   listener.stop!
         #
-        def listen deadline: nil, message_ordering: nil, streams: nil, inventory: nil, threads: {}, &block
+        # @example Immediately release unprocessed messages on shutdown:
+        #   require "google/cloud/pubsub"
+        #
+        #   pubsub = Google::Cloud::PubSub.new
+        #
+        #   subscriber = pubsub.subscriber "my-topic-sub"
+        #
+        #   listener = subscriber.listen shutdown_behavior: :nack_immediately do |received_message|
+        #     # process message
+        #     puts "Data: #{received_message.message.data}"
+        #     received_message.acknowledge!
+        #   end
+        #
+        #   listener.start
+        #
+        #   # Shut down immediately, releasing (nacking) any unprocessed messages
+        #   listener.stop!
+        #
+        # @example Gracefully shut down with a custom timeout:
+        #   require "google/cloud/pubsub"
+        #
+        #   pubsub = Google::Cloud::PubSub.new
+        #
+        #   subscriber = pubsub.subscriber "my-topic-sub"
+        #
+        #   listener = subscriber.listen shutdown_behavior: :wait_for_processing, shutdown_timeout: 30 do |received_message|
+        #     # process message
+        #     puts "Data: #{received_message.message.data}"
+        #     received_message.acknowledge!
+        #   end
+        #
+        #   listener.start
+        #
+        #   # Wait up to 30 seconds for in-flight callbacks before forcing remaining to nack
+        #   listener.stop!
+        #
+        def listen deadline: nil, message_ordering: nil, streams: nil, inventory: nil, threads: {},
+                   shutdown_behavior: :wait_for_processing, shutdown_timeout: nil, &block
           ensure_service!
           deadline ||= self.deadline
           message_ordering = message_ordering? if message_ordering.nil?
 
           MessageListener.new name, block, deadline: deadline, streams: streams, inventory: inventory,
-                                      message_ordering: message_ordering, threads: threads, service: service
+                                      message_ordering: message_ordering, threads: threads,
+                                      shutdown_behavior: shutdown_behavior, shutdown_timeout: shutdown_timeout,
+                                      service: service
         end
 
         ##

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

@@ -16,7 +16,7 @@
 module Google
   module Cloud
     module PubSub
-      VERSION = "3.4.0".freeze
+      VERSION = "3.5.0".freeze
     end
 
     Pubsub = PubSub unless const_defined? :Pubsub

data/lib/google/cloud/pubsub.rb

@@ -122,7 +122,6 @@ module Google
         project_id = project_id.to_s # Always cast to a string
         raise ArgumentError, "project_id is missing" if project_id.empty?
 
-        logger = Google::Cloud::PubSub::InternalLogger.new logger
         service = PubSub::Service.new project_id, credentials,
                                       host: endpoint,
                                       timeout: timeout,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: google-cloud-pubsub
 version: !ruby/object:Gem::Version
-  version: 3.4.0
+  version: 3.5.0
 platform: ruby
 authors:
 - Mike Moore