google-cloud-debugger 0.26.1 → 0.27.0

data/lib/google/cloud/debugger/breakpoint/evaluator.rb

@@ -38,10 +38,6 @@ module Google
         # for details.
         #
         module Evaluator
-          ##
-          # Max number of top stacks to collect local variables information
-          STACK_EVAL_DEPTH = 5
-
           ##
           # @private YARV bytecode that the evaluator blocks during expression
           # evaluation. If the breakpoint contains expressions that uses the
@@ -773,85 +769,14 @@ module Google
             }).freeze
           }.freeze
 
-          class << self
-            ##
-            # Evaluates call stack. Collects function name and location of each
-            # frame from given binding objects. Collects local variable
-            # information from top frames.
-            #
-            # @param [Array<Binding>] call_stack_bindings A list of binding
-            #   objects that come from each of the call stack frames.
-            # @return [Array<Google::Cloud::Debugger::Breakpoint::StackFrame>]
-            #   A list of StackFrame objects that represent state of the
-            #   call stack
-            #
-            def eval_call_stack call_stack_bindings
-              result = []
-              call_stack_bindings.each_with_index do |frame_binding, i|
-                frame_info = StackFrame.new.tap do |sf|
-                  sf.function = frame_binding.eval("__method__").to_s
-                  sf.location = SourceLocation.new.tap do |l|
-                    l.path =
-                      frame_binding.eval("::File.absolute_path(__FILE__)")
-                    l.line = frame_binding.eval("__LINE__")
-                  end
-                end
-
-                if i < STACK_EVAL_DEPTH
-                  frame_info.locals = eval_frame_variables frame_binding
-                end
+          PROHIBITED_OPERATION_MSG = "Prohibited operation detected".freeze
+          MUTATION_DETECTED_MSG = "Mutation detected!".freeze
+          COMPILATION_FAIL_MSG = "Unable to compile expression".freeze
+          LONG_EVAL_MSG = "Evaluation exceeded time limit".freeze
 
-                result << frame_info
-              end
-
-              result
-            end
-
-            ##
-            # Evaluates a boolean conditional expression in the given context
-            # binding. The evaluation subjects to the read-only rules. If
-            # the expression does any write operation, the evaluation aborts
-            # and returns false.
-            #
-            # @param [Binding] binding The binding object from the context
-            # @param [String] condition A string of code to be evaluates
-            #
-            # @return [Boolean] True if condition expression read-only evaluates
-            #   to true. Otherwise false.
-            #
-            def eval_condition binding, condition
-              result = readonly_eval_expression_exec binding, condition
-
-              if result.is_a?(Exception) &&
-                 result.instance_variable_get(:@mutation_cause)
-                return false
-              end
-
-              result ? true : false
-            end
-
-            ##
-            # Evaluates the breakpoint expressions at the point that triggered
-            # the breakpoint. The expressions subject to the read-only rules.
-            # If the expressions do any write operations, the evaluations abort
-            # and show an error message in place of the real result.
-            #
-            # @param [Binding] binding The binding object from the context
-            # @param [Array<String>] expressions A list of code strings to be
-            #   evaluated
-            # @return [Array<Google::Cloud::Debugger::Breakpoint::Variable>]
-            #   A list of Breakpoint::Variables objects that represent the
-            #   expression evaluations results.
-            #
-            def eval_expressions binding, expressions
-              expressions.map do |expression|
-                eval_result = readonly_eval_expression binding, expression
-                evaluated_var = Variable.from_rb_var eval_result
-                evaluated_var.name = expression
-                evaluated_var
-              end
-            end
+          EXPRESSION_EVALUATION_TIME_THRESHOLD = 0.05
 
+          class << self
             ##
             # @private Read-only evaluates a single expression in a given
             # context binding. Handles any exceptions raised.
@@ -861,48 +786,16 @@ module Google
             #
             # @return [Object] The result Ruby object from evaluating the
             #   expression. If the expression is blocked from mutating
-            #   the state of program. An error message is returned instead.
+            #   the state of program. A
+            #   {Google::Cloud::Debugger::MutationError} will be returned.
             #
             def readonly_eval_expression binding, expression
-              begin
-                result = readonly_eval_expression_exec binding, expression
-              rescue => e
-                result = "Unable to evaluate expression: #{e.message}"
-              end
-
-              if result.is_a?(Exception) &&
-                 result.instance_variable_get(:@mutation_cause)
-                return "Error: #{result.message}"
-              end
-
-              result
-            end
-
-            ##
-            # Format log message by interpolate expressions.
-            #
-            # @example
-            #   Evaluator.format_log_message("Hello $0",
-            #                                ["World"]) #=> "Hello World"
-            #
-            # @param [String] message_format The message with with
-            #   expression placeholders such as `$0`, `$1`, etc.
-            # @param [Array<Google::Cloud::Debugger::Breakpoint::Variable>]
-            #   expressions An array of evaluated expression variables to be
-            #   placed into message_format's placeholders. The variables need
-            #   to have type equal String.
-            #
-            # @return [String] The formatted message string
-            #
-            def format_message message_format, expressions
-              # Substitute placeholders with expressions
-              message = message_format.gsub(/(?<!\$)\$\d+/) do |placeholder|
-                index = placeholder.match(/\$(\d+)/)[1].to_i
-                index < expressions.size ? expressions[index].inspect : ""
-              end
+              compilation_result = validate_compiled_expression expression
+              return compilation_result if compilation_result.is_a?(Exception)
 
-              # Unescape "$" charactors
-              message.gsub(/\$\$/, "$")
+              readonly_eval_expression_exec binding, expression
+            rescue => e
+              "Unable to evaluate expression: #{e.message}"
             end
 
             private
@@ -921,9 +814,6 @@ module Google
             #   if a mutation is caught.
             #
             def readonly_eval_expression_exec binding, expression
-              compilation_result = validate_compiled_expression expression
-              return compilation_result if compilation_result.is_a?(Exception)
-
               # The evaluation is most likely triggered from a trace callback,
               # where addtional nested tracing is disabled by VM. So we need to
               # do evaluation in a new thread, where function calls can be
@@ -932,17 +822,28 @@ module Google
                 begin
                   binding.eval wrap_expression(expression)
                 rescue => e
-                  # Threat all StandardError as mutation and set @mutation_cause
+                  # Treat all StandardError as mutation and set @mutation_cause
                   unless e.instance_variable_get :@mutation_cause
                     e.instance_variable_set(
                       :@mutation_cause,
-                      Google::Cloud::Debugger::MutationError::UNKNOWN_CAUSE)
+                      Google::Cloud::Debugger::EvaluationError::UNKNOWN_CAUSE)
                   end
+
                   e
                 end
               end
 
-              thr.join.value
+              thr.join EXPRESSION_EVALUATION_TIME_THRESHOLD
+
+              # Force terminate evaluation thread if not finished already and
+              # return an Exception
+              if thr.alive?
+                thr.kill
+
+                Google::Cloud::Debugger::EvaluationError.new LONG_EVAL_MSG
+              else
+                thr.value
+              end
             end
 
             ##
@@ -962,43 +863,21 @@ module Google
                   RubyVM::InstructionSequence.compile(expression).disasm
               rescue ScriptError
                 return Google::Cloud::Debugger::MutationError.new(
-                  "Unable to compile expression",
-                  Google::Cloud::Debugger::MutationError::PROHIBITED_YARV
+                  COMPILATION_FAIL_MSG,
+                  Google::Cloud::Debugger::EvaluationError::PROHIBITED_YARV
                 )
               end
 
               unless immutable_yarv_instructions? yarv_instructions
                 return Google::Cloud::Debugger::MutationError.new(
-                  "Mutation detected!",
-                  Google::Cloud::Debugger::MutationError::PROHIBITED_YARV
+                  MUTATION_DETECTED_MSG,
+                  Google::Cloud::Debugger::EvaluationError::PROHIBITED_YARV
                 )
               end
 
               yarv_instructions
             end
 
-            ##
-            # @private Helps evaluating local variables from a single frame
-            # binding
-            #
-            # @param [Binding] frame_binding The context binding object from
-            #   a given frame.
-            # @return [Array<Google::Cloud::Debugger::Variable>] A list of
-            #   Breakpoint::Variables that represent all the local variables
-            #   in a context frame.
-            #
-            def eval_frame_variables frame_binding
-              result_variables = []
-              result_variables +=
-                frame_binding.local_variables.map do |local_var_name|
-                  local_var = frame_binding.local_variable_get(local_var_name)
-
-                  Variable.from_rb_var(local_var, name: local_var_name)
-                end
-
-              result_variables
-            end
-
             ##
             # @private Helps checking if a given set of YARV instructions
             # contains any prohibited bytecode or instructions.
@@ -1061,8 +940,8 @@ module Google
               return if immutable_yarv_instructions?(yarv_instructions,
                                                      allow_localops: true)
               fail Google::Cloud::Debugger::MutationError.new(
-                "Mutation detected!",
-                Google::Cloud::Debugger::MutationError::PROHIBITED_YARV)
+                MUTATION_DETECTED_MSG,
+                Google::Cloud::Debugger::EvaluationError::PROHIBITED_YARV)
             end
 
             ##
@@ -1091,8 +970,8 @@ module Google
               Google::Cloud::Debugger::Breakpoint::Evaluator.send(
                 :disable_method_trace_for_thread)
               fail Google::Cloud::Debugger::MutationError.new(
-                "Invalid operation detected",
-                Google::Cloud::Debugger::MutationError::PROHIBITED_C_FUNC)
+                PROHIBITED_OPERATION_MSG,
+                Google::Cloud::Debugger::EvaluationError::PROHIBITED_C_FUNC)
             end
 
             ##
@@ -1116,23 +995,31 @@ module Google
       end
 
       ##
-      # @private Custom error type used to identify mutation during breakpoint
-      # expression evaluations
-      class MutationError < StandardError
+      # @private Custom error type used to identify evaluation error during
+      # breakpoint expression evaluation.
+      class EvaluationError < StandardError
         UNKNOWN_CAUSE = Object.new.freeze
         PROHIBITED_YARV = Object.new.freeze
         PROHIBITED_C_FUNC = Object.new.freeze
 
         attr_reader :mutation_cause
 
-        def initialize msg = "Mutation detected!",
-                       mutation_cause = UNKNOWN_CAUSE
+        def initialize msg = nil, mutation_cause = UNKNOWN_CAUSE
           @mutation_cause = mutation_cause
           super(msg)
         end
 
         def inspect
-          "#<MutationError: #{message}>"
+          "#<#{self.class}: #{message}>"
+        end
+      end
+
+      ##
+      # @private Custom error type used to identify mutation during breakpoint
+      # expression evaluations
+      class MutationError < EvaluationError
+        def initialize msg = "Mutation detected!", *args
+          super
         end
       end
     end

data/lib/google/cloud/debugger/breakpoint/status_message.rb

@@ -0,0 +1,95 @@
+# Copyright 2017 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.
+
+
+module Google
+  module Cloud
+    module Debugger
+      class Breakpoint
+        ##
+        # # StatusMessage
+        #
+        # Represents a contextual status message. The message can indicate an
+        # error or informational status, and refer to specific parts of the
+        # containing object. For example, the Breakpoint.status field can
+        # indicate an error referring to the BREAKPOINT_SOURCE_LOCATION with
+        # the message Location not found.
+        class StatusMessage
+          ##
+          # Constants used as references to which the message applies.
+          UNSPECIFIED = :UNSPECIFIED
+          BREAKPOINT_SOURCE_LOCATION = :BREAKPOINT_SOURCE_LOCATION
+          BREAKPOINT_CONDITION = :BREAKPOINT_CONDITION
+          BREAKPOINT_EXPRESSION = :BREAKPOINT_EXPRESSION
+          BREAKPOINT_AGE = :BREAKPOINT_AGE
+          VARIABLE_NAME = :VARIABLE_NAME
+          VARIABLE_VALUE = :VARIABLE_VALUE
+
+          ##
+          # Distinguishes errors from informational messages.
+          attr_accessor :is_error
+
+          ##
+          # Reference to which the message applies.
+          attr_accessor :refers_to
+
+          ##
+          # Status message text.
+          attr_accessor :description
+
+          ##
+          # New Google::Cloud::Debugger::Breakpoint::StatusMessage
+          # from a Google::Devtools::Clouddebugger::V2::StatusMessage object.
+          def self.from_grpc grpc
+            return nil if grpc.nil?
+            new.tap do |s|
+              s.is_error = grpc.is_error
+              s.refers_to = grpc.refers_to
+              s.description = grpc.description.format
+            end
+          end
+
+          ##
+          # @private Construct a new StatusMessage instance.
+          def initialize
+            @refers_to = UNSPECIFIED
+          end
+
+          ##
+          # @private Determines if the Variable has any data.
+          def empty?
+            is_error.nil? &&
+              refers_to.nil? &&
+              description.nil?
+          end
+
+          ##
+          # Exports the StatusMessage to a
+          # Google::Devtools::Clouddebugger::V2::StatusMessage object.
+          def to_grpc
+            return nil if empty?
+            description_grpc =
+              Google::Devtools::Clouddebugger::V2::FormatMessage.new \
+                format: description.to_s
+
+            Google::Devtools::Clouddebugger::V2::StatusMessage.new \
+              is_error: true,
+              refers_to: refers_to,
+              description: description_grpc
+          end
+        end
+      end
+    end
+  end
+end

data/lib/google/cloud/debugger/breakpoint/validator.rb

@@ -0,0 +1,91 @@
+# Copyright 2017 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.
+
+
+module Google
+  module Cloud
+    module Debugger
+      class Breakpoint
+        ##
+        # # Validator
+        #
+        # A collection of static methods to help validate a given breakpoint.
+        module Validator
+          FILE_NOT_FOUND_MSG = "File not found."
+          WRONG_FILE_TYPE_MSG = "File must be a `.rb` file."
+          INVALID_LINE_MSG = "Invalid line."
+
+          ##
+          # Validate a given breakpoint. Set breakpoint to error state if
+          # the breakpoint fails validation.
+          def self.validate breakpoint
+            error_msg = nil
+            if !verify_file_path breakpoint.full_path
+              error_msg = FILE_NOT_FOUND_MSG
+            elsif !verify_file_type breakpoint.full_path
+              error_msg = WRONG_FILE_TYPE_MSG
+            elsif !verify_line breakpoint.full_path, breakpoint.line
+              error_msg = INVALID_LINE_MSG
+            end
+
+            if error_msg
+              cause = Breakpoint::StatusMessage::BREAKPOINT_SOURCE_LOCATION
+              breakpoint.set_error_state error_msg, refers_to: cause
+              false
+            else
+              true
+            end
+          end
+
+          ##
+          # @private Verifies the given file path exists
+          def self.verify_file_path file_path
+            File.exist? file_path
+          rescue
+            false
+          end
+
+          ##
+          # @private Check the file from given file path is a ".rb" file
+          def self.verify_file_type file_path
+            File.extname(file_path) == ".rb"
+          rescue
+            false
+          end
+
+          ##
+          # @private Verifies the given line from a Ruby
+          def self.verify_line file_path, line
+            file = File.open file_path, "r"
+
+            # Skip through lines from beginning
+            file.gets while file.lineno < line - 1 && !file.eof?
+
+            line = file.gets
+
+            # Make sure we have a line (not eof)
+            return false unless line
+
+            blank_line = line =~ /^\s*$/
+            comment_line = line =~ /^\s*#.*$/
+
+            blank_line || comment_line ? false : true
+          rescue
+            false
+          end
+        end
+      end
+    end
+  end
+end