path: root/chromium/components/autofill_assistant/browser/metrics.cc

// Copyright 2019 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 "components/autofill_assistant/browser/metrics.h"

#include "base/containers/flat_map.h"
#include "base/logging.h"
#include "base/metrics/histogram_functions.h"
#include "base/no_destructor.h"
#include "components/autofill_assistant/browser/features.h"
#include "components/autofill_assistant/browser/intent_strings.h"
#include "components/ukm/content/source_url_recorder.h"
#include "services/metrics/public/cpp/ukm_builders.h"

namespace autofill_assistant {
namespace {
int64_t ToEntryCountBucket(int entry_count) {
  DCHECK_GE(entry_count, 0);
  if (entry_count < 5)
    return static_cast<int64_t>(entry_count);

  return static_cast<int64_t>(Metrics::UserDataEntryCount::FIVE_OR_MORE);
}
}  // namespace

// Intent not set constant.
const char* const kIntentNotSet = "NotSet";

namespace {
const char kDropOut[] = "Android.AutofillAssistant.DropOutReason";
const char kTtsButtonAction[] =
    "Android.AutofillAssistant.TextToSpeech.ButtonAction";
const char kTtsEngineEvent[] =
    "Android.AutofillAssistant.TextToSpeech.EngineEvent";
const char kFeatureModuleInstallation[] =
    "Android.AutofillAssistant.FeatureModuleInstallation";
const char kPaymentRequestPrefilled[] =
    "Android.AutofillAssistant.PaymentRequest.Prefilled";
const char kPaymentRequestAutofillInfoChanged[] =
    "Android.AutofillAssistant.PaymentRequest.AutofillChanged";
const char kPaymentRequestFirstNameOnly[] =
    "Android.AutofillAssistant.PaymentRequest.FirstNameOnly";
const char kDependenciesInvalidated[] =
    "Android.AutofillAssistant.DependenciesInvalidated";
const char kOnboardingFetcherResultStatus[] =
    "Android.AutofillAssistant.OnboardingFetcher.ResultStatus";
static bool DROPOUT_RECORDED = false;

std::string GetSuffixForIntent(const std::string& intent) {
  base::flat_map<std::string, std::string> histogramsSuffixes = {
      {kBuyMovieTicket, ".BuyMovieTicket"},
      {kFlightsCheckin, ".FlightsCheckin"},
      {kFoodOrdering, ".FoodOrdering"},
      {kFoodOrderingDelivery, ".FoodOrderingDelivery"},
      {kFoodOrderingPickup, ".FoodOrderingPickup"},
      {kPasswordChange, ".PasswordChange"},
      {kRentCar, ".RentCar"},
      {kShopping, ".Shopping"},
      {kShoppingAssistedCheckout, ".ShoppingAssistedCheckout"},
      {kTeleport, ".Teleport"},
      {kIntentNotSet, ".NotSet"}};

  // Check if histogram exists for given intent.
  if (histogramsSuffixes.count(intent) == 0) {
    DVLOG(2) << "Unknown intent " << intent;
    return ".UnknownIntent";
  }
  return histogramsSuffixes[intent];
}

// Extracts the enum value corresponding to the intent specified in
// |script_parameters|.
Metrics::AutofillAssistantIntent ExtractIntentFromScriptParameters(
    const ScriptParameters& script_parameters) {
  auto intent = script_parameters.GetIntent();
  if (!intent) {
    return Metrics::AutofillAssistantIntent::UNDEFINED_INTENT;
  }
  // The list of intents that is known at compile-time. Intents not in this list
  // will be recorded as UNDEFINED_INTENT.
  static const base::NoDestructor<
      base::flat_map<std::string, Metrics::AutofillAssistantIntent>>
      intents(
          {{"BUY_MOVIE_TICKET",
            Metrics::AutofillAssistantIntent::BUY_MOVIE_TICKET},
           {"RENT_CAR", Metrics::AutofillAssistantIntent::RENT_CAR},
           {"SHOPPING", Metrics::AutofillAssistantIntent::SHOPPING},
           {"TELEPORT", Metrics::AutofillAssistantIntent::TELEPORT},
           {"SHOPPING_ASSISTED_CHECKOUT",
            Metrics::AutofillAssistantIntent::SHOPPING_ASSISTED_CHECKOUT},
           {"FLIGHTS_CHECKIN",
            Metrics::AutofillAssistantIntent::FLIGHTS_CHECKIN},
           {"FOOD_ORDERING", Metrics::AutofillAssistantIntent::FOOD_ORDERING},
           {"PASSWORD_CHANGE",
            Metrics::AutofillAssistantIntent::PASSWORD_CHANGE},
           {"FOOD_ORDERING_PICKUP",
            Metrics::AutofillAssistantIntent::FOOD_ORDERING_PICKUP},
           {"FOOD_ORDERING_DELIVERY",
            Metrics::AutofillAssistantIntent::FOOD_ORDERING_DELIVERY},
           {"UNLAUNCHED_VERTICAL_1",
            Metrics::AutofillAssistantIntent::UNLAUNCHED_VERTICAL_1},
           {"FIND_COUPONS", Metrics::AutofillAssistantIntent::FIND_COUPONS}});

  auto enum_value_iter = intents->find(*intent);
  if (enum_value_iter == intents->end()) {
    return Metrics::AutofillAssistantIntent::UNDEFINED_INTENT;
  }
  return enum_value_iter->second;
}  // namespace

// Extracts the enum value corresponding to the caller specified in
// |script_parameters|.
Metrics::AutofillAssistantCaller ExtractCallerFromScriptParameters(
    const ScriptParameters& script_parameters) {
  auto caller = script_parameters.GetCaller();
  if (!caller ||
      *caller >
          static_cast<int64_t>(Metrics::AutofillAssistantCaller::kMaxValue) ||
      *caller < 0) {
    return Metrics::AutofillAssistantCaller::UNKNOWN_CALLER;
  }

  return static_cast<Metrics::AutofillAssistantCaller>(*caller);
}

// Extracts the enum value corresponding to the source specified in
// |script_parameters|.
Metrics::AutofillAssistantSource ExtractSourceFromScriptParameters(
    const ScriptParameters& script_parameters) {
  auto source = script_parameters.GetSource();
  if (!source ||
      *source >
          static_cast<int64_t>(Metrics::AutofillAssistantSource::kMaxValue) ||
      *source < 0) {
    return Metrics::AutofillAssistantSource::UNKNOWN_SOURCE;
  }

  return static_cast<Metrics::AutofillAssistantSource>(*source);
}

// Extracts the list of experiments specified in |script_parameters|, if any.
// Returns a bit-wise OR of the running experiments.
int64_t ExtractExperimentsFromScriptParameters(
    const ScriptParameters& script_parameters) {
  std::vector<std::string> experiments = script_parameters.GetExperiments();
  if (experiments.empty()) {
    return static_cast<int64_t>(
        Metrics::AutofillAssistantExperiment::NO_EXPERIMENT);
  }

  // This will be bit-wise OR of running experiments. Currently, there are no
  // known experiments.
  return static_cast<int64_t>(
      Metrics::AutofillAssistantExperiment::UNKNOWN_EXPERIMENT);
}

Metrics::AutofillAssistantStarted ToAutofillAssistantStarted(
    StartupUtil::StartupMode event) {
  switch (event) {
    case StartupUtil::StartupMode::FEATURE_DISABLED:
      return Metrics::AutofillAssistantStarted::FAILED_FEATURE_DISABLED;
    case StartupUtil::StartupMode::MANDATORY_PARAMETERS_MISSING:
      return Metrics::AutofillAssistantStarted::
          FAILED_MANDATORY_PARAMETER_MISSING;
    case StartupUtil::StartupMode::SETTING_DISABLED:
      return Metrics::AutofillAssistantStarted::FAILED_SETTING_DISABLED;
    case StartupUtil::StartupMode::NO_INITIAL_URL:
      return Metrics::AutofillAssistantStarted::FAILED_NO_INITIAL_URL;
    case StartupUtil::StartupMode::START_REGULAR:
      return Metrics::AutofillAssistantStarted::OK_IMMEDIATE_START;
    case StartupUtil::StartupMode::START_BASE64_TRIGGER_SCRIPT:
    case StartupUtil::StartupMode::START_RPC_TRIGGER_SCRIPT:
      return Metrics::AutofillAssistantStarted::OK_DELAYED_START;
  }
}

}  // namespace

// static
void Metrics::RecordDropOut(DropOutReason reason, const std::string& intent) {
  // TODO(arbesser): use an RAII token instead of a static variable to ensure
  // that dropout recording happens exactly once per startup attempt.
  DCHECK_LE(reason, DropOutReason::kMaxValue);
  if (DROPOUT_RECORDED) {
    return;
  }

  auto suffix = GetSuffixForIntent(intent.empty() ? kIntentNotSet : intent);
  base::UmaHistogramEnumeration(kDropOut + suffix, reason);
  base::UmaHistogramEnumeration(kDropOut, reason);
  if (reason != DropOutReason::AA_START) {
    DVLOG(3) << "Drop out with reason: " << reason;
    DROPOUT_RECORDED = true;
  }
}

// static
void Metrics::RecordPaymentRequestPrefilledSuccess(bool initially_complete,
                                                   bool success) {
  if (initially_complete && success) {
    base::UmaHistogramEnumeration(kPaymentRequestPrefilled,
                                  PaymentRequestPrefilled::PREFILLED_SUCCESS);
  } else if (initially_complete && !success) {
    base::UmaHistogramEnumeration(kPaymentRequestPrefilled,
                                  PaymentRequestPrefilled::PREFILLED_FAILURE);
  } else if (!initially_complete && success) {
    base::UmaHistogramEnumeration(
        kPaymentRequestPrefilled,
        PaymentRequestPrefilled::NOTPREFILLED_SUCCESS);
  } else if (!initially_complete && !success) {
    base::UmaHistogramEnumeration(
        kPaymentRequestPrefilled,
        PaymentRequestPrefilled::NOTPREFILLED_FAILURE);
  }
}

// static
void Metrics::RecordPaymentRequestAutofillChanged(bool changed, bool success) {
  if (changed && success) {
    base::UmaHistogramEnumeration(
        kPaymentRequestAutofillInfoChanged,
        PaymentRequestAutofillInfoChanged::CHANGED_SUCCESS);
  } else if (changed && !success) {
    base::UmaHistogramEnumeration(
        kPaymentRequestAutofillInfoChanged,
        PaymentRequestAutofillInfoChanged::CHANGED_FAILURE);
  } else if (!changed && success) {
    base::UmaHistogramEnumeration(
        kPaymentRequestAutofillInfoChanged,
        PaymentRequestAutofillInfoChanged::NOTCHANGED_SUCCESS);
  } else if (!changed && !success) {
    base::UmaHistogramEnumeration(
        kPaymentRequestAutofillInfoChanged,
        PaymentRequestAutofillInfoChanged::NOTCHANGED_FAILURE);
  }
}

// static
void Metrics::RecordPaymentRequestFirstNameOnly(bool first_name_only) {
  base::UmaHistogramBoolean(kPaymentRequestFirstNameOnly, first_name_only);
}

// static
void Metrics::RecordTriggerScriptStarted(ukm::UkmRecorder* ukm_recorder,
                                         ukm::SourceId source_id,
                                         TriggerScriptStarted event) {
  ukm::builders::AutofillAssistant_LiteScriptStarted(source_id)
      .SetLiteScriptStarted(static_cast<int64_t>(event))
      .Record(ukm_recorder);
}

// static
void Metrics::RecordTriggerScriptStarted(ukm::UkmRecorder* ukm_recorder,
                                         ukm::SourceId source_id,
                                         StartupUtil::StartupMode startup_mode,
                                         bool feature_module_installed,
                                         bool is_first_time_user) {
  TriggerScriptStarted event;
  switch (startup_mode) {
    case StartupUtil::StartupMode::FEATURE_DISABLED:
      if (base::FeatureList::IsEnabled(
              features::kAutofillAssistantProactiveHelp) &&
          !feature_module_installed) {
        event = TriggerScriptStarted::DFM_UNAVAILABLE;
      } else {
        event = TriggerScriptStarted::FEATURE_DISABLED;
      }
      break;
    case StartupUtil::StartupMode::SETTING_DISABLED:
      event = TriggerScriptStarted::PROACTIVE_TRIGGERING_DISABLED;
      break;
    case StartupUtil::StartupMode::NO_INITIAL_URL:
      event = TriggerScriptStarted::NO_INITIAL_URL;
      break;
    case StartupUtil::StartupMode::MANDATORY_PARAMETERS_MISSING:
      event = TriggerScriptStarted::MANDATORY_PARAMETER_MISSING;
      break;
    case StartupUtil::StartupMode::START_BASE64_TRIGGER_SCRIPT:
    case StartupUtil::StartupMode::START_RPC_TRIGGER_SCRIPT:
      event = is_first_time_user ? TriggerScriptStarted::FIRST_TIME_USER
                                 : TriggerScriptStarted::RETURNING_USER;
      break;
    case StartupUtil::StartupMode::START_REGULAR:
      // Regular starts do not record impressions for |TriggerScriptStarted|.
      return;
  }

  RecordTriggerScriptStarted(ukm_recorder, source_id, event);
}

// static
void Metrics::RecordTriggerScriptFinished(
    ukm::UkmRecorder* ukm_recorder,
    ukm::SourceId source_id,
    TriggerScriptProto::TriggerUIType trigger_ui_type,
    TriggerScriptFinishedState event) {
  ukm::builders::AutofillAssistant_LiteScriptFinished(source_id)
      .SetTriggerUIType(static_cast<int64_t>(trigger_ui_type))
      .SetLiteScriptFinished(static_cast<int64_t>(event))
      .Record(ukm_recorder);
}

// static
void Metrics::RecordTriggerScriptShownToUser(
    ukm::UkmRecorder* ukm_recorder,
    ukm::SourceId source_id,
    TriggerScriptProto::TriggerUIType trigger_ui_type,
    TriggerScriptShownToUser event) {
  ukm::builders::AutofillAssistant_LiteScriptShownToUser(source_id)
      .SetTriggerUIType(static_cast<int64_t>(trigger_ui_type))
      .SetLiteScriptShownToUser(static_cast<int64_t>(event))
      .Record(ukm_recorder);
}

// static
void Metrics::RecordTriggerScriptOnboarding(
    ukm::UkmRecorder* ukm_recorder,
    ukm::SourceId source_id,
    TriggerScriptProto::TriggerUIType trigger_ui_type,
    TriggerScriptOnboarding event) {
  ukm::builders::AutofillAssistant_LiteScriptOnboarding(source_id)
      .SetTriggerUIType(static_cast<int64_t>(trigger_ui_type))
      .SetLiteScriptOnboarding(static_cast<int64_t>(event))
      .Record(ukm_recorder);
}

// static
void Metrics::RecordRegularScriptOnboarding(ukm::UkmRecorder* ukm_recorder,
                                            ukm::SourceId source_id,
                                            Metrics::Onboarding event) {
  ukm::builders::AutofillAssistant_RegularScriptOnboarding(source_id)
      .SetOnboarding(static_cast<int64_t>(event))
      .Record(ukm_recorder);
}

// static
void Metrics::RecordInChromeTriggerAction(ukm::UkmRecorder* ukm_recorder,
                                          ukm::SourceId source_id,
                                          InChromeTriggerAction event) {
  ukm::builders::AutofillAssistant_InChromeTriggering(source_id)
      .SetInChromeTriggerAction(static_cast<int64_t>(event))
      .Record(ukm_recorder);
}

// static
void Metrics::RecordTtsButtonAction(TtsButtonAction action) {
  DCHECK_LE(action, TtsButtonAction::kMaxValue);
  base::UmaHistogramEnumeration(kTtsButtonAction, action);
}

// static
void Metrics::RecordTtsEngineEvent(TtsEngineEvent event) {
  DCHECK_LE(event, TtsEngineEvent::kMaxValue);
  base::UmaHistogramEnumeration(kTtsEngineEvent, event);
}

// static
void Metrics::RecordFeatureModuleInstallation(FeatureModuleInstallation event) {
  DCHECK_LE(event, FeatureModuleInstallation::kMaxValue);
  base::UmaHistogramEnumeration(kFeatureModuleInstallation, event);
}

// static
void Metrics::RecordTriggerConditionEvaluationTime(
    ukm::UkmRecorder* ukm_recorder,
    ukm::SourceId source_id,
    base::TimeDelta evaluation_time) {
  ukm::builders::AutofillAssistant_Timing(source_id)
      .SetTriggerConditionEvaluationMs(evaluation_time.InMilliseconds())
      .Record(ukm_recorder);
}

// static
void Metrics::RecordDependenciesInvalidated(
    DependenciesInvalidated dependencies_invalidated) {
  DCHECK_LE(dependencies_invalidated, DependenciesInvalidated::kMaxValue);
  base::UmaHistogramEnumeration(kDependenciesInvalidated,
                                dependencies_invalidated);
}

// static
void Metrics::RecordStartRequest(ukm::UkmRecorder* ukm_recorder,
                                 ukm::SourceId source_id,
                                 const ScriptParameters& script_parameters,
                                 StartupUtil::StartupMode event) {
  ukm::builders::AutofillAssistant_StartRequest(source_id)
      .SetCaller(static_cast<int64_t>(
          ExtractCallerFromScriptParameters(script_parameters)))
      .SetSource(static_cast<int64_t>(
          ExtractSourceFromScriptParameters(script_parameters)))
      .SetIntent(static_cast<int64_t>(
          ExtractIntentFromScriptParameters(script_parameters)))
      .SetExperiments(ExtractExperimentsFromScriptParameters(script_parameters))
      .SetStarted(static_cast<int64_t>(ToAutofillAssistantStarted(event)))
      .Record(ukm_recorder);
}

// static
void Metrics::RecordContactMetrics(ukm::UkmRecorder* ukm_recorder,
                                   ukm::SourceId source_id,
                                   int complete_count,
                                   int incomplete_count,
                                   int initially_selected_field_bitmask,
                                   UserDataSelectionState selection_state) {
  ukm::builders::AutofillAssistant_CollectContact(source_id)
      .SetCompleteContactProfilesCount(ToEntryCountBucket(complete_count))
      .SetIncompleteContactProfilesCount(ToEntryCountBucket(incomplete_count))
      .SetInitialContactFieldsStatus(initially_selected_field_bitmask)
      .SetContactModified(static_cast<int64_t>(selection_state))
      .Record(ukm_recorder);
}

void Metrics::RecordCreditCardMetrics(
    ukm::UkmRecorder* ukm_recorder,
    ukm::SourceId source_id,
    int complete_count,
    int incomplete_count,
    int initially_selected_card_field_bitmask,
    int initially_selected_billing_address_field_bitmask,
    UserDataSelectionState selection_state) {
  ukm::builders::AutofillAssistant_CollectPayment(source_id)
      .SetCompleteCreditCardsCount(ToEntryCountBucket(complete_count))
      .SetIncompleteCreditCardsCount(ToEntryCountBucket(incomplete_count))
      .SetInitialCreditCardFieldsStatus(initially_selected_card_field_bitmask)
      .SetInitialBillingAddressFieldsStatus(
          initially_selected_billing_address_field_bitmask)
      .SetCreditCardModified(static_cast<int64_t>(selection_state))
      .Record(ukm_recorder);
}

// static
void Metrics::RecordShippingMetrics(ukm::UkmRecorder* ukm_recorder,
                                    ukm::SourceId source_id,
                                    int complete_count,
                                    int incomplete_count,
                                    int initially_selected_field_bitmask,
                                    UserDataSelectionState selection_state) {
  ukm::builders::AutofillAssistant_CollectShippingAddress(source_id)
      .SetCompleteShippingProfilesCount(ToEntryCountBucket(complete_count))
      .SetIncompleteShippingProfilesCount(ToEntryCountBucket(incomplete_count))
      .SetInitialShippingFieldsStatus(initially_selected_field_bitmask)
      .SetShippingModified(static_cast<int64_t>(selection_state))
      .Record(ukm_recorder);
}

// static
void Metrics::RecordCollectUserDataSuccess(ukm::UkmRecorder* ukm_recorder,
                                           ukm::SourceId source_id,
                                           bool success,
                                           int64_t time_taken_ms) {
  ukm::builders::AutofillAssistant_CollectUserDataResult(source_id)
      .SetResult(static_cast<int64_t>(
          success ? Metrics::CollectUserDataResult::SUCCESS
                  : Metrics::CollectUserDataResult::FAILURE))
      .SetTimeTakenMs(time_taken_ms)
      .Record(ukm_recorder);
}

// static
void Metrics::RecordOnboardingFetcherResult(
    OnboardingFetcherResultStatus status) {
  DCHECK_LE(status, OnboardingFetcherResultStatus::kMaxValue);
  base::UmaHistogramEnumeration(kOnboardingFetcherResultStatus, status);
}

}  // namespace autofill_assistant