chrome/browser/metrics/chrome_browser_sampling_trials.cc - chromium/src - Git at Google

 // Copyright 2022 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "chrome/browser/metrics/chrome_browser_sampling_trials.h"

 #include "base/feature_list.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/field_trial_params.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/metrics/chrome_metrics_services_manager_client.h"
 #include "chrome/common/channel_info.h"
 #include "components/ukm/ukm_recorder_impl.h"
 #include "components/version_info/channel.h"

 namespace metrics {
 namespace {

 // Note that the trial name must be kept in sync with the server config
 // controlling sampling. If they don't match, then clients will be shuffled into
 // different groups when the server config takes over from the fallback trial.
 #if BUILDFLAG(IS_WIN) || BUILDFLAG(IS_ANDROID)
 constexpr char kSamplingTrialName[] = "MetricsAndCrashSampling";
 #endif  // BUILDFLAG(IS_WIN) || BUILDFLAG(IS_ANDROID)
 #if BUILDFLAG(IS_ANDROID)
 constexpr char kPostFREFixSamplingTrialName[] =
     "PostFREFixMetricsAndCrashSampling";
 #endif  // BUILDFLAG(IS_ANDROID)
 constexpr char kUkmSamplingTrialName[] = "UkmSamplingRate";

 #if BUILDFLAG(IS_WIN) || BUILDFLAG(IS_ANDROID)
 // Appends a group to the sampling controlling |trial|. The group will be
 // associated with a variation param for reporting sampling |rate| in per mille.
 void AppendSamplingTrialGroup(const std::string& group_name,
                               int rate,
                               bool disable_crashes,
                               base::FieldTrial* trial) {
   std::map<std::string, std::string> params = {
       {metrics::internal::kRateParamName, base::NumberToString(rate)}};

   if (disable_crashes) {
     params.insert({"disable_crashes", "true"});
   }

   base::AssociateFieldTrialParams(trial->trial_name(), group_name, params);
   trial->AppendGroup(group_name, rate);
 }

 // Unconditionally attempts to create a field trial to control client side
 // metrics/crash sampling to use as a fallback when one hasn't been
 // provided. This is expected to occur on first-run on platforms that don't
 // have first-run variations support, or when no valid seed is available. This
 // should only be called when there is no existing field trial controlling the
 // sampling feature. |feature_name| is the name of the feature that determines
 // sampling.
 // Rates:
 //   |sampled_in_rate_per_mille| is the sampling rate per mille.
 //   |reporting_full_rate_per_mille| is the rate for clients who are sampled in,
 //   in the special ReportingFull group.
 //   All other clients are in the OutOfSampling group.
 void CreateFallbackSamplingTrial(
     const base::FieldTrial::EntropyProvider& entropy_provider,
     const std::string& trial_name,
     const std::string& feature_name,
     const int sampled_in_rate_per_mille,
     const int reporting_full_rate_per_mille,
     const bool starts_active,
     base::FeatureList* feature_list) {
   scoped_refptr<base::FieldTrial> trial(
       base::FieldTrialList::FactoryGetFieldTrial(
           trial_name, /*total_probability=*/1000, "Default", entropy_provider));

   // Like the trial name, the order that these groups are added to the trial
   // must be kept in sync with the order that they appear in the server config.
   // The desired order is: OutOfReportingSample, ReportingFull,
   // InReportingSample.

   const char kSampledOutGroup[] = "OutOfReportingSample";
   const int sampled_out_rate_per_mille =
       1000 - sampled_in_rate_per_mille - reporting_full_rate_per_mille;
   AppendSamplingTrialGroup(kSampledOutGroup, sampled_out_rate_per_mille,
                            /*disable_crashes=*/false, trial.get());

   // This group uploads to UMA but does not upload crashes.
   const char kReportingFullGroup[] = "ReportingFull";
   AppendSamplingTrialGroup(kReportingFullGroup, reporting_full_rate_per_mille,
                            /*disable_crashes=*/true, trial.get());

   const char kInSampleGroup[] = "InReportingSample";
   AppendSamplingTrialGroup(kInSampleGroup, sampled_in_rate_per_mille,
                            /*disable_crashes=*/false, trial.get());

   // Set up the feature. This must be done after all groups are added since
   // GetGroupNameWithoutActivation() will finalize the group choice.
   const std::string& group_name = trial->GetGroupNameWithoutActivation();

   // Note that this will set both ReportingFull and InReportingSample to enable
   // the feature.
   feature_list->RegisterFieldTrialOverride(
       feature_name,
       group_name == kSampledOutGroup
           ? base::FeatureList::OVERRIDE_DISABLE_FEATURE
           : base::FeatureList::OVERRIDE_ENABLE_FEATURE,
       trial.get());

   if (starts_active) {
     trial->Activate();
   }
 }
 #endif  // BUILDFLAG(IS_WIN) || BUILDFLAG(IS_ANDROID)

 // Unconditionally attempts to create a field trial to control client side
 // UKM sampling to use as a fallback when one hasn't been provided. This is
 // expected to occur on first-run on platforms that don't have first-run
 // variations support. This should only be called when there is no existing
 // field trial controlling the sampling feature.
 void CreateFallbackUkmSamplingTrial(
     const base::FieldTrial::EntropyProvider& entropy_provider,
     bool is_stable_channel,
     base::FeatureList* feature_list) {
   static const char kSampledGroup_Stable[] = "Sampled_NoSeed_Stable";
   static const char kSampledGroup_Other[] = "Sampled_NoSeed_Other";
   const char* sampled_group = kSampledGroup_Other;
   int default_sampling = 1;  // Sampling is 1-in-N; this is N.

   // Nothing is sampled out except for "stable" which omits almost everything
   // in this configuration. This is done so that clients that fail to receive
   // a configuration from the server do not bias aggregated results because
   // of a relatively large number of records from them.
   if (is_stable_channel) {
     sampled_group = kSampledGroup_Stable;
     default_sampling = 1000000;
   }

   scoped_refptr<base::FieldTrial> trial(
       base::FieldTrialList::FactoryGetFieldTrial(
           kUkmSamplingTrialName, /*total_probability=*/100, sampled_group,
           entropy_provider));

   // Everybody (100%) should have a sampling configuration.
   std::map<std::string, std::string> params = {
       {"_default_sampling", base::NumberToString(default_sampling)}};
   base::AssociateFieldTrialParams(trial->trial_name(), sampled_group, params);
   trial->AppendGroup(sampled_group, 100);

   // Setup the feature.
   feature_list->RegisterFieldTrialOverride(
       ukm::kUkmSamplingRateFeature.name,
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, trial.get());
 }

 }  // namespace

 void CreateFallbackSamplingTrialsIfNeeded(
     const base::FieldTrial::EntropyProvider& entropy_provider,
     base::FeatureList* feature_list) {
 #if BUILDFLAG(IS_WIN) || BUILDFLAG(IS_ANDROID)

   const bool is_stable = chrome::GetChannel() == version_info::Channel::STABLE;

   if (!base::FieldTrialList::TrialExists(kSamplingTrialName)) {
 #if BUILDFLAG(IS_WIN)

     // On all channels except stable, we sample out at a minimal rate to ensure
     // the code paths are exercised in the wild before hitting stable.
     const int kPreStableSampledInRatePerMille = 990;    // 99%
     const int kPreStableReportingFullRatePerMille = 5;  // 0.5%
     // This leaves 0.5% for OutOfReportingSample.

     const int kStableSampledInRatePerMille = 100;      // 10%
     const int kStableReportingFullRatePerMille = 900;  // 90%

 #endif  // BUILDFLAG(IS_WIN)

 #if BUILDFLAG(IS_ANDROID)

     // On all channels except stable, we sample out at a minimal rate to ensure
     // the code paths are exercised in the wild before hitting stable.
     const int kPreStableSampledInRatePerMille = 995;    // 99.5%
     const int kPreStableReportingFullRatePerMille = 0;  // 0%
     // This leaves 0.5% for OutOfReportingSample.

     // We use 5.3% for this set of users to work around an old bug
     // (crbug.com/1306481). This should be ~10% in practice.
     const int kStableSampledInRatePerMille = 53;     // 5.3%
     const int kStableReportingFullRatePerMille = 0;  // 0%

 #endif  // BUILDFLAG(IS_ANDROID)

     const int kSamplingInRatePerMille = is_stable
                                             ? kStableSampledInRatePerMille
                                             : kPreStableSampledInRatePerMille;

     const int kReportingFullRatePerMille =
         is_stable ? kStableReportingFullRatePerMille
                   : kPreStableReportingFullRatePerMille;

     // Note that the trial has to be activated immediately. Otherwise, it would
     // be possible for this session to crash before its feature was queried, and
     // the independent log produced would not contain the sampling trial.
     CreateFallbackSamplingTrial(
         entropy_provider, kSamplingTrialName,
         metrics::internal::kMetricsReportingFeature.name,
         kSamplingInRatePerMille, kReportingFullRatePerMille,
         /*starts_active=*/true, feature_list);
   }

 #if BUILDFLAG(IS_ANDROID)
   if (!base::FieldTrialList::TrialExists(kPostFREFixSamplingTrialName)) {
     // On all channels except stable, we sample out at a minimal rate to ensure
     // the code paths are exercised in the wild before hitting stable.
     const int kPreStableSampledInRatePerMille = 995;  // 99.5%

     // This is meant to be 10%, and this population, unlike the set of users
     // under the kSamplingTrialName trial should correctly be 10% in practice.
     const int kStableSampledInRatePerMille = 100;  // 10%

     const int kReportingFullRatePerMille = 0;

     // Note that as per the serverside config, this trial does not start active
     // (so that it is possible to determine from the serverside whether the
     // client used the old or new trial to determine sampling). So if Chrome
     // crashes before its feature is queried, the independent log produced will
     // not contain this trial, even if the client normally uses this trial to
     // determine sampling.
     CreateFallbackSamplingTrial(
         entropy_provider, kPostFREFixSamplingTrialName,
         metrics::internal::kPostFREFixMetricsReportingFeature.name,
         is_stable ? kStableSampledInRatePerMille
                   : kPreStableSampledInRatePerMille,
         kReportingFullRatePerMille,
         /*starts_active=*/false, feature_list);
   }
 #endif  // BUILDFLAG(IS_ANDROID)

 #endif  // BUILDFLAG(IS_WIN) || BUILDFLAG(IS_ANDROID)
 }

 void CreateFallbackUkmSamplingTrialIfNeeded(
     const base::FieldTrial::EntropyProvider& entropy_provider,
     base::FeatureList* feature_list) {
   if (!base::FieldTrialList::TrialExists(kUkmSamplingTrialName)) {
     const bool is_stable =
         chrome::GetChannel() == version_info::Channel::STABLE;
     CreateFallbackUkmSamplingTrial(entropy_provider, is_stable, feature_list);
   }
 }

 }  // namespace metrics
	// Copyright 2022 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "chrome/browser/metrics/chrome_browser_sampling_trials.h"

	#include "base/feature_list.h"
	#include "base/metrics/field_trial.h"
	#include "base/metrics/field_trial_params.h"
	#include "base/strings/string_number_conversions.h"
	#include "chrome/browser/metrics/chrome_metrics_services_manager_client.h"
	#include "chrome/common/channel_info.h"
	#include "components/ukm/ukm_recorder_impl.h"
	#include "components/version_info/channel.h"

	namespace metrics {
	namespace {

	// Note that the trial name must be kept in sync with the server config
	// controlling sampling. If they don't match, then clients will be shuffled into
	// different groups when the server config takes over from the fallback trial.
	#if BUILDFLAG(IS_WIN) \|\| BUILDFLAG(IS_ANDROID)
	constexpr char kSamplingTrialName[] = "MetricsAndCrashSampling";
	#endif // BUILDFLAG(IS_WIN) \|\| BUILDFLAG(IS_ANDROID)
	#if BUILDFLAG(IS_ANDROID)
	constexpr char kPostFREFixSamplingTrialName[] =
	"PostFREFixMetricsAndCrashSampling";
	#endif // BUILDFLAG(IS_ANDROID)
	constexpr char kUkmSamplingTrialName[] = "UkmSamplingRate";

	#if BUILDFLAG(IS_WIN) \|\| BUILDFLAG(IS_ANDROID)
	// Appends a group to the sampling controlling \|trial\|. The group will be
	// associated with a variation param for reporting sampling \|rate\| in per mille.
	void AppendSamplingTrialGroup(const std::string& group_name,
	int rate,
	bool disable_crashes,
	base::FieldTrial* trial) {
	std::map<std::string, std::string> params = {
	{metrics::internal::kRateParamName, base::NumberToString(rate)}};

	if (disable_crashes) {
	params.insert({"disable_crashes", "true"});
	}

	base::AssociateFieldTrialParams(trial->trial_name(), group_name, params);
	trial->AppendGroup(group_name, rate);
	}

	// Unconditionally attempts to create a field trial to control client side
	// metrics/crash sampling to use as a fallback when one hasn't been
	// provided. This is expected to occur on first-run on platforms that don't
	// have first-run variations support, or when no valid seed is available. This
	// should only be called when there is no existing field trial controlling the
	// sampling feature. \|feature_name\| is the name of the feature that determines
	// sampling.
	// Rates:
	// \|sampled_in_rate_per_mille\| is the sampling rate per mille.
	// \|reporting_full_rate_per_mille\| is the rate for clients who are sampled in,
	// in the special ReportingFull group.
	// All other clients are in the OutOfSampling group.
	void CreateFallbackSamplingTrial(
	const base::FieldTrial::EntropyProvider& entropy_provider,
	const std::string& trial_name,
	const std::string& feature_name,
	const int sampled_in_rate_per_mille,
	const int reporting_full_rate_per_mille,
	const bool starts_active,
	base::FeatureList* feature_list) {
	scoped_refptr<base::FieldTrial> trial(
	base::FieldTrialList::FactoryGetFieldTrial(
	trial_name, /total_probability=/1000, "Default", entropy_provider));

	// Like the trial name, the order that these groups are added to the trial
	// must be kept in sync with the order that they appear in the server config.
	// The desired order is: OutOfReportingSample, ReportingFull,
	// InReportingSample.

	const char kSampledOutGroup[] = "OutOfReportingSample";
	const int sampled_out_rate_per_mille =
	1000 - sampled_in_rate_per_mille - reporting_full_rate_per_mille;
	AppendSamplingTrialGroup(kSampledOutGroup, sampled_out_rate_per_mille,
	/disable_crashes=/false, trial.get());

	// This group uploads to UMA but does not upload crashes.
	const char kReportingFullGroup[] = "ReportingFull";
	AppendSamplingTrialGroup(kReportingFullGroup, reporting_full_rate_per_mille,
	/disable_crashes=/true, trial.get());

	const char kInSampleGroup[] = "InReportingSample";
	AppendSamplingTrialGroup(kInSampleGroup, sampled_in_rate_per_mille,
	/disable_crashes=/false, trial.get());

	// Set up the feature. This must be done after all groups are added since
	// GetGroupNameWithoutActivation() will finalize the group choice.
	const std::string& group_name = trial->GetGroupNameWithoutActivation();

	// Note that this will set both ReportingFull and InReportingSample to enable
	// the feature.
	feature_list->RegisterFieldTrialOverride(
	feature_name,
	group_name == kSampledOutGroup
	? base::FeatureList::OVERRIDE_DISABLE_FEATURE
	: base::FeatureList::OVERRIDE_ENABLE_FEATURE,
	trial.get());

	if (starts_active) {
	trial->Activate();
	}
	}
	#endif // BUILDFLAG(IS_WIN) \|\| BUILDFLAG(IS_ANDROID)

	// Unconditionally attempts to create a field trial to control client side
	// UKM sampling to use as a fallback when one hasn't been provided. This is
	// expected to occur on first-run on platforms that don't have first-run
	// variations support. This should only be called when there is no existing
	// field trial controlling the sampling feature.
	void CreateFallbackUkmSamplingTrial(
	const base::FieldTrial::EntropyProvider& entropy_provider,
	bool is_stable_channel,
	base::FeatureList* feature_list) {
	static const char kSampledGroup_Stable[] = "Sampled_NoSeed_Stable";
	static const char kSampledGroup_Other[] = "Sampled_NoSeed_Other";
	const char* sampled_group = kSampledGroup_Other;
	int default_sampling = 1; // Sampling is 1-in-N; this is N.

	// Nothing is sampled out except for "stable" which omits almost everything
	// in this configuration. This is done so that clients that fail to receive
	// a configuration from the server do not bias aggregated results because
	// of a relatively large number of records from them.
	if (is_stable_channel) {
	sampled_group = kSampledGroup_Stable;
	default_sampling = 1000000;
	}

	scoped_refptr<base::FieldTrial> trial(
	base::FieldTrialList::FactoryGetFieldTrial(
	kUkmSamplingTrialName, /total_probability=/100, sampled_group,
	entropy_provider));

	// Everybody (100%) should have a sampling configuration.
	std::map<std::string, std::string> params = {
	{"_default_sampling", base::NumberToString(default_sampling)}};
	base::AssociateFieldTrialParams(trial->trial_name(), sampled_group, params);
	trial->AppendGroup(sampled_group, 100);

	// Setup the feature.
	feature_list->RegisterFieldTrialOverride(
	ukm::kUkmSamplingRateFeature.name,
	base::FeatureList::OVERRIDE_ENABLE_FEATURE, trial.get());
	}

	} // namespace

	void CreateFallbackSamplingTrialsIfNeeded(
	const base::FieldTrial::EntropyProvider& entropy_provider,
	base::FeatureList* feature_list) {
	#if BUILDFLAG(IS_WIN) \|\| BUILDFLAG(IS_ANDROID)

	const bool is_stable = chrome::GetChannel() == version_info::Channel::STABLE;

	if (!base::FieldTrialList::TrialExists(kSamplingTrialName)) {
	#if BUILDFLAG(IS_WIN)

	// On all channels except stable, we sample out at a minimal rate to ensure
	// the code paths are exercised in the wild before hitting stable.
	const int kPreStableSampledInRatePerMille = 990; // 99%
	const int kPreStableReportingFullRatePerMille = 5; // 0.5%
	// This leaves 0.5% for OutOfReportingSample.

	const int kStableSampledInRatePerMille = 100; // 10%
	const int kStableReportingFullRatePerMille = 900; // 90%

	#endif // BUILDFLAG(IS_WIN)

	#if BUILDFLAG(IS_ANDROID)

	// On all channels except stable, we sample out at a minimal rate to ensure
	// the code paths are exercised in the wild before hitting stable.
	const int kPreStableSampledInRatePerMille = 995; // 99.5%
	const int kPreStableReportingFullRatePerMille = 0; // 0%
	// This leaves 0.5% for OutOfReportingSample.

	// We use 5.3% for this set of users to work around an old bug
	// (crbug.com/1306481). This should be ~10% in practice.
	const int kStableSampledInRatePerMille = 53; // 5.3%
	const int kStableReportingFullRatePerMille = 0; // 0%

	#endif // BUILDFLAG(IS_ANDROID)

	const int kSamplingInRatePerMille = is_stable
	? kStableSampledInRatePerMille
	: kPreStableSampledInRatePerMille;

	const int kReportingFullRatePerMille =
	is_stable ? kStableReportingFullRatePerMille
	: kPreStableReportingFullRatePerMille;

	// Note that the trial has to be activated immediately. Otherwise, it would
	// be possible for this session to crash before its feature was queried, and
	// the independent log produced would not contain the sampling trial.
	CreateFallbackSamplingTrial(
	entropy_provider, kSamplingTrialName,
	metrics::internal::kMetricsReportingFeature.name,
	kSamplingInRatePerMille, kReportingFullRatePerMille,
	/starts_active=/true, feature_list);
	}

	#if BUILDFLAG(IS_ANDROID)
	if (!base::FieldTrialList::TrialExists(kPostFREFixSamplingTrialName)) {
	// On all channels except stable, we sample out at a minimal rate to ensure
	// the code paths are exercised in the wild before hitting stable.
	const int kPreStableSampledInRatePerMille = 995; // 99.5%

	// This is meant to be 10%, and this population, unlike the set of users
	// under the kSamplingTrialName trial should correctly be 10% in practice.
	const int kStableSampledInRatePerMille = 100; // 10%

	const int kReportingFullRatePerMille = 0;

	// Note that as per the serverside config, this trial does not start active
	// (so that it is possible to determine from the serverside whether the
	// client used the old or new trial to determine sampling). So if Chrome
	// crashes before its feature is queried, the independent log produced will
	// not contain this trial, even if the client normally uses this trial to
	// determine sampling.
	CreateFallbackSamplingTrial(
	entropy_provider, kPostFREFixSamplingTrialName,
	metrics::internal::kPostFREFixMetricsReportingFeature.name,
	is_stable ? kStableSampledInRatePerMille
	: kPreStableSampledInRatePerMille,
	kReportingFullRatePerMille,
	/starts_active=/false, feature_list);
	}
	#endif // BUILDFLAG(IS_ANDROID)

	#endif // BUILDFLAG(IS_WIN) \|\| BUILDFLAG(IS_ANDROID)
	}

	void CreateFallbackUkmSamplingTrialIfNeeded(
	const base::FieldTrial::EntropyProvider& entropy_provider,
	base::FeatureList* feature_list) {
	if (!base::FieldTrialList::TrialExists(kUkmSamplingTrialName)) {
	const bool is_stable =
	chrome::GetChannel() == version_info::Channel::STABLE;
	CreateFallbackUkmSamplingTrial(entropy_provider, is_stable, feature_list);
	}
	}

	} // namespace metrics