Per isolate Log with block support

runtime/vm/isolate.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/isolate.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
 #include "vm/code_observers.h"
 #include "vm/compiler_stats.h"
 #include "vm/coverage.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/deopt_instructions.h"
 #include "vm/heap.h"
 #include "vm/lockers.h"
+#include "vm/log.h"
 #include "vm/message_handler.h"
 #include "vm/object_id_ring.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/port.h"
 #include "vm/profiler.h"
 #include "vm/reusable_handles.h"
 #include "vm/service.h"
 #include "vm/simulator.h"
 #include "vm/stack_frame.h"
@@ skipping 10 matching lines @@
 
 DEFINE_FLAG(bool, trace_isolates, false,
             "Trace isolate creation and shut down.");
 DEFINE_FLAG(bool, pause_isolates_on_start, false,
             "Pause isolates before starting.");
 DEFINE_FLAG(bool, pause_isolates_on_exit, false,
             "Pause isolates exiting.");
 DEFINE_FLAG(bool, break_at_isolate_spawn, false,
             "Insert a one-time breakpoint at the entrypoint for all spawned "
             "isolates");
-
+DEFINE_FLAG(charp, isolate_log_filter, NULL,
+            "Log isolates whose name include the filter. "
+            "Default: service isolate log messages are suppressed.");
 
 // Quick access to the locally defined isolate() method.
 #define I (isolate())
 
 
 #if defined(DEBUG)
 // Helper class to ensure that a live origin_id is never reused
 // and assigned to an isolate.
 class VerifyOriginId : public IsolateVisitor {
  public:
@@ skipping 408 matching lines @@
       stack_base_(0),
       stack_overflow_flags_(0),
       stack_overflow_count_(0),
       message_handler_(NULL),
       spawn_state_(NULL),
       is_runnable_(false),
       gc_prologue_callback_(NULL),
       gc_epilogue_callback_(NULL),
       defer_finalization_count_(0),
       deopt_context_(NULL),
+      is_service_isolate_(false),
+      log_(new class Log()),
       stacktrace_(NULL),
       stack_frame_index_(-1),
       last_allocationprofile_accumulator_reset_timestamp_(0),
       last_allocationprofile_gc_timestamp_(0),
       cha_(NULL),
       object_id_ring_(NULL),
       trace_buffer_(NULL),
       profiler_data_(NULL),
       thread_state_(NULL),
       tag_table_(GrowableObjectArray::null()),
@@ skipping 39 matching lines @@
       saved_stack_limit_(0),
       stack_overflow_flags_(0),
       stack_overflow_count_(0),
       message_handler_(NULL),
       spawn_state_(NULL),
       is_runnable_(false),
       gc_prologue_callback_(NULL),
       gc_epilogue_callback_(NULL),
       defer_finalization_count_(0),
       deopt_context_(NULL),
+      is_service_isolate_(false),
+      log_(new class Log()),
       stacktrace_(NULL),
       stack_frame_index_(-1),
       last_allocationprofile_accumulator_reset_timestamp_(0),
       last_allocationprofile_gc_timestamp_(0),
       cha_(NULL),
       object_id_ring_(NULL),
       trace_buffer_(NULL),
       profiler_data_(NULL),
       thread_state_(NULL),
       tag_table_(GrowableObjectArray::null()),
@@ skipping 17 matching lines @@
   delete debugger_;
 #if defined(USING_SIMULATOR)
   delete simulator_;
 #endif
   delete mutex_;
   mutex_ = NULL;  // Fail fast if interrupts are scheduled on a dead isolate.
   delete message_handler_;
   message_handler_ = NULL;  // Fail fast if we send messages to a dead isolate.
   ASSERT(deopt_context_ == NULL);  // No deopt in progress when isolate deleted.
   delete spawn_state_;
+  delete log_;
+  log_ = NULL;
 }
 
 
 void Isolate::SetCurrent(Isolate* current) {
   Isolate* old_current = Current();
   if (old_current != NULL) {
     old_current->set_vm_tag(VMTag::kIdleTagId);
     old_current->set_thread_state(NULL);
     Profiler::EndExecution(old_current);
   }
@@ skipping 104 matching lines @@
     name_ = strdup(name_prefix);
     return;
   }
   const char* kFormat = "%s-%lld";
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, name_prefix, main_port()) + 1;
   name_ = reinterpret_cast<char*>(malloc(len));
   OS::SNPrint(name_, len, kFormat, name_prefix, main_port());
 }
 
 
+Log* Isolate::Log() const {
+  if (FLAG_isolate_log_filter == NULL) {
+    if (is_service_isolate_) {
+      // By default, do not log for the service isolate.
+      return Log::NoOpLog();
+    }
+    return log_;
+  }
+  ASSERT(name_ != NULL);
+  if (strstr(name_, FLAG_isolate_log_filter) == NULL) {
+    // Filter does not match, do not log for this isolate.
+    return Log::NoOpLog();
+  }
+  return log_;
+}
+
+
 // TODO(5411455): Use flag to override default value and Validate the
 // stack size by querying OS.
 uword Isolate::GetSpecifiedStackSize() {
   ASSERT(Isolate::kStackSizeBuffer < OSThread::GetMaxStackSize());
   uword stack_size = OSThread::GetMaxStackSize() - Isolate::kStackSizeBuffer;
   return stack_size;
 }
 
 
 void Isolate::SetStackLimitFromStackBase(uword stack_base) {
@@ skipping 940 matching lines @@
                            serialized_message_, serialized_message_len_);
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart