mirror of
https://github.com/dart-lang/sdk
synced 2024-10-14 23:49:45 +00:00
7920d53b89
TEST=local build Change-Id: I9aa9830134d922465d7aa1194edc29bc857f97b1 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/321747 Reviewed-by: Derek Xu <derekx@google.com> Commit-Queue: Ryan Macnak <rmacnak@google.com>
344 lines
11 KiB
C++
344 lines
11 KiB
C++
// Copyright (c) 2015, 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/service_event.h"
|
|
|
|
#include "vm/debugger.h"
|
|
#include "vm/message_handler.h"
|
|
#include "vm/service_isolate.h"
|
|
#include "vm/timeline.h"
|
|
|
|
namespace dart {
|
|
|
|
#ifndef PRODUCT
|
|
|
|
ServiceEvent::ServiceEvent(EventKind event_kind)
|
|
: ServiceEvent(nullptr, nullptr, event_kind) {}
|
|
|
|
ServiceEvent::ServiceEvent(IsolateGroup* isolate_group, EventKind event_kind)
|
|
: ServiceEvent(isolate_group, nullptr, event_kind) {}
|
|
|
|
ServiceEvent::ServiceEvent(Isolate* isolate, EventKind event_kind)
|
|
: ServiceEvent(isolate != nullptr ? isolate->group() : nullptr,
|
|
isolate,
|
|
event_kind) {}
|
|
|
|
ServiceEvent::ServiceEvent(IsolateGroup* isolate_group,
|
|
Isolate* isolate,
|
|
EventKind event_kind)
|
|
: isolate_(isolate),
|
|
isolate_group_(isolate_group),
|
|
kind_(event_kind),
|
|
flag_name_(nullptr),
|
|
flag_new_value_(nullptr),
|
|
previous_tag_(nullptr),
|
|
updated_tag_(nullptr),
|
|
embedder_kind_(nullptr),
|
|
embedder_stream_id_(nullptr),
|
|
breakpoint_(nullptr),
|
|
top_frame_(nullptr),
|
|
timeline_event_block_(nullptr),
|
|
extension_rpc_(nullptr),
|
|
exception_(nullptr),
|
|
reload_error_(nullptr),
|
|
spawn_token_(nullptr),
|
|
spawn_error_(nullptr),
|
|
at_async_jump_(false),
|
|
inspectee_(nullptr),
|
|
gc_stats_(nullptr),
|
|
bytes_(nullptr),
|
|
bytes_length_(0),
|
|
timestamp_(OS::GetCurrentTimeMillis()) {
|
|
// We should never generate events for the vm isolate as it is never reported
|
|
// over the service.
|
|
ASSERT(isolate_ != Dart::vm_isolate());
|
|
|
|
// VM internal isolates should never post service events. However, the Isolate
|
|
// service object uses a service event to represent the current running state
|
|
// of the isolate, so we need to allow for system isolates to create resume
|
|
// and none events for this purpose. The resume event represents a running
|
|
// isolate and the none event is returned for an isolate that has not yet
|
|
// been marked as runnable (see "pauseEvent" in Isolate::PrintJSON).
|
|
ASSERT(isolate == nullptr || !Isolate::IsVMInternalIsolate(isolate) ||
|
|
(Isolate::IsVMInternalIsolate(isolate) &&
|
|
(event_kind == ServiceEvent::kResume ||
|
|
event_kind == ServiceEvent::kNone ||
|
|
// VM service can print Observatory information to Stdout or Stderr
|
|
// which are embedder streams.
|
|
event_kind == ServiceEvent::kEmbedder ||
|
|
event_kind == ServiceEvent::kCpuSamples)));
|
|
|
|
if ((event_kind == ServiceEvent::kPauseStart) ||
|
|
(event_kind == ServiceEvent::kPauseExit)) {
|
|
timestamp_ = isolate_->message_handler()->paused_timestamp();
|
|
} else if (event_kind == ServiceEvent::kResume) {
|
|
timestamp_ = isolate_->last_resume_timestamp();
|
|
}
|
|
ASSERT(timestamp_ > -1);
|
|
}
|
|
|
|
void ServiceEvent::UpdateTimestamp() {
|
|
timestamp_ = OS::GetCurrentTimeMillis();
|
|
}
|
|
|
|
const char* ServiceEvent::KindAsCString() const {
|
|
switch (kind()) {
|
|
case kVMUpdate:
|
|
return "VMUpdate";
|
|
case kVMFlagUpdate:
|
|
return "VMFlagUpdate";
|
|
case kIsolateStart:
|
|
return "IsolateStart";
|
|
case kIsolateRunnable:
|
|
return "IsolateRunnable";
|
|
case kIsolateExit:
|
|
return "IsolateExit";
|
|
case kIsolateUpdate:
|
|
return "IsolateUpdate";
|
|
case kServiceExtensionAdded:
|
|
return "ServiceExtensionAdded";
|
|
case kIsolateReload:
|
|
return "IsolateReload";
|
|
case kPauseStart:
|
|
return "PauseStart";
|
|
case kPauseExit:
|
|
return "PauseExit";
|
|
case kPauseBreakpoint:
|
|
return "PauseBreakpoint";
|
|
case kPauseInterrupted:
|
|
return "PauseInterrupted";
|
|
case kPauseException:
|
|
return "PauseException";
|
|
case kPausePostRequest:
|
|
return "PausePostRequest";
|
|
case kNone:
|
|
return "None";
|
|
case kResume:
|
|
return "Resume";
|
|
case kBreakpointAdded:
|
|
return "BreakpointAdded";
|
|
case kBreakpointResolved:
|
|
return "BreakpointResolved";
|
|
case kBreakpointRemoved:
|
|
return "BreakpointRemoved";
|
|
case kBreakpointUpdated:
|
|
return "BreakpointUpdated";
|
|
case kGC:
|
|
return "GC"; // TODO(koda): Change to GarbageCollected.
|
|
case kInspect:
|
|
return "Inspect";
|
|
case kEmbedder:
|
|
return embedder_kind();
|
|
case kLogging:
|
|
return "Logging";
|
|
case kDebuggerSettingsUpdate:
|
|
return "_DebuggerSettingsUpdate";
|
|
case kIllegal:
|
|
return "Illegal";
|
|
case kExtension:
|
|
return "Extension";
|
|
case kTimelineEvents:
|
|
return "TimelineEvents";
|
|
case kTimelineStreamSubscriptionsUpdate:
|
|
return "TimelineStreamSubscriptionsUpdate";
|
|
case kUserTagChanged:
|
|
return "UserTagChanged";
|
|
case kCpuSamples:
|
|
return "CpuSamples";
|
|
default:
|
|
UNREACHABLE();
|
|
return "Unknown";
|
|
}
|
|
}
|
|
|
|
const StreamInfo* ServiceEvent::stream_info() const {
|
|
switch (kind()) {
|
|
case kVMUpdate:
|
|
case kVMFlagUpdate:
|
|
return &Service::vm_stream;
|
|
|
|
case kIsolateStart:
|
|
case kIsolateRunnable:
|
|
case kIsolateExit:
|
|
case kIsolateUpdate:
|
|
case kIsolateReload:
|
|
case kServiceExtensionAdded:
|
|
return &Service::isolate_stream;
|
|
|
|
case kPauseStart:
|
|
case kPauseExit:
|
|
case kPauseBreakpoint:
|
|
case kPauseInterrupted:
|
|
case kPauseException:
|
|
case kPausePostRequest:
|
|
case kNone:
|
|
case kResume:
|
|
case kBreakpointAdded:
|
|
case kBreakpointResolved:
|
|
case kBreakpointRemoved:
|
|
case kBreakpointUpdated:
|
|
case kInspect:
|
|
case kDebuggerSettingsUpdate:
|
|
return &Service::debug_stream;
|
|
|
|
case kGC:
|
|
return &Service::gc_stream;
|
|
|
|
case kLogging:
|
|
return &Service::logging_stream;
|
|
|
|
case kExtension:
|
|
return &Service::extension_stream;
|
|
|
|
case kTimelineEvents:
|
|
case kTimelineStreamSubscriptionsUpdate:
|
|
return &Service::timeline_stream;
|
|
|
|
case kEmbedder:
|
|
return nullptr;
|
|
|
|
case kCpuSamples:
|
|
case kUserTagChanged:
|
|
return &Service::profiler_stream;
|
|
|
|
default:
|
|
UNREACHABLE();
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
const char* ServiceEvent::stream_id() const {
|
|
const StreamInfo* stream = stream_info();
|
|
if (stream == nullptr) {
|
|
ASSERT(kind() == kEmbedder);
|
|
return embedder_stream_id_;
|
|
} else {
|
|
return stream->id();
|
|
}
|
|
}
|
|
|
|
void ServiceEvent::PrintJSON(JSONStream* js) const {
|
|
JSONObject jsobj(js);
|
|
PrintJSONHeader(&jsobj);
|
|
if (kind() == kVMFlagUpdate) {
|
|
jsobj.AddProperty("flag", flag_name());
|
|
// For backwards compatibility, "new_value" is also provided.
|
|
jsobj.AddProperty("newValue", flag_new_value());
|
|
}
|
|
if (kind() == kUserTagChanged) {
|
|
jsobj.AddProperty("previousTag", previous_tag());
|
|
jsobj.AddProperty("updatedTag", updated_tag());
|
|
}
|
|
if (kind() == kIsolateReload) {
|
|
if (reload_error_ == nullptr) {
|
|
jsobj.AddProperty("status", "success");
|
|
} else {
|
|
jsobj.AddProperty("status", "failure");
|
|
jsobj.AddProperty("reloadError", *(reload_error()));
|
|
}
|
|
}
|
|
if (kind() == kServiceExtensionAdded) {
|
|
ASSERT(extension_rpc_ != nullptr);
|
|
jsobj.AddProperty("extensionRPC", extension_rpc_->ToCString());
|
|
}
|
|
if (kind() == kPauseBreakpoint) {
|
|
JSONArray jsarr(&jsobj, "pauseBreakpoints");
|
|
// TODO(rmacnak): If we are paused at more than one breakpoint,
|
|
// provide it here.
|
|
if (breakpoint() != nullptr) {
|
|
jsarr.AddValue(breakpoint());
|
|
}
|
|
} else {
|
|
if (breakpoint() != nullptr) {
|
|
jsobj.AddProperty("breakpoint", breakpoint());
|
|
}
|
|
}
|
|
if (kind() == kTimelineEvents) {
|
|
jsobj.AddProperty("timelineEvents", timeline_event_block_);
|
|
}
|
|
if (kind() == kTimelineStreamSubscriptionsUpdate) {
|
|
JSONArray arr(&jsobj, "updatedStreams");
|
|
Timeline::PrintFlagsToJSONArray(&arr);
|
|
}
|
|
if (kind() == kDebuggerSettingsUpdate) {
|
|
JSONObject jssettings(&jsobj, "_debuggerSettings");
|
|
isolate()->debugger()->PrintSettingsToJSONObject(&jssettings);
|
|
}
|
|
#if !defined(DART_PRECOMPILED_RUNTIME)
|
|
if (top_frame() != nullptr) {
|
|
JSONObject jsFrame(&jsobj, "topFrame");
|
|
top_frame()->PrintToJSONObject(&jsFrame);
|
|
intptr_t index = 0; // Avoid ambiguity in call to AddProperty.
|
|
jsFrame.AddProperty("index", index);
|
|
}
|
|
#endif
|
|
if (exception() != nullptr) {
|
|
jsobj.AddProperty("exception", *(exception()));
|
|
}
|
|
if (at_async_jump()) {
|
|
jsobj.AddProperty("atAsyncSuspension", true);
|
|
}
|
|
if (inspectee() != nullptr) {
|
|
jsobj.AddProperty("inspectee", *(inspectee()));
|
|
}
|
|
if (gc_stats() != nullptr) {
|
|
jsobj.AddProperty("reason", Heap::GCReasonToString(gc_stats()->reason_));
|
|
jsobj.AddProperty("gcType", Heap::GCTypeToString(gc_stats()->type_));
|
|
isolate_group()->heap()->PrintToJSONObject(Heap::kNew, &jsobj);
|
|
isolate_group()->heap()->PrintToJSONObject(Heap::kOld, &jsobj);
|
|
}
|
|
if (bytes() != nullptr) {
|
|
jsobj.AddPropertyBase64("bytes", bytes(), bytes_length());
|
|
}
|
|
if (kind() == kLogging) {
|
|
JSONObject logRecord(&jsobj, "logRecord");
|
|
logRecord.AddProperty("type", "LogRecord");
|
|
logRecord.AddProperty64("sequenceNumber", log_record_.sequence_number);
|
|
logRecord.AddPropertyTimeMillis("time", log_record_.timestamp);
|
|
logRecord.AddProperty64("level", log_record_.level);
|
|
logRecord.AddProperty("loggerName", *(log_record_.name));
|
|
logRecord.AddProperty("message", *(log_record_.message));
|
|
logRecord.AddProperty("zone", *(log_record_.zone));
|
|
logRecord.AddProperty("error", *(log_record_.error));
|
|
logRecord.AddProperty("stackTrace", *(log_record_.stack_trace));
|
|
}
|
|
if (kind() == kExtension) {
|
|
js->AppendSerializedObject("extensionData",
|
|
extension_event_.event_data->ToCString());
|
|
}
|
|
|
|
if (kind() == kCpuSamples) {
|
|
JSONObject cpu_profile(&jsobj, "cpuSamples");
|
|
cpu_profile_->PrintProfileJSON(&cpu_profile, /*include_code_samples=*/false,
|
|
/*is_event=*/true);
|
|
}
|
|
}
|
|
|
|
void ServiceEvent::PrintJSONHeader(JSONObject* jsobj) const {
|
|
ASSERT(jsobj != nullptr);
|
|
jsobj->AddProperty("type", "Event");
|
|
jsobj->AddProperty("kind", KindAsCString());
|
|
if (kind() == kExtension) {
|
|
ASSERT(extension_event_.event_kind != nullptr);
|
|
jsobj->AddProperty("extensionKind",
|
|
extension_event_.event_kind->ToCString());
|
|
}
|
|
if (isolate_group() != nullptr) {
|
|
jsobj->AddProperty("isolateGroup", isolate_group());
|
|
}
|
|
if (isolate() != nullptr) {
|
|
ASSERT(isolate_group() != nullptr);
|
|
jsobj->AddProperty("isolate", isolate());
|
|
}
|
|
if (isolate_group() == nullptr && isolate() == nullptr) {
|
|
jsobj->AddPropertyVM("vm");
|
|
}
|
|
ASSERT(timestamp_ != -1);
|
|
jsobj->AddPropertyTimeMillis("timestamp", timestamp_);
|
|
}
|
|
|
|
#endif // !PRODUCT
|
|
|
|
} // namespace dart
|