google-cloud-logging 0.20.1 → 0.21.0

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

@@ -0,0 +1,121 @@
+# Copyright 2016 Google Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "google/cloud/logging"
+
+module Google
+  module Cloud
+    module Logging
+      ##
+      # Default log name to be used for Stackdriver Logging
+      DEFAULT_LOG_NAME = "ruby_app_log"
+
+      ##
+      # Railtie
+      #
+      # Google::Cloud::Logging::Railtie automatically add the
+      # Google::Cloud::Logging::Middleware to Rack in a Rails environment.
+      # The middleware will set env['rack.logger'] to a
+      # Google::Cloud::Logging::Logger instance to be used by the Rails
+      # application.
+      #
+      # The Middleware is only added when certain conditions are met. See
+      # {use_logging?} for detail.
+      #
+      # 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
+      # should also initialize the logger with correct GCP project_id
+      # and keyfile if they are defined in Rails environment.rb as follow:
+      #   config.google_cloud.logging.project_id = "my-gcp-project"
+      #   config.google_cloud.logging.keyfile = "/path/to/secret.json"
+      # or
+      #   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.
+      #
+      class Railtie < ::Rails::Railtie
+        config.google_cloud = ::ActiveSupport::OrderedOptions.new unless
+          config.respond_to? :google_cloud
+        config.google_cloud.logging = ::ActiveSupport::OrderedOptions.new
+
+        initializer "Stackdriver.Logging", before: :initialize_logger do |app|
+          if self.class.use_logging? app.config
+            gcp_config = app.config.google_cloud
+            log_config = gcp_config.logging
+
+            project_id = log_config.project_id || gcp_config.project_id
+            keyfile = log_config.keyfile || gcp_config.keyfile
+
+            logging = Google::Cloud::Logging.new project: project_id,
+                                                 keyfile: keyfile
+            resource =
+              Google::Cloud::Logging::Middleware.build_monitoring_resource
+            log_name = log_config.log_name || DEFAULT_LOG_NAME
+
+            app.config.logger = Google::Cloud::Logging::Logger.new logging,
+                                                                   log_name,
+                                                                   resource
+            app.middleware.insert_before Rails::Rack::Logger,
+                                         Google::Cloud::Logging::Middleware,
+                                         logger: app.config.logger
+          end
+        end
+
+        ##
+        # Determine whether to use Stackdriver Logging or not.
+        #
+        # Returns true if valid GCP project_id is provided and underneath API is
+        # able to authenticate. Also either Rails needs to be in "production"
+        # environment or config.stackdriver.use_logging is explicitly true.
+        #
+        # @param config The Rails.application.config
+        #
+        # @return [Boolean]
+        #
+        def self.use_logging? config
+          gcp_config = config.google_cloud
+          # Return false if config.stackdriver.use_logging is explicitly false
+          return false if gcp_config.key?(:use_logging) &&
+                          !gcp_config.use_logging
+
+          # Try authenticate authorize client API. Return false if unable to
+          # authorize.
+          keyfile = gcp_config.logging.keyfile || gcp_config.keyfile
+          begin
+            Google::Cloud::Logging::Credentials.credentials_with_scope keyfile
+          rescue Exception => e
+            warn "Unable to initialize Google::Cloud::Logging due " \
+              "to authorization error: #{e.message}"
+            return false
+          end
+
+          project_id = gcp_config.logging.project_id || gcp_config.project_id ||
+                       Google::Cloud::Logging::Project.default_project
+          if project_id.to_s.empty?
+            warn "Unable to initialize Google::Cloud::Logging with empty " \
+              "project_id"
+            return false
+          end
+
+          # Otherwise default to true if Rails is running in production or
+          # config.stackdriver.use_logging is explicitly true
+          Rails.env.production? ||
+            (gcp_config.key?(:use_logging) && gcp_config.use_logging)
+        end
+      end
+    end
+  end
+end

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

@@ -30,10 +30,9 @@ module Google
       # {Google::Cloud::Logging::Project#write_entries}.
       #
       # @example
-      #   require "google/cloud"
+      #   require "google/cloud/logging"
       #
-      #   gcloud = Google::Cloud.new
-      #   logging = gcloud.logging
+      #   logging = Google::Cloud::Logging.new
       #   resource = logging.resource "gae_app",
       #                               "module_id" => "1",
       #                               "version_id" => "20150925t173233"

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

@@ -31,10 +31,9 @@ module Google
       # instances, but you can list them with {Project#resource_descriptors}.
       #
       # @example
-      #   require "google/cloud"
+      #   require "google/cloud/logging"
       #
-      #   gcloud = Google::Cloud.new
-      #   logging = gcloud.logging
+      #   logging = Google::Cloud::Logging.new
       #   resource_descriptor = logging.resource_descriptors.first
       #   resource_descriptor.type #=> "cloudsql_database"
       #   resource_descriptor.name #=> "Cloud SQL Database"
@@ -93,10 +92,9 @@ module Google
         # their `database_id`. See {ResourceDescriptor#labels}.
         #
         # @example
-        #   require "google/cloud"
+        #   require "google/cloud/logging"
         #
-        #   gcloud = Google::Cloud.new
-        #   logging = gcloud.logging
+        #   logging = Google::Cloud::Logging.new
         #   resource_descriptor = logging.resource_descriptors.first
         #   label_descriptor = resource_descriptor.labels.first
         #   label_descriptor.key #=> "database_id"

data/lib/google/cloud/logging/resource_descriptor/list.rb

@@ -41,10 +41,9 @@ module Google
           # @return [Boolean]
           #
           # @example
-          #   require "google/cloud"
+          #   require "google/cloud/logging"
           #
-          #   gcloud = Google::Cloud.new
-          #   logging = gcloud.logging
+          #   logging = Google::Cloud::Logging.new
           #
           #   resource_descriptors = logging.resource_descriptors
           #   if resource_descriptors.next?
@@ -61,10 +60,9 @@ module Google
           # @return [Sink::List]
           #
           # @example
-          #   require "google/cloud"
+          #   require "google/cloud/logging"
           #
-          #   gcloud = Google::Cloud.new
-          #   logging = gcloud.logging
+          #   logging = Google::Cloud::Logging.new
           #
           #   resource_descriptors = logging.resource_descriptors
           #   if resource_descriptors.next?
@@ -100,10 +98,9 @@ module Google
           # @return [Enumerator]
           #
           # @example Iterating each resource descriptor by passing a block:
-          #   require "google/cloud"
+          #   require "google/cloud/logging"
           #
-          #   gcloud = Google::Cloud.new
-          #   logging = gcloud.logging
+          #   logging = Google::Cloud::Logging.new
           #   resource_descriptors = logging.resource_descriptors
           #
           #   resource_descriptors.all do |rd|
@@ -111,10 +108,9 @@ module Google
           #   end
           #
           # @example Using the enumerator by not passing a block:
-          #   require "google/cloud"
+          #   require "google/cloud/logging"
           #
-          #   gcloud = Google::Cloud.new
-          #   logging = gcloud.logging
+          #   logging = Google::Cloud::Logging.new
           #   resource_descriptors = logging.resource_descriptors
           #
           #   all_types = resource_descriptors.all.map do |rd|
@@ -122,10 +118,9 @@ module Google
           #   end
           #
           # @example Limit the number of API calls made:
-          #   require "google/cloud"
+          #   require "google/cloud/logging"
           #
-          #   gcloud = Google::Cloud.new
-          #   logging = gcloud.logging
+          #   logging = Google::Cloud::Logging.new
           #   resource_descriptors = logging.resource_descriptors
           #
           #   resource_descriptors.all(request_limit: 10) do |rd|

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

@@ -14,10 +14,8 @@
 
 
 require "google/cloud/errors"
-require "google/cloud/core/grpc_backoff"
-require "google/logging/v2/logging_pb"
-require "google/logging/v2/logging_config_pb"
-require "google/logging/v2/logging_metrics_pb"
+require "google/cloud/logging/v2"
+require "google/gax/errors"
 
 module Google
   module Cloud
@@ -26,69 +24,92 @@ module Google
       # @private Represents the gRPC Logging service, including all the API
       # methods.
       class Service
-        attr_accessor :project, :credentials, :host, :retries, :timeout
+        attr_accessor :project, :credentials, :host, :timeout, :client_config
 
         ##
         # Creates a new Service instance.
-        def initialize project, credentials, host: nil, retries: nil,
-                       timeout: nil
+        def initialize project, credentials, host: nil, timeout: nil,
+                       client_config: nil
           @project = project
           @credentials = credentials
-          @host = host || "logging.googleapis.com"
-          @retries = retries
+          @host = host || V2::LoggingServiceV2Api::SERVICE_ADDRESS
           @timeout = timeout
+          @client_config = client_config || {}
         end
 
-        def creds
+        def channel
+          require "grpc"
+          GRPC::Core::Channel.new host, nil, chan_creds
+        end
+
+        def chan_creds
+          return credentials if insecure?
+          require "grpc"
           GRPC::Core::ChannelCredentials.new.compose \
             GRPC::Core::CallCredentials.new credentials.client.updater_proc
         end
 
         def logging
           return mocked_logging if mocked_logging
-          @logging ||= begin
-            require "google/logging/v2/logging_services_pb"
-
-            Google::Logging::V2::LoggingServiceV2::Stub.new(
-              host, creds, timeout: timeout)
-          end
+          @logging ||= \
+            V2::LoggingServiceV2Api.new(
+              service_path: host,
+              channel: channel,
+              timeout: timeout,
+              client_config: client_config,
+              app_name: "gcloud-ruby",
+              app_version: Google::Cloud::Logging::VERSION)
         end
         attr_accessor :mocked_logging
 
         def sinks
           return mocked_sinks if mocked_sinks
-          @sinks ||= begin
-            require "google/logging/v2/logging_config_services_pb"
-
-            Google::Logging::V2::ConfigServiceV2::Stub.new(
-              host, creds, timeout: timeout)
-          end
+          @sinks ||= \
+            V2::ConfigServiceV2Api.new(
+              service_path: host,
+              channel: channel,
+              timeout: timeout,
+              client_config: client_config,
+              app_name: "gcloud-ruby",
+              app_version: Google::Cloud::Logging::VERSION)
         end
         attr_accessor :mocked_sinks
 
         def metrics
           return mocked_metrics if mocked_metrics
-          @metrics ||= begin
-            require "google/logging/v2/logging_metrics_services_pb"
-
-            Google::Logging::V2::MetricsServiceV2::Stub.new(
-              host, creds, timeout: timeout)
-          end
+          @metrics ||= \
+            V2::MetricsServiceV2Api.new(
+              service_path: host,
+              channel: channel,
+              timeout: timeout,
+              client_config: client_config,
+              app_name: "gcloud-ruby",
+              app_version: Google::Cloud::Logging::VERSION)
         end
         attr_accessor :mocked_metrics
 
+        def insecure?
+          credentials == :this_channel_is_insecure
+        end
+
         def list_entries projects: nil, filter: nil, order: nil, token: nil,
                          max: nil
-          list_params = { project_ids: Array(projects || @project),
-                          filter: filter,
-                          order_by: order,
-                          page_token: token,
-                          page_size: max
-                        }.delete_if { |_, v| v.nil? }
 
-          list_req = Google::Logging::V2::ListLogEntriesRequest.new(list_params)
+          project_ids = Array(projects || @project)
+          call_opts = default_options
+          if token
+            call_opts = Google::Gax::CallOptions.new(kwargs: default_headers,
+                                                     page_token: token)
+          end
 
-          execute { logging.list_log_entries list_req }
+          execute do
+            paged_enum = logging.list_log_entries project_ids,
+                                                  filter: filter,
+                                                  order_by: order,
+                                                  page_size: max,
+                                                  options: call_opts
+            paged_enum.page.response
+          end
         end
 
         def write_entries entries, log_name: nil, resource: nil, labels: nil
@@ -99,147 +120,124 @@ module Google
           resource = resource.to_grpc if resource
           labels = Hash[labels.map { |k, v| [String(k), String(v)] }] if labels
 
-          write_params = { entries: entries,
-                           log_name: log_path(log_name),
-                           resource: resource, labels: labels
-                         }.delete_if { |_, v| v.nil? }
-
-          write_req = Google::Logging::V2::WriteLogEntriesRequest.new(
-            write_params)
-
-          execute { logging.write_log_entries write_req }
+          execute do
+            logging.write_log_entries entries,
+                                      log_name: log_path(log_name),
+                                      resource: resource, labels: labels,
+                                      options: default_options
+          end
         end
 
         def delete_log name
-          delete_req = Google::Logging::V2::DeleteLogRequest.new(
-            log_name: log_path(name)
-          )
-
-          execute { logging.delete_log delete_req }
+          execute do
+            logging.delete_log log_path(name), options: default_options
+          end
         end
 
         def list_resource_descriptors token: nil, max: nil
-          list_params = { page_token: token,
-                          page_size: max
-                        }.delete_if { |_, v| v.nil? }
-
-          list_req = \
-            Google::Logging::V2::ListMonitoredResourceDescriptorsRequest.new(
-              list_params)
+          call_opts = default_options
+          if token
+            call_opts = Google::Gax::CallOptions.new(kwargs: default_headers,
+                                                     page_token: token)
+          end
 
-          execute { logging.list_monitored_resource_descriptors list_req }
+          execute do
+            logging.list_monitored_resource_descriptors \
+              page_size: max, options: call_opts
+          end
         end
 
         def list_sinks token: nil, max: nil
-          list_params = { parent: project_path,
-                          page_token: token,
-                          page_size: max
-                        }.delete_if { |_, v| v.nil? }
-
-          list_req = Google::Logging::V2::ListSinksRequest.new(list_params)
+          call_opts = default_options
+          if token
+            call_opts = Google::Gax::CallOptions.new(kwargs: default_headers,
+                                                     page_token: token)
+          end
 
-          execute { sinks.list_sinks list_req }
+          execute do
+            paged_enum = sinks.list_sinks \
+              project_path, page_size: max, options: call_opts
+            paged_enum.page.response
+          end
         end
 
         def create_sink name, destination, filter, version
-          sink_params = {
-            name: name, destination: destination,
-            filter: filter, output_version_format: version
-          }.delete_if { |_, v| v.nil? }
+          sink = Google::Logging::V2::LogSink.new({
+            name: name, destination: destination, filter: filter,
+            output_version_format: version }.delete_if { |_, v| v.nil? })
 
-          create_req = Google::Logging::V2::CreateSinkRequest.new(
-            parent: project_path,
-            sink: Google::Logging::V2::LogSink.new(sink_params)
-          )
-
-          execute { sinks.create_sink create_req }
+          execute do
+            sinks.create_sink project_path, sink, options: default_options
+          end
         end
 
         def get_sink name
-          get_req = Google::Logging::V2::GetSinkRequest.new(
-            sink_name: sink_path(name)
-          )
-
-          execute { sinks.get_sink get_req }
+          execute { sinks.get_sink sink_path(name), options: default_options }
         end
 
         def update_sink name, destination, filter, version
-          sink_params = {
-            name: name, destination: destination,
-            filter: filter, output_version_format: version
-          }.delete_if { |_, v| v.nil? }
+          sink = Google::Logging::V2::LogSink.new({
+            name: name, destination: destination, filter: filter,
+            output_version_format: version }.delete_if { |_, v| v.nil? })
 
-          update_req = Google::Logging::V2::UpdateSinkRequest.new(
-            sink_name: sink_path(name),
-            sink: Google::Logging::V2::LogSink.new(sink_params)
-          )
-
-          execute { sinks.update_sink update_req }
+          execute do
+            sinks.update_sink sink_path(name), sink, options: default_options
+          end
         end
 
         def delete_sink name
-          delete_req = Google::Logging::V2::DeleteSinkRequest.new(
-            sink_name: sink_path(name)
-          )
-
-          execute { sinks.delete_sink delete_req }
+          execute do
+            sinks.delete_sink sink_path(name), options: default_options
+          end
         end
 
         def list_metrics token: nil, max: nil
-          list_params = { parent: project_path,
-                          page_token: token,
-                          page_size: max
-                        }.delete_if { |_, v| v.nil? }
-
-          list_req = Google::Logging::V2::ListLogMetricsRequest.new(list_params)
+          call_opts = default_options
+          if token
+            call_opts = Google::Gax::CallOptions.new(kwargs: default_headers,
+                                                     page_token: token)
+          end
 
-          execute { metrics.list_log_metrics list_req }
+          execute do
+            paged_enum = metrics.list_log_metrics \
+              project_path, page_size: max, options: call_opts
+            paged_enum.page.response
+          end
         end
 
         def create_metric name, filter, description
-          metric_params = {
-            name: name,
-            description: description,
-            filter: filter
-          }.delete_if { |_, v| v.nil? }
-
-          create_req = Google::Logging::V2::CreateLogMetricRequest.new(
-            parent: project_path,
-            metric: Google::Logging::V2::LogMetric.new(metric_params)
-          )
-
-          execute { metrics.create_log_metric create_req }
+          metric = Google::Logging::V2::LogMetric.new({
+            name: name, description: description,
+            filter: filter }.delete_if { |_, v| v.nil? })
+
+          execute do
+            metrics.create_log_metric project_path, metric,
+                                      options: default_options
+          end
         end
 
         def get_metric name
-          get_req = Google::Logging::V2::GetLogMetricRequest.new(
-            metric_name: metric_path(name)
-          )
-
-          execute { metrics.get_log_metric get_req }
+          execute do
+            metrics.get_log_metric metric_path(name), options: default_options
+          end
         end
 
         def update_metric name, description, filter
-          metric_params = {
-            name: name,
-            description: description,
-            filter: filter
-          }.delete_if { |_, v| v.nil? }
-
-          update_req = Google::Logging::V2::UpdateLogMetricRequest.new(
-            metric_name: metric_path(name),
-            metric: Google::Logging::V2::LogMetric.new(metric_params)
-          )
-
-          execute { metrics.update_log_metric update_req }
+          metric = Google::Logging::V2::LogMetric.new({
+            name: name, description: description,
+            filter: filter }.delete_if { |_, v| v.nil? })
+
+          execute do
+            metrics.update_log_metric metric_path(name), metric,
+                                      options: default_options
+          end
         end
 
         def delete_metric name
-          delete_req = Google::Logging::V2::DeleteLogMetricRequest.new(
-            metric_name: metric_path(name)
-          )
-
-          execute { metrics.delete_log_metric delete_req }
+          execute do
+            metrics.delete_log_metric metric_path(name),
+                                      options: default_options
+          end
         end
 
         def inspect
@@ -269,12 +267,19 @@ module Google
           "#{project_path}/metrics/#{metric_name}"
         end
 
+        def default_headers
+          { "google-cloud-resource-prefix" => "projects/#{@project}" }
+        end
+
+        def default_options
+          Google::Gax::CallOptions.new kwargs: default_headers
+        end
+
         def execute
-          Google::Cloud::Core::GrpcBackoff.new(retries: retries).execute do
-            yield
-          end
-        rescue GRPC::BadStatus => e
-          raise Google::Cloud::Error.from_error(e)
+          yield
+        rescue Google::Gax::GaxError => e
+          # GaxError wraps BadStatus, but exposes it as #cause
+          raise Google::Cloud::Error.from_error(e.cause)
         end
       end
     end