Added a whitelist for trace events that are known to be PII-less.

base/trace_event/trace_event_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/trace_event/trace_event_impl.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/base_switches.h"
@@ skipping 50 matching lines @@
 // trace.
 const int kOverheadReportThresholdInMicroseconds = 50;
 
 // String options that can be used to initialize TraceOptions.
 const char kRecordUntilFull[] = "record-until-full";
 const char kRecordContinuously[] = "record-continuously";
 const char kRecordAsMuchAsPossible[] = "record-as-much-as-possible";
 const char kTraceToConsole[] = "trace-to-console";
 const char kEnableSampling[] = "enable-sampling";
 const char kEnableSystrace[] = "enable-systrace";
+const char kEnableArgumentFilter[] = "enable-argument-filter";
 
 // Controls the number of trace events we will buffer in-memory
 // before throwing them away.
 const size_t kTraceBufferChunkSize = TraceBufferChunk::kTraceBufferChunkSize;
 const size_t kTraceEventVectorBigBufferChunks =
     512000000 / kTraceBufferChunkSize;
 const size_t kTraceEventVectorBufferChunks = 256000 / kTraceBufferChunkSize;
 const size_t kTraceEventRingBufferChunks = kTraceEventVectorBufferChunks / 4;
 const size_t kTraceEventBufferSizeInBytes = 100 * 1024;
 // Can store results for 30 seconds with 1 ms sampling interval.
@@ skipping 607 matching lines @@
     case TRACE_VALUE_TYPE_STRING:
     case TRACE_VALUE_TYPE_COPY_STRING:
       EscapeJSONString(value.as_string ? value.as_string : "NULL", true, out);
       break;
     default:
       NOTREACHED() << "Don't know how to print this value";
       break;
   }
 }
 
-void TraceEvent::AppendAsJSON(std::string* out) const {
+void TraceEvent::AppendAsJSON(
+    std::string* out,
+    const ArgumentFilterPredicate& argument_filter_predicate) const {
   int64 time_int64 = timestamp_.ToInternalValue();
   int process_id = TraceLog::GetInstance()->process_id();
+  const char* category_group_name =
+      TraceLog::GetCategoryGroupName(category_group_enabled_);
+
   // Category group checked at category creation time.
   DCHECK(!strchr(name_, '"'));
-  StringAppendF(out,
-      "{\"pid\":%i,\"tid\":%i,\"ts\":%" PRId64 ","
-      "\"ph\":\"%c\",\"cat\":\"%s\",\"name\":\"%s\",\"args\":{",
-      process_id,
-      thread_id_,
-      time_int64,
-      phase_,
-      TraceLog::GetCategoryGroupName(category_group_enabled_),
-      name_);
+  StringAppendF(out, "{\"pid\":%i,\"tid\":%i,\"ts\":%" PRId64
+                     ","
+                     "\"ph\":\"%c\",\"cat\":\"%s\",\"name\":\"%s\",\"args\":{",
+                process_id, thread_id_, time_int64, phase_, category_group_name,
+                name_);
 
   // Output argument names and values, stop at first NULL argument name.
-  for (int i = 0; i < kTraceMaxNumArgs && arg_names_[i]; ++i) {
-    if (i > 0)
-      *out += ",";
-    *out += "\"";
-    *out += arg_names_[i];
-    *out += "\":";
+  if (arg_names_[0]) {
+    bool allow_args = argument_filter_predicate.is_null() ||
+                      argument_filter_predicate.Run(category_group_name, name_);
 
-    if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE)
-      convertable_values_[i]->AppendAsTraceFormat(out);
-    else
-      AppendValueAsJSON(arg_types_[i], arg_values_[i], out);
+    if (allow_args) {
+      for (int i = 0; i < kTraceMaxNumArgs && arg_names_[i]; ++i) {
+        if (i > 0)
+          *out += ",";
+        *out += "\"";
+        *out += arg_names_[i];
+        *out += "\":";
+
+        if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE)
+          convertable_values_[i]->AppendAsTraceFormat(out);
+        else
+          AppendValueAsJSON(arg_types_[i], arg_values_[i], out);
+      }
+    } else {
+      *out += "\"stripped\":1";
+    }
   }
+
   *out += "}";
 
   if (phase_ == TRACE_EVENT_PHASE_COMPLETE) {
     int64 duration = duration_.ToInternalValue();
     if (duration != -1)
       StringAppendF(out, ",\"dur\":%" PRId64, duration);
     if (!thread_timestamp_.is_null()) {
       int64 thread_duration = thread_duration_.ToInternalValue();
       if (thread_duration != -1)
         StringAppendF(out, ",\"tdur\":%" PRId64, thread_duration);
@@ skipping 260 matching lines @@
     } else if (*iter == kRecordContinuously) {
       record_mode = RECORD_CONTINUOUSLY;
     } else if (*iter == kTraceToConsole) {
       record_mode = ECHO_TO_CONSOLE;
     } else if (*iter == kRecordAsMuchAsPossible) {
       record_mode = RECORD_AS_MUCH_AS_POSSIBLE;
     } else if (*iter == kEnableSampling) {
       enable_sampling = true;
     } else if (*iter == kEnableSystrace) {
       enable_systrace = true;
+    } else if (*iter == kEnableArgumentFilter) {
+      enable_argument_filter = true;
     } else {
       return false;
     }
   }
   return true;
 }
 
 std::string TraceOptions::ToString() const {
   std::string ret;
   switch (record_mode) {
     case RECORD_UNTIL_FULL:
       ret = kRecordUntilFull;
       break;
     case RECORD_CONTINUOUSLY:
       ret = kRecordContinuously;
       break;
     case ECHO_TO_CONSOLE:
       ret = kTraceToConsole;
       break;
     case RECORD_AS_MUCH_AS_POSSIBLE:
       ret = kRecordAsMuchAsPossible;
       break;
     default:
       NOTREACHED();
   }
   if (enable_sampling)
     ret = ret + "," + kEnableSampling;
   if (enable_systrace)
     ret = ret + "," + kEnableSystrace;
+  if (enable_argument_filter)
+    ret = ret + "," + kEnableArgumentFilter;
   return ret;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // TraceLog
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 class TraceLog::ThreadLocalEventBuffer
@@ skipping 434 matching lines @@
   // Notify observers outside the lock in case they trigger trace events.
   for (size_t i = 0; i < observer_list.size(); ++i)
     observer_list[i]->OnTraceLogEnabled();
 
   {
     AutoLock lock(lock_);
     dispatching_to_observer_list_ = false;
   }
 }
 
+void TraceLog::SetArgumentFilterPredicate(
+    const TraceEvent::ArgumentFilterPredicate& argument_filter_predicate) {
+  AutoLock lock(lock_);
+  DCHECK(!argument_filter_predicate.is_null());
+  DCHECK(argument_filter_predicate_.is_null());
+  argument_filter_predicate_ = argument_filter_predicate;
+}
+
 TraceLog::InternalTraceOptions TraceLog::GetInternalOptionsFromTraceOptions(
     const TraceOptions& options) {
   InternalTraceOptions ret =
       options.enable_sampling ? kInternalEnableSampling : kInternalNone;
+  if (options.enable_argument_filter)
+    ret |= kInternalEnableArgumentFilter;
   switch (options.record_mode) {
     case RECORD_UNTIL_FULL:
       return ret | kInternalRecordUntilFull;
     case RECORD_CONTINUOUSLY:
       return ret | kInternalRecordContinuously;
     case ECHO_TO_CONSOLE:
       return ret | kInternalEchoToConsole;
     case RECORD_AS_MUCH_AS_POSSIBLE:
       return ret | kInternalRecordAsMuchAsPossible;
   }
   NOTREACHED();
   return kInternalNone;
 }
 
 CategoryFilter TraceLog::GetCurrentCategoryFilter() {
   AutoLock lock(lock_);
   return category_filter_;
 }
 
 TraceOptions TraceLog::GetCurrentTraceOptions() const {
   TraceOptions ret;
   InternalTraceOptions option = trace_options();
   ret.enable_sampling = (option & kInternalEnableSampling) != 0;
+  ret.enable_argument_filter = (option & kInternalEnableArgumentFilter) != 0;
   if (option & kInternalRecordUntilFull)
     ret.record_mode = RECORD_UNTIL_FULL;
   else if (option & kInternalRecordContinuously)
     ret.record_mode = RECORD_CONTINUOUSLY;
   else if (option & kInternalEchoToConsole)
     ret.record_mode = ECHO_TO_CONSOLE;
   else if (option & kInternalRecordAsMuchAsPossible)
     ret.record_mode = RECORD_AS_MUCH_AS_POSSIBLE;
   else
     NOTREACHED();
@@ skipping 223 matching lines @@
         TimeDelta::FromMilliseconds(kThreadFlushTimeoutMs));
     return;
   }
 
   FinishFlush(generation);
 }
 
 // Usually it runs on a different thread.
 void TraceLog::ConvertTraceEventsToTraceFormat(
     scoped_ptr<TraceBuffer> logged_events,
-    const TraceLog::OutputCallback& flush_output_callback) {
-
+    const OutputCallback& flush_output_callback,
+    const TraceEvent::ArgumentFilterPredicate& argument_filter_predicate) {
   if (flush_output_callback.is_null())
     return;
 
   // The callback need to be called at least once even if there is no events
   // to let the caller know the completion of flush.
   bool has_more_events = true;
   do {
     scoped_refptr<RefCountedString> json_events_str_ptr =
         new RefCountedString();
 
     while (json_events_str_ptr->size() < kTraceEventBufferSizeInBytes) {
       const TraceBufferChunk* chunk = logged_events->NextChunk();
       has_more_events = chunk != NULL;
       if (!chunk)
         break;
       for (size_t j = 0; j < chunk->size(); ++j) {
         if (json_events_str_ptr->size())
           json_events_str_ptr->data().append(",\n");
-        chunk->GetEventAt(j)->AppendAsJSON(&(json_events_str_ptr->data()));
+        chunk->GetEventAt(j)->AppendAsJSON(&(json_events_str_ptr->data()),
+                                           argument_filter_predicate);
       }
     }
     flush_output_callback.Run(json_events_str_ptr, has_more_events);
   } while (has_more_events);
 }
 
 void TraceLog::FinishFlush(int generation) {
   scoped_ptr<TraceBuffer> previous_logged_events;
   OutputCallback flush_output_callback;
+  TraceEvent::ArgumentFilterPredicate argument_filter_predicate;
 
   if (!CheckGeneration(generation))
     return;
 
   {
     AutoLock lock(lock_);
 
     previous_logged_events.swap(logged_events_);
     UseNextTraceBuffer();
     thread_message_loops_.clear();
 
     flush_task_runner_ = NULL;
     flush_output_callback = flush_output_callback_;
     flush_output_callback_.Reset();
+
+    if (trace_options() & kInternalEnableArgumentFilter) {
+      CHECK(!argument_filter_predicate_.is_null());
+      argument_filter_predicate = argument_filter_predicate_;
+    }
   }
 
   if (use_worker_thread_ &&
       WorkerPool::PostTask(
-          FROM_HERE,
-          Bind(&TraceLog::ConvertTraceEventsToTraceFormat,
-               Passed(&previous_logged_events),
-               flush_output_callback),
+          FROM_HERE, Bind(&TraceLog::ConvertTraceEventsToTraceFormat,
+                          Passed(&previous_logged_events),
+                          flush_output_callback, argument_filter_predicate),
           true)) {
     return;
   }
 
   ConvertTraceEventsToTraceFormat(previous_logged_events.Pass(),
-                                  flush_output_callback);
+                                  flush_output_callback,
+                                  argument_filter_predicate);
 }
 
 // Run in each thread holding a local event buffer.
 void TraceLog::FlushCurrentThread(int generation) {
   {
     AutoLock lock(lock_);
     if (!CheckGeneration(generation) || !flush_task_runner_) {
       // This is late. The corresponding flush has finished.
       return;
     }
@@ skipping 29 matching lines @@
          it != thread_message_loops_.end(); ++it) {
       LOG(WARNING) << "Thread: " << (*it)->thread_name();
     }
   }
   FinishFlush(generation);
 }
 
 void TraceLog::FlushButLeaveBufferIntact(
     const TraceLog::OutputCallback& flush_output_callback) {
   scoped_ptr<TraceBuffer> previous_logged_events;
+  TraceEvent::ArgumentFilterPredicate argument_filter_predicate;
   {
     AutoLock lock(lock_);
     AddMetadataEventsWhileLocked();
     if (thread_shared_chunk_) {
       // Return the chunk to the main buffer to flush the sampling data.
       logged_events_->ReturnChunk(thread_shared_chunk_index_,
                                   thread_shared_chunk_.Pass());
     }
     previous_logged_events = logged_events_->CloneForIteration().Pass();
+
+    if (trace_options() & kInternalEnableArgumentFilter) {
+      CHECK(!argument_filter_predicate_.is_null());
+      argument_filter_predicate = argument_filter_predicate_;
+    }
   }  // release lock
 
   ConvertTraceEventsToTraceFormat(previous_logged_events.Pass(),
-                                  flush_output_callback);
+                                  flush_output_callback,
+                                  argument_filter_predicate);
 }
 
 void TraceLog::UseNextTraceBuffer() {
   logged_events_.reset(CreateTraceBuffer());
   subtle::NoBarrier_AtomicIncrement(&generation_, 1);
   thread_shared_chunk_.reset();
   thread_shared_chunk_index_ = 0;
 }
 
 TraceEventHandle TraceLog::AddTraceEvent(
@@ skipping 752 matching lines @@
 }
 
 ScopedTraceBinaryEfficient::~ScopedTraceBinaryEfficient() {
   if (*category_group_enabled_) {
     TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(category_group_enabled_,
                                                 name_, event_handle_);
   }
 }
 
 }  // namespace trace_event_internal