google-cloud-logging 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4c12b20d76a762cc4d57a454cc8464d4e301f31a
-  data.tar.gz: 36cda33c662c40a95bafff6068adaad0b7c1df71
+  metadata.gz: ce60628d40d567770462e9e345948453b717dc33
+  data.tar.gz: 9a64aa5f9e7daf8c418186a89d7b38cd281ae78b
 SHA512:
-  metadata.gz: 1bb3bbec95098e11bb58fe87c41edbb93f8b8fb36dadfbe627434fdf7540e4f1dab64d79215d6da4e97b280fc15ac923cc686e53b3a3c6f7aba0f5a657095148
-  data.tar.gz: '059dfed7ab14d14903c65824489e968b001947e7b13be4671aa69b9719ab3c7e701c10d7cce1bed08c20c8b787d93af102c1eb583174c92ea8654b47b828155f'
+  metadata.gz: 5dbf4f38b4eafd181fe939fd1c77fe37a77ca4dd56faaab440aaa5c7161a25554f80df0a0cf2585038eeaceabec0dd7d315b3450b026634099035569673e6526
+  data.tar.gz: c45e64d63897784f481b6b1e61ff6486d430ed03bf3f25d1e78d48e4b19e5bc03a349f4b19f9075190921c802d9c7d3f01cd422e7ed79359c18a723998247aeb

data/lib/google/cloud/logging.rb

@@ -15,6 +15,7 @@
 
 require "google-cloud-logging"
 require "google/cloud/logging/project"
+require "stackdriver/core"
 
 module Google
   module Cloud
@@ -328,6 +329,12 @@ module Google
     # ```
     #
     module Logging
+      # Initialize :error_reporting as a nested Configuration under
+      # Google::Cloud if haven't already
+      unless Google::Cloud.configure.option? :logging
+        Google::Cloud.configure.add_options logging: :monitored_resource
+      end
+
       ##
       # Creates a new object for connecting to the Stackdriver Logging service.
       # Each call creates a new connection.
@@ -379,6 +386,23 @@ module Google
             project, credentials, timeout: timeout,
                                   client_config: client_config))
       end
+
+      ##
+      # Configure the Google::Cloud::Logging::Middleware when used in a
+      # Rack-based application.
+      #
+      # See the [Configuration
+      # Guide](https://googlecloudplatform.github.io/google-cloud-ruby/#/docs/stackdriver/guides/instrumentation_configuration)
+      # for full configuration parameters.
+      #
+      # @return [Stackdriver::Core::Configuration] The configuration object
+      #   the Google::Cloud::Logging module uses.
+      #
+      def self.configure
+        yield Google::Cloud.configure.logging if block_given?
+
+        Google::Cloud.configure.logging
+      end
     end
   end
 end

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

@@ -82,6 +82,11 @@ module Google
         # attribute for API compatibility with the standard Logger.
         attr_accessor :datetime_format
 
+        ##
+        # The project ID this logger is sending data to. If set, this value is
+        # used to set the trace field of log entries.
+        attr_accessor :project
+
         ##
         # This logger treats progname as an alias for log_name.
         def progname= name
@@ -146,6 +151,10 @@ module Google
           # Unused, but present for API compatibility
           @formatter = ::Logger::Formatter.new
           @datetime_format = ""
+
+          # The writer is usually a Project or AsyncWriter.
+          logging = @writer.respond_to?(:logging) ? @writer.logging : @writer
+          @project = logging.project if logging.respond_to? :project
         end
 
         ##
@@ -454,19 +463,34 @@ module Google
             e.payload = message
           end
 
-          # merge input labels and request info
-          merged_labels = {}
           actual_log_name = log_name
           info = request_info
           if info
             actual_log_name = info.log_name || actual_log_name
-            merged_labels["traceId"] = info.trace_id unless info.trace_id.nil?
+            unless info.trace_id.nil? || @project.nil?
+              entry.trace = "projects/#{@project}/traces/#{info.trace_id}"
+            end
           end
-          merged_labels = labels.merge(merged_labels) unless labels.nil?
 
           writer.write_entries entry, log_name: actual_log_name,
                                       resource: resource,
-                                      labels: merged_labels
+                                      labels: entry_labels
+        end
+
+        ##
+        # @private generate the labels hash for a log entry.
+        def entry_labels
+          merged_labels = {}
+          info = request_info
+
+          if info && !info.trace_id.nil?
+            merged_labels["traceId"] = info.trace_id
+            if Google::Cloud.env.app_engine?
+              merged_labels["appengine.googleapis.com/trace_id"] = info.trace_id
+            end
+          end
+
+          labels.nil? ? merged_labels : labels.merge(merged_labels)
         end
 
         ##

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

@@ -42,34 +42,30 @@ module Google
         #   to track Stackdriver request trace ID. It also properly sets
         #   env["rack.logger"] to this assigned logger for accessing. If not
         #   specified, a default logger with be used.
-        # @param [String] project_id Project identifier for the Stackdriver
-        #   Logging service. Used to create a default logger if one isn't
-        #   specified and a service account is used for authentication.
-        #   Optional.
-        # @param [String, Hash] keyfile Keyfile downloaded from Google Cloud. If
-        #   file path the file must be readable. Used to create a default logger
-        #   if one isn't specified and a service account is used for
-        #   authentication. Optional.
-        # @param [Hash] log_name_map A map from URI path to log name override.
-        #   The path may be a string or regex. If a request path matches an
-        #   entry in this map, the log name is set accordingly, otherwise the
-        #   logger's default log_name is used.
+        # @param [Hash] *kwargs Hash of configuration settings. Used for
+        #   backward API compatibility. See the [Configuration
+        #   Guide](https://googlecloudplatform.github.io/google-cloud-ruby/#/docs/stackdriver/guides/instrumentation_configuration)
+        #   for the prefered way to set configuration parameters.
         #
         # @return [Google::Cloud::Logging::Middleware] A new
         #   Google::Cloud::Logging::Middleware instance
         #
-        def initialize app, logger: nil, project_id: nil, keyfile: nil,
-                       log_name_map: DEFAULT_LOG_NAME_MAP
+        def initialize app, logger: nil, **kwargs
           @app = app
+
+          load_config kwargs
+
           if logger
             @logger = logger
           else
-            logging = Google::Cloud::Logging.new project: project_id,
-                                                 keyfile: keyfile
-            resource = Middleware.build_monitored_resource
-            @logger = logging.logger DEFAULT_LOG_NAME, resource
+            log_name = configuration.log_name
+            logging = Logging.new project: configuration.project_id,
+                                  keyfile: configuration.keyfile
+            resource = Middleware.build_monitored_resource(
+              configuration.monitored_resource.type,
+              configuration.monitored_resource.labels)
+            @logger = logging.logger log_name, resource
           end
-          @log_name_map = log_name_map
         end
 
         ##
@@ -116,10 +112,11 @@ module Google
         #     no override.
         #
         def get_log_name env
-          return nil unless @log_name_map
+          log_name_map = configuration.log_name_map
+          return nil unless log_name_map
           path = "#{env['SCRIPT_NAME']}#{env['PATH_INFO']}"
           path = "/#{path}" unless path.start_with? "/"
-          @log_name_map.each do |k, v|
+          log_name_map.each do |k, v|
             return v if k === path
           end
           nil
@@ -249,6 +246,40 @@ module Google
         end
 
         private_class_method :default_monitored_resource
+
+        private
+
+        ##
+        # Consolidate configurations from various sources. Also set
+        # instrumentation config parameters to default values if not set
+        # already.
+        #
+        def load_config **kwargs
+          configuration.project_id = kwargs[:project_id] ||
+                                     configuration.project_id
+          configuration.keyfile = kwargs[:keyfile] ||
+                                  configuration.keyfile
+          configuration.log_name_map ||= kwargs[:log_name_map] ||
+                                         configuration.log_name_map
+
+          init_default_config
+        end
+
+        ##
+        # Fallback to default configuration values if not defined already
+        def init_default_config
+          configuration.project_id ||= Cloud.configure.project_id ||
+                                       Logging::Project.default_project
+          configuration.keyfile ||= Cloud.configure.keyfile
+          configuration.log_name ||= DEFAULT_LOG_NAME
+          configuration.log_name_map ||= DEFAULT_LOG_NAME_MAP
+        end
+
+        ##
+        # @private Get Google::Cloud::Logging.configure
+        def configuration
+          Google::Cloud::Logging.configure
+        end
       end
     end
   end

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

@@ -34,25 +34,10 @@ module Google
       #
       # When loaded, the {Google::Cloud::Logging::Middleware} will be inserted
       # before the `Rails::Rack::Logger Middleware`, which allows it to set the
-      # `env['rack.logger']` in place of Rails's default logger. The Railtie
-      # will also initialize the logger with correct GCP `project_id`
-      # and `keyfile` if they are defined in the Rails `environment.rb` file as
-      # follows:
-      #
-      # ```ruby
-      # config.google_cloud.logging.project_id = "my-gcp-project"
-      # config.google_cloud.logging.keyfile = "/path/to/secret.json"
-      # ```
-      #
-      # or
-      #
-      # ```ruby
-      # config.google_cloud.project_id = "my-gcp-project"
-      # config.google_cloud.keyfile = "/path/to/secret.json"
-      # ```
-      #
-      # If omitted, project_id will be initialized with default environment
-      # variables.
+      # `env['rack.logger']` in place of Rails's default logger.
+      # See the [Configuration
+      # Guide](https://googlecloudplatform.github.io/google-cloud-ruby/#/docs/stackdriver/guides/instrumentation_configuration)
+      # on how to configure the Railtie and Middleware.
       #
       class Railtie < ::Rails::Railtie
         config.google_cloud = ::ActiveSupport::OrderedOptions.new unless
@@ -64,60 +49,94 @@ module Google
           ::ActiveSupport::OrderedOptions.new
 
         initializer "Stackdriver.Logging", before: :initialize_logger do |app|
-          if self.class.use_logging? app.config
-            logging_config = Railtie.parse_rails_config config
-
-            project_id = logging_config[:project_id]
-            keyfile = logging_config[:keyfile]
-            resource_type = logging_config[:resource_type]
-            resource_labels = logging_config[:resource_labels]
-            log_name = logging_config[:log_name]
-
-            logging = Google::Cloud::Logging.new project: project_id,
-                                                 keyfile: keyfile
-            resource =
-              Logging::Middleware.build_monitored_resource resource_type,
-                                                           resource_labels
-
-            app.config.logger = logging.logger log_name, resource
-            app.middleware.insert_before Rails::Rack::Logger,
-                                         Google::Cloud::Logging::Middleware,
-                                         logger: app.config.logger
-          end
+          self.class.consolidate_rails_config app.config
+
+          self.class.init_middleware app if Cloud.configure.use_logging
         end
 
         ##
-        # Determine whether to use Stackdriver Logging or not.
-        #
-        # Returns `true` if Stackdriver Logging is enabled for this application.
-        # That is, if all of the following are true:
-        #
-        # * A valid GCP `project_id` is available, either because the
-        #   application is hosted on Google Cloud or because it is set in the
-        #   configuration.
-        # * The API is able to authenticate, again either because the
-        #   application is hosted on Google Cloud or because an appropriate
-        #   keyfile is provided in the configuration.
-        # * Either the Rails environment is set to `production` or the
-        #   `config.google_cloud.use_logging` configuration is explicitly set to
-        #   `true`.
+        # @private Init Logging integration for Rails. Setup configuration and
+        # insert the Middleware.
+        def self.init_middleware app
+          project_id = Logging.configure.project_id
+          keyfile = Logging.configure.keyfile
+          resource_type = Logging.configure.monitored_resource.type
+          resource_labels = Logging.configure.monitored_resource.labels
+          log_name = Logging.configure.log_name
+
+          logging = Google::Cloud::Logging.new project: project_id,
+                                               keyfile: keyfile
+          resource =
+            Logging::Middleware.build_monitored_resource resource_type,
+                                                         resource_labels
+
+          app.config.logger = logging.logger log_name, resource
+          app.middleware.insert_before Rails::Rack::Logger,
+                                       Google::Cloud::Logging::Middleware,
+                                       logger: app.config.logger
+        end
+
+        ##
+        # @private Consolidate Rails configuration into Logging instrumentation
+        # configuration. Also consolidate the `use_logging` setting by verifying
+        # credentials and Rails environment. The `use_logging` setting will be
+        # true if credentials are valid, and the setting is manually set to true
+        # or Rails is in production environment.
         #
         # @param [Rails::Railtie::Configuration] config The
-        #   `Rails.application.config`
-        #
-        # @return [Boolean] Whether to use Stackdriver Logging
+        #   Rails.application.config
         #
-        def self.use_logging? config
-          logging_config = Railtie.parse_rails_config config
+        def self.consolidate_rails_config config
+          merge_rails_config config
 
-          # Return false if config.google_cloud.use_logging is explicitly false
-          use_logging = logging_config[:use_logging]
-          return false if use_logging == false
+          init_default_config
 
-          project_id = logging_config[:project_id] ||
-                       Google::Cloud::Logging::Project.default_project
-          keyfile = logging_config[:keyfile]
+          # Done if Google::Cloud.configure.use_logging is explicitly false
+          return if Google::Cloud.configure.use_logging == false
+
+          # Verify credentials and set use_error_reporting to false if
+          # credentials are invalid
+          unless valid_credentials? Logging.configure.project_id,
+                                    Logging.configure.keyfile
+            Cloud.configure.use_logging = false
+            return
+          end
 
+          # Otherwise set use_logging to true if Rails is running in production
+          Google::Cloud.configure.use_logging ||= Rails.env.production?
+        end
+
+        ##
+        # @private Merge Rails configuration into Logging instrumentation
+        # configuration.
+        def self.merge_rails_config rails_config
+          gcp_config = rails_config.google_cloud
+          logging_config = gcp_config.logging
+
+          Cloud.configure.use_logging ||= gcp_config.use_logging
+          Logging.configure do |config|
+            config.project_id ||= logging_config.project_id ||
+                                  gcp_config.project_id
+            config.keyfile ||= logging_config.keyfile || gcp_config.keyfile
+            config.log_name ||= logging_config.log_name
+            config.log_name_map ||= logging_config.log_name_map
+            config.monitored_resource.type ||=
+              logging_config.monitored_resource.type
+            config.monitored_resource.labels ||=
+              logging_config.monitored_resource.labels.to_h
+          end
+        end
+
+        ##
+        # Fallback to default config values if config parameters not provided.
+        def self.init_default_config
+          Logging.configure.project_id ||= Logging::Project.default_project
+          Logging.configure.log_name ||= Middleware::DEFAULT_LOG_NAME
+        end
+
+        ##
+        # @private Verify credentials
+        def self.valid_credentials? project_id, keyfile
           # Try authenticate authorize client API. Return false if unable to
           # authorize.
           begin
@@ -136,27 +155,12 @@ module Google
             return false
           end
 
-          # Otherwise default to true if Rails is running in production or
-          # config.google_cloud.use_logging is true
-          Rails.env.production? || use_logging
+          true
         end
 
-        ##
-        # @private Helper method to parse rails config into a flattened hash
-        def self.parse_rails_config config
-          gcp_config = config.google_cloud
-          logging_config = gcp_config.logging
-          use_logging =
-            gcp_config.key?(:use_logging) ? gcp_config.use_logging : nil
-          {
-            project_id: logging_config.project_id || gcp_config.project_id,
-            keyfile: logging_config.keyfile || gcp_config.keyfile,
-            resource_type: logging_config.monitored_resource.type,
-            resource_labels: logging_config.monitored_resource.labels,
-            log_name: logging_config.log_name || Middleware::DEFAULT_LOG_NAME,
-            use_logging: use_logging
-          }
-        end
+        private_class_method :merge_rails_config,
+                             :init_default_config,
+                             :valid_credentials?
       end
     end
   end

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

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: google-cloud-logging
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Mike Moore
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-21 00:00:00.000000000 Z
+date: 2017-05-26 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.0'
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: google-gax
   requirement: !ruby/object:Gem::Requirement
@@ -266,7 +266,7 @@ files:
 - lib/google/logging/v2/logging_metrics_services_pb.rb
 - lib/google/logging/v2/logging_pb.rb
 - lib/google/logging/v2/logging_services_pb.rb
-homepage: http://googlecloudplatform.github.io/google-cloud-ruby/
+homepage: https://github.com/GoogleCloudPlatform/google-cloud-ruby/tree/master/google-cloud-logging
 licenses:
 - Apache-2.0
 metadata: {}
@@ -286,7 +286,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: API Client library for Stackdriver Logging