google-cloud-logging 2.0.0

data/lib/google/cloud/logging/entry/http_request.rb

@@ -0,0 +1,167 @@
+# Copyright 2016 Google LLC
+#
+# 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
+#
+#     https://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.
+
+
+module Google
+  module Cloud
+    module Logging
+      class Entry
+        ##
+        # # Http Request
+        #
+        # HTTP request data associated with a log entry.
+        #
+        # See also {Google::Cloud::Logging::Entry#http_request}.
+        #
+        class HttpRequest
+          ##
+          # @private Create an empty HttpRequest object.
+          def initialize; end
+
+          ##
+          # The request method. Examples: `"GET"`, `"HEAD"`, `"PUT"`, `"POST"`.
+          # (String)
+          attr_accessor :request_method
+
+          ##
+          # @overload method()
+          #   Deprecated. Use {#request_method} instead.
+          #
+          #   The request method. Examples: `"GET"`, `"HEAD"`, `"PUT"`,
+          #   `"POST"`. (String)
+          def method *args
+            # Call Object#method when args are present.
+            return super unless args.empty?
+
+            request_method
+          end
+
+          ##
+          # @overload method()
+          #   Deprecated. Use {#request_method=} instead.
+          #
+          #   The request method. Examples: `"GET"`, `"HEAD"`, `"PUT"`,
+          #   `"POST"`. (String)
+          def method= new_request_method
+            self.request_method = new_request_method
+          end
+
+          ##
+          # The URL. The scheme (http, https), the host name, the path and the
+          # query portion of the URL that was requested. Example:
+          # `"http://example.com/some/info?color=red"`. (String)
+          attr_accessor :url
+
+          ##
+          # The size of the HTTP request message in bytes, including the request
+          # headers and the request body. (Integer)
+          attr_accessor :size
+
+          ##
+          # The response code indicating the status of response. Examples:
+          # `200`, `404`. (Integer)
+          attr_accessor :status
+
+          ##
+          # The size of the HTTP response message sent back to the client, in
+          # bytes, including the response headers and the response body.
+          # (Integer)
+          attr_accessor :response_size
+
+          ##
+          # The user agent sent by the client. Example: `"Mozilla/4.0
+          # (compatible; MSIE 6.0; Windows 98; Q312461; .NET CLR 1.0.3705)"`.
+          # (String)
+          attr_accessor :user_agent
+
+          ##
+          # The IP address (IPv4 or IPv6) of the client that issued the HTTP
+          # request. Examples: `"192.168.1.1"`, `"FE80::0202:B3FF:FE1E:8329"`.
+          # (String)
+          attr_accessor :remote_ip
+
+          ##
+          # The referer URL of the request, as defined in [HTTP/1.1 Header Field
+          # Definitions](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html).
+          # (String)
+          attr_accessor :referer
+
+          ##
+          # Whether an entity was served from cache (with or without
+          # validation). (Boolean)
+          attr_accessor :cache_hit
+
+          ##
+          # Whether the response was validated with the origin server before
+          # being served from cache. This field is only meaningful if
+          # `cache_hit` is `true`. (Boolean)
+          attr_accessor :validated
+
+          ##
+          # @private Determines if the HttpRequest has any data.
+          def empty?
+            method.nil? &&
+              url.nil? &&
+              size.nil? &&
+              status.nil? &&
+              response_size.nil? &&
+              user_agent.nil? &&
+              remote_ip.nil? &&
+              referer.nil? &&
+              cache_hit.nil? &&
+              validated.nil?
+          end
+
+          ##
+          # @private Exports the HttpRequest to a
+          # Google::Cloud::Logging::Type::HttpRequest object.
+          def to_grpc
+            return nil if empty?
+            Google::Cloud::Logging::Type::HttpRequest.new(
+              request_method:                     request_method.to_s,
+              request_url:                        url.to_s,
+              request_size:                       size.to_i,
+              status:                             status.to_i,
+              response_size:                      response_size.to_i,
+              user_agent:                         user_agent.to_s,
+              remote_ip:                          remote_ip.to_s,
+              referer:                            referer.to_s,
+              cache_hit:                          !(!cache_hit),
+              cache_validated_with_origin_server: !(!validated)
+            )
+          end
+
+          ##
+          # @private New HttpRequest from a Google::Cloud::Logging::Type::HttpRequest
+          # object.
+          def self.from_grpc grpc
+            return new if grpc.nil?
+            new.tap do |h|
+              h.request_method = grpc.request_method
+              h.url            = grpc.request_url
+              h.size           = grpc.request_size
+              h.status         = grpc.status
+              h.response_size  = grpc.response_size
+              h.user_agent     = grpc.user_agent
+              h.remote_ip      = grpc.remote_ip
+              h.referer        = grpc.referer
+              h.cache_hit      = grpc.cache_hit
+              h.validated      = grpc.cache_validated_with_origin_server
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,178 @@
+# Copyright 2016 Google LLC
+#
+# 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
+#
+#     https://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 "delegate"
+
+module Google
+  module Cloud
+    module Logging
+      class Entry
+        ##
+        # Entry::List is a special case Array with additional values.
+        class List < DelegateClass(::Array)
+          ##
+          # If not empty, indicates that there are more records that match
+          # the request and this value should be passed to continue.
+          attr_accessor :token
+
+          ##
+          # @private Create a new Entry::List with an array of Entry instances.
+          def initialize arr = []
+            super arr
+          end
+
+          ##
+          # Whether there is a next page of entries.
+          #
+          # @return [Boolean]
+          #
+          # @example
+          #   require "google/cloud/logging"
+          #
+          #   logging = Google::Cloud::Logging.new
+          #
+          #   entries = logging.entries
+          #   if entries.next?
+          #     next_entries = entries.next
+          #   end
+          #
+          def next?
+            !token.nil?
+          end
+
+          ##
+          # Retrieve the next page of entries.
+          #
+          # @return [Sink::List]
+          #
+          # @example
+          #   require "google/cloud/logging"
+          #
+          #   logging = Google::Cloud::Logging.new
+          #
+          #   entries = logging.entries
+          #   if entries.next?
+          #     next_entries = entries.next
+          #   end
+          #
+          def next
+            return nil unless next?
+            ensure_service!
+            grpc = @service.list_entries token: token, resources: @resources,
+                                         filter: @filter, order: @order,
+                                         max: @max, projects: @projects
+            self.class.from_grpc grpc, @service, resources: @resources,
+                                                 filter: @filter, order: @order,
+                                                 max: @max, projects: @projects
+          end
+
+          ##
+          # Retrieves remaining results by repeatedly invoking {#next} until
+          # {#next?} returns `false`. Calls the given block once for each
+          # result, which is passed as the argument to the block.
+          #
+          # An Enumerator is returned if no block is given.
+          #
+          # This method will make repeated API calls until all remaining results
+          # are retrieved. (Unlike `#each`, for example, which merely iterates
+          # over the results returned by a single API call.) Use with caution.
+          #
+          # @param [Integer] request_limit The upper limit of API requests to
+          #   make to load all log entries. Default is no limit.
+          # @yield [entry] The block for accessing each log entry.
+          # @yieldparam [Entry] entry The log entry object.
+          #
+          # @return [Enumerator]
+          #
+          # @example Iterating each log entry by passing a block:
+          #   require "google/cloud/logging"
+          #
+          #   logging = Google::Cloud::Logging.new
+          #   entries = logging.entries order: "timestamp desc"
+          #
+          #   entries.all do |e|
+          #     puts "[#{e.timestamp}] #{e.log_name} #{e.payload.inspect}"
+          #   end
+          #
+          # @example Using the enumerator by not passing a block:
+          #   require "google/cloud/logging"
+          #
+          #   logging = Google::Cloud::Logging.new
+          #   entries = logging.entries order: "timestamp desc"
+          #
+          #   all_payloads = entries.all.map do |entry|
+          #     entry.payload
+          #   end
+          #
+          # @example Limit the number of API calls made:
+          #   require "google/cloud/logging"
+          #
+          #   logging = Google::Cloud::Logging.new
+          #   entries = logging.entries order: "timestamp desc"
+          #
+          #   entries.all(request_limit: 10) do |e|
+          #     puts "[#{e.timestamp}] #{e.log_name} #{e.payload.inspect}"
+          #   end
+          #
+          def all request_limit: nil
+            request_limit = request_limit.to_i if request_limit
+            unless block_given?
+              return enum_for :all, request_limit: request_limit
+            end
+            results = self
+            loop do
+              results.each { |r| yield r }
+              if request_limit
+                request_limit -= 1
+                break if request_limit < 0
+              end
+              break unless results.next?
+              results = results.next
+            end
+          end
+
+          ##
+          # @private New Entry::List from a
+          # Google::Cloud::Logging::V2::ListLogEntryResponse object.
+          def self.from_grpc grpc_list, service, resources: nil, filter: nil,
+                             order: nil, max: nil, projects: nil
+            entries = new(Array(grpc_list.entries).map do |grpc_entry|
+              Entry.from_grpc grpc_entry
+            end)
+            token = grpc_list.next_page_token
+            token = nil if token == "".freeze
+            entries.instance_variable_set :@token,     token
+            entries.instance_variable_set :@service,   service
+            entries.instance_variable_set :@projects,  projects
+            entries.instance_variable_set :@resources, resources
+            entries.instance_variable_set :@filter,    filter
+            entries.instance_variable_set :@order,     order
+            entries.instance_variable_set :@max,       max
+            entries
+          end
+
+          protected
+
+          ##
+          # @private Raise an error unless an active connection to the service
+          # is available.
+          def ensure_service!
+            raise "Must have active connection to service" unless @service
+          end
+        end
+      end
+    end
+  end
+end

data/lib/google/cloud/logging/entry/operation.rb

@@ -0,0 +1,91 @@
+# Copyright 2016 Google LLC
+#
+# 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
+#
+#     https://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.
+
+
+module Google
+  module Cloud
+    module Logging
+      class Entry
+        ##
+        # # Operation
+        #
+        # Additional information about a potentially long-running operation with
+        # which a log entry is associated.
+        #
+        # See also {Google::Cloud::Logging::Entry#operation}.
+        #
+        class Operation
+          ##
+          # @private Create an empty Operation object.
+          def initialize; end
+
+          ##
+          # An arbitrary operation identifier. Log entries with the same
+          # identifier are assumed to be part of the same operation.
+          attr_accessor :id
+
+          ##
+          # An arbitrary producer identifier. The combination of `id` and
+          # `producer` must be globally unique. Examples for `producer`:
+          # `"MyDivision.MyBigCompany.com"`,
+          # `"github.com/MyProject/MyApplication"`.
+          attr_accessor :producer
+
+          ##
+          # Set this to `true` if this is the first log entry in the operation.
+          attr_accessor :first
+
+          ##
+          # Set this to `true` if this is the last log entry in the operation.
+          attr_accessor :last
+
+          ##
+          # @private Determines if the Operation has any data.
+          def empty?
+            id.nil? &&
+              producer.nil? &&
+              first.nil? &&
+              last.nil?
+          end
+
+          ##
+          # @private Exports the Operation to a
+          # Google::Cloud::Logging::V2::LogEntryOperation object.
+          def to_grpc
+            return nil if empty?
+            Google::Cloud::Logging::V2::LogEntryOperation.new(
+              id:       id.to_s,
+              producer: producer.to_s,
+              first:    !(!first),
+              last:     !(!last)
+            )
+          end
+
+          ##
+          # @private New Google::Cloud::Logging::Entry::Operation from a
+          # Google::Cloud::Logging::V2::LogEntryOperation object.
+          def self.from_grpc grpc
+            return new if grpc.nil?
+            new.tap do |o|
+              o.id       = grpc.id
+              o.producer = grpc.producer
+              o.first    = grpc.first
+              o.last     = grpc.last
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/google/cloud/logging/entry/source_location.rb

@@ -0,0 +1,85 @@
+# Copyright 2017 Google LLC
+#
+# 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
+#
+#     https://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.
+
+
+module Google
+  module Cloud
+    module Logging
+      class Entry
+        ##
+        # # SourceLocation
+        #
+        # Additional information about the source code location that produced
+        # the log entry.
+        #
+        # See also {Google::Cloud::Logging::Entry#source_location}.
+        #
+        class SourceLocation
+          ##
+          # @private Create an empty SourceLocation object.
+          def initialize; end
+
+          ##
+          # Source file name. Depending on the runtime environment, this might
+          # be a simple name or a fully-qualified name. Optional.
+          attr_accessor :file
+
+          ##
+          # Line within the source file. 1-based; `0` indicates no line number
+          # available. Optional.
+          attr_accessor :line
+
+          ##
+          # Human-readable name of the function or method being invoked, with
+          # optional context such as the class or package name. This information
+          # may be used in contexts such as the logs viewer, where a file and
+          # line number are less meaningful. Optional.
+          attr_accessor :function
+
+          ##
+          # @private Determines if the SourceLocation has any data.
+          def empty?
+            file.nil? &&
+              line.nil? &&
+              function.nil?
+          end
+
+          ##
+          # @private Exports the SourceLocation to a
+          # Google::Cloud::Logging::V2::LogEntrySourceLocation object.
+          def to_grpc
+            return nil if empty?
+            Google::Cloud::Logging::V2::LogEntrySourceLocation.new(
+              file:     file.to_s,
+              line:     line,
+              function: function.to_s
+            )
+          end
+
+          ##
+          # @private New Google::Cloud::Logging::Entry::SourceLocation from a
+          # Google::Cloud::Logging::V2::LogEntrySourceLocation object.
+          def self.from_grpc grpc
+            return new if grpc.nil?
+            new.tap do |o|
+              o.file       = grpc.file
+              o.line       = grpc.line
+              o.function   = grpc.function
+            end
+          end
+        end
+      end
+    end
+  end
+end