| //===-- DarwinLogCollector.cpp ----------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "DarwinLogCollector.h" |
| #include "ActivityStreamSPI.h" |
| |
| #include <dlfcn.h> |
| |
| #include <cinttypes> |
| #include <mutex> |
| #include <vector> |
| |
| #include "DNB.h" |
| #include "DNBLog.h" |
| #include "DarwinLogTypes.h" |
| #include "LogFilterChain.h" |
| #include "LogFilterExactMatch.h" |
| #include "LogFilterRegex.h" |
| #include "LogMessageOsLog.h" |
| #include "MachProcess.h" |
| #include "RNBContext.h" |
| #include "RNBDefs.h" |
| #include "RNBRemote.h" |
| |
| // Use an anonymous namespace for variables and methods that have no |
| // reason to leak out through the interface. |
| namespace { |
| /// Specify max depth that the activity parent-child chain will search |
| /// back to get the full activity chain name. If we do more than this, |
| /// we assume either we hit a loop or it's just too long. |
| static const size_t MAX_ACTIVITY_CHAIN_DEPTH = 10; |
| |
| // Used to tap into and retrieve logs from target process. |
| // (Consumer of os_log). |
| static os_activity_stream_for_pid_t s_os_activity_stream_for_pid; |
| static os_activity_stream_resume_t s_os_activity_stream_resume; |
| static os_activity_stream_cancel_t s_os_activity_stream_cancel; |
| static os_log_copy_formatted_message_t s_os_log_copy_formatted_message; |
| static os_activity_stream_set_event_handler_t |
| s_os_activity_stream_set_event_handler; |
| |
| bool LookupSPICalls() { |
| static std::once_flag s_once_flag; |
| static bool s_has_spi; |
| |
| std::call_once(s_once_flag, [] { |
| dlopen ("/System/Library/PrivateFrameworks/LoggingSupport.framework/LoggingSupport", RTLD_NOW); |
| s_os_activity_stream_for_pid = (os_activity_stream_for_pid_t)dlsym( |
| RTLD_DEFAULT, "os_activity_stream_for_pid"); |
| s_os_activity_stream_resume = (os_activity_stream_resume_t)dlsym( |
| RTLD_DEFAULT, "os_activity_stream_resume"); |
| s_os_activity_stream_cancel = (os_activity_stream_cancel_t)dlsym( |
| RTLD_DEFAULT, "os_activity_stream_cancel"); |
| s_os_log_copy_formatted_message = (os_log_copy_formatted_message_t)dlsym( |
| RTLD_DEFAULT, "os_log_copy_formatted_message"); |
| s_os_activity_stream_set_event_handler = |
| (os_activity_stream_set_event_handler_t)dlsym( |
| RTLD_DEFAULT, "os_activity_stream_set_event_handler"); |
| |
| // We'll indicate we're all set if every function entry point |
| // was found. |
| s_has_spi = (s_os_activity_stream_for_pid != nullptr) && |
| (s_os_activity_stream_resume != nullptr) && |
| (s_os_activity_stream_cancel != nullptr) && |
| (s_os_log_copy_formatted_message != nullptr) && |
| (s_os_activity_stream_set_event_handler != nullptr); |
| if (s_has_spi) { |
| DNBLogThreadedIf(LOG_DARWIN_LOG, "Found os_log SPI calls."); |
| // Tell LogMessageOsLog how to format messages when search |
| // criteria requires it. |
| LogMessageOsLog::SetFormatterFunction(s_os_log_copy_formatted_message); |
| } else { |
| DNBLogThreadedIf(LOG_DARWIN_LOG, "Failed to find os_log SPI " |
| "calls."); |
| } |
| }); |
| |
| return s_has_spi; |
| } |
| |
| using Mutex = std::mutex; |
| static Mutex s_collector_mutex; |
| static std::vector<DarwinLogCollectorSP> s_collectors; |
| |
| static void TrackCollector(const DarwinLogCollectorSP &collector_sp) { |
| std::lock_guard<Mutex> locker(s_collector_mutex); |
| if (std::find(s_collectors.begin(), s_collectors.end(), collector_sp) != |
| s_collectors.end()) { |
| DNBLogThreadedIf(LOG_DARWIN_LOG, |
| "attempted to add same collector multiple times"); |
| return; |
| } |
| s_collectors.push_back(collector_sp); |
| } |
| |
| static void StopTrackingCollector(const DarwinLogCollectorSP &collector_sp) { |
| std::lock_guard<Mutex> locker(s_collector_mutex); |
| s_collectors.erase( |
| std::remove(s_collectors.begin(), s_collectors.end(), collector_sp), |
| s_collectors.end()); |
| } |
| |
| static DarwinLogCollectorSP FindCollectorForProcess(pid_t pid) { |
| std::lock_guard<Mutex> locker(s_collector_mutex); |
| for (const auto &collector_sp : s_collectors) { |
| if (collector_sp && (collector_sp->GetProcessID() == pid)) |
| return collector_sp; |
| } |
| return DarwinLogCollectorSP(); |
| } |
| |
| static FilterTarget TargetStringToEnum(const std::string &filter_target_name) { |
| if (filter_target_name == "activity") |
| return eFilterTargetActivity; |
| else if (filter_target_name == "activity-chain") |
| return eFilterTargetActivityChain; |
| else if (filter_target_name == "category") |
| return eFilterTargetCategory; |
| else if (filter_target_name == "message") |
| return eFilterTargetMessage; |
| else if (filter_target_name == "subsystem") |
| return eFilterTargetSubsystem; |
| else |
| return eFilterTargetInvalid; |
| } |
| |
| class Configuration { |
| public: |
| Configuration(const JSONObject &config) |
| : m_is_valid(false), |
| m_activity_stream_flags(OS_ACTIVITY_STREAM_PROCESS_ONLY), |
| m_filter_chain_sp(nullptr) { |
| // Parse out activity stream flags |
| if (!ParseSourceFlags(config)) { |
| m_is_valid = false; |
| return; |
| } |
| |
| // Parse filter rules |
| if (!ParseFilterRules(config)) { |
| m_is_valid = false; |
| return; |
| } |
| |
| // Everything worked. |
| m_is_valid = true; |
| } |
| |
| bool ParseSourceFlags(const JSONObject &config) { |
| // Get the source-flags dictionary. |
| auto source_flags_sp = config.GetObject("source-flags"); |
| if (!source_flags_sp) |
| return false; |
| if (!JSONObject::classof(source_flags_sp.get())) |
| return false; |
| |
| const JSONObject &source_flags = |
| *static_cast<JSONObject *>(source_flags_sp.get()); |
| |
| // Parse out the flags. |
| bool include_any_process = false; |
| bool include_callstacks = false; |
| bool include_info_level = false; |
| bool include_debug_level = false; |
| bool live_stream = false; |
| |
| if (!source_flags.GetObjectAsBool("any-process", include_any_process)) { |
| DNBLogThreadedIf(LOG_DARWIN_LOG, "Source-flag 'any-process' missing from " |
| "configuration."); |
| return false; |
| } |
| if (!source_flags.GetObjectAsBool("callstacks", include_callstacks)) { |
| // We currently suppress the availability of this on the lldb |
| // side. We include here for devices when we enable in the |
| // future. |
| // DNBLogThreadedIf(LOG_DARWIN_LOG, |
| // "Source-flag 'callstacks' missing from " |
| // "configuration."); |
| |
| // OK. We just skip callstacks. |
| // return false; |
| } |
| if (!source_flags.GetObjectAsBool("info-level", include_info_level)) { |
| DNBLogThreadedIf(LOG_DARWIN_LOG, "Source-flag 'info-level' missing from " |
| "configuration."); |
| return false; |
| } |
| if (!source_flags.GetObjectAsBool("debug-level", include_debug_level)) { |
| DNBLogThreadedIf(LOG_DARWIN_LOG, "Source-flag 'debug-level' missing from " |
| "configuration."); |
| return false; |
| } |
| if (!source_flags.GetObjectAsBool("live-stream", live_stream)) { |
| DNBLogThreadedIf(LOG_DARWIN_LOG, "Source-flag 'live-stream' missing from " |
| "configuration."); |
| return false; |
| } |
| |
| // Setup the SPI flags based on this. |
| m_activity_stream_flags = 0; |
| if (!include_any_process) |
| m_activity_stream_flags |= OS_ACTIVITY_STREAM_PROCESS_ONLY; |
| if (include_callstacks) |
| m_activity_stream_flags |= OS_ACTIVITY_STREAM_CALLSTACK; |
| if (include_info_level) |
| m_activity_stream_flags |= OS_ACTIVITY_STREAM_INFO; |
| if (include_debug_level) |
| m_activity_stream_flags |= OS_ACTIVITY_STREAM_DEBUG; |
| if (!live_stream) |
| m_activity_stream_flags |= OS_ACTIVITY_STREAM_BUFFERED; |
| |
| DNBLogThreadedIf(LOG_DARWIN_LOG, "m_activity_stream_flags = 0x%03x", |
| m_activity_stream_flags); |
| |
| return true; |
| } |
| |
| bool ParseFilterRules(const JSONObject &config) { |
| // Retrieve the default rule. |
| bool filter_default_accept = true; |
| if (!config.GetObjectAsBool("filter-fall-through-accepts", |
| filter_default_accept)) { |
| DNBLogThreadedIf(LOG_DARWIN_LOG, "Setting 'filter-fall-through-accepts' " |
| "missing from configuration."); |
| return false; |
| } |
| m_filter_chain_sp.reset(new LogFilterChain(filter_default_accept)); |
| DNBLogThreadedIf(LOG_DARWIN_LOG, "DarwinLog no-match rule: %s.", |
| filter_default_accept ? "accept" : "reject"); |
| |
| // If we don't have the filter-rules array, we're done. |
| auto filter_rules_sp = config.GetObject("filter-rules"); |
| if (!filter_rules_sp) { |
| DNBLogThreadedIf(LOG_DARWIN_LOG, |
| "No 'filter-rules' config element, all log " |
| "entries will use the no-match action (%s).", |
| filter_default_accept ? "accept" : "reject"); |
| return true; |
| } |
| if (!JSONArray::classof(filter_rules_sp.get())) |
| return false; |
| const JSONArray &rules_config = |
| *static_cast<JSONArray *>(filter_rules_sp.get()); |
| |
| // Create the filters. |
| for (auto &rule_sp : rules_config.m_elements) { |
| if (!JSONObject::classof(rule_sp.get())) |
| return false; |
| const JSONObject &rule_config = *static_cast<JSONObject *>(rule_sp.get()); |
| |
| // Get whether this filter accepts or rejects. |
| bool filter_accepts = true; |
| if (!rule_config.GetObjectAsBool("accept", filter_accepts)) { |
| DNBLogThreadedIf(LOG_DARWIN_LOG, "Filter 'accept' element missing."); |
| return false; |
| } |
| |
| // Grab the target log field attribute for the match. |
| std::string target_attribute; |
| if (!rule_config.GetObjectAsString("attribute", target_attribute)) { |
| DNBLogThreadedIf(LOG_DARWIN_LOG, "Filter 'attribute' element missing."); |
| return false; |
| } |
| auto target_enum = TargetStringToEnum(target_attribute); |
| if (target_enum == eFilterTargetInvalid) { |
| DNBLogThreadedIf(LOG_DARWIN_LOG, "Filter attribute '%s' unsupported.", |
| target_attribute.c_str()); |
| return false; |
| } |
| |
| // Handle operation-specific fields and filter creation. |
| std::string filter_type; |
| if (!rule_config.GetObjectAsString("type", filter_type)) { |
| DNBLogThreadedIf(LOG_DARWIN_LOG, "Filter 'type' element missing."); |
| return false; |
| } |
| DNBLogThreadedIf(LOG_DARWIN_LOG, "Reading filter of type '%s'", |
| filter_type.c_str()); |
| |
| LogFilterSP filter_sp; |
| if (filter_type == "regex") { |
| // Grab the regex for the match. |
| std::string regex; |
| if (!rule_config.GetObjectAsString("regex", regex)) { |
| DNBLogError("Regex filter missing 'regex' element."); |
| return false; |
| } |
| DNBLogThreadedIf(LOG_DARWIN_LOG, "regex for filter: \"%s\"", |
| regex.c_str()); |
| |
| // Create the regex filter. |
| auto regex_filter = |
| new LogFilterRegex(filter_accepts, target_enum, regex); |
| filter_sp.reset(regex_filter); |
| |
| // Validate that the filter is okay. |
| if (!regex_filter->IsValid()) { |
| DNBLogError("Invalid regex in filter: " |
| "regex=\"%s\", error=%s", |
| regex.c_str(), regex_filter->GetErrorAsCString()); |
| return false; |
| } |
| } else if (filter_type == "match") { |
| // Grab the regex for the match. |
| std::string exact_text; |
| if (!rule_config.GetObjectAsString("exact_text", exact_text)) { |
| DNBLogError("Exact match filter missing " |
| "'exact_text' element."); |
| return false; |
| } |
| |
| // Create the filter. |
| filter_sp.reset( |
| new LogFilterExactMatch(filter_accepts, target_enum, exact_text)); |
| } |
| |
| // Add the filter to the chain. |
| m_filter_chain_sp->AppendFilter(filter_sp); |
| } |
| return true; |
| } |
| |
| bool IsValid() const { return m_is_valid; } |
| |
| os_activity_stream_flag_t GetActivityStreamFlags() const { |
| return m_activity_stream_flags; |
| } |
| |
| const LogFilterChainSP &GetLogFilterChain() const { |
| return m_filter_chain_sp; |
| } |
| |
| private: |
| bool m_is_valid; |
| os_activity_stream_flag_t m_activity_stream_flags; |
| LogFilterChainSP m_filter_chain_sp; |
| }; |
| } |
| |
| bool DarwinLogCollector::IsSupported() { |
| // We're supported if we have successfully looked up the SPI entry points. |
| return LookupSPICalls(); |
| } |
| |
| bool DarwinLogCollector::StartCollectingForProcess(nub_process_t pid, |
| const JSONObject &config) { |
| // If we're currently collecting for this process, kill the existing |
| // collector. |
| if (CancelStreamForProcess(pid)) { |
| DNBLogThreadedIf(LOG_DARWIN_LOG, |
| "%s() killed existing DarwinLog collector for pid %d.", |
| __FUNCTION__, pid); |
| } |
| |
| // If the process isn't alive, we're done. |
| if (!DNBProcessIsAlive(pid)) { |
| DNBLogThreadedIf(LOG_DARWIN_LOG, |
| "%s() cannot collect for pid %d: process not alive.", |
| __FUNCTION__, pid); |
| return false; |
| } |
| |
| // Validate the configuration. |
| auto spi_config = Configuration(config); |
| if (!spi_config.IsValid()) { |
| DNBLogThreadedIf(LOG_DARWIN_LOG, |
| "%s() invalid configuration, will not enable log " |
| "collection", |
| __FUNCTION__); |
| return false; |
| } |
| |
| // Create the stream collector that will manage collected data |
| // for this pid. |
| DarwinLogCollectorSP collector_sp( |
| new DarwinLogCollector(pid, spi_config.GetLogFilterChain())); |
| std::weak_ptr<DarwinLogCollector> collector_wp(collector_sp); |
| |
| // Setup the stream handling block. |
| os_activity_stream_block_t block = |
| ^bool(os_activity_stream_entry_t entry, int error) { |
| // Check if our collector is still alive. |
| DarwinLogCollectorSP inner_collector_sp = collector_wp.lock(); |
| if (!inner_collector_sp) |
| return false; |
| return inner_collector_sp->HandleStreamEntry(entry, error); |
| }; |
| |
| os_activity_stream_event_block_t stream_event_block = ^void( |
| os_activity_stream_t stream, os_activity_stream_event_t event) { |
| switch (event) { |
| case OS_ACTIVITY_STREAM_EVENT_STARTED: |
| DNBLogThreadedIf(LOG_DARWIN_LOG, |
| "received stream event: " |
| "OS_ACTIVITY_STREAM_EVENT_STARTED, stream %p.", |
| (void *)stream); |
| break; |
| case OS_ACTIVITY_STREAM_EVENT_STOPPED: |
| DNBLogThreadedIf(LOG_DARWIN_LOG, |
| "received stream event: " |
| "OS_ACTIVITY_STREAM_EVENT_STOPPED, stream %p.", |
| (void *)stream); |
| break; |
| case OS_ACTIVITY_STREAM_EVENT_FAILED: |
| DNBLogThreadedIf(LOG_DARWIN_LOG, |
| "received stream event: " |
| "OS_ACTIVITY_STREAM_EVENT_FAILED, stream %p.", |
| (void *)stream); |
| break; |
| case OS_ACTIVITY_STREAM_EVENT_CHUNK_STARTED: |
| DNBLogThreadedIf(LOG_DARWIN_LOG, |
| "received stream event: " |
| "OS_ACTIVITY_STREAM_EVENT_CHUNK_STARTED, stream %p.", |
| (void *)stream); |
| break; |
| case OS_ACTIVITY_STREAM_EVENT_CHUNK_FINISHED: |
| DNBLogThreadedIf(LOG_DARWIN_LOG, |
| "received stream event: " |
| "OS_ACTIVITY_STREAM_EVENT_CHUNK_FINISHED, stream %p.", |
| (void *)stream); |
| break; |
| } |
| }; |
| |
| // Create the stream. |
| os_activity_stream_t activity_stream = (*s_os_activity_stream_for_pid)( |
| pid, spi_config.GetActivityStreamFlags(), block); |
| collector_sp->SetActivityStream(activity_stream); |
| |
| // Specify the stream-related event handler. |
| (*s_os_activity_stream_set_event_handler)(activity_stream, |
| stream_event_block); |
| |
| // Start the stream. |
| (*s_os_activity_stream_resume)(activity_stream); |
| |
| TrackCollector(collector_sp); |
| return true; |
| } |
| |
| DarwinLogEventVector |
| DarwinLogCollector::GetEventsForProcess(nub_process_t pid) { |
| auto collector_sp = FindCollectorForProcess(pid); |
| if (!collector_sp) { |
| // We're not tracking a stream for this process. |
| return DarwinLogEventVector(); |
| } |
| |
| return collector_sp->RemoveEvents(); |
| } |
| |
| bool DarwinLogCollector::CancelStreamForProcess(nub_process_t pid) { |
| auto collector_sp = FindCollectorForProcess(pid); |
| if (!collector_sp) { |
| // We're not tracking a stream for this process. |
| return false; |
| } |
| |
| collector_sp->CancelActivityStream(); |
| StopTrackingCollector(collector_sp); |
| |
| return true; |
| } |
| |
| const char * |
| DarwinLogCollector::GetActivityForID(os_activity_id_t activity_id) const { |
| auto find_it = m_activity_map.find(activity_id); |
| return (find_it != m_activity_map.end()) ? find_it->second.m_name.c_str() |
| : nullptr; |
| } |
| |
| /// Retrieve the full parent-child chain for activity names. These |
| /// can be arbitrarily deep. This method assumes the caller has already |
| /// locked the activity mutex. |
| void DarwinLogCollector::GetActivityChainForID_internal( |
| os_activity_id_t activity_id, std::string &result, size_t depth) const { |
| if (depth > MAX_ACTIVITY_CHAIN_DEPTH) { |
| // Terminating condition - too deeply nested. |
| return; |
| } else if (activity_id == 0) { |
| // Terminating condition - no activity. |
| return; |
| } |
| |
| auto find_it = m_activity_map.find(activity_id); |
| if (find_it == m_activity_map.end()) { |
| // Terminating condition - no data for activity_id. |
| return; |
| } |
| |
| // Activity name becomes parent activity name chain + ':' + our activity |
| // name. |
| GetActivityChainForID_internal(find_it->second.m_parent_id, result, |
| depth + 1); |
| if (!result.empty()) |
| result += ':'; |
| result += find_it->second.m_name; |
| } |
| |
| std::string |
| DarwinLogCollector::GetActivityChainForID(os_activity_id_t activity_id) const { |
| std::string result; |
| { |
| std::lock_guard<std::mutex> locker(m_activity_info_mutex); |
| GetActivityChainForID_internal(activity_id, result, 1); |
| } |
| return result; |
| } |
| |
| DarwinLogCollector::DarwinLogCollector(nub_process_t pid, |
| const LogFilterChainSP &filter_chain_sp) |
| : ActivityStore(), m_pid(pid), m_activity_stream(0), m_events(), |
| m_events_mutex(), m_filter_chain_sp(filter_chain_sp), |
| m_activity_info_mutex(), m_activity_map() {} |
| |
| DarwinLogCollector::~DarwinLogCollector() { |
| // Cancel the stream. |
| if (m_activity_stream) { |
| DNBLogThreadedIf(LOG_DARWIN_LOG, "tearing down activity stream " |
| "collector for %d", |
| m_pid); |
| (*s_os_activity_stream_cancel)(m_activity_stream); |
| m_activity_stream = 0; |
| } else { |
| DNBLogThreadedIf(LOG_DARWIN_LOG, "no stream to tear down for %d", m_pid); |
| } |
| } |
| |
| void DarwinLogCollector::SignalDataAvailable() { |
| RNBRemoteSP remoteSP(g_remoteSP); |
| if (!remoteSP) { |
| // We're done. This is unexpected. |
| StopTrackingCollector(shared_from_this()); |
| return; |
| } |
| |
| RNBContext &ctx = remoteSP->Context(); |
| ctx.Events().SetEvents(RNBContext::event_darwin_log_data_available); |
| // Wait for the main thread to consume this notification if it requested |
| // we wait for it. |
| ctx.Events().WaitForResetAck(RNBContext::event_darwin_log_data_available); |
| } |
| |
| void DarwinLogCollector::SetActivityStream( |
| os_activity_stream_t activity_stream) { |
| m_activity_stream = activity_stream; |
| } |
| |
| bool DarwinLogCollector::HandleStreamEntry(os_activity_stream_entry_t entry, |
| int error) { |
| if ((error == 0) && (entry != nullptr)) { |
| if (entry->pid != m_pid) { |
| // For now, skip messages not originating from our process. |
| // Later we might want to keep all messages related to an event |
| // that we're tracking, even when it came from another process, |
| // possibly doing work on our behalf. |
| return true; |
| } |
| |
| switch (entry->type) { |
| case OS_ACTIVITY_STREAM_TYPE_ACTIVITY_CREATE: |
| DNBLogThreadedIf( |
| LOG_DARWIN_LOG, "received activity create: " |
| "%s, creator aid %" PRIu64 ", unique_pid %" PRIu64 |
| "(activity id=%" PRIu64 ", parent id=%" PRIu64 ")", |
| entry->activity_create.name, entry->activity_create.creator_aid, |
| entry->activity_create.unique_pid, entry->activity_id, |
| entry->parent_id); |
| { |
| std::lock_guard<std::mutex> locker(m_activity_info_mutex); |
| m_activity_map.insert( |
| std::make_pair(entry->activity_id, |
| ActivityInfo(entry->activity_create.name, |
| entry->activity_id, entry->parent_id))); |
| } |
| break; |
| |
| case OS_ACTIVITY_STREAM_TYPE_ACTIVITY_TRANSITION: |
| DNBLogThreadedIf( |
| LOG_DARWIN_LOG, "received activity transition:" |
| "new aid: %" PRIu64 "(activity id=%" PRIu64 |
| ", parent id=%" PRIu64 ", tid %" PRIu64 ")", |
| entry->activity_transition.transition_id, entry->activity_id, |
| entry->parent_id, entry->activity_transition.thread); |
| break; |
| |
| case OS_ACTIVITY_STREAM_TYPE_LOG_MESSAGE: { |
| DNBLogThreadedIf( |
| LOG_DARWIN_LOG, "received log message: " |
| "(activity id=%" PRIu64 ", parent id=%" PRIu64 ", " |
| "tid %" PRIu64 "): format %s", |
| entry->activity_id, entry->parent_id, entry->log_message.thread, |
| entry->log_message.format ? entry->log_message.format |
| : "<invalid-format>"); |
| |
| // Do the real work here. |
| { |
| // Ensure our process is still alive. If not, we can |
| // cancel the collection. |
| if (!DNBProcessIsAlive(m_pid)) { |
| // We're outta here. This is the manner in which we |
| // stop collecting for a process. |
| StopTrackingCollector(shared_from_this()); |
| return false; |
| } |
| |
| LogMessageOsLog os_log_message(*this, *entry); |
| if (!m_filter_chain_sp || |
| !m_filter_chain_sp->GetAcceptMessage(os_log_message)) { |
| // This log message was rejected by the filter, |
| // so stop processing it now. |
| return true; |
| } |
| |
| // Copy over the relevant bits from the message. |
| const struct os_log_message_s &log_message = entry->log_message; |
| |
| DarwinLogEventSP message_sp(new DarwinLogEvent()); |
| // Indicate this event is a log message event. |
| message_sp->AddStringItem("type", "log"); |
| |
| // Add the message contents (fully expanded). |
| // Consider expanding on the remote side. |
| // Then we don't pay for expansion until when it is |
| // used. |
| const char *message_text = os_log_message.GetMessage(); |
| if (message_text) |
| message_sp->AddStringItem("message", message_text); |
| |
| // Add some useful data fields. |
| message_sp->AddIntegerItem("timestamp", log_message.timestamp); |
| |
| // Do we want to do all activity name resolution on this |
| // side? Maybe. For now, send IDs and ID->name mappings |
| // and fix this up on that side. Later, when we add |
| // debugserver-side filtering, we'll want to get the |
| // activity names over here, so we should probably |
| // just send them as resolved strings. |
| message_sp->AddIntegerItem("activity_id", entry->activity_id); |
| message_sp->AddIntegerItem("parent_id", entry->parent_id); |
| message_sp->AddIntegerItem("thread_id", log_message.thread); |
| if (log_message.subsystem && strlen(log_message.subsystem) > 0) |
| message_sp->AddStringItem("subsystem", log_message.subsystem); |
| if (log_message.category && strlen(log_message.category) > 0) |
| message_sp->AddStringItem("category", log_message.category); |
| if (entry->activity_id != 0) { |
| std::string activity_chain = |
| GetActivityChainForID(entry->activity_id); |
| if (!activity_chain.empty()) |
| message_sp->AddStringItem("activity-chain", activity_chain); |
| } |
| |
| // Add it to the list for later collection. |
| { |
| std::lock_guard<std::mutex> locker(m_events_mutex); |
| m_events.push_back(message_sp); |
| } |
| SignalDataAvailable(); |
| } |
| break; |
| } |
| } |
| } else { |
| DNBLogThreadedIf(LOG_DARWIN_LOG, "HandleStreamEntry: final call, " |
| "error %d", |
| error); |
| } |
| return true; |
| } |
| |
| DarwinLogEventVector DarwinLogCollector::RemoveEvents() { |
| DarwinLogEventVector returned_events; |
| { |
| std::lock_guard<std::mutex> locker(m_events_mutex); |
| returned_events.swap(m_events); |
| } |
| DNBLogThreadedIf(LOG_DARWIN_LOG, "DarwinLogCollector::%s(): removing %lu " |
| "queued log entries", |
| __FUNCTION__, returned_events.size()); |
| return returned_events; |
| } |
| |
| void DarwinLogCollector::CancelActivityStream() { |
| if (!m_activity_stream) |
| return; |
| |
| DNBLogThreadedIf(LOG_DARWIN_LOG, "DarwinLogCollector::%s(): canceling " |
| "activity stream %p", |
| __FUNCTION__, reinterpret_cast<void *>(m_activity_stream)); |
| (*s_os_activity_stream_cancel)(m_activity_stream); |
| m_activity_stream = nullptr; |
| } |
