Slow Reports - Embed Metadata in Traces

content/browser/tracing/background_tracing_manager_impl.cc

 // Copyright 2015 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 "content/browser/tracing/background_tracing_manager_impl.h"
 
+#include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/time/time.h"
 #include "content/public/browser/background_tracing_preemptive_config.h"
 #include "content/public/browser/background_tracing_reactive_config.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/tracing_delegate.h"
 #include "content/public/common/content_client.h"
 
 namespace content {
 
 namespace {
 
 base::LazyInstance<BackgroundTracingManagerImpl>::Leaky g_controller =
     LAZY_INSTANCE_INITIALIZER;
 
+const char kMetaDataConfigKey[] = "config";
+const char kMetaDataVersionKey[] = "product_version";
+
 // These values are used for a histogram. Do not reorder.
 enum BackgroundTracingMetrics {
   SCENARIO_ACTIVATION_REQUESTED = 0,
   SCENARIO_ACTIVATED_SUCCESSFULLY = 1,
   RECORDING_ENABLED = 2,
   PREEMPTIVE_TRIGGERED = 3,
   REACTIVE_TRIGGERED = 4,
   FINALIZATION_ALLOWED = 5,
   FINALIZATION_DISALLOWED = 6,
   FINALIZATION_STARTED = 7,
@@ skipping 329 matching lines @@
 }
 
 void BackgroundTracingManagerImpl::OnFinalizeStarted(
     scoped_refptr<base::RefCountedString> file_contents) {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   RecordBackgroundTracingMetric(FINALIZATION_STARTED);
   UMA_HISTOGRAM_MEMORY_KB("Tracing.Background.FinalizingTraceSizeInKB",
                           file_contents->size() / 1024);
 
-  if (!receive_callback_.is_null())
+  if (!receive_callback_.is_null()) {
     receive_callback_.Run(
-        file_contents,
+        file_contents, GenerateMetadataDict(),
         base::Bind(&BackgroundTracingManagerImpl::OnFinalizeComplete,
                    base::Unretained(this)));
+  }
 }
 
 void BackgroundTracingManagerImpl::OnFinalizeComplete() {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&BackgroundTracingManagerImpl::OnFinalizeComplete,
                    base::Unretained(this)));
     return;
   }
 
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   is_gathering_ = false;
 
   if (!idle_callback_.is_null())
     idle_callback_.Run();
 
   // Now that a trace has completed, we may need to enable recording again.
   EnableRecordingIfConfigNeedsIt();
   RecordBackgroundTracingMetric(FINALIZATION_COMPLETE);
 }
 
+scoped_ptr<base::DictionaryValue>
+BackgroundTracingManagerImpl::GenerateMetadataDict() const {
+  // Grab the product version.
+  std::string product_version = GetContentClient()->GetProduct();
+
+  // Serialize the config into json.
+  scoped_ptr<base::DictionaryValue> config_dict(new base::DictionaryValue());
+
+  BackgroundTracingConfig::IntoDict(config_.get(), config_dict.get());
+
+  scoped_ptr<base::DictionaryValue> metadata_dict(new base::DictionaryValue());
+  metadata_dict->Set(kMetaDataConfigKey, config_dict.Pass());
+  metadata_dict->SetString(kMetaDataVersionKey, product_version);
+
+  return metadata_dict.Pass();
+}
+
 void BackgroundTracingManagerImpl::BeginFinalizing(
     StartedFinalizingCallback callback) {
   is_gathering_ = true;
   is_tracing_ = false;
 
   bool is_allowed_finalization =
       !delegate_ || (config_ &&
                      delegate_->IsAllowedToEndBackgroundScenario(
                          *config_.get(), requires_anonymized_data_));
 
   scoped_refptr<TracingControllerImpl::TraceDataSink> trace_data_sink;
   if (is_allowed_finalization) {
     trace_data_sink = content::TracingController::CreateCompressedStringSink(
         data_endpoint_wrapper_);
     RecordBackgroundTracingMetric(FINALIZATION_ALLOWED);
+
+    if (auto metadata_dict = GenerateMetadataDict()) {
+      std::string results;
+      if (base::JSONWriter::Write(*metadata_dict.get(), &results))
+        trace_data_sink->SetMetadata(results);
+    }
   } else {
     RecordBackgroundTracingMetric(FINALIZATION_DISALLOWED);
   }
 
   content::TracingController::GetInstance()->DisableRecording(trace_data_sink);
 
   if (!callback.is_null())
     callback.Run(is_allowed_finalization);
 }
 
 std::string
 BackgroundTracingManagerImpl::GetCategoryFilterStringForCategoryPreset(
     BackgroundTracingConfig::CategoryPreset preset) const {
   switch (preset) {
     case BackgroundTracingConfig::CategoryPreset::BENCHMARK:
       return "benchmark,"
              "disabled-by-default-toplevel.flow,"
              "disabled-by-default-ipc.flow";
     case BackgroundTracingConfig::CategoryPreset::BENCHMARK_DEEP:
       return "*,disabled-by-default-blink.debug.layout";
   }
   NOTREACHED();
   return "";
 }
 
 }  // namspace content