google-cloud-debugger 0.25.0 → 0.26.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 123026733717c135b469d6151982edc6b0cd8f24
-  data.tar.gz: 0ee45f3037ad8503a1b05dd08274e207e580d6dc
+  metadata.gz: 7a8f4cd45e74a4f18bf53c08fb05284529937c6b
+  data.tar.gz: '0718436023043859a8c9b958dc43bb623fb7ec79'
 SHA512:
-  metadata.gz: 555b2972eb3db4112e4cb51c2a0f72adfc1c058f9519ffa31fd8d367280db39e91a9be14c10a07b9fd7d3b73c1e37c29f81fee13e66ddd1e7b68311568ef328b
-  data.tar.gz: 7c7780ab4ffd74371586bb256cd4c22094af3b2b2d5a9bdebbbb36ff8c2c49c7abe97f5bf687448869409d8a07a4d312e61370f7b03d2ae07fdf905f9cbaf792
+  metadata.gz: 323fde821b65e2167e7ea0b56f2ff988203d62d5391032890be39636bec869750e4bf701a7756b50b59b7b9eb11c71819a8a0df3830574304b7b3d38e1cfa595
+  data.tar.gz: e68aa3d18c0aaf72db470b4dba4e1ecf439da21b43aeb081a552a49d8da093121795ffd32beec52fda075b68a90564cc70a88b579fca4008b1f2b6386032920c

data/ext/google/cloud/debugger/debugger_c/evaluator.c

@@ -26,12 +26,17 @@ eval_trace_callback(void *data, rb_trace_arg_t *trace_arg)
     VALUE klass = rb_tracearg_defined_class(trace_arg);
     VALUE obj = rb_tracearg_self(trace_arg);
     VALUE method_id = rb_tracearg_method_id(trace_arg);
+    ID trace_func_cb_id;
+    ID trace_c_func_cb_id;
+
+    CONST_ID(trace_func_cb_id, "trace_func_callback");
+    CONST_ID(trace_c_func_cb_id, "trace_c_func_callback");
 
     if (event & RUBY_EVENT_CALL) {
-        rb_funcall(evaluator, rb_intern("trace_func_callback"), 2, obj, method_id);
+        rb_funcall(evaluator, trace_func_cb_id, 2, obj, method_id);
     }
     if (event & RUBY_EVENT_C_CALL) {
-        rb_funcall(evaluator, rb_intern("trace_c_func_callback"), 3, obj, klass, method_id);
+        rb_funcall(evaluator, trace_c_func_cb_id, 3, obj, klass, method_id);
     }
 
     return;
@@ -40,13 +45,24 @@ eval_trace_callback(void *data, rb_trace_arg_t *trace_arg)
 static VALUE
 rb_disable_method_trace_for_thread(VALUE self)
 {
-    VALUE current_thread = rb_thread_current();
-    VALUE thread_variables_hash = rb_ivar_get(current_thread, rb_intern("locals"));
-    VALUE trace_set = rb_hash_aref(thread_variables_hash, rb_str_new2("gcloud_eval_trace_set"));
+    VALUE current_thread;
+    VALUE thread_variables_hash;
+    VALUE trace_set;
+    ID locals_id;
+    ID eval_trace_thread_id;
+    VALUE eval_trace_thread_flag;
+
+    CONST_ID(locals_id, "locals");
+    CONST_ID(eval_trace_thread_id, "gcloud_eval_trace_set");
+    eval_trace_thread_flag = ID2SYM(eval_trace_thread_id);
+
+    current_thread = rb_thread_current();
+    thread_variables_hash = rb_ivar_get(current_thread, locals_id);
+    trace_set = rb_hash_aref(thread_variables_hash, eval_trace_thread_flag);
 
     if (RTEST(trace_set)) {
         rb_thread_remove_event_hook(current_thread, (rb_event_hook_func_t)eval_trace_callback);
-        rb_hash_aset(thread_variables_hash, rb_str_new2("gcloud_eval_trace_set"), Qfalse);
+        rb_hash_aset(thread_variables_hash, eval_trace_thread_flag, Qfalse);
     }
 
     return Qnil;
@@ -55,13 +71,24 @@ rb_disable_method_trace_for_thread(VALUE self)
 static VALUE
 rb_enable_method_trace_for_thread(VALUE self)
 {
-    VALUE current_thread = rb_thread_current();
-    VALUE thread_variables_hash = rb_ivar_get(current_thread, rb_intern("locals"));
-    VALUE trace_set = rb_hash_aref(thread_variables_hash, rb_str_new2("gcloud_eval_trace_set"));
+    VALUE current_thread;
+    VALUE thread_variables_hash;
+    VALUE trace_set;
+    ID locals_id;
+    ID eval_trace_thread_id;
+    VALUE eval_trace_thread_flag;
+
+    CONST_ID(locals_id, "locals");
+    CONST_ID(eval_trace_thread_id, "gcloud_eval_trace_set");
+    eval_trace_thread_flag = ID2SYM(eval_trace_thread_id);
+
+    current_thread = rb_thread_current();
+    thread_variables_hash = rb_ivar_get(current_thread, locals_id);
+    trace_set = rb_hash_aref(thread_variables_hash, eval_trace_thread_flag);
 
     if (!RTEST(trace_set)) {
         rb_thread_add_event_hook2(current_thread, (rb_event_hook_func_t)eval_trace_callback, RUBY_EVENT_CALL | RUBY_EVENT_C_CALL, self, RUBY_EVENT_HOOK_FLAG_RAW_ARG | RUBY_EVENT_HOOK_FLAG_SAFE);
-        rb_hash_aset(thread_variables_hash, rb_str_new2("gcloud_eval_trace_set"), Qtrue);
+        rb_hash_aset(thread_variables_hash, eval_trace_thread_flag, Qtrue);
     }
 
     return Qnil;

data/ext/google/cloud/debugger/debugger_c/tracer.c

@@ -150,6 +150,12 @@ line_trace_callback(rb_event_flag_t event, VALUE data, VALUE obj, ID mid, VALUE
     VALUE matching_breakpoint;
     int matching_breakpoints_len;
 
+    ID callers_id;
+    ID breakpoint_hit_id;
+
+    CONST_ID(callers_id, "callers");
+    CONST_ID(breakpoint_hit_id, "breakpoint_hit");
+
     // If matching result isn't an array, it means we're in completely wrong file,
     // or not on the right line. Turn line tracing off if we're in wrong file.
     if (!RB_TYPE_P(matching_result, T_ARRAY)) {
@@ -162,13 +168,13 @@ line_trace_callback(rb_event_flag_t event, VALUE data, VALUE obj, ID mid, VALUE
     c_matching_breakpoints = RARRAY_PTR(matching_result);
     matching_breakpoints_len = RARRAY_LEN(matching_result);
     trace_binding = rb_binding_new();
-    call_stack_bindings = rb_funcall(trace_binding, rb_intern("callers"), 0);
+    call_stack_bindings = rb_funcall(trace_binding, callers_id, 0);
     rb_ary_pop(call_stack_bindings);
 
     // Evaluate each of the matching breakpoint
     for (i = 0; i < matching_breakpoints_len; i++) {
         matching_breakpoint = c_matching_breakpoints[i];
-        rb_funcall(self, rb_intern("eval_breakpoint"), 2, matching_breakpoint, call_stack_bindings);
+        rb_funcall(self, breakpoint_hit_id, 2, matching_breakpoint, call_stack_bindings);
     }
 
     return;
@@ -185,16 +191,23 @@ disable_line_trace_for_thread(VALUE thread)
 {
     VALUE thread_variables_hash;
     VALUE line_trace_set;
+    ID locals_id;
+    ID line_trace_thread_id;
+    VALUE line_trace_thread_flag;
+
+    CONST_ID(locals_id, "locals");
+    CONST_ID(line_trace_thread_id, "gcloud_line_trace_set");
+    line_trace_thread_flag = ID2SYM(line_trace_thread_id);
 
     if (!RTEST(thread)) {
         thread = rb_thread_current();
     }
-    thread_variables_hash = rb_ivar_get(thread, rb_intern("locals"));
-    line_trace_set = rb_hash_aref(thread_variables_hash, rb_str_new2("gcloud_line_trace_set"));
+    thread_variables_hash = rb_ivar_get(thread, locals_id);
+    line_trace_set = rb_hash_aref(thread_variables_hash, line_trace_thread_flag);
 
     if (RTEST(line_trace_set)) {
         rb_thread_remove_event_hook(thread, line_trace_callback);
-        rb_hash_aset(thread_variables_hash, rb_str_new2("gcloud_line_trace_set"), Qfalse);
+        rb_hash_aset(thread_variables_hash, line_trace_thread_flag, Qfalse);
     }
 
     return Qnil;
@@ -208,13 +221,24 @@ disable_line_trace_for_thread(VALUE thread)
 static VALUE
 enable_line_trace_for_thread(VALUE self)
 {
-    VALUE current_thread = rb_thread_current();
-    VALUE thread_variables_hash = rb_ivar_get(current_thread, rb_intern("locals"));
-    VALUE line_trace_set = rb_hash_aref(thread_variables_hash, rb_str_new2("gcloud_line_trace_set"));
+    VALUE current_thread;
+    VALUE thread_variables_hash;
+    VALUE line_trace_set;
+    ID locals_id;
+    ID line_trace_thread_id;
+    VALUE line_trace_thread_flag;
+
+    CONST_ID(locals_id, "locals");
+    CONST_ID(line_trace_thread_id, "gcloud_line_trace_set");
+    line_trace_thread_flag = ID2SYM(line_trace_thread_id);
+
+    current_thread = rb_thread_current();
+    thread_variables_hash = rb_ivar_get(current_thread, locals_id);
+    line_trace_set = rb_hash_aref(thread_variables_hash, line_trace_thread_flag);
 
     if (!RTEST(line_trace_set)) {
         rb_thread_add_event_hook(current_thread, line_trace_callback, RUBY_EVENT_LINE, self);
-        rb_hash_aset(thread_variables_hash, rb_str_new2("gcloud_line_trace_set"), Qtrue);
+        rb_hash_aset(thread_variables_hash, line_trace_thread_flag, Qtrue);
     }
 
     return Qnil;
@@ -236,18 +260,26 @@ return_trace_callback(void *data, rb_trace_arg_t *trace_arg)
 {
     VALUE match_found;
     VALUE self = (VALUE) data;
-    VALUE caller_locations = rb_funcall(rb_mKernel, rb_intern("caller_locations"), 2, INT2NUM(0), INT2NUM(1));
+    VALUE caller_locations;
     VALUE *c_caller_locations;
     VALUE caller_location;
     VALUE caller_path;
 
+    ID caller_locations_id;
+    ID absolute_path_id;
+
+    CONST_ID(caller_locations_id, "caller_locations");
+    CONST_ID(absolute_path_id, "absolute_path");
+
+    caller_locations = rb_funcall(rb_mKernel, caller_locations_id, 2, INT2NUM(0), INT2NUM(1));
+
     if(!RTEST(caller_locations)) {
         return;
     }
 
     c_caller_locations = RARRAY_PTR(caller_locations);
     caller_location = c_caller_locations[0];
-    caller_path = rb_funcall(caller_location, rb_intern("absolute_path"), 0);
+    caller_path = rb_funcall(caller_location, absolute_path_id, 0);
 
     if(!RTEST(caller_path)) {
         return;
@@ -273,16 +305,23 @@ disable_return_trace_for_thread(VALUE thread)
 {
     VALUE thread_variables_hash;
     VALUE return_trace_set;
+    ID locals_id;
+    ID return_trace_thread_id;
+    VALUE return_trace_thread_flag;
+
+    CONST_ID(locals_id, "locals");
+    CONST_ID(return_trace_thread_id, "gcloud_return_trace_set");
+    return_trace_thread_flag = ID2SYM(return_trace_thread_id);
 
     if (!RTEST(thread)) {
         thread = rb_thread_current();
     }
-    thread_variables_hash = rb_ivar_get(thread, rb_intern("locals"));
-    return_trace_set = rb_hash_aref(thread_variables_hash, rb_str_new2("gcloud_return_trace_set"));
+    thread_variables_hash = rb_ivar_get(thread, locals_id);
+    return_trace_set = rb_hash_aref(thread_variables_hash, return_trace_thread_flag);
 
     if (RTEST(return_trace_set)) {
         rb_thread_remove_event_hook(thread, (rb_event_hook_func_t)return_trace_callback);
-        rb_hash_aset(thread_variables_hash, rb_str_new2("gcloud_return_trace_set"), Qfalse);
+        rb_hash_aset(thread_variables_hash, return_trace_thread_flag, Qfalse);
     }
 
     return Qnil;
@@ -296,14 +335,26 @@ disable_return_trace_for_thread(VALUE thread)
 static VALUE
 enable_return_trace_for_thread(VALUE self)
 {
-    VALUE current_thread = rb_thread_current();
-    VALUE thread_variables_hash = rb_ivar_get(current_thread, rb_intern("locals"));
-    VALUE return_trace_set = rb_hash_aref(thread_variables_hash, rb_str_new2("gcloud_return_trace_set"));
+    VALUE current_thread;
+    VALUE thread_variables_hash;
+    VALUE return_trace_set;
+
+    ID locals_id;
+    ID return_trace_thread_id;
+    VALUE return_trace_thread_flag;
+
+    CONST_ID(locals_id, "locals");
+    CONST_ID(return_trace_thread_id, "gcloud_return_trace_set");
+    return_trace_thread_flag = ID2SYM(return_trace_thread_id);
+
+    current_thread = rb_thread_current();
+    thread_variables_hash = rb_ivar_get(current_thread, locals_id);
+    return_trace_set = rb_hash_aref(thread_variables_hash, return_trace_thread_flag);
 
     if (!RTEST(return_trace_set)) {
         int return_tracepoint_event = RUBY_EVENT_END | RUBY_EVENT_RETURN | RUBY_EVENT_C_RETURN | RUBY_EVENT_B_RETURN;
         rb_thread_add_event_hook2(current_thread, (rb_event_hook_func_t)return_trace_callback, return_tracepoint_event, self, RUBY_EVENT_HOOK_FLAG_RAW_ARG | RUBY_EVENT_HOOK_FLAG_SAFE);
-        rb_hash_aset(thread_variables_hash, rb_str_new2("gcloud_return_trace_set"), Qtrue);
+        rb_hash_aset(thread_variables_hash, return_trace_thread_flag, Qtrue);
     }
 
     return Qnil;
@@ -398,9 +449,14 @@ rb_disable_traces(VALUE self)
     int c_threads_len;
     VALUE thread;
     int i;
+    ID alive_q_id;
+    ID list_id;
+
+    CONST_ID(alive_q_id, "alive?");
+    CONST_ID(list_id, "list");
 
     file_tracepoint = rb_iv_get(self, "@file_tracepoint");
-    threads = rb_funcall(rb_cThread, rb_intern("list"), 0);
+    threads = rb_funcall(rb_cThread, list_id, 0);
     c_threads_len = RARRAY_LEN(threads);
     c_threads = RARRAY_PTR(threads);
     UNUSED(fiber_tracepoint);
@@ -416,7 +472,7 @@ rb_disable_traces(VALUE self)
 
     for (i = 0; i < c_threads_len; i++) {
         thread = c_threads[i];
-        if (RTEST(rb_funcall(thread, rb_intern("alive?"), 0))) {
+        if (RTEST(rb_funcall(thread, alive_q_id, 0))) {
             disable_line_trace_for_thread(thread);
             disable_return_trace_for_thread(thread);
         }

data/lib/google/cloud/debugger/agent.rb

@@ -13,12 +13,13 @@
 # limitations under the License.
 
 
-require "google/cloud/debugger/async_actor"
 require "google/cloud/debugger/breakpoint_manager"
 require "google/cloud/debugger/debuggee"
 require "google/cloud/debugger/debugger_c"
 require "google/cloud/debugger/tracer"
 require "google/cloud/debugger/transmitter"
+require "google/cloud/logging"
+require "stackdriver/core/async_actor"
 
 module Google
   module Cloud
@@ -46,9 +47,13 @@ module Google
       #   agent.start
       #
       class Agent
+        ##
+        # Name of the logpoints log file.
+        DEFAULT_LOG_NAME = "debugger_logpoints"
+
         ##
         # @private Debugger Agent is an asynchronous actor
-        include AsyncActor
+        include Stackdriver::Core::AsyncActor
 
         ##
         # @private The gRPC Service object.
@@ -81,6 +86,10 @@ module Google
         # @return [Google::Cloud::Debugger::Transmiter]
         attr_reader :transmitter
 
+        ##
+        # The logger used to write the results of Logpoints.
+        attr_accessor :logger
+
         ##
         # @private The last exception captured in the agent child thread
         attr_reader :last_exception
@@ -90,23 +99,30 @@ module Google
         #
         # @param [Google::Cloud::Debugger::Service] service The gRPC Service
         #   object
+        # @param [Google::Cloud::Logging::Logger] logger The logger used
+        #   to write the results of Logpoints.
         # @param [String] module_name Name for the debuggee application.
         #   Optional.
         # @param [String] module_version Version identifier for the debuggee
         #   application. Optional.
         #
-        def initialize service, module_name:, module_version:
+        def initialize service, logger: nil, module_name:, module_version:
           super()
 
           @service = service
           @debuggee = Debuggee.new service, module_name: module_name,
                                             module_version: module_version
           @tracer = Debugger::Tracer.new self
-          @breakpoint_manager = BreakpointManager.new service
+          @breakpoint_manager = BreakpointManager.new self, service
           @breakpoint_manager.on_breakpoints_change =
             method :breakpoints_change_callback
 
-          @transmitter = Transmitter.new service, self
+          @transmitter = Transmitter.new self, service
+
+          @logger = logger || default_logger
+
+          # Agent actor thread needs to force exit immediately.
+          set_cleanup_options timeout: 0
         end
 
         ##
@@ -126,7 +142,6 @@ module Google
         # Once Debugger Agent is stopped, it cannot be started again.
         #
         def stop
-          tracer.stop
           transmitter.stop
           async_stop
         end
@@ -154,6 +169,16 @@ module Google
           @last_exception = e
         end
 
+        ##
+        # @private Callback function when the async actor thread state changes
+        def on_async_state_change
+          if async_running?
+            tracer.start
+          else
+            tracer.stop
+          end
+        end
+
         private
 
         ##
@@ -184,19 +209,17 @@ module Google
         end
 
         ##
-        # @private Override AsyncActor#async_stop to immediately kill the child
-        # thread instead of waiting for it to return, because the breakpoints
-        # are queried with a hanging long poll mechanism.
-        def async_stop
-          @startup_lock.synchronize do
-            unless @thread.nil?
-              tracer.stop
-
-              @async_state = :stopped
-              @thread.kill
-              @thread.join
-            end
-          end
+        # @private Create a default logger
+        def default_logger
+          project_id = @service.project
+          credentials = @service.credentials
+          logging = Google::Cloud::Logging::Project.new(
+            Google::Cloud::Logging::Service.new(
+              project_id, credentials))
+          resource =
+            Google::Cloud::Logging::Middleware.build_monitored_resource
+
+          logging.logger DEFAULT_LOG_NAME, resource
         end
       end
     end

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

@@ -29,10 +29,26 @@ module Google
         # Breakpoint identifier, unique in the scope of the debuggee.
         attr_accessor :id
 
-        # TODO: Implement logpoint
-        # attr_accessor :action
-        # attr_accessor :log_message_format
-        # attr_accessor :log_level
+        ##
+        # Action to take when a breakpoint is hit. Either :CAPTURE or :LOG.
+        # @return [Symbol]
+        attr_accessor :action
+
+        ##
+        # Only relevant when action is LOG. Defines the message to log when the
+        # breakpoint hits. The message may include parameter placeholders $0,
+        # $1, etc. These placeholders are replaced with the evaluated value of
+        # the appropriate expression. Expressions not referenced in
+        # logMessageFormat are not logged.
+        attr_accessor :log_message_format
+
+        ##
+        # Indicates the severity of the log. Only relevant when action is LOG.
+        attr_accessor :log_level
+
+        ##
+        # The evaluated log message when action is LOG.
+        attr_accessor :evaluated_log_message
 
         ##
         # Breakpoint source location.
@@ -128,7 +144,7 @@ module Google
           super()
 
           @id = id
-          # @action = :capture
+          @action = :CAPTURE
           @location = SourceLocation.new.tap do |sl|
             sl.path = path
             sl.line = line.to_i
@@ -144,19 +160,23 @@ module Google
         # from a Google::Devtools::Clouddebugger::V2::Breakpoint object.
         def self.from_grpc grpc
           return new if grpc.nil?
-          new(grpc.id).tap do |b|
-            b.location = Breakpoint::SourceLocation.from_grpc grpc.location
+          new.tap do |b|
+            b.id = grpc.id
+            b.action = grpc.action
             b.condition = grpc.condition
-            b.is_final_state = grpc.is_final_state
-            b.expressions = grpc.expressions.to_a
+            b.create_time = timestamp_from_grpc grpc.create_time
             b.evaluated_expressions =
               Breakpoint::Variable.from_grpc_list grpc.evaluated_expressions
-            b.create_time = timestamp_from_grpc grpc.create_time
+            b.expressions = grpc.expressions.to_a
             b.final_time = timestamp_from_grpc grpc.final_time
-            b.user_email = grpc.user_email
-            b.status = grpc.status
             b.labels = hashify_labels grpc.labels
+            b.log_message_format = grpc.log_message_format
+            b.log_level = grpc.log_level
+            b.location = Breakpoint::SourceLocation.from_grpc grpc.location
+            b.is_final_state = grpc.is_final_state
+            b.status = grpc.status
             b.stack_frames = stack_frames_from_grpc grpc
+            b.user_email = grpc.user_email
           end
         end
 
@@ -243,9 +263,11 @@ module Google
         end
 
         ##
-        # Evaluate the breakpoint unless it's already marked as completed. Use
-        # "@stack_frames" and "@evaluated_expressions" instance variables to
-        # store the result snapshot. Set breakpoint to complete when done.
+        # Evaluate the breakpoint unless it's already marked as completed.
+        # Store evaluted results in @evaluated_expressions, @stack_frames, and
+        # @evaluated_log_message, depends on the action of breakpoint. Mark
+        # breakpoint complete if successfully evaluated a breakpoint with
+        # :CAPTURE action.
         #
         # @param [Array<Binding>] call_stack_bindings An array of Ruby Binding
         #   objects, from the call stack that leads to the triggering of the
@@ -253,28 +275,13 @@ module Google
         #
         # @return [Boolean] True if evaluated successfully; false otherwise.
         #
-        def eval_call_stack call_stack_bindings
-          synchronize do
-            return false if complete?
-
-            top_frame_binding = call_stack_bindings[0]
-
-            # Abort evaluation if breakpoint condition isn't met
-            return false unless check_condition top_frame_binding
-
-            begin
-              @stack_frames = Evaluator.eval_call_stack call_stack_bindings
-              unless expressions.empty?
-                @evaluated_expressions =
-                  Evaluator.eval_expressions top_frame_binding, @expressions
-              end
-            rescue
-              return false
-            end
-
-            complete
+        def evaluate call_stack_bindings
+          case action
+          when :CAPTURE
+            evaluate_snapshot_point call_stack_bindings
+          when :LOG
+            evaluate_logpoint call_stack_bindings[0]
           end
-          true
         end
 
         ##
@@ -342,6 +349,55 @@ module Google
 
         private
 
+        ##
+        # @private Evaluate snapshot point
+        def evaluate_snapshot_point call_stack_bindings
+          synchronize do
+            top_binding = call_stack_bindings[0]
+
+            return false if complete? || !check_condition(top_binding)
+
+            begin
+              unless expressions.empty?
+                @evaluated_expressions =
+                  Evaluator.eval_expressions top_binding, @expressions
+              end
+
+              @stack_frames = Evaluator.eval_call_stack call_stack_bindings
+
+              complete
+            rescue
+              return false
+            end
+          end
+
+          true
+        end
+
+        ##
+        # @private Evaluate logpoint
+        def evaluate_logpoint binding
+          synchronize do
+            return false if complete? || !check_condition(binding)
+
+            begin
+              unless expressions.empty?
+                @evaluated_expressions = expressions.map do |expression|
+                  Evaluator.readonly_eval_expression binding, expression
+                end
+              end
+              @evaluated_log_message =
+                Evaluator.format_message log_message_format,
+                                         evaluated_expressions
+            rescue
+              return false
+            end
+          end
+
+          true
+        end
+
+
         ##
         # @private Formats the labels so they can be saved to a
         # Google::Devtools::Clouddebugger::V2::Breakpoint object.