google-cloud-logging 1.1.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ce60628d40d567770462e9e345948453b717dc33
-  data.tar.gz: 9a64aa5f9e7daf8c418186a89d7b38cd281ae78b
+  metadata.gz: 2040c01767882892eec9ab8951ae42563a026a48
+  data.tar.gz: 5024c4eae693b2e0822d5928da4a305837ffcac7
 SHA512:
-  metadata.gz: 5dbf4f38b4eafd181fe939fd1c77fe37a77ca4dd56faaab440aaa5c7161a25554f80df0a0cf2585038eeaceabec0dd7d315b3450b026634099035569673e6526
-  data.tar.gz: c45e64d63897784f481b6b1e61ff6486d430ed03bf3f25d1e78d48e4b19e5bc03a349f4b19f9075190921c802d9c7d3f01cd422e7ed79359c18a723998247aeb
+  metadata.gz: 394d202895b1719f155846ea0b38423aabc9b8c173f39283348a12a3ec69d915a3e6e17d1193dc7dcd7f251f3560f6d78b4338a3be44eb53978319cecaebcada
+  data.tar.gz: 8274d6c0f7686057113cb07a5cf5e89cd0302b3861fc3095ee96adacc134fdd9b4b05b810a8ac982ec5389915c162e5be0f6d7de3e813290f72aafe0c9c13812

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

@@ -12,8 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require "set"
 
+require "set"
+require "stackdriver/core/async_actor"
 
 module Google
   module Cloud
@@ -53,12 +54,11 @@ module Google
       #                       labels: labels
       #
       class AsyncWriter
-        DEFAULT_MAX_QUEUE_SIZE = 10000
-        CLEANUP_TIMEOUT = 10.0
-        WAIT_INTERVAL = 1.0
+        include Stackdriver::Core::AsyncActor
 
-        @cleanup_list = nil
-        @exit_lock = Mutex.new
+        DEFAULT_MAX_QUEUE_SIZE = 10000
+        CLEANUP_TIMEOUT = Stackdriver::Core::AsyncActor::CLEANUP_TIMEOUT
+        WAIT_INTERVAL = Stackdriver::Core::AsyncActor::WAIT_INTERVAL
 
         ##
         # @private Item in the log entries queue.
@@ -85,7 +85,9 @@ module Google
 
         ##
         # The current state. Either :running, :suspended, :stopping, or :stopped
-        attr_reader :state
+        #
+        # DEPRECATED. Use #async_state instead.
+        alias_method :state, :async_state
 
         ##
         # The last exception thrown by the background thread, or nil if nothing
@@ -95,11 +97,13 @@ module Google
         ##
         # @private Creates a new AsyncWriter instance.
         def initialize logging, max_queue_size = DEFAULT_MAX_QUEUE_SIZE
+          super()
+
           @logging = logging
           @max_queue_size = max_queue_size
-          @startup_lock = Mutex.new
-          @thread = nil
-          @state = :running
+          @queue_resource = new_cond
+          @queue = []
+          @queue_size = 0
         end
 
         ##
@@ -145,16 +149,16 @@ module Google
         def write_entries entries, log_name: nil, resource: nil, labels: nil
           ensure_thread
           entries = Array(entries)
-          @lock.synchronize do
+          synchronize do
             fail "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
-            @lock_cond.broadcast
+            @queue_resource.broadcast
             while @max_queue_size && @queue_size > @max_queue_size
-              @lock_cond.wait
+              @queue_resource.wait
             end
           end
           self
@@ -202,21 +206,12 @@ module Google
         # issued writes will complete. Once any existing backlog has been
         # cleared, the state will change to :stopped.
         #
+        # DEPRECATED. Use #async_stop instead.
+        #
         # @return [Boolean] Returns true if the writer was running, or false
         #   if the writer had already been stopped.
         #
-        def stop
-          ensure_thread
-          @lock.synchronize do
-            if state != :stopped
-              @state = :stopping
-              @lock_cond.broadcast
-              true
-            else
-              false
-            end
-          end
-        end
+        alias_method :stop, :async_stop
 
         ##
         # Suspends this asynchronous writer.
@@ -224,21 +219,12 @@ module Google
         # After this call succeeds, the state will change to :suspended, and
         # the writer will stop sending RPCs until resumed.
         #
+        # DEPRECATED. Use #async_suspend instead.
+        #
         # @return [Boolean] Returns true if the writer had been running and was
         #   suspended, otherwise false.
         #
-        def suspend
-          ensure_thread
-          @lock.synchronize do
-            if state == :running
-              @state = :suspended
-              @lock_cond.broadcast
-              true
-            else
-              false
-            end
-          end
-        end
+        alias_method :suspend, :async_suspend
 
         ##
         # Resumes this suspended asynchronous writer.
@@ -246,99 +232,69 @@ module Google
         # After this call succeeds, the state will change to :running, and
         # the writer will resume sending RPCs.
         #
+        # DEPRECATED. Use #async_resume instead.
+        #
         # @return [Boolean] Returns true if the writer had been suspended and
         #   is now running, otherwise false.
         #
-        def resume
-          ensure_thread
-          @lock.synchronize do
-            if state == :suspended
-              @state = :running
-              @lock_cond.broadcast
-              true
-            else
-              false
-            end
-          end
-        end
+        alias_method :resume, :async_resume
 
         ##
         # Returns true if this writer is running.
         #
+        # DEPRECATED. Use #async_running? instead.
+        #
         # @return [Boolean] Returns true if the writer is currently running.
         #
-        def running?
-          ensure_thread
-          @lock.synchronize do
-            state == :running
-          end
-        end
+        alias_method :running?, :async_running?
 
         ##
         # Returns true if this writer is suspended.
         #
+        # DEPRECATED. Use #async_suspended? instead.
+        #
         # @return [Boolean] Returns true if the writer is currently suspended.
         #
-        def suspended?
-          ensure_thread
-          @lock.synchronize do
-            state == :suspended
-          end
-        end
+        alias_method :suspended?, :async_suspended?
 
         ##
         # Returns true if this writer is still accepting writes. This means
         # it is either running or suspended.
         #
+        # DEPRECATED. Use #async_working? instead.
+        #
         # @return [Boolean] Returns true if the writer is accepting writes.
         #
-        def writable?
-          ensure_thread
-          @lock.synchronize do
-            state == :suspended || state == :running
-          end
-        end
+        alias_method :writable?, :async_working?
 
         ##
         # Returns true if this writer is fully stopped.
         #
+        # DEPRECATED. Use #async_stopped? instead.
+        #
         # @return [Boolean] Returns true if the writer is fully stopped.
         #
-        def stopped?
-          ensure_thread
-          @lock.synchronize do
-            state == :stopped
-          end
-        end
+        alias_method :stopped?, :async_stopped?
 
         ##
         # Blocks until this asynchronous writer has been stopped, or the given
         # timeout (if present) has elapsed.
         #
+        # DEPRECATED. Use #wait_until_async_stopped instead.
+        #
         # @param [Number, nil] timeout Timeout in seconds, or `nil` for no
         #     timeout.
         #
         # @return [Boolean] Returns true if the writer is stopped, or false
         #   if the timeout expired.
         #
-        def wait_until_stopped timeout = nil
-          ensure_thread
-          deadline = timeout ? ::Time.new.to_f + timeout : nil
-          @lock.synchronize do
-            until state == :stopped
-              cur_time = ::Time.new.to_f
-              return false if deadline && cur_time >= deadline
-              interval = deadline ? deadline - cur_time : WAIT_INTERVAL
-              interval = WAIT_INTERVAL if interval > WAIT_INTERVAL
-              @lock_cond.wait interval
-            end
-          end
-          true
-        end
+        alias_method :wait_until_stopped, :wait_until_async_stopped
 
         ##
         # Stop this asynchronous writer and block until it has been stopped.
         #
+        # DEPRECATED. Use #async_stop! 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
@@ -351,63 +307,41 @@ module Google
         #     after the timeout, or `:forced` if it was forcibly killed.
         #
         def stop! timeout, force: false
-          return :stopped unless stop
-          return :waited if wait_until_stopped timeout
-          return :timeout unless force
-          @thread.kill
-          @thread.join
-          :forced
-        end
+          @cleanup_options[:timeout] = timeout unless timeout.nil?
+          @cleanup_options[:force] = force unless force.nil?
 
-        protected
+          async_stop!
+        end
 
         ##
-        # @private Ensures the background thread is running. This is called
-        # at the start of all public methods, and kicks off the thread lazily.
-        # It also ensures the thread gets restarted (with an empty queue) in
-        # case this object is forked into a child process.
-        #
-        def ensure_thread
-          @startup_lock.synchronize do
-            if (@thread.nil? || !@thread.alive?) && @state != :stopped
-              @queue_size = 0
-              @queue = []
-              @lock = Monitor.new
-              @lock_cond = @lock.new_cond
-              AsyncWriter.register_for_cleanup self
-              @thread = Thread.new do
-                run_backgrounder
-                AsyncWriter.unregister_for_cleanup self
-              end
-            end
+        # @private Callback function when the async actor thread state changes
+        def on_async_state_change
+          synchronize do
+            @queue_resource.broadcast
           end
         end
 
+        protected
+
         ##
         # @private The background thread implementation, which continuously
         # waits for and performs work, and returns only when fully stopped.
         #
         def run_backgrounder
-          loop do
-            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
-              )
-            rescue => e
-              # Ignore any exceptions thrown from the background thread, but
-              # keep running to ensure its state behavior remains consistent.
-              @last_exception = e
-            end
+          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
+            )
+          rescue => e
+            # Ignore any exceptions thrown from the background thread, but
+            # keep running to ensure its state behavior remains consistent.
+            @last_exception = e
           end
-        ensure
-          # If something drastic happened like the thread was killed, make
-          # sure the state is consistent.
-          @state = :stopped
         end
 
         ##
@@ -418,61 +352,28 @@ module Google
         #   queue, returns `nil`.
         #
         def wait_next_item
-          @lock.synchronize do
+          synchronize do
             while state == :suspended ||
                   (state == :running && @queue.empty?)
-              @lock_cond.wait
+              @queue_resource.wait
             end
             queue_item = nil
-            if @queue.empty?
-              @state = :stopped
-            else
+            unless @queue.empty?
               queue_item = @queue.shift
               @queue_size -= queue_item.entries.size
             end
-            @lock_cond.broadcast
+            @queue_resource.broadcast
             queue_item
           end
         end
 
         ##
-        # Register the given AsyncWriter for cleanup on VM exit.
-        #
-        # @private
-        #
-        def self.register_for_cleanup async
-          @exit_lock.synchronize do
-            unless @cleanup_list
-              @cleanup_list = ::Set.new
-              at_exit { AsyncWriter.run_cleanup }
-            end
-            @cleanup_list.add async
-          end
-        end
-
-        ##
-        # Unregister the given AsyncWriter for cleanup on VM exit.
-        #
-        # @private
-        #
-        def self.unregister_for_cleanup async
-          @exit_lock.synchronize do
-            @cleanup_list.delete async if @cleanup_list
-          end
-        end
-
-        ##
-        # Exit hook that cleans up any running AsyncWriters.
-        #
-        # @private
-        #
-        def self.run_cleanup
-          @exit_lock.synchronize do
-            if @cleanup_list
-              @cleanup_list.each do |async|
-                async.stop! CLEANUP_TIMEOUT, force: true
-              end
-            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?
           end
         end
       end

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

@@ -71,6 +71,12 @@ module Google
         # The logging severity threshold (e.g. `Logger::INFO`)
         attr_reader :level
         alias_method :sev_threshold, :level
+        alias_method :local_level, :level
+
+        ##
+        # Boolean flag that indicates whether this logger can be silenced or
+        # not.
+        attr_accessor :silencer
 
         ##
         # This logger does not use a formatter, but it provides a default
@@ -144,13 +150,14 @@ module Google
           @writer = writer
           @log_name = log_name
           @resource = resource
-          @labels = labels
+          @labels = labels || {}
           @level = 0 # DEBUG is the default behavior
           @request_info = {}
           @closed = false
           # Unused, but present for API compatibility
           @formatter = ::Logger::Formatter.new
           @datetime_format = ""
+          @silencer = true
 
           # The writer is usually a Project or AsyncWriter.
           logging = @writer.respond_to?(:logging) ? @writer.logging : @writer
@@ -169,9 +176,9 @@ module Google
         #
         def debug message = nil, &block
           if block_given?
-            add 0, nil, message, &block
+            add ::Logger::DEBUG, nil, message, &block
           else
-            add 0, message, nil, &block
+            add ::Logger::DEBUG, message
           end
         end
 
@@ -187,9 +194,9 @@ module Google
         #
         def info message = nil, &block
           if block_given?
-            add 1, nil, message, &block
+            add ::Logger::INFO, nil, message, &block
           else
-            add 1, message, nil, &block
+            add ::Logger::INFO, message
           end
         end
 
@@ -205,9 +212,9 @@ module Google
         #
         def warn message = nil, &block
           if block_given?
-            add 2, nil, message, &block
+            add ::Logger::WARN, nil, message, &block
           else
-            add 2, message, nil, &block
+            add ::Logger::WARN, message
           end
         end
 
@@ -223,9 +230,9 @@ module Google
         #
         def error message = nil, &block
           if block_given?
-            add 3, nil, message, &block
+            add ::Logger::ERROR, nil, message, &block
           else
-            add 3, message, nil, &block
+            add ::Logger::ERROR, message
           end
         end
 
@@ -241,9 +248,9 @@ module Google
         #
         def fatal message = nil, &block
           if block_given?
-            add 4, nil, message, &block
+            add ::Logger::FATAL, nil, message, &block
           else
-            add 4, message, nil, &block
+            add ::Logger::FATAL, message
           end
         end
 
@@ -260,9 +267,9 @@ module Google
         #
         def unknown message = nil, &block
           if block_given?
-            add 5, nil, message, &block
+            add ::Logger::UNKNOWN, nil, message, &block
           else
-            add 5, message, nil, &block
+            add ::Logger::UNKNOWN, message
           end
         end
 
@@ -281,7 +288,7 @@ module Google
         #   called when the logger is configured to show them.
         #
         def add severity, message = nil, progname = nil
-          severity = derive_severity(severity) || 5 # 5 is UNKNOWN/DEFAULT
+          severity = derive_severity(severity) || ::Logger::UNKNOWN
           return true if severity < @level
 
           if message.nil?
@@ -312,35 +319,42 @@ module Google
         # Returns `true` if the current severity level allows for sending
         # `DEBUG` messages.
         def debug?
-          @level <= 0
+          @level <= ::Logger::DEBUG
         end
 
         ##
         # Returns `true` if the current severity level allows for sending `INFO`
         # messages.
         def info?
-          @level <= 1
+          @level <= ::Logger::INFO
         end
 
         ##
         # Returns `true` if the current severity level allows for sending `WARN`
         # messages.
         def warn?
-          @level <= 2
+          @level <= ::Logger::WARN
         end
 
         ##
         # Returns `true` if the current severity level allows for sending
         # `ERROR` messages.
         def error?
-          @level <= 3
+          @level <= ::Logger::ERROR
         end
 
         ##
         # Returns `true` if the current severity level allows for sending
         # `FATAL` messages.
         def fatal?
-          @level <= 4
+          @level <= ::Logger::FATAL
+        end
+
+        ##
+        # Returns `true` if the current severity level allows for sending
+        # `UNKNOWN` messages.
+        def unknown?
+          @level <= ::Logger::UNKNOWN
         end
 
         ##
@@ -369,6 +383,7 @@ module Google
           @level = new_level
         end
         alias_method :sev_threshold=, :level=
+        alias_method :local_level=, :level=
 
         ##
         # Close the logging "device". This effectively disables logging from
@@ -452,6 +467,50 @@ module Google
         # @deprecated Use delete_request_info
         alias_method :delete_trace_id, :delete_request_info
 
+        ##
+        # No-op method. Created to match the spec of ActiveSupport::Logger#flush
+        # method when used in Rails application.
+        def flush
+          self
+        end
+
+        ##
+        # Filter out low severity messages within block.
+        #
+        # @param [Integer] temp_level Severity threshold to filter within the
+        #   block. Messages with lower severity will be blocked. Default
+        #   ::Logger::ERROR
+        #
+        # @example
+        #   require "google/cloud/logging"
+        #
+        #   logging = Google::Cloud::Logging.new
+        #
+        #   resource = logging.resource "gae_app",
+        #                               module_id: "1",
+        #                               version_id: "20150925t173233"
+        #
+        #   logger = logging.logger "my_app_log", resource, env: :production
+        #
+        #   logger.silence do
+        #     logger.info "Info message"   # No log entry written
+        #     logger.error "Error message" # Log entry written
+        #   end
+        def silence temp_level = ::Logger::ERROR
+          if silencer
+            begin
+              old_level = level
+              self.level = temp_level
+
+              yield self
+            ensure
+              self.level = old_level
+            end
+          else
+            yield self
+          end
+        end
+
         protected
 
         ##
@@ -490,7 +549,7 @@ module Google
             end
           end
 
-          labels.nil? ? merged_labels : labels.merge(merged_labels)
+          labels.merge(merged_labels)
         end
 
         ##
@@ -500,12 +559,12 @@ module Google
 
           downcase_severity = severity.to_s.downcase
           case downcase_severity
-          when "debug".freeze then 0
-          when "info".freeze then 1
-          when "warn".freeze then 2
-          when "error".freeze then 3
-          when "fatal".freeze then 4
-          when "unknown".freeze then 5
+          when "debug".freeze then ::Logger::DEBUG
+          when "info".freeze then ::Logger::INFO
+          when "warn".freeze then ::Logger::WARN
+          when "error".freeze then ::Logger::ERROR
+          when "fatal".freeze then ::Logger::FATAL
+          when "unknown".freeze then ::Logger::UNKNOWN
           else nil
           end
         end

data/lib/google/cloud/logging/v2/config_service_v2_client_config.json

@@ -6,9 +6,7 @@
           "DEADLINE_EXCEEDED",
           "UNAVAILABLE"
         ],
-        "non_idempotent": [
-          "UNAVAILABLE"
-        ]
+        "non_idempotent": []
       },
       "retry_params": {
         "default": {

data/lib/google/cloud/logging/v2/logging_service_v2_client_config.json

@@ -6,9 +6,7 @@
           "DEADLINE_EXCEEDED",
           "UNAVAILABLE"
         ],
-        "non_idempotent": [
-          "UNAVAILABLE"
-        ]
+        "non_idempotent": []
       },
       "retry_params": {
         "default": {

data/lib/google/cloud/logging/v2/metrics_service_v2_client_config.json

@@ -6,9 +6,7 @@
           "DEADLINE_EXCEEDED",
           "UNAVAILABLE"
         ],
-        "non_idempotent": [
-          "UNAVAILABLE"
-        ]
+        "non_idempotent": []
       },
       "retry_params": {
         "default": {

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

@@ -16,7 +16,7 @@
 module Google
   module Cloud
     module Logging
-      VERSION = "1.1.0"
+      VERSION = "1.2.1"
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: google-cloud-logging
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Mike Moore
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-26 00:00:00.000000000 Z
+date: 2017-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-cloud-core
@@ -31,14 +31,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: google-gax
   requirement: !ruby/object:Gem::Requirement