google-cloud-logging 1.5.7 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e2ccb4454a6582fc62db7993ea414a404812b896a638d38f5648bfc5873cb33
-  data.tar.gz: 4958689bf6ce20e588f13ffa5995b4c316e0ff8762d33a6a052fe2f2427c1bd1
+  metadata.gz: e0666c5ecdf0723fa5c0457bf6fd39c46a23e854204f6b3d3c88c0147c76a8ff
+  data.tar.gz: 4ffc01aa4b54a78d1af59681c832a972d5bb65c35d5dc59da3b5366a5e08248e
 SHA512:
-  metadata.gz: ec371b02b78e6ae7f128190adfe25d8baf400e9b0dde2b9ea63143fb0df306f945b7148861bd673b09c7a4636a3371626b150773044b2422b1b591ba243164a0
-  data.tar.gz: b852883c7e539a9bbe74e433583885f08f585235f3cdb7b3abe842363d6b5436a73a0bbbb731f3dd9a7d0600770704fd4ea9d5383babad377e21bcb357a24fc0
+  metadata.gz: 02a939f01d6ccf2c220a175732fda505140981feeb8fdc249df25831d6efa747b7aa355f7448f56a2b955b0c17e0c05310bf92e105c60c1f4bccd4ff9a9f3223
+  data.tar.gz: 1b94165958561e0f4f19afdde06471c88037ac828ecb97639a2a497eba30a77c9430599b33201495e9d467868df317386e6c2dbfc61e4061d8ace47751972e2b

data/CHANGELOG.md

@@ -1,5 +1,45 @@
 # Release History
 
+### 1.6.0 / 2019-01-22
+
+* AsyncWriter buffer entries and make batch API calls
+  * Update AsyncWriter to buffer log entries and batch API calls.
+  * Maintain backwards compatibility with the previous AsyncWriter's public API,
+    although the implementation is changed.
+  * Back pressure is applied by limiting the number of queued API calls.
+    Errors will now be raised when there are not enough resources.
+  * Errors are reported using the AsyncWriter#on_error callback.
+  * Pending log entries are sent before the process closes using at_exit.
+  * Add Logging on_error configuration.
+* Add default insert_id value for Entry
+  * Add Entry.insert_id
+  * Add default insert_id value for Entry
+    An Entry object is assigned an insert_id when created so that if the
+    Entry object gets persisted multiple times it would know its insert_id
+    value and not attempt to generate a new one for each persist attempt.
+    An Entry object will still be considered empty if the only value it has
+    is the insert_id.
+  * (This change does not use SecureRandom for performance reasons.)
+* Add Logging trace_sampled
+  * Add Entry#trace_sampled attribute
+  * Add trace_sampled to Logger::RequestInfo
+* Changes to Rails default Logger
+  * Delay updating the Rails default logger until the first web request.
+    * This will avoid issues with forking processes and gRPC resources.
+    * This is accomplished by adding the on_init argument to middleware.
+  * Add Railtie.set_default_logger
+    * This method can be called post-fork to update the Rails default logger.  
+* Make use of Credentials#project_id
+  * Use Credentials#project_id
+    If a project_id is not provided, use the value on the Credentials object.
+    This value was added in googleauth 0.7.0.
+  * Loosen googleauth dependency
+    Allow for new releases up to 0.10.
+    The googleauth devs have committed to maintanining the current API
+    and will not make backwards compatible changes before 0.10.
+* Direct logs for "/healthz" requests to the health check log.
+* Update documentation.
+
 ### 1.5.7 / 2018-11-15
 
 * Add Google::Logging::V2::LogEntry#trace_sampled.

data/CONTRIBUTING.md

@@ -45,7 +45,7 @@ there is a small amount of setup:
 
    ```sh
    $ cd google-cloud-logging/
-   $ bundle exec rake bundleupdate
+   $ bundle update
    ```
 
 ## Console

data/lib/google-cloud-logging.rb

@@ -67,8 +67,9 @@ module Google
     #   logging = gcloud.logging scope: platform_scope
     #
     def logging scope: nil, timeout: nil, client_config: nil
-      Google::Cloud.logging @project, @keyfile, scope: scope,
-                                                timeout: (timeout || @timeout),
+      timeout ||= @timeout
+      Google::Cloud.logging @project, @keyfile, scope:         scope,
+                                                timeout:       timeout,
                                                 client_config: client_config
     end
 
@@ -134,16 +135,15 @@ Google::Cloud.configure.add_config! :logging do |config|
     ENV["LOGGING_PROJECT"]
   end
   default_creds = Google::Cloud::Config.deferred do
-    Google::Cloud::Config.credentials_from_env(
+    Google::Cloud::Config.credentials_from_env \
       "LOGGING_CREDENTIALS", "LOGGING_CREDENTIALS_JSON",
       "LOGGING_KEYFILE", "LOGGING_KEYFILE_JSON"
-    )
   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],
+                    match:     [String, Hash, Google::Auth::Credentials],
                     allow_nil: true
   config.add_alias! :keyfile, :credentials
   config.add_field! :scope, nil, match: [String, Array]
@@ -156,4 +156,6 @@ Google::Cloud.configure.add_config! :logging do |config|
     mrconfig.add_field! :type, nil, match: String
     mrconfig.add_field! :labels, nil, match: Hash
   end
+  config.add_field! :set_default_logger_on_rails_init, nil, enum: [true, false]
+  config.add_field! :on_error, nil, match: Proc
 end

data/lib/google/cloud/logging.rb

@@ -83,22 +83,25 @@ module Google
       #
       def self.new project_id: nil, credentials: nil, scope: nil, timeout: nil,
                    client_config: nil, project: nil, keyfile: nil
-        project_id ||= (project || default_project_id)
-        project_id = project_id.to_s # Always cast to a string
-        raise ArgumentError, "project_id is missing" if project_id.empty?
-
-        scope ||= configure.scope
-        timeout ||= configure.timeout
+        project_id    ||= (project || default_project_id)
+        scope         ||= configure.scope
+        timeout       ||= configure.timeout
         client_config ||= configure.client_config
+        credentials   ||= (keyfile || default_credentials(scope: scope))
 
-        credentials ||= (keyfile || default_credentials(scope: scope))
         unless credentials.is_a? Google::Auth::Credentials
           credentials = Logging::Credentials.new credentials, scope: scope
         end
 
+        if credentials.respond_to? :project_id
+          project_id ||= credentials.project_id
+        end
+        project_id = project_id.to_s # Always cast to a string
+        raise ArgumentError, "project_id is missing" if project_id.empty?
+
         Logging::Project.new(
           Logging::Service.new(
-            project_id, credentials, timeout: timeout,
+            project_id, credentials, timeout:       timeout,
                                      client_config: client_config
           )
         )
@@ -136,6 +139,17 @@ module Google
       # * `labels` - (Hash) User defined labels. A `Hash` of label names to
       #   string label values or callables/`Proc` which are functions of the
       #   Rack environment.
+      # * `set_default_logger_on_rails_init` - (Boolean) Whether Google Cloud
+      #   Logging Logger should be allowed to start background threads and open
+      #   gRPC connections during Rails initialization. This should only be used
+      #   with a non-forking web server. Web servers such as Puma and Unicorn
+      #   should not set this, and instead set the Rails logger to a Google
+      #   Cloud Logging Logger object on the worker process by calling
+      #   {Railtie.set_default_logger} at the appropriate time, such as a
+      #   post-fork hook.
+      # * `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 {AsyncWriter.on_error}.)
       #
       # See the [Configuration
       # Guide](https://googleapis.github.io/google-cloud-ruby/docs/stackdriver/latest/file.INSTRUMENTATION_CONFIGURATION)

data/lib/google/cloud/logging/async_writer.rb

@@ -13,8 +13,9 @@
 # limitations under the License.
 
 
-require "set"
-require "stackdriver/core/async_actor"
+require "monitor"
+require "concurrent"
+require "google/cloud/logging/errors"
 
 module Google
   module Cloud
@@ -22,12 +23,13 @@ module Google
       ##
       # # AsyncWriter
       #
-      # An object that batches and transmits log entries asynchronously.
+      # AsyncWriter buffers, batches, and transmits log entries efficiently.
+      # Writing log entries is asynchronous and will not block.
       #
-      # Use this object to transmit log entries efficiently. It keeps a queue
-      # of log entries, and runs a background thread that transmits them to
-      # the logging service in batches. Generally, adding to the queue will
-      # not block.
+      # Batches that cannot be delivered immediately are queued. When the queue
+      # is full new batch requests will raise errors that can be consumed using
+      # the {#on_error} callback. This provides back pressure in case the writer
+      # cannot keep up with requests.
       #
       # This object is thread-safe; it may accept write requests from
       # multiple threads simultaneously, and will serialize them when
@@ -54,58 +56,37 @@ module Google
       #                       labels: labels
       #
       class AsyncWriter
-        include Stackdriver::Core::AsyncActor
-
-        DEFAULT_MAX_QUEUE_SIZE = 10000
-        CLEANUP_TIMEOUT = Stackdriver::Core::AsyncActor::CLEANUP_TIMEOUT
-        WAIT_INTERVAL = Stackdriver::Core::AsyncActor::WAIT_INTERVAL
+        include MonitorMixin
 
         ##
-        # @private Item in the log entries queue.
-        QueueItem = Struct.new(:entries, :log_name, :resource, :labels) do
-          def try_combine next_item
-            if log_name == next_item.log_name &&
-               resource == next_item.resource &&
-               labels == next_item.labels
-              entries.concat(next_item.entries)
-              true
-            else
-              false
-            end
-          end
-        end
+        # @private Implementation accessors
+        attr_reader :logging, :max_bytes, :max_count, :interval,
+                    :threads, :max_queue, :partial_success
 
         ##
-        # @private The logging object.
-        attr_accessor :logging
+        # @private Creates a new AsyncWriter instance.
+        def initialize logging, max_count: 10000, max_bytes: 10000000,
+                       max_queue: 100, interval: 5, threads: 10,
+                       partial_success: false
+          @logging = logging
 
-        ##
-        # @private The maximum size of the entries queue, or nil if not set.
-        attr_accessor :max_queue_size
+          @max_count = max_count
+          @max_bytes = max_bytes
+          @max_queue = max_queue
+          @interval  = interval
+          @threads   = threads
 
-        ##
-        # The current state. Either :running, :suspended, :stopping, or :stopped
-        #
-        # DEPRECATED. Use #async_state instead.
-        alias state async_state
+          @partial_success = partial_success
 
-        ##
-        # The last exception thrown by the background thread, or nil if nothing
-        # has been thrown.
-        attr_reader :last_exception
+          @error_callbacks = []
 
-        ##
-        # @private Creates a new AsyncWriter instance.
-        def initialize logging, max_queue_size = DEFAULT_MAX_QUEUE_SIZE,
-                       partial_success = false
-          super()
+          @cond = new_cond
 
-          @logging = logging
-          @max_queue_size = max_queue_size
-          @partial_success = partial_success
-          @queue_resource = new_cond
-          @queue = []
-          @queue_size = 0
+          # Make sure all buffered messages are sent when process exits.
+          at_exit { stop }
+
+          # init MonitorMixin
+          super()
         end
 
         ##
@@ -149,19 +130,35 @@ module Google
         #   async.write_entries entry
         #
         def write_entries entries, log_name: nil, resource: nil, labels: nil
-          ensure_thread
-          entries = Array(entries)
           synchronize do
-            raise "AsyncWriter has been stopped" unless writable?
-            queue_item = QueueItem.new entries, log_name, resource, labels
-            if @queue.empty? || !@queue.last.try_combine(queue_item)
-              @queue.push queue_item
-            end
-            @queue_size += entries.size
-            @queue_resource.broadcast
-            while @max_queue_size && @queue_size > @max_queue_size
-              @queue_resource.wait
+            raise "AsyncWriter has been stopped" if @stopped
+
+            Array(entries).each do |entry|
+              # Update the entry to have all the data directly on it
+              entry.log_name ||= log_name
+              if entry.resource.nil? || entry.resource.empty?
+                entry.resource = resource
+              end
+              entry.labels = labels if entry.labels.nil? || entry.labels.empty?
+
+              # Add the entry to the batch
+              @batch ||= Batch.new self
+              next if @batch.try_add entry
+
+              # If we can't add to the batch, publish and create a new batch
+              publish_batch!
+              @batch = Batch.new self
+              @batch.add entry
             end
+
+            @thread_pool ||= \
+              Concurrent::CachedThreadPool.new max_threads: @threads,
+                                               max_queue:   @max_queue
+            @thread ||= Thread.new { run_background }
+
+            publish_batch! if @batch.ready?
+
+            @cond.broadcast
           end
           self
         end
@@ -201,182 +198,306 @@ module Google
         end
 
         ##
-        # Stops this asynchronous writer.
-        #
-        # After this call succeeds, the state will change to :stopping, and
-        # you may not issue any additional write_entries calls. Any previously
-        # issued writes will complete. Once any existing backlog has been
-        # cleared, the state will change to :stopped.
-        #
-        # DEPRECATED. Use #async_stop instead.
+        # Begins the process of stopping the writer. Entries already in the
+        # queue will be published, but no new entries can be added. Use {#wait!}
+        # to block until the writer is fully stopped and all pending entries
+        # have been published.
         #
-        # @return [Boolean] Returns true if the writer was running, or false
-        #   if the writer had already been stopped.
-        #
-        alias stop async_stop
+        # @return [AsyncWriter] returns self so calls can be chained.
+        def stop
+          synchronize do
+            break if @stopped
+
+            @stopped = true
+            publish_batch!
+            @cond.broadcast
+            @thread_pool.shutdown if @thread_pool
+          end
+
+          self
+        end
 
         ##
-        # Suspends this asynchronous writer.
-        #
-        # After this call succeeds, the state will change to :suspended, and
-        # the writer will stop sending RPCs until resumed.
-        #
-        # DEPRECATED. Use #async_suspend instead.
+        # Blocks until the writer is fully stopped, all pending entries have
+        # been published, and all callbacks have completed. Does not stop the
+        # writer. To stop the writer, first call {#stop} and then call {#wait!}
+        # to block until the writer is stopped.
         #
-        # @return [Boolean] Returns true if the writer had been running and was
-        #   suspended, otherwise false.
-        #
-        alias suspend async_suspend
+        # @return [AsyncWriter] returns self so calls can be chained.
+        def wait! timeout = nil
+          synchronize do
+            if @thread_pool
+              @thread_pool.shutdown
+              @thread_pool.wait_for_termination timeout
+            end
+          end
+
+          self
+        end
 
         ##
-        # Resumes this suspended asynchronous writer.
-        #
-        # After this call succeeds, the state will change to :running, and
-        # the writer will resume sending RPCs.
+        # Stop this asynchronous writer and block until it has been stopped.
         #
-        # DEPRECATED. Use #async_resume instead.
+        # @param [Number] timeout Timeout in seconds.
+        # @param [Boolean] force If set to true, and the writer hasn't stopped
+        #     within the given timeout, kill it forcibly by terminating the
+        #     thread. This should be used with extreme caution, as it can
+        #     leave RPCs unfinished. Default is false.
         #
-        # @return [Boolean] Returns true if the writer had been suspended and
-        #   is now running, otherwise false.
+        # @return [Symbol] Returns `:stopped` if the AsyncWriter was already
+        #     stopped at the time of invocation, `:waited` if it stopped
+        #     during the timeout period, `:timeout` if it is still running
+        #     after the timeout, or `:forced` if it was forcibly killed.
         #
-        alias resume async_resume
+        def stop! timeout = nil, force: nil
+          return :stopped if stopped?
+
+          stop
+          wait! timeout
+
+          if synchronize { @thread_pool.shutdown? }
+            return :waited if timeout
+          elsif force
+            @thread_pool.kill
+            return :forced
+          end
+          :timeout
+        end
+        alias async_stop! stop!
 
         ##
-        # Returns true if this writer is running.
+        # Forces all entries in the current batch to be published
+        # immediately.
         #
-        # DEPRECATED. Use #async_running? instead.
+        # @return [AsyncWriter] returns self so calls can be chained.
+        def flush
+          synchronize do
+            publish_batch!
+            @cond.broadcast
+          end
+
+          self
+        end
+
+        ##
+        # Whether the writer has been started.
         #
-        # @return [Boolean] Returns true if the writer is currently running.
+        # @return [boolean] `true` when started, `false` otherwise.
+        def started?
+          !stopped?
+        end
+
+        ##
+        # Whether the writer has been stopped.
         #
-        alias running? async_running?
+        # @return [boolean] `true` when stopped, `false` otherwise.
+        def stopped?
+          synchronize { @stopped }
+        end
 
         ##
-        # Returns true if this writer is suspended.
+        # Register to be notified of errors when raised.
         #
-        # DEPRECATED. Use #async_suspended? instead.
+        # If an unhandled error has occurred the writer will attempt to
+        # recover from the error and resume buffering, batching, and
+        # transmitting log entries
         #
-        # @return [Boolean] Returns true if the writer is currently suspended.
+        # Multiple error handlers can be added.
         #
-        alias suspended? async_suspended?
-
-        ##
-        # Returns true if this writer is still accepting writes. This means
-        # it is either running or suspended.
+        # @yield [callback] The block to be called when an error is raised.
+        # @yieldparam [Exception] error The error raised.
         #
-        # DEPRECATED. Use #async_working? instead.
+        # @example
+        #   require "google/cloud/logging"
+        #   require "google/cloud/error_reporting"
         #
-        # @return [Boolean] Returns true if the writer is accepting writes.
+        #   logging = Google::Cloud::Logging.new
         #
-        alias writable? async_working?
-
-        ##
-        # Returns true if this writer is fully stopped.
+        #   resource = logging.resource "gae_app",
+        #                               module_id: "1",
+        #                               version_id: "20150925t173233"
+        #
+        #   async = logging.async_writer
         #
-        # DEPRECATED. Use #async_stopped? instead.
+        #   # Register to be notified when unhandled errors occur.
+        #   async.on_error do |error|
+        #     # error can be a AsyncWriterError or AsyncWriteEntriesError
+        #     Google::Cloud::ErrorReporting.report error
+        #   end
         #
-        # @return [Boolean] Returns true if the writer is fully stopped.
+        #   logger = async.logger "my_app_log", resource, env: :production
+        #   logger.info "Job started."
         #
-        alias stopped? async_stopped?
+        def on_error &block
+          synchronize do
+            @error_callbacks << block
+          end
+        end
 
         ##
-        # Blocks until this asynchronous writer has been stopped, or the given
-        # timeout (if present) has elapsed.
+        # The most recent unhandled error to occur while transmitting log
+        # entries.
         #
-        # DEPRECATED. Use #wait_until_async_stopped instead.
+        # If an unhandled error has occurred the subscriber will attempt to
+        # recover from the error and resume buffering, batching, and
+        # transmitting log entries.
         #
-        # @param [Number, nil] timeout Timeout in seconds, or `nil` for no
-        #     timeout.
+        # @return [Exception, nil] error The most recent error raised.
         #
-        # @return [Boolean] Returns true if the writer is stopped, or false
-        #   if the timeout expired.
+        # @example
+        #   require "google/cloud/logging"
         #
-        alias wait_until_stopped wait_until_async_stopped
-
-        ##
-        # Stop this asynchronous writer and block until it has been stopped.
+        #   logging = Google::Cloud::Logging.new
         #
-        # DEPRECATED. Use #async_stop! instead.
+        #   resource = logging.resource "gae_app",
+        #                               module_id: "1",
+        #                               version_id: "20150925t173233"
         #
-        # @param [Number] timeout Timeout in seconds.
-        # @param [Boolean] force If set to true, and the writer hasn't stopped
-        #     within the given timeout, kill it forcibly by terminating the
-        #     thread. This should be used with extreme caution, as it can
-        #     leave RPCs unfinished. Default is false.
+        #   async = logging.async_writer
         #
-        # @return [Symbol] Returns `:stopped` if the AsyncWriter was already
-        #     stopped at the time of invocation, `:waited` if it stopped
-        #     during the timeout period, `:timeout` if it is still running
-        #     after the timeout, or `:forced` if it was forcibly killed.
+        #   logger = async.logger "my_app_log", resource, env: :production
+        #   logger.info "Job started."
         #
-        def stop! timeout, force: false
-          @cleanup_options[:timeout] = timeout unless timeout.nil?
-          @cleanup_options[:force] = force unless force.nil?
-
-          async_stop!
+        #   # If an error was raised, it can be retrieved here:
+        #   async.last_error #=> nil
+        #
+        def last_error
+          synchronize { @last_error }
         end
+        alias last_exception last_error
 
-        ##
-        # @private Callback function when the async actor thread state changes
-        def on_async_state_change
+        protected
+
+        def run_background
           synchronize do
-            @queue_resource.broadcast
+            until @stopped
+              if @batch.nil?
+                @cond.wait
+                next
+              end
+
+              if @batch.ready?
+                # interval met, publish the batch...
+                publish_batch!
+                @cond.wait
+              else
+                # still waiting for the interval to publish the batch...
+                @cond.wait(@batch.publish_wait)
+              end
+            end
           end
         end
 
-        protected
+        def publish_batch!
+          return unless @batch
 
-        ##
-        # @private The background thread implementation, which continuously
-        # waits for and performs work, and returns only when fully stopped.
-        #
-        def run_backgrounder
-          queue_item = wait_next_item
-          return unless queue_item
-          begin
-            logging.write_entries(
-              queue_item.entries,
-              log_name: queue_item.log_name,
-              resource: queue_item.resource,
-              labels: queue_item.labels,
-              partial_success: @partial_success
-            )
-          rescue StandardError => e
-            # Ignore any exceptions thrown from the background thread, but
-            # keep running to ensure its state behavior remains consistent.
-            @last_exception = e
+          batch_to_be_published = @batch
+          @batch = nil
+          publish_batch_async batch_to_be_published
+        end
+
+        # Sets the last_error and calls all error callbacks.
+        def error! error
+          error_callbacks = synchronize do
+            @last_error = error
+            @error_callbacks
           end
+          error_callbacks = default_error_callbacks if error_callbacks.empty?
+          error_callbacks.each { |error_callback| error_callback.call error }
         end
 
-        ##
-        # @private Wait for and dequeue the next set of log entries to transmit.
-        #
-        # @return [QueueItem, nil] Returns the next set of entries. If
-        #   the writer has been stopped and no more entries are left in the
-        #   queue, returns `nil`.
-        #
-        def wait_next_item
-          synchronize do
-            while state == :suspended ||
-                  (state == :running && @queue.empty?)
-              @queue_resource.wait
-            end
-            queue_item = nil
-            unless @queue.empty?
-              queue_item = @queue.shift
-              @queue_size -= queue_item.entries.size
+        def default_error_callbacks
+          # This is memoized to reduce calls to the configuration.
+          @default_error_callbacks ||= begin
+            error_callback = Google::Cloud::Logging.configuration.on_error
+            error_callback ||= Google::Cloud.configure.on_error
+            if error_callback
+              [error_callback]
+            else
+              []
             end
-            @queue_resource.broadcast
-            queue_item
           end
         end
 
+        def publish_batch_async batch
+          Concurrent::Promises.future_on(
+            @thread_pool, batch.entries
+          ) do |entries|
+            write_entries_with entries
+          end
+        rescue Concurrent::RejectedExecutionError => e
+          async_error = AsyncWriterError.new(
+            "Error writing entries: #{e.message}",
+            batch.entries
+          )
+          # Manually set backtrace so we don't have to raise
+          async_error.set_backtrace caller
+          error! async_error
+        end
+
+        def write_entries_with entries
+          logging.write_entries entries, partial_success: partial_success
+        rescue StandardError => e
+          write_error = AsyncWriteEntriesError.new(
+            "Error writing entries: #{e.message}",
+            entries
+          )
+          # Manually set backtrace so we don't have to raise
+          write_error.set_backtrace caller
+          error! write_error
+        end
+
         ##
-        # @private Override the #backgrounder_stoppable? method from AsyncActor
-        # module. The actor can be gracefully stopped when queue is
-        # empty.
-        def backgrounder_stoppable?
-          synchronize do
-            @queue.empty?
+        # @private
+        class Batch
+          attr_reader :created_at, :entries
+
+          def initialize writer
+            @writer = writer
+            @entries = []
+            @entries_bytes = 2 # initial size w/ partial_success
+            @created_at = nil
+          end
+
+          def add entry, addl_bytes: nil
+            addl_bytes ||= addl_bytes_for entry
+            @entries << entry
+            @entries_bytes += addl_bytes
+            @created_at ||= Time.now
+            nil
+          end
+
+          def try_add entry
+            addl_bytes = addl_bytes_for entry
+            new_message_count = @entries.count + 1
+            new_message_bytes = @entries_bytes + addl_bytes
+            if new_message_count > @writer.max_count ||
+               new_message_bytes >= @writer.max_bytes
+              return false
+            end
+            add entry, addl_bytes: addl_bytes
+            true
+          end
+
+          def ready?
+            @entries.count >= @writer.max_count ||
+              @entries_bytes >= @writer.max_bytes ||
+              (@created_at.nil? || (publish_at < Time.now))
+          end
+
+          def publish_at
+            return nil if @created_at.nil?
+            @created_at + @writer.interval
+          end
+
+          def publish_wait
+            publish_wait = publish_at - Time.now
+            return 0 if publish_wait < 0
+            publish_wait
+          end
+
+          def addl_bytes_for entry
+            entry.to_grpc.to_proto.bytesize + 2
           end
         end
       end