diff options
Diffstat (limited to 'toolkit/components/glean/bindings/private')
41 files changed, 3756 insertions, 0 deletions
diff --git a/toolkit/components/glean/bindings/private/Boolean.cpp b/toolkit/components/glean/bindings/private/Boolean.cpp new file mode 100644 index 0000000000..253c4d5b9d --- /dev/null +++ b/toolkit/components/glean/bindings/private/Boolean.cpp @@ -0,0 +1,79 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/glean/bindings/Boolean.h" + +#include "nsString.h" +#include "mozilla/Components.h" +#include "mozilla/ResultVariant.h" +#include "mozilla/glean/bindings/ScalarGIFFTMap.h" +#include "mozilla/glean/fog_ffi_generated.h" +#include "nsIClassInfoImpl.h" +#include "Common.h" + +namespace mozilla::glean { + +namespace impl { + +void BooleanMetric::Set(bool aValue) const { + auto scalarId = ScalarIdForMetric(mId); + if (scalarId) { + Telemetry::ScalarSet(scalarId.extract(), aValue); + } else if (IsSubmetricId(mId)) { + GetLabeledMirrorLock().apply([&](auto& lock) { + auto tuple = lock.ref()->MaybeGet(mId); + if (tuple) { + Telemetry::ScalarSet(std::get<0>(tuple.ref()), std::get<1>(tuple.ref()), + aValue); + } + }); + } + fog_boolean_set(mId, int(aValue)); +} + +Result<Maybe<bool>, nsCString> BooleanMetric::TestGetValue( + const nsACString& aPingName) const { + nsCString err; + if (fog_boolean_test_get_error(mId, &err)) { + return Err(err); + } + if (!fog_boolean_test_has_value(mId, &aPingName)) { + return Maybe<bool>(); + } + return Some(fog_boolean_test_get_value(mId, &aPingName)); +} + +} // namespace impl + +NS_IMPL_CLASSINFO(GleanBoolean, nullptr, 0, {0}) +NS_IMPL_ISUPPORTS_CI(GleanBoolean, nsIGleanBoolean) + +NS_IMETHODIMP +GleanBoolean::Set(bool aValue) { + mBoolean.Set(aValue); + return NS_OK; +} + +NS_IMETHODIMP +GleanBoolean::TestGetValue(const nsACString& aStorageName, + JS::MutableHandle<JS::Value> aResult) { + auto result = mBoolean.TestGetValue(aStorageName); + if (result.isErr()) { + aResult.set(JS::UndefinedValue()); + LogToBrowserConsole(nsIScriptError::errorFlag, + NS_ConvertUTF8toUTF16(result.unwrapErr())); + return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; + } + auto optresult = result.unwrap(); + if (optresult.isNothing()) { + aResult.set(JS::UndefinedValue()); + } else { + aResult.set(JS::BooleanValue(optresult.value())); + } + return NS_OK; +} + +} // namespace mozilla::glean diff --git a/toolkit/components/glean/bindings/private/Boolean.h b/toolkit/components/glean/bindings/private/Boolean.h new file mode 100644 index 0000000000..890820440d --- /dev/null +++ b/toolkit/components/glean/bindings/private/Boolean.h @@ -0,0 +1,72 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_glean_GleanBoolean_h +#define mozilla_glean_GleanBoolean_h + +#include "mozilla/Result.h" +#include "nsIGleanMetrics.h" +#include "nsString.h" + +namespace mozilla { +namespace glean { + +namespace impl { + +class BooleanMetric { + public: + constexpr explicit BooleanMetric(uint32_t id) : mId(id) {} + + /** + * Set to the specified boolean value. + * + * @param aValue the value to set. + */ + void Set(bool aValue) const; + + /** + * **Test-only API** + * + * Gets the currently stored value as a boolean. + * + * This function will attempt to await the last parent-process task (if any) + * writing to the the metric's storage engine before returning a value. + * This function will not wait for data from child processes. + * + * This doesn't clear the stored value. + * Parent process only. Panics in child processes. + * + * @param aPingName The (optional) name of the ping to retrieve the metric + * for. Defaults to the first value in `send_in_pings`. + * + * @return value of the stored metric. + */ + Result<Maybe<bool>, nsCString> TestGetValue( + const nsACString& aPingName = nsCString()) const; + + private: + const uint32_t mId; +}; + +} // namespace impl + +class GleanBoolean final : public nsIGleanBoolean { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIGLEANBOOLEAN + + explicit GleanBoolean(uint32_t id) : mBoolean(id){}; + + private: + virtual ~GleanBoolean() = default; + + const impl::BooleanMetric mBoolean; +}; + +} // namespace glean +} // namespace mozilla + +#endif /* mozilla_glean_GleanBoolean.h */ diff --git a/toolkit/components/glean/bindings/private/Common.cpp b/toolkit/components/glean/bindings/private/Common.cpp new file mode 100644 index 0000000000..f84c39c05d --- /dev/null +++ b/toolkit/components/glean/bindings/private/Common.cpp @@ -0,0 +1,33 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "Common.h" +#include "nsComponentManagerUtils.h" +#include "nsIConsoleService.h" +#include "nsIScriptError.h" +#include "nsServiceManagerUtils.h" + +namespace mozilla::glean { + +// This is copied from TelemetryCommons.cpp (and modified because consoleservice +// handles threading), but that one is not exported. +// There's _at least_ a third instance of `LogToBrowserConsole`, +// but that one is slightly different. +void LogToBrowserConsole(uint32_t aLogLevel, const nsAString& aMsg) { + nsCOMPtr<nsIConsoleService> console( + do_GetService("@mozilla.org/consoleservice;1")); + if (!console) { + NS_WARNING("Failed to log message to console."); + return; + } + + nsCOMPtr<nsIScriptError> error(do_CreateInstance(NS_SCRIPTERROR_CONTRACTID)); + error->Init(aMsg, u""_ns, u""_ns, 0, 0, aLogLevel, "chrome javascript"_ns, + false /* from private window */, true /* from chrome context */); + console->LogMessage(error); +} + +} // namespace mozilla::glean diff --git a/toolkit/components/glean/bindings/private/Common.h b/toolkit/components/glean/bindings/private/Common.h new file mode 100644 index 0000000000..e3dd7a0a47 --- /dev/null +++ b/toolkit/components/glean/bindings/private/Common.h @@ -0,0 +1,24 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2; -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_glean_Common_h +#define mozilla_glean_Common_h + +#include "nsIScriptError.h" + +namespace mozilla::glean { + +/** + * Dumps a log message to the Browser Console using the provided level. + * + * @param aLogLevel The level to use when displaying the message in the browser + * console (e.g. nsIScriptError::warningFlag, ...). + * @param aMsg The text message to print to the console. + */ +void LogToBrowserConsole(uint32_t aLogLevel, const nsAString& aMsg); + +} // namespace mozilla::glean + +#endif /* mozilla_glean_Common_h */ diff --git a/toolkit/components/glean/bindings/private/Counter.cpp b/toolkit/components/glean/bindings/private/Counter.cpp new file mode 100644 index 0000000000..965bde75f4 --- /dev/null +++ b/toolkit/components/glean/bindings/private/Counter.cpp @@ -0,0 +1,82 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/glean/bindings/Counter.h" + +#include "nsString.h" +#include "mozilla/Components.h" +#include "mozilla/ResultVariant.h" +#include "mozilla/glean/bindings/ScalarGIFFTMap.h" +#include "mozilla/glean/fog_ffi_generated.h" +#include "Common.h" +#include "nsIClassInfoImpl.h" +#include "nsIScriptError.h" + +namespace mozilla::glean { + +namespace impl { + +void CounterMetric::Add(int32_t aAmount) const { + auto scalarId = ScalarIdForMetric(mId); + if (aAmount >= 0) { + if (scalarId) { + Telemetry::ScalarAdd(scalarId.extract(), aAmount); + } else if (IsSubmetricId(mId)) { + GetLabeledMirrorLock().apply([&](auto& lock) { + auto tuple = lock.ref()->MaybeGet(mId); + if (tuple && aAmount > 0) { + Telemetry::ScalarAdd(std::get<0>(tuple.ref()), + std::get<1>(tuple.ref()), (uint32_t)aAmount); + } + }); + } + } + fog_counter_add(mId, aAmount); +} + +Result<Maybe<int32_t>, nsCString> CounterMetric::TestGetValue( + const nsACString& aPingName) const { + nsCString err; + if (fog_counter_test_get_error(mId, &err)) { + return Err(err); + } + if (!fog_counter_test_has_value(mId, &aPingName)) { + return Maybe<int32_t>(); // can't use Nothing() or templates will fail. + } + return Some(fog_counter_test_get_value(mId, &aPingName)); +} + +} // namespace impl + +NS_IMPL_CLASSINFO(GleanCounter, nullptr, 0, {0}) +NS_IMPL_ISUPPORTS_CI(GleanCounter, nsIGleanCounter) + +NS_IMETHODIMP +GleanCounter::Add(int32_t aAmount) { + mCounter.Add(aAmount); + return NS_OK; +} + +NS_IMETHODIMP +GleanCounter::TestGetValue(const nsACString& aStorageName, + JS::MutableHandle<JS::Value> aResult) { + auto result = mCounter.TestGetValue(aStorageName); + if (result.isErr()) { + aResult.set(JS::UndefinedValue()); + LogToBrowserConsole(nsIScriptError::errorFlag, + NS_ConvertUTF8toUTF16(result.unwrapErr())); + return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; + } + auto optresult = result.unwrap(); + if (optresult.isNothing()) { + aResult.set(JS::UndefinedValue()); + } else { + aResult.set(JS::Int32Value(optresult.value())); + } + return NS_OK; +} + +} // namespace mozilla::glean diff --git a/toolkit/components/glean/bindings/private/Counter.h b/toolkit/components/glean/bindings/private/Counter.h new file mode 100644 index 0000000000..e1e7190e4e --- /dev/null +++ b/toolkit/components/glean/bindings/private/Counter.h @@ -0,0 +1,70 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_glean_GleanCounter_h +#define mozilla_glean_GleanCounter_h + +#include "mozilla/Maybe.h" +#include "mozilla/Result.h" +#include "nsIGleanMetrics.h" +#include "nsString.h" + +namespace mozilla::glean { + +namespace impl { + +class CounterMetric { + public: + constexpr explicit CounterMetric(uint32_t aId) : mId(aId) {} + + /* + * Increases the counter by `amount`. + * + * @param aAmount The amount to increase by. Should be positive. + */ + void Add(int32_t aAmount = 1) const; + + /** + * **Test-only API** + * + * Gets the currently stored value as an integer. + * + * This function will attempt to await the last parent-process task (if any) + * writing to the the metric's storage engine before returning a value. + * This function will not wait for data from child processes. + * + * This doesn't clear the stored value. + * Parent process only. Panics in child processes. + * + * @param aPingName The (optional) name of the ping to retrieve the metric + * for. Defaults to the first value in `send_in_pings`. + * + * @return value of the stored metric, or Nothing() if there is no value. + */ + Result<Maybe<int32_t>, nsCString> TestGetValue( + const nsACString& aPingName = nsCString()) const; + + private: + const uint32_t mId; +}; +} // namespace impl + +class GleanCounter final : public nsIGleanCounter { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIGLEANCOUNTER + + explicit GleanCounter(uint32_t id) : mCounter(id){}; + + private: + virtual ~GleanCounter() = default; + + const impl::CounterMetric mCounter; +}; + +} // namespace mozilla::glean + +#endif /* mozilla_glean_GleanCounter_h */ diff --git a/toolkit/components/glean/bindings/private/CustomDistribution.cpp b/toolkit/components/glean/bindings/private/CustomDistribution.cpp new file mode 100644 index 0000000000..4abd0100e7 --- /dev/null +++ b/toolkit/components/glean/bindings/private/CustomDistribution.cpp @@ -0,0 +1,125 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/glean/bindings/CustomDistribution.h" + +#include "Common.h" +#include "mozilla/Components.h" +#include "mozilla/ResultVariant.h" +#include "mozilla/glean/bindings/HistogramGIFFTMap.h" +#include "mozilla/glean/fog_ffi_generated.h" +#include "nsIClassInfoImpl.h" +#include "nsJSUtils.h" +#include "nsPrintfCString.h" +#include "nsString.h" +#include "js/PropertyAndElement.h" // JS_DefineProperty + +namespace mozilla::glean { + +namespace impl { + +void CustomDistributionMetric::AccumulateSamples( + const nsTArray<uint64_t>& aSamples) const { + auto hgramId = HistogramIdForMetric(mId); + if (hgramId) { + auto id = hgramId.extract(); + // N.B.: There is an `Accumulate(nsTArray<T>)`, but `T` is `uint32_t` and + // we got `uint64_t`s here. + for (auto sample : aSamples) { + Telemetry::Accumulate(id, sample); + } + } + fog_custom_distribution_accumulate_samples(mId, &aSamples); +} + +void CustomDistributionMetric::AccumulateSamplesSigned( + const nsTArray<int64_t>& aSamples) const { + auto hgramId = HistogramIdForMetric(mId); + if (hgramId) { + auto id = hgramId.extract(); + // N.B.: There is an `Accumulate(nsTArray<T>)`, but `T` is `uint32_t` and + // we got `int64_t`s here. + for (auto sample : aSamples) { + Telemetry::Accumulate(id, sample); + } + } + fog_custom_distribution_accumulate_samples_signed(mId, &aSamples); +} + +Result<Maybe<DistributionData>, nsCString> +CustomDistributionMetric::TestGetValue(const nsACString& aPingName) const { + nsCString err; + if (fog_custom_distribution_test_get_error(mId, &err)) { + return Err(err); + } + if (!fog_custom_distribution_test_has_value(mId, &aPingName)) { + return Maybe<DistributionData>(); + } + nsTArray<uint64_t> buckets; + nsTArray<uint64_t> counts; + uint64_t sum; + fog_custom_distribution_test_get_value(mId, &aPingName, &sum, &buckets, + &counts); + return Some(DistributionData(buckets, counts, sum)); +} + +} // namespace impl + +NS_IMPL_CLASSINFO(GleanCustomDistribution, nullptr, 0, {0}) +NS_IMPL_ISUPPORTS_CI(GleanCustomDistribution, nsIGleanCustomDistribution) + +NS_IMETHODIMP +GleanCustomDistribution::AccumulateSamples(const nsTArray<int64_t>& aSamples) { + mCustomDist.AccumulateSamplesSigned(aSamples); + return NS_OK; +} + +NS_IMETHODIMP +GleanCustomDistribution::TestGetValue(const nsACString& aPingName, + JSContext* aCx, + JS::MutableHandle<JS::Value> aResult) { + auto result = mCustomDist.TestGetValue(aPingName); + if (result.isErr()) { + aResult.set(JS::UndefinedValue()); + LogToBrowserConsole(nsIScriptError::errorFlag, + NS_ConvertUTF8toUTF16(result.unwrapErr())); + return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; + } + auto optresult = result.unwrap(); + if (optresult.isNothing()) { + aResult.set(JS::UndefinedValue()); + } else { + // Build return value of the form: { sum: #, values: {bucket1: count1, ...} + JS::Rooted<JSObject*> root(aCx, JS_NewPlainObject(aCx)); + if (!root) { + return NS_ERROR_FAILURE; + } + uint64_t sum = optresult.ref().sum; + if (!JS_DefineProperty(aCx, root, "sum", static_cast<double>(sum), + JSPROP_ENUMERATE)) { + return NS_ERROR_FAILURE; + } + JS::Rooted<JSObject*> valuesObj(aCx, JS_NewPlainObject(aCx)); + if (!valuesObj || + !JS_DefineProperty(aCx, root, "values", valuesObj, JSPROP_ENUMERATE)) { + return NS_ERROR_FAILURE; + } + auto& data = optresult.ref().values; + for (const auto& entry : data) { + const uint64_t bucket = entry.GetKey(); + const uint64_t count = entry.GetData(); + if (!JS_DefineProperty(aCx, valuesObj, + nsPrintfCString("%" PRIu64, bucket).get(), + static_cast<double>(count), JSPROP_ENUMERATE)) { + return NS_ERROR_FAILURE; + } + } + aResult.setObject(*root); + } + return NS_OK; +} + +} // namespace mozilla::glean diff --git a/toolkit/components/glean/bindings/private/CustomDistribution.h b/toolkit/components/glean/bindings/private/CustomDistribution.h new file mode 100644 index 0000000000..1ed9b78788 --- /dev/null +++ b/toolkit/components/glean/bindings/private/CustomDistribution.h @@ -0,0 +1,83 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_glean_GleanCustomDistribution_h +#define mozilla_glean_GleanCustomDistribution_h + +#include "mozilla/glean/bindings/DistributionData.h" +#include "mozilla/Maybe.h" +#include "mozilla/Result.h" +#include "nsIGleanMetrics.h" +#include "nsTArray.h" + +namespace mozilla::glean { + +namespace impl { + +class CustomDistributionMetric { + public: + constexpr explicit CustomDistributionMetric(uint32_t aId) : mId(aId) {} + + /** + * Accumulates the provided samples in the metric. + * + * @param aSamples The vector holding the samples to be recorded by the + * metric. + */ + void AccumulateSamples(const nsTArray<uint64_t>& aSamples) const; + + /** + * Accumulates the provided samples in the metric. + * + * @param aSamples The vector holding the samples to be recorded by the + * metric. + * + * Notes: Discards any negative value in `samples` + * and reports an `InvalidValue` error for each of them. + */ + void AccumulateSamplesSigned(const nsTArray<int64_t>& aSamples) const; + + /** + * **Test-only API** + * + * Gets the currently stored value as a DistributionData. + * + * This function will attempt to await the last parent-process task (if any) + * writing to the the metric's storage engine before returning a value. + * This function will not wait for data from child processes. + * + * This doesn't clear the stored value. + * Parent process only. Panics in child processes. + * + * @param aPingName The (optional) name of the ping to retrieve the metric + * for. Defaults to the first value in `send_in_pings`. + * + * @return value of the stored metric, or Nothing() if there is no value. + */ + Result<Maybe<DistributionData>, nsCString> TestGetValue( + const nsACString& aPingName = nsCString()) const; + + private: + const uint32_t mId; +}; +} // namespace impl + +class GleanCustomDistribution final : public nsIGleanCustomDistribution { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIGLEANCUSTOMDISTRIBUTION + + explicit GleanCustomDistribution(uint64_t aId) : mCustomDist(aId){}; + + private: + virtual ~GleanCustomDistribution() = default; + + const impl::CustomDistributionMetric mCustomDist; +}; + +} // namespace mozilla::glean + +#endif /* mozilla_glean_GleanCustomDistribution_h */ diff --git a/toolkit/components/glean/bindings/private/Datetime.cpp b/toolkit/components/glean/bindings/private/Datetime.cpp new file mode 100644 index 0000000000..788de6eb8f --- /dev/null +++ b/toolkit/components/glean/bindings/private/Datetime.cpp @@ -0,0 +1,126 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/glean/bindings/Datetime.h" + +#include "jsapi.h" +#include "js/Date.h" +#include "nsString.h" +#include "nsIScriptError.h" +#include "mozilla/Components.h" +#include "mozilla/ResultVariant.h" +#include "mozilla/glean/bindings/ScalarGIFFTMap.h" +#include "mozilla/glean/fog_ffi_generated.h" +#include "nsIClassInfoImpl.h" +#include "Common.h" +#include "prtime.h" + +namespace mozilla::glean { + +namespace impl { + +void DatetimeMetric::Set(const PRExplodedTime* aValue) const { + PRExplodedTime exploded; + if (!aValue) { + PR_ExplodeTime(PR_Now(), PR_LocalTimeParameters, &exploded); + } else { + exploded = *aValue; + } + + auto id = ScalarIdForMetric(mId); + if (id) { + const uint32_t buflen = 64; // More than enough for now. + char buf[buflen]; + uint32_t written = PR_FormatTime(buf, buflen, "%FT%T%z", &exploded); + if (written > 2 && written < 64) { + // Format's still not quite there. Gotta put a `:` between timezone + // hours and minutes + buf[written] = '\0'; + buf[written - 1] = buf[written - 2]; + buf[written - 2] = buf[written - 3]; + buf[written - 3] = ':'; + Telemetry::ScalarSet(id.extract(), NS_ConvertASCIItoUTF16(buf)); + } + } + + int32_t offset = + exploded.tm_params.tp_gmt_offset + exploded.tm_params.tp_dst_offset; + FogDatetime dt{exploded.tm_year, + static_cast<uint32_t>(exploded.tm_month + 1), + static_cast<uint32_t>(exploded.tm_mday), + static_cast<uint32_t>(exploded.tm_hour), + static_cast<uint32_t>(exploded.tm_min), + static_cast<uint32_t>(exploded.tm_sec), + static_cast<uint32_t>(exploded.tm_usec * 1000), + offset}; + fog_datetime_set(mId, &dt); +} + +Result<Maybe<PRExplodedTime>, nsCString> DatetimeMetric::TestGetValue( + const nsACString& aPingName) const { + nsCString err; + if (fog_datetime_test_get_error(mId, &err)) { + return Err(err); + } + if (!fog_datetime_test_has_value(mId, &aPingName)) { + return Maybe<PRExplodedTime>(); + } + FogDatetime ret{0}; + fog_datetime_test_get_value(mId, &aPingName, &ret); + PRExplodedTime pret{0}; + pret.tm_year = static_cast<PRInt16>(ret.year); + pret.tm_month = static_cast<PRInt32>(ret.month - 1); + pret.tm_mday = static_cast<PRInt32>(ret.day); + pret.tm_hour = static_cast<PRInt32>(ret.hour); + pret.tm_min = static_cast<PRInt32>(ret.minute); + pret.tm_sec = static_cast<PRInt32>(ret.second); + pret.tm_usec = static_cast<PRInt32>(ret.nano / 1000); // truncated is fine + pret.tm_params.tp_gmt_offset = static_cast<PRInt32>(ret.offset_seconds); + return Some(std::move(pret)); +} + +} // namespace impl + +NS_IMPL_CLASSINFO(GleanDatetime, nullptr, 0, {0}) +NS_IMPL_ISUPPORTS_CI(GleanDatetime, nsIGleanDatetime) + +NS_IMETHODIMP +GleanDatetime::Set(PRTime aValue, uint8_t aOptionalArgc) { + if (aOptionalArgc == 0) { + mDatetime.Set(); + } else { + PRExplodedTime exploded; + PR_ExplodeTime(aValue, PR_LocalTimeParameters, &exploded); + mDatetime.Set(&exploded); + } + + return NS_OK; +} + +NS_IMETHODIMP +GleanDatetime::TestGetValue(const nsACString& aStorageName, JSContext* aCx, + JS::MutableHandle<JS::Value> aResult) { + auto result = mDatetime.TestGetValue(aStorageName); + if (result.isErr()) { + aResult.set(JS::UndefinedValue()); + LogToBrowserConsole(nsIScriptError::errorFlag, + NS_ConvertUTF8toUTF16(result.unwrapErr())); + return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; + } + auto optresult = result.unwrap(); + if (optresult.isNothing()) { + aResult.set(JS::UndefinedValue()); + } else { + double millis = + static_cast<double>(PR_ImplodeTime(optresult.ptr())) / PR_USEC_PER_MSEC; + JS::Rooted<JSObject*> root(aCx, + JS::NewDateObject(aCx, JS::TimeClip(millis))); + aResult.setObject(*root); + } + return NS_OK; +} + +} // namespace mozilla::glean diff --git a/toolkit/components/glean/bindings/private/Datetime.h b/toolkit/components/glean/bindings/private/Datetime.h new file mode 100644 index 0000000000..4fec93d251 --- /dev/null +++ b/toolkit/components/glean/bindings/private/Datetime.h @@ -0,0 +1,71 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_glean_GleanDatetime_h +#define mozilla_glean_GleanDatetime_h + +#include "mozilla/Maybe.h" +#include "mozilla/Result.h" +#include "nsIGleanMetrics.h" +#include "nsString.h" +#include "prtime.h" + +namespace mozilla::glean { + +namespace impl { + +class DatetimeMetric { + public: + constexpr explicit DatetimeMetric(uint32_t aId) : mId(aId) {} + + /* + * Set the datetime to the provided value, or the local now. + * + * @param amount The date value to set. + */ + void Set(const PRExplodedTime* aValue = nullptr) const; + + /** + * **Test-only API** + * + * Gets the currently stored value as a PRExplodedTime. + * + * This function will attempt to await the last parent-process task (if any) + * writing to the the metric's storage engine before returning a value. + * This function will not wait for data from child processes. + * + * This doesn't clear the stored value. + * Parent process only. Panics in child processes. + * + * @param aPingName The (optional) name of the ping to retrieve the metric + * for. Defaults to the first value in `send_in_pings`. + * + * @return value of the stored metric, or Nothing() if there is no value. + */ + Result<Maybe<PRExplodedTime>, nsCString> TestGetValue( + const nsACString& aPingName = nsCString()) const; + + private: + const uint32_t mId; +}; +} // namespace impl + +class GleanDatetime final : public nsIGleanDatetime { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIGLEANDATETIME + + explicit GleanDatetime(uint32_t aId) : mDatetime(aId){}; + + private: + virtual ~GleanDatetime() = default; + + const impl::DatetimeMetric mDatetime; +}; + +} // namespace mozilla::glean + +#endif /* mozilla_glean_GleanDatetime_h */ diff --git a/toolkit/components/glean/bindings/private/Denominator.cpp b/toolkit/components/glean/bindings/private/Denominator.cpp new file mode 100644 index 0000000000..3162c27f76 --- /dev/null +++ b/toolkit/components/glean/bindings/private/Denominator.cpp @@ -0,0 +1,72 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/glean/bindings/Denominator.h" + +#include "nsString.h" +#include "mozilla/Components.h" +#include "mozilla/ResultVariant.h" +#include "mozilla/glean/bindings/ScalarGIFFTMap.h" +#include "mozilla/glean/fog_ffi_generated.h" +#include "nsIClassInfoImpl.h" +#include "nsIScriptError.h" +#include "Common.h" + +namespace mozilla::glean { + +namespace impl { + +void DenominatorMetric::Add(int32_t aAmount) const { + auto scalarId = ScalarIdForMetric(mId); + if (scalarId && aAmount >= 0) { + Telemetry::ScalarAdd(scalarId.extract(), aAmount); + } + fog_denominator_add(mId, aAmount); +} + +Result<Maybe<int32_t>, nsCString> DenominatorMetric::TestGetValue( + const nsACString& aPingName) const { + nsCString err; + if (fog_denominator_test_get_error(mId, &err)) { + return Err(err); + } + if (!fog_denominator_test_has_value(mId, &aPingName)) { + return Maybe<int32_t>(); + } + return Some(fog_denominator_test_get_value(mId, &aPingName)); +} + +} // namespace impl + +NS_IMPL_CLASSINFO(GleanDenominator, nullptr, 0, {0}) +NS_IMPL_ISUPPORTS_CI(GleanDenominator, nsIGleanDenominator) + +NS_IMETHODIMP +GleanDenominator::Add(int32_t aAmount) { + mDenominator.Add(aAmount); + return NS_OK; +} + +NS_IMETHODIMP +GleanDenominator::TestGetValue(const nsACString& aStorageName, + JS::MutableHandle<JS::Value> aResult) { + auto result = mDenominator.TestGetValue(aStorageName); + if (result.isErr()) { + aResult.set(JS::UndefinedValue()); + LogToBrowserConsole(nsIScriptError::errorFlag, + NS_ConvertUTF8toUTF16(result.unwrapErr())); + return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; + } + auto optresult = result.unwrap(); + if (optresult.isNothing()) { + aResult.set(JS::UndefinedValue()); + } else { + aResult.set(JS::Int32Value(optresult.value())); + } + return NS_OK; +} + +} // namespace mozilla::glean diff --git a/toolkit/components/glean/bindings/private/Denominator.h b/toolkit/components/glean/bindings/private/Denominator.h new file mode 100644 index 0000000000..c96bf17e8d --- /dev/null +++ b/toolkit/components/glean/bindings/private/Denominator.h @@ -0,0 +1,70 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_glean_GleanDenominator_h +#define mozilla_glean_GleanDenominator_h + +#include "mozilla/Maybe.h" +#include "mozilla/Result.h" +#include "nsIGleanMetrics.h" +#include "nsString.h" + +namespace mozilla::glean { + +namespace impl { + +class DenominatorMetric { + public: + constexpr explicit DenominatorMetric(uint32_t aId) : mId(aId) {} + + /* + * Increases the counter by `amount`. + * + * @param aAmount The amount to increase by. Should be positive. + */ + void Add(int32_t aAmount = 1) const; + + /** + * **Test-only API** + * + * Gets the currently stored value as an integer. + * + * This function will attempt to await the last parent-process task (if any) + * writing to the the metric's storage engine before returning a value. + * This function will not wait for data from child processes. + * + * This doesn't clear the stored value. + * Parent process only. Panics in child processes. + * + * @param aPingName The (optional) name of the ping to retrieve the metric + * for. Defaults to the first value in `send_in_pings`. + * + * @return value of the stored metric, or Nothing() if there is no value. + */ + Result<Maybe<int32_t>, nsCString> TestGetValue( + const nsACString& aPingName = nsCString()) const; + + private: + const uint32_t mId; +}; +} // namespace impl + +class GleanDenominator final : public nsIGleanDenominator { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIGLEANDENOMINATOR + + explicit GleanDenominator(uint32_t id) : mDenominator(id){}; + + private: + virtual ~GleanDenominator() = default; + + const impl::DenominatorMetric mDenominator; +}; + +} // namespace mozilla::glean + +#endif /* mozilla_glean_GleanDenominator_h */ diff --git a/toolkit/components/glean/bindings/private/DistributionData.h b/toolkit/components/glean/bindings/private/DistributionData.h new file mode 100644 index 0000000000..6ff995f222 --- /dev/null +++ b/toolkit/components/glean/bindings/private/DistributionData.h @@ -0,0 +1,32 @@ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_glean_DistributionData_h +#define mozilla_glean_DistributionData_h + +#include "nsTHashMap.h" + +namespace mozilla::glean { + +struct DistributionData final { + uint64_t sum; + nsTHashMap<nsUint64HashKey, uint64_t> values; + + /** + * Create distribution data from the buckets, counts and sum, + * as returned by `fog_*_distribution_test_get_value`. + */ + DistributionData(const nsTArray<uint64_t>& aBuckets, + const nsTArray<uint64_t>& aCounts, uint64_t aSum) + : sum(aSum) { + for (size_t i = 0; i < aBuckets.Length(); ++i) { + this->values.InsertOrUpdate(aBuckets[i], aCounts[i]); + } + } +}; + +} // namespace mozilla::glean + +#endif /* mozilla_glean_DistributionData_h */ diff --git a/toolkit/components/glean/bindings/private/Event.cpp b/toolkit/components/glean/bindings/private/Event.cpp new file mode 100644 index 0000000000..d211c91856 --- /dev/null +++ b/toolkit/components/glean/bindings/private/Event.cpp @@ -0,0 +1,206 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/glean/bindings/Event.h" + +#include "Common.h" +#include "nsString.h" +#include "mozilla/Components.h" +#include "mozilla/dom/ToJSValue.h" +#include "nsIClassInfoImpl.h" +#include "jsapi.h" +#include "js/PropertyAndElement.h" // JS_DefineElement, JS_DefineProperty, JS_Enumerate, JS_GetProperty, JS_GetPropertyById +#include "nsIScriptError.h" + +namespace mozilla::glean { + +NS_IMPL_CLASSINFO(GleanEvent, nullptr, 0, {0}) +NS_IMPL_ISUPPORTS_CI(GleanEvent, nsIGleanEvent) + +// Convert all capital letters to "_x" where "x" is the corresponding lowercase. +nsCString camelToSnake(const nsACString& aCamel) { + nsCString snake; + const auto* start = aCamel.BeginReading(); + const auto* end = aCamel.EndReading(); + for (; start != end; ++start) { + if ('A' <= *start && *start <= 'Z') { + snake.AppendLiteral("_"); + snake.Append(static_cast<char>(std::tolower(*start))); + } else { + snake.Append(*start); + } + } + return snake; +} + +NS_IMETHODIMP +GleanEvent::Record(JS::Handle<JS::Value> aExtra, JSContext* aCx) { + if (aExtra.isNullOrUndefined()) { + mEvent.Record(); + return NS_OK; + } + + if (!aExtra.isObject()) { + LogToBrowserConsole( + nsIScriptError::warningFlag, + u"Extras need to be an object. Event will not be recorded."_ns); + return NS_OK; + } + + nsTArray<nsCString> extraKeys; + nsTArray<nsCString> extraValues; + CopyableTArray<Telemetry::EventExtraEntry> telExtras; + + JS::Rooted<JSObject*> obj(aCx, &aExtra.toObject()); + JS::Rooted<JS::IdVector> ids(aCx, JS::IdVector(aCx)); + if (!JS_Enumerate(aCx, obj, &ids)) { + LogToBrowserConsole( + nsIScriptError::warningFlag, + u"Failed to enumerate object. Event will not be recorded."_ns); + return NS_OK; + } + + for (size_t i = 0, n = ids.length(); i < n; i++) { + nsAutoJSCString jsKey; + if (!jsKey.init(aCx, ids[i])) { + LogToBrowserConsole( + nsIScriptError::warningFlag, + u"Extra dictionary should only contain string keys. Event will not be recorded."_ns); + return NS_OK; + } + + // We accept camelCase extra keys, but Glean requires snake_case. + auto snakeKey = camelToSnake(jsKey); + + JS::Rooted<JS::Value> value(aCx); + if (!JS_GetPropertyById(aCx, obj, ids[i], &value)) { + LogToBrowserConsole( + nsIScriptError::warningFlag, + u"Failed to get extra property. Event will not be recorded."_ns); + return NS_OK; + } + + nsAutoJSCString jsValue; + if (value.isString() || (value.isInt32() && value.toInt32() >= 0) || + value.isBoolean()) { + if (!jsValue.init(aCx, value)) { + LogToBrowserConsole( + nsIScriptError::warningFlag, + u"Can't extract extra property. Event will not be recorded."_ns); + return NS_OK; + } + } else if (value.isNullOrUndefined()) { + // The extra key is present, but has an empty value. + // Treat as though it weren't here at all. + continue; + } else { + LogToBrowserConsole( + nsIScriptError::warningFlag, + u"Extra properties should have string, bool or non-negative integer values. Event will not be recorded."_ns); + return NS_OK; + } + + extraKeys.AppendElement(snakeKey); + extraValues.AppendElement(jsValue); + telExtras.EmplaceBack(Telemetry::EventExtraEntry{jsKey, jsValue}); + } + + // Since this calls the implementation directly, we need to implement GIFFT + // here as well as in EventMetric::Record. + auto id = EventIdForMetric(mEvent.mId); + if (id) { + Telemetry::RecordEvent(id.extract(), Nothing(), + telExtras.IsEmpty() ? Nothing() : Some(telExtras)); + } + + // Calling the implementation directly, because we have a `string->string` + // map, not a `T->string` map the C++ API expects. + impl::fog_event_record(mEvent.mId, &extraKeys, &extraValues); + return NS_OK; +} + +NS_IMETHODIMP +GleanEvent::TestGetValue(const nsACString& aStorageName, JSContext* aCx, + JS::MutableHandle<JS::Value> aResult) { + auto resEvents = mEvent.TestGetValue(aStorageName); + if (resEvents.isErr()) { + aResult.set(JS::UndefinedValue()); + LogToBrowserConsole(nsIScriptError::errorFlag, + NS_ConvertUTF8toUTF16(resEvents.unwrapErr())); + return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; + } + auto optEvents = resEvents.unwrap(); + if (optEvents.isNothing()) { + aResult.set(JS::UndefinedValue()); + return NS_OK; + } + + auto events = optEvents.extract(); + + auto count = events.Length(); + JS::Rooted<JSObject*> eventArray(aCx, JS::NewArrayObject(aCx, count)); + if (NS_WARN_IF(!eventArray)) { + return NS_ERROR_FAILURE; + } + + for (size_t i = 0; i < count; i++) { + auto* value = &events[i]; + + JS::Rooted<JSObject*> eventObj(aCx, JS_NewPlainObject(aCx)); + if (NS_WARN_IF(!eventObj)) { + return NS_ERROR_FAILURE; + } + + if (!JS_DefineProperty(aCx, eventObj, "timestamp", + (double)value->mTimestamp, JSPROP_ENUMERATE)) { + NS_WARNING("Failed to define timestamp for event object."); + return NS_ERROR_FAILURE; + } + + JS::Rooted<JS::Value> catStr(aCx); + if (!dom::ToJSValue(aCx, value->mCategory, &catStr) || + !JS_DefineProperty(aCx, eventObj, "category", catStr, + JSPROP_ENUMERATE)) { + NS_WARNING("Failed to define category for event object."); + return NS_ERROR_FAILURE; + } + JS::Rooted<JS::Value> nameStr(aCx); + if (!dom::ToJSValue(aCx, value->mName, &nameStr) || + !JS_DefineProperty(aCx, eventObj, "name", nameStr, JSPROP_ENUMERATE)) { + NS_WARNING("Failed to define name for event object."); + return NS_ERROR_FAILURE; + } + + JS::Rooted<JSObject*> extraObj(aCx, JS_NewPlainObject(aCx)); + if (!JS_DefineProperty(aCx, eventObj, "extra", extraObj, + JSPROP_ENUMERATE)) { + NS_WARNING("Failed to define extra for event object."); + return NS_ERROR_FAILURE; + } + + for (auto pair : value->mExtra) { + auto key = std::get<0>(pair); + auto val = std::get<1>(pair); + JS::Rooted<JS::Value> valStr(aCx); + if (!dom::ToJSValue(aCx, val, &valStr) || + !JS_DefineProperty(aCx, extraObj, key.Data(), valStr, + JSPROP_ENUMERATE)) { + NS_WARNING("Failed to define extra property for event object."); + return NS_ERROR_FAILURE; + } + } + + if (!JS_DefineElement(aCx, eventArray, i, eventObj, JSPROP_ENUMERATE)) { + NS_WARNING("Failed to define item in events array."); + return NS_ERROR_FAILURE; + } + } + + aResult.setObject(*eventArray); + return NS_OK; +} + +} // namespace mozilla::glean diff --git a/toolkit/components/glean/bindings/private/Event.h b/toolkit/components/glean/bindings/private/Event.h new file mode 100644 index 0000000000..c0907252a5 --- /dev/null +++ b/toolkit/components/glean/bindings/private/Event.h @@ -0,0 +1,163 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_glean_GleanEvent_h +#define mozilla_glean_GleanEvent_h + +#include "nsIGleanMetrics.h" +#include "mozilla/glean/bindings/EventGIFFTMap.h" +#include "mozilla/glean/fog_ffi_generated.h" +#include "mozilla/ResultVariant.h" + +#include "nsString.h" +#include "nsTArray.h" + +namespace mozilla::glean { + +// forward declaration +class GleanEvent; + +namespace impl { + +/** + * Represents the recorded data for a single event + */ +struct RecordedEvent { + public: + uint64_t mTimestamp; + nsCString mCategory; + nsCString mName; + + nsTArray<std::tuple<nsCString, nsCString>> mExtra; +}; + +template <class T> +class EventMetric { + friend class mozilla::glean::GleanEvent; + + public: + constexpr explicit EventMetric(uint32_t id) : mId(id) {} + + /** + * Record an event. + * + * @param aExtras The list of (extra key, value) pairs. Allowed extra keys are + * defined in the metric definition. + * If the wrong keys are used or values are too large + * an error is report and no event is recorded. + */ + void Record(const Maybe<T>& aExtras = Nothing()) const { + auto id = EventIdForMetric(mId); + if (id) { + // NB. In case `aExtras` is filled we call `ToFfiExtra`, causing + // twice the required allocation. We could be smarter and reuse the data. + // But this is GIFFT-only allocation, so wait to be told it's a problem. + Maybe<CopyableTArray<Telemetry::EventExtraEntry>> telExtras; + if (aExtras) { + CopyableTArray<Telemetry::EventExtraEntry> extras; + auto serializedExtras = aExtras->ToFfiExtra(); + auto keys = std::move(std::get<0>(serializedExtras)); + auto values = std::move(std::get<1>(serializedExtras)); + for (size_t i = 0; i < keys.Length(); i++) { + extras.EmplaceBack(Telemetry::EventExtraEntry{keys[i], values[i]}); + } + telExtras = Some(extras); + } + Telemetry::RecordEvent(id.extract(), Nothing(), telExtras); + } + if (aExtras) { + auto extra = aExtras->ToFfiExtra(); + fog_event_record(mId, &std::get<0>(extra), &std::get<1>(extra)); + } else { + nsTArray<nsCString> keys; + nsTArray<nsCString> vals; + fog_event_record(mId, &keys, &vals); + } + } + + /** + * **Test-only API** + * + * Get a list of currently stored events for this event metric. + * + * This function will attempt to await the last parent-process task (if any) + * writing to the the metric's storage engine before returning a value. + * This function will not wait for data from child processes. + * + * This doesn't clear the stored value. + * Parent process only. Panics in child processes. + * + * @param aPingName The (optional) name of the ping to retrieve the metric + * for. Defaults to the first value in `send_in_pings`. + * + * @return value of the stored metric, or Nothing() if there is no value. + */ + Result<Maybe<nsTArray<RecordedEvent>>, nsCString> TestGetValue( + const nsACString& aPingName = nsCString()) const { + nsCString err; + if (fog_event_test_get_error(mId, &err)) { + return Err(err); + } + + if (!fog_event_test_has_value(mId, &aPingName)) { + return Maybe<nsTArray<RecordedEvent>>(); + } + + nsTArray<FfiRecordedEvent> events; + fog_event_test_get_value(mId, &aPingName, &events); + + nsTArray<RecordedEvent> result; + for (const auto& event : events) { + auto ev = result.AppendElement(); + ev->mTimestamp = event.timestamp; + ev->mCategory.Append(event.category); + ev->mName.Assign(event.name); + + MOZ_ASSERT(event.extras.Length() % 2 == 0); + ev->mExtra.SetCapacity(event.extras.Length() / 2); + for (unsigned int i = 0; i < event.extras.Length(); i += 2) { + // keys & values are interleaved. + nsCString key = std::move(event.extras[i]); + nsCString value = std::move(event.extras[i + 1]); + ev->mExtra.AppendElement( + std::make_tuple(std::move(key), std::move(value))); + } + } + return Some(std::move(result)); + } + + private: + static const nsCString ExtraStringForKey(uint32_t aKey); + + const uint32_t mId; +}; + +} // namespace impl + +struct NoExtraKeys { + std::tuple<nsTArray<nsCString>, nsTArray<nsCString>> ToFfiExtra() const { + nsTArray<nsCString> extraKeys; + nsTArray<nsCString> extraValues; + return std::make_tuple(std::move(extraKeys), std::move(extraValues)); + } +}; + +class GleanEvent final : public nsIGleanEvent { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIGLEANEVENT + + explicit GleanEvent(uint32_t id) : mEvent(id){}; + + private: + virtual ~GleanEvent() = default; + + const impl::EventMetric<NoExtraKeys> mEvent; +}; + +} // namespace mozilla::glean + +#endif /* mozilla_glean_GleanEvent.h */ diff --git a/toolkit/components/glean/bindings/private/Labeled.cpp b/toolkit/components/glean/bindings/private/Labeled.cpp new file mode 100644 index 0000000000..d627b987e1 --- /dev/null +++ b/toolkit/components/glean/bindings/private/Labeled.cpp @@ -0,0 +1,58 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/glean/bindings/Labeled.h" + +#include "mozilla/dom/GleanBinding.h" +#include "mozilla/glean/fog_ffi_generated.h" +#include "mozilla/glean/bindings/GleanJSMetricsLookup.h" +#include "mozilla/glean/bindings/MetricTypes.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/glean/bindings/ScalarGIFFTMap.h" +#include "nsString.h" + +namespace mozilla::glean { + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(GleanLabeled) + +NS_IMPL_CYCLE_COLLECTING_ADDREF(GleanLabeled) +NS_IMPL_CYCLE_COLLECTING_RELEASE(GleanLabeled) +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(GleanLabeled) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +JSObject* GleanLabeled::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return dom::GleanLabeled_Binding::Wrap(aCx, this, aGivenProto); +} + +already_AddRefed<nsISupports> GleanLabeled::NamedGetter(const nsAString& aName, + bool& aFound) { + auto label = NS_ConvertUTF16toUTF8(aName); + aFound = true; + uint32_t submetricId = 0; + already_AddRefed<nsISupports> submetric = + NewSubMetricFromIds(mTypeId, mId, label, &submetricId); + + auto mirrorId = ScalarIdForMetric(mId); + if (mirrorId) { + GetLabeledMirrorLock().apply([&](auto& lock) { + auto tuple = std::make_tuple<Telemetry::ScalarID, nsString>( + mirrorId.extract(), nsString(aName)); + lock.ref()->InsertOrUpdate(submetricId, std::move(tuple)); + }); + } + return submetric; +} + +bool GleanLabeled::NameIsEnumerable(const nsAString& aName) { return false; } + +void GleanLabeled::GetSupportedNames(nsTArray<nsString>& aNames) { + // We really don't know, so don't do anything. +} + +} // namespace mozilla::glean diff --git a/toolkit/components/glean/bindings/private/Labeled.h b/toolkit/components/glean/bindings/private/Labeled.h new file mode 100644 index 0000000000..2b8c474913 --- /dev/null +++ b/toolkit/components/glean/bindings/private/Labeled.h @@ -0,0 +1,260 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_glean_Labeled_h +#define mozilla_glean_Labeled_h + +#include "nsIGleanMetrics.h" +#include "nsISupports.h" +#include "nsWrapperCache.h" +#include "mozilla/dom/BindingDeclarations.h" +#include "mozilla/glean/bindings/Boolean.h" +#include "mozilla/glean/bindings/Counter.h" +#include "mozilla/glean/bindings/ScalarGIFFTMap.h" +#include "mozilla/glean/bindings/String.h" +#include "mozilla/glean/fog_ffi_generated.h" + +enum class DynamicLabel : uint16_t; + +namespace mozilla::glean { + +namespace impl { + +template <typename T, typename E> +class Labeled { + public: + constexpr explicit Labeled<T, E>(uint32_t id) : mId(id) {} + + /** + * Gets a specific metric for a given label. + * + * If a set of acceptable labels were specified in the `metrics.yaml` file, + * and the given label is not in the set, it will be recorded under the + * special `OTHER_LABEL` label. + * + * If a set of acceptable labels was not specified in the `metrics.yaml` file, + * only the first 16 unique labels will be used. + * After that, any additional labels will be recorded under the special + * `OTHER_LABEL` label. + * + * @param aLabel - a snake_case string under 30 characters in length, + * otherwise the metric will be recorded under the special + * `OTHER_LABEL` label and an error will be recorded. + */ + T Get(const nsACString& aLabel) const; + + /** + * Gets a specific metric for a given label, using the label's enum variant. + * + * @param aLabel - a variant of this label's label enum. + */ + T EnumGet(E aLabel) const; + + private: + const uint32_t mId; +}; + +static inline void UpdateLabeledMirror(Telemetry::ScalarID aMirrorId, + uint32_t aSubmetricId, + const nsACString& aLabel) { + GetLabeledMirrorLock().apply([&](auto& lock) { + auto tuple = std::make_tuple<Telemetry::ScalarID, nsString>( + std::move(aMirrorId), NS_ConvertUTF8toUTF16(aLabel)); + lock.ref()->InsertOrUpdate(aSubmetricId, std::move(tuple)); + }); +} + +template <typename E> +class Labeled<BooleanMetric, E> { + public: + constexpr explicit Labeled(uint32_t id) : mId(id) {} + + BooleanMetric Get(const nsACString& aLabel) const { + auto submetricId = fog_labeled_boolean_get(mId, &aLabel); + // If this labeled metric is mirrored, we need to map the submetric id back + // to the label string and mirrored scalar so we can mirror its operations. + auto mirrorId = ScalarIdForMetric(mId); + if (mirrorId) { + UpdateLabeledMirror(mirrorId.extract(), submetricId, aLabel); + } + return BooleanMetric(submetricId); + } + + BooleanMetric EnumGet(E aLabel) const { + auto submetricId = + fog_labeled_boolean_enum_get(mId, static_cast<uint16_t>(aLabel)); + auto mirrorId = ScalarIdForMetric(mId); + if (mirrorId) { + // Telemetry's keyed scalars operate on (16-bit) strings, + // so we're going to need the string for this enum. + nsCString label; + fog_labeled_enum_to_str(mId, static_cast<uint16_t>(aLabel), &label); + UpdateLabeledMirror(mirrorId.extract(), submetricId, label); + } + return BooleanMetric(submetricId); + } + + private: + const uint32_t mId; +}; + +template <typename E> +class Labeled<CounterMetric, E> { + public: + constexpr explicit Labeled(uint32_t id) : mId(id) {} + + CounterMetric Get(const nsACString& aLabel) const { + auto submetricId = fog_labeled_counter_get(mId, &aLabel); + // If this labeled metric is mirrored, we need to map the submetric id back + // to the label string and mirrored scalar so we can mirror its operations. + auto mirrorId = ScalarIdForMetric(mId); + if (mirrorId) { + GetLabeledMirrorLock().apply([&](auto& lock) { + auto tuple = std::make_tuple<Telemetry::ScalarID, nsString>( + mirrorId.extract(), NS_ConvertUTF8toUTF16(aLabel)); + lock.ref()->InsertOrUpdate(submetricId, std::move(tuple)); + }); + } + return CounterMetric(submetricId); + } + + CounterMetric EnumGet(E aLabel) const { + auto submetricId = + fog_labeled_counter_enum_get(mId, static_cast<uint16_t>(aLabel)); + auto mirrorId = ScalarIdForMetric(mId); + if (mirrorId) { + // Telemetry's keyed scalars operate on (16-bit) strings, + // so we're going to need the string for this enum. + nsCString label; + fog_labeled_enum_to_str(mId, static_cast<uint16_t>(aLabel), &label); + UpdateLabeledMirror(mirrorId.extract(), submetricId, label); + } + return CounterMetric(submetricId); + } + + private: + const uint32_t mId; +}; + +template <typename E> +class Labeled<StringMetric, E> { + public: + constexpr explicit Labeled(uint32_t id) : mId(id) {} + + StringMetric Get(const nsACString& aLabel) const { + auto submetricId = fog_labeled_string_get(mId, &aLabel); + // Why no GIFFT map here? + // Labeled Strings can't be mirrored. Telemetry has no compatible probe. + return StringMetric(submetricId); + } + + StringMetric EnumGet(E aLabel) const { + auto submetricId = + fog_labeled_string_enum_get(mId, static_cast<uint16_t>(aLabel)); + // Why no GIFFT map here? + // Labeled Strings can't be mirrored. Telemetry has no compatible probe. + return StringMetric(submetricId); + } + + private: + const uint32_t mId; +}; + +template <> +class Labeled<BooleanMetric, DynamicLabel> { + public: + constexpr explicit Labeled(uint32_t id) : mId(id) {} + + BooleanMetric Get(const nsACString& aLabel) const { + auto submetricId = fog_labeled_boolean_get(mId, &aLabel); + // If this labeled metric is mirrored, we need to map the submetric id back + // to the label string and mirrored scalar so we can mirror its operations. + auto mirrorId = ScalarIdForMetric(mId); + if (mirrorId) { + UpdateLabeledMirror(mirrorId.extract(), submetricId, aLabel); + } + return BooleanMetric(submetricId); + } + + BooleanMetric EnumGet(DynamicLabel aLabel) const = delete; + + private: + const uint32_t mId; +}; + +template <> +class Labeled<CounterMetric, DynamicLabel> { + public: + constexpr explicit Labeled(uint32_t id) : mId(id) {} + + CounterMetric Get(const nsACString& aLabel) const { + auto submetricId = fog_labeled_counter_get(mId, &aLabel); + // If this labeled metric is mirrored, we need to map the submetric id back + // to the label string and mirrored scalar so we can mirror its operations. + auto mirrorId = ScalarIdForMetric(mId); + if (mirrorId) { + GetLabeledMirrorLock().apply([&](auto& lock) { + auto tuple = std::make_tuple<Telemetry::ScalarID, nsString>( + mirrorId.extract(), NS_ConvertUTF8toUTF16(aLabel)); + lock.ref()->InsertOrUpdate(submetricId, std::move(tuple)); + }); + } + return CounterMetric(submetricId); + } + + CounterMetric EnumGet(DynamicLabel aLabel) const = delete; + + private: + const uint32_t mId; +}; + +template <> +class Labeled<StringMetric, DynamicLabel> { + public: + constexpr explicit Labeled(uint32_t id) : mId(id) {} + + StringMetric Get(const nsACString& aLabel) const { + auto submetricId = fog_labeled_string_get(mId, &aLabel); + // Why no GIFFT map here? + // Labeled Strings can't be mirrored. Telemetry has no compatible probe. + return StringMetric(submetricId); + } + + StringMetric EnumGet(DynamicLabel aLabel) const = delete; + + private: + const uint32_t mId; +}; + +} // namespace impl + +class GleanLabeled final : public nsISupports, public nsWrapperCache { + public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(GleanLabeled) + + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + nsISupports* GetParentObject() { return nullptr; } + + explicit GleanLabeled(uint32_t aId, uint32_t aTypeId) + : mId(aId), mTypeId(aTypeId){}; + + already_AddRefed<nsISupports> NamedGetter(const nsAString& aName, + bool& aFound); + bool NameIsEnumerable(const nsAString& aName); + void GetSupportedNames(nsTArray<nsString>& aNames); + + private: + virtual ~GleanLabeled() = default; + + const uint32_t mId; + const uint32_t mTypeId; +}; + +} // namespace mozilla::glean + +#endif /* mozilla_glean_Labeled_h */ diff --git a/toolkit/components/glean/bindings/private/MemoryDistribution.cpp b/toolkit/components/glean/bindings/private/MemoryDistribution.cpp new file mode 100644 index 0000000000..f21cbd3880 --- /dev/null +++ b/toolkit/components/glean/bindings/private/MemoryDistribution.cpp @@ -0,0 +1,106 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/glean/bindings/MemoryDistribution.h" + +#include "mozilla/Components.h" +#include "mozilla/Maybe.h" +#include "mozilla/ResultVariant.h" +#include "mozilla/glean/bindings/HistogramGIFFTMap.h" +#include "mozilla/glean/fog_ffi_generated.h" +#include "nsIClassInfoImpl.h" +#include "nsJSUtils.h" +#include "nsPrintfCString.h" +#include "nsString.h" +#include "js/PropertyAndElement.h" // JS_DefineProperty + +namespace mozilla::glean { + +namespace impl { + +void MemoryDistributionMetric::Accumulate(size_t aSample) const { + auto hgramId = HistogramIdForMetric(mId); + if (hgramId) { + Telemetry::Accumulate(hgramId.extract(), aSample); + } + static_assert(sizeof(size_t) <= sizeof(uint64_t), + "Memory distribution samples might overflow."); + fog_memory_distribution_accumulate(mId, aSample); +} + +Result<Maybe<DistributionData>, nsCString> +MemoryDistributionMetric::TestGetValue(const nsACString& aPingName) const { + nsCString err; + if (fog_memory_distribution_test_get_error(mId, &err)) { + return Err(err); + } + if (!fog_memory_distribution_test_has_value(mId, &aPingName)) { + return Maybe<DistributionData>(); + } + nsTArray<uint64_t> buckets; + nsTArray<uint64_t> counts; + uint64_t sum; + fog_memory_distribution_test_get_value(mId, &aPingName, &sum, &buckets, + &counts); + return Some(DistributionData(buckets, counts, sum)); +} + +} // namespace impl + +NS_IMPL_CLASSINFO(GleanMemoryDistribution, nullptr, 0, {0}) +NS_IMPL_ISUPPORTS_CI(GleanMemoryDistribution, nsIGleanMemoryDistribution) + +NS_IMETHODIMP +GleanMemoryDistribution::Accumulate(uint64_t aSample) { + mMemoryDist.Accumulate(aSample); + return NS_OK; +} + +NS_IMETHODIMP +GleanMemoryDistribution::TestGetValue(const nsACString& aPingName, + JSContext* aCx, + JS::MutableHandle<JS::Value> aResult) { + auto result = mMemoryDist.TestGetValue(aPingName); + if (result.isErr()) { + aResult.set(JS::UndefinedValue()); + return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; + } + auto optresult = result.unwrap(); + if (optresult.isNothing()) { + aResult.set(JS::UndefinedValue()); + } else { + // Build return value of the form: + // { sum: #, values: {bucket1: count1, ...} } + JS::Rooted<JSObject*> root(aCx, JS_NewPlainObject(aCx)); + if (!root) { + return NS_ERROR_FAILURE; + } + uint64_t sum = optresult.ref().sum; + if (!JS_DefineProperty(aCx, root, "sum", static_cast<double>(sum), + JSPROP_ENUMERATE)) { + return NS_ERROR_FAILURE; + } + JS::Rooted<JSObject*> valuesObj(aCx, JS_NewPlainObject(aCx)); + if (!valuesObj || + !JS_DefineProperty(aCx, root, "values", valuesObj, JSPROP_ENUMERATE)) { + return NS_ERROR_FAILURE; + } + auto& data = optresult.ref().values; + for (const auto& entry : data) { + const uint64_t bucket = entry.GetKey(); + const uint64_t count = entry.GetData(); + if (!JS_DefineProperty(aCx, valuesObj, + nsPrintfCString("%" PRIu64, bucket).get(), + static_cast<double>(count), JSPROP_ENUMERATE)) { + return NS_ERROR_FAILURE; + } + } + aResult.setObject(*root); + } + return NS_OK; +} + +} // namespace mozilla::glean diff --git a/toolkit/components/glean/bindings/private/MemoryDistribution.h b/toolkit/components/glean/bindings/private/MemoryDistribution.h new file mode 100644 index 0000000000..136cdb6c91 --- /dev/null +++ b/toolkit/components/glean/bindings/private/MemoryDistribution.h @@ -0,0 +1,74 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_glean_GleanMemoryDistribution_h +#define mozilla_glean_GleanMemoryDistribution_h + +#include "mozilla/glean/bindings/DistributionData.h" +#include "mozilla/Maybe.h" +#include "nsIGleanMetrics.h" +#include "nsTArray.h" + +namespace mozilla::glean { + +namespace impl { + +class MemoryDistributionMetric { + public: + constexpr explicit MemoryDistributionMetric(uint32_t aId) : mId(aId) {} + + /* + * Accumulates the provided sample in the metric. + * + * @param aSample The sample to be recorded by the metric. The sample is + * assumed to be in the confgured memory unit of the metric. + * + * Notes: Values bigger than 1 Terabyte (2^40 bytes) are truncated and an + * InvalidValue error is recorded. + */ + void Accumulate(size_t aSample) const; + + /** + * **Test-only API** + * + * Gets the currently stored value as a DistributionData. + * + * This function will attempt to await the last parent-process task (if any) + * writing to the the metric's storage engine before returning a value. + * This function will not wait for data from child processes. + * + * This doesn't clear the stored value. + * Parent process only. Panics in child processes. + * + * @param aPingName The (optional) name of the ping to retrieve the metric + * for. Defaults to the first value in `send_in_pings`. + * + * @return value of the stored metric, or Nothing() if there is no value. + */ + Result<Maybe<DistributionData>, nsCString> TestGetValue( + const nsACString& aPingName = nsCString()) const; + + private: + const uint32_t mId; +}; +} // namespace impl + +class GleanMemoryDistribution final : public nsIGleanMemoryDistribution { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIGLEANMEMORYDISTRIBUTION + + explicit GleanMemoryDistribution(uint64_t aId) : mMemoryDist(aId){}; + + private: + virtual ~GleanMemoryDistribution() = default; + + const impl::MemoryDistributionMetric mMemoryDist; +}; + +} // namespace mozilla::glean + +#endif /* mozilla_glean_GleanMemoryDistribution_h */ diff --git a/toolkit/components/glean/bindings/private/Numerator.cpp b/toolkit/components/glean/bindings/private/Numerator.cpp new file mode 100644 index 0000000000..4b8efe53be --- /dev/null +++ b/toolkit/components/glean/bindings/private/Numerator.cpp @@ -0,0 +1,92 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/glean/bindings/Numerator.h" + +#include "nsString.h" +#include "mozilla/Components.h" +#include "mozilla/ResultVariant.h" +#include "mozilla/glean/bindings/ScalarGIFFTMap.h" +#include "mozilla/glean/fog_ffi_generated.h" +#include "nsIClassInfoImpl.h" +#include "nsIScriptError.h" +#include "Common.h" +#include "jsapi.h" + +namespace mozilla::glean { + +namespace impl { + +void NumeratorMetric::AddToNumerator(int32_t aAmount) const { + auto scalarId = ScalarIdForMetric(mId); + if (scalarId && aAmount >= 0) { + Telemetry::ScalarAdd(scalarId.extract(), u"numerator"_ns, aAmount); + } + fog_numerator_add_to_numerator(mId, aAmount); +} + +Result<Maybe<std::pair<int32_t, int32_t>>, nsCString> +NumeratorMetric::TestGetValue(const nsACString& aPingName) const { + nsCString err; + if (fog_numerator_test_get_error(mId, &err)) { + return Err(err); + } + if (!fog_numerator_test_has_value(mId, &aPingName)) { + return Maybe<std::pair<int32_t, int32_t>>(); + } + int32_t num = 0; + int32_t den = 0; + fog_numerator_test_get_value(mId, &aPingName, &num, &den); + return Some(std::make_pair(num, den)); +} + +} // namespace impl + +NS_IMPL_CLASSINFO(GleanNumerator, nullptr, 0, {0}) +NS_IMPL_ISUPPORTS_CI(GleanNumerator, nsIGleanNumerator) + +NS_IMETHODIMP +GleanNumerator::AddToNumerator(int32_t aAmount) { + mNumerator.AddToNumerator(aAmount); + return NS_OK; +} + +NS_IMETHODIMP +GleanNumerator::TestGetValue(const nsACString& aPingName, JSContext* aCx, + JS::MutableHandle<JS::Value> aResult) { + auto result = mNumerator.TestGetValue(aPingName); + if (result.isErr()) { + aResult.set(JS::UndefinedValue()); + LogToBrowserConsole(nsIScriptError::errorFlag, + NS_ConvertUTF8toUTF16(result.unwrapErr())); + return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; + } + auto optresult = result.unwrap(); + if (optresult.isNothing()) { + aResult.set(JS::UndefinedValue()); + } else { + // Build return value of the form: { numerator: n, denominator: d } + JS::Rooted<JSObject*> root(aCx, JS_NewPlainObject(aCx)); + if (!root) { + return NS_ERROR_FAILURE; + } + auto pair = optresult.extract(); + int32_t num = pair.first; + int32_t den = pair.second; + if (!JS_DefineProperty(aCx, root, "numerator", static_cast<double>(num), + JSPROP_ENUMERATE)) { + return NS_ERROR_FAILURE; + } + if (!JS_DefineProperty(aCx, root, "denominator", static_cast<double>(den), + JSPROP_ENUMERATE)) { + return NS_ERROR_FAILURE; + } + aResult.setObject(*root); + } + return NS_OK; +} + +} // namespace mozilla::glean diff --git a/toolkit/components/glean/bindings/private/Numerator.h b/toolkit/components/glean/bindings/private/Numerator.h new file mode 100644 index 0000000000..66b7eef295 --- /dev/null +++ b/toolkit/components/glean/bindings/private/Numerator.h @@ -0,0 +1,72 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_glean_GleanNumerator_h +#define mozilla_glean_GleanNumerator_h + +#include "mozilla/Maybe.h" +#include "mozilla/Result.h" +#include "nsIGleanMetrics.h" +#include "nsString.h" + +namespace mozilla::glean { + +namespace impl { + +// Actually a RateMetric, but one whose denominator is a CounterMetric external +// to the RateMetric. +class NumeratorMetric { + public: + constexpr explicit NumeratorMetric(uint32_t aId) : mId(aId) {} + + /* + * Increases the numerator by `amount`. + * + * @param aAmount The amount to increase by. Should be positive. + */ + void AddToNumerator(int32_t aAmount = 1) const; + + /** + * **Test-only API** + * + * Gets the currently stored value as a pair of integers. + * + * This function will attempt to await the last parent-process task (if any) + * writing to the the metric's storage engine before returning a value. + * This function will not wait for data from child processes. + * + * This doesn't clear the stored value. + * Parent process only. Panics in child processes. + * + * @param aPingName The (optional) name of the ping to retrieve the metric + * for. Defaults to the first value in `send_in_pings`. + * + * @return value of the stored metric, or Nothing() if there is no value. + */ + Result<Maybe<std::pair<int32_t, int32_t>>, nsCString> TestGetValue( + const nsACString& aPingName = nsCString()) const; + + private: + const uint32_t mId; +}; +} // namespace impl + +class GleanNumerator final : public nsIGleanNumerator { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIGLEANNUMERATOR + + explicit GleanNumerator(uint32_t id) : mNumerator(id){}; + + private: + virtual ~GleanNumerator() = default; + + const impl::NumeratorMetric mNumerator; +}; + +} // namespace mozilla::glean + +#endif /* mozilla_glean_GleanNumerator_h */ diff --git a/toolkit/components/glean/bindings/private/Ping.cpp b/toolkit/components/glean/bindings/private/Ping.cpp new file mode 100644 index 0000000000..7e46207993 --- /dev/null +++ b/toolkit/components/glean/bindings/private/Ping.cpp @@ -0,0 +1,83 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/glean/bindings/Ping.h" + +#include "mozilla/AppShutdown.h" +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/Components.h" +#include "nsIClassInfoImpl.h" +#include "nsTHashMap.h" +#include "nsString.h" + +namespace mozilla::glean { + +namespace impl { + +using CallbackMapType = nsTHashMap<uint32_t, PingTestCallback>; +using MetricIdToCallbackMutex = StaticDataMutex<UniquePtr<CallbackMapType>>; +static Maybe<MetricIdToCallbackMutex::AutoLock> GetCallbackMapLock() { + static MetricIdToCallbackMutex sCallbacks("sCallbacks"); + auto lock = sCallbacks.Lock(); + // Test callbacks will continue to work until the end of AppShutdownTelemetry + if (AppShutdown::IsInOrBeyond(ShutdownPhase::XPCOMWillShutdown)) { + return Nothing(); + } + if (!*lock) { + *lock = MakeUnique<CallbackMapType>(); + RunOnShutdown( + [&] { + auto lock = sCallbacks.Lock(); + *lock = nullptr; // deletes, see UniquePtr.h + }, + ShutdownPhase::XPCOMWillShutdown); + } + return Some(std::move(lock)); +} + +void Ping::Submit(const nsACString& aReason) const { + { + GetCallbackMapLock().apply([&](auto& lock) { + auto callback = lock.ref()->Extract(mId); + if (callback) { + callback.extract()(aReason); + } + }); + } + fog_submit_ping_by_id(mId, &aReason); +} + +void Ping::TestBeforeNextSubmit(PingTestCallback&& aCallback) const { + { + GetCallbackMapLock().apply( + [&](auto& lock) { lock.ref()->InsertOrUpdate(mId, aCallback); }); + } +} + +} // namespace impl + +NS_IMPL_CLASSINFO(GleanPing, nullptr, 0, {0}) +NS_IMPL_ISUPPORTS_CI(GleanPing, nsIGleanPing) + +NS_IMETHODIMP +GleanPing::Submit(const nsACString& aReason) { + mPing.Submit(aReason); + return NS_OK; +} + +NS_IMETHODIMP +GleanPing::TestBeforeNextSubmit(nsIGleanPingTestCallback* aCallback) { + if (NS_WARN_IF(!aCallback)) { + return NS_ERROR_INVALID_ARG; + } + // Throw the bare ptr into a COM ptr to keep it around in the lambda. + nsCOMPtr<nsIGleanPingTestCallback> callback = aCallback; + mPing.TestBeforeNextSubmit( + [callback](const nsACString& aReason) { callback->Call(aReason); }); + return NS_OK; +} + +} // namespace mozilla::glean diff --git a/toolkit/components/glean/bindings/private/Ping.h b/toolkit/components/glean/bindings/private/Ping.h new file mode 100644 index 0000000000..6bcd4cb478 --- /dev/null +++ b/toolkit/components/glean/bindings/private/Ping.h @@ -0,0 +1,83 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_glean_Ping_h +#define mozilla_glean_Ping_h + +#include "mozilla/DataMutex.h" +#include "mozilla/glean/fog_ffi_generated.h" +#include "mozilla/Maybe.h" +#include "nsIGleanMetrics.h" +#include "nsString.h" + +namespace mozilla::glean { + +typedef std::function<void(const nsACString& aReason)> PingTestCallback; + +namespace impl { + +class Ping { + public: + constexpr explicit Ping(uint32_t aId) : mId(aId) {} + + /** + * Collect and submit the ping for eventual upload. + * + * This will collect all stored data to be included in the ping. + * Data with lifetime `ping` will then be reset. + * + * If the ping is configured with `send_if_empty = false` + * and the ping currently contains no content, + * it will not be queued for upload. + * If the ping is configured with `send_if_empty = true` + * it will be queued for upload even if empty. + * + * Pings always contain the `ping_info` and `client_info` sections. + * See [ping + * sections](https://mozilla.github.io/glean/book/user/pings/index.html#ping-sections) + * for details. + * + * @param aReason - Optional. The reason the ping is being submitted. + * Must match one of the configured `reason_codes`. + */ + void Submit(const nsACString& aReason = nsCString()) const; + + /** + * **Test-only API** + * + * Register a callback to be called right before this ping is next submitted. + * The provided function is called exactly once before submitting. + * + * Note: The callback will be called on any call to submit. + * A ping may not be sent afterwards, e.g. if the ping is empty and + * `send_if_empty` is `false` + * + * @param aCallback - The callback to call on the next submit. + */ + void TestBeforeNextSubmit(PingTestCallback&& aCallback) const; + + private: + const uint32_t mId; +}; + +} // namespace impl + +class GleanPing final : public nsIGleanPing { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIGLEANPING + + explicit GleanPing(uint32_t aId) : mPing(aId) {} + + private: + virtual ~GleanPing() = default; + + const impl::Ping mPing; +}; + +} // namespace mozilla::glean + +#endif /* mozilla_glean_Ping_h */ diff --git a/toolkit/components/glean/bindings/private/Quantity.cpp b/toolkit/components/glean/bindings/private/Quantity.cpp new file mode 100644 index 0000000000..a8bf3e19a7 --- /dev/null +++ b/toolkit/components/glean/bindings/private/Quantity.cpp @@ -0,0 +1,75 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/glean/bindings/Quantity.h" + +#include "mozilla/Components.h" +#include "mozilla/ResultVariant.h" +#include "mozilla/glean/bindings/ScalarGIFFTMap.h" +#include "mozilla/glean/fog_ffi_generated.h" +#include "nsIClassInfoImpl.h" +#include "nsString.h" +#include "Common.h" + +namespace mozilla::glean { + +namespace impl { + +void QuantityMetric::Set(int64_t aValue) const { + auto scalarId = ScalarIdForMetric(mId); + if (scalarId && aValue >= 0) { + uint32_t theValue = static_cast<uint32_t>(aValue); + if (aValue > std::numeric_limits<uint32_t>::max()) { + theValue = std::numeric_limits<uint32_t>::max(); + } + Telemetry::ScalarSet(scalarId.extract(), theValue); + } + fog_quantity_set(mId, aValue); +} + +Result<Maybe<int64_t>, nsCString> QuantityMetric::TestGetValue( + const nsACString& aPingName) const { + nsCString err; + if (fog_quantity_test_get_error(mId, &err)) { + return Err(err); + } + if (!fog_quantity_test_has_value(mId, &aPingName)) { + return Maybe<int64_t>(); + } + return Some(fog_quantity_test_get_value(mId, &aPingName)); +} + +} // namespace impl + +NS_IMPL_CLASSINFO(GleanQuantity, nullptr, 0, {0}) +NS_IMPL_ISUPPORTS_CI(GleanQuantity, nsIGleanQuantity) + +NS_IMETHODIMP +GleanQuantity::Set(int64_t aValue) { + mQuantity.Set(aValue); + return NS_OK; +} + +NS_IMETHODIMP +GleanQuantity::TestGetValue(const nsACString& aPingName, + JS::MutableHandle<JS::Value> aResult) { + auto result = mQuantity.TestGetValue(aPingName); + if (result.isErr()) { + aResult.set(JS::UndefinedValue()); + LogToBrowserConsole(nsIScriptError::errorFlag, + NS_ConvertUTF8toUTF16(result.unwrapErr())); + return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; + } + auto optresult = result.unwrap(); + if (optresult.isNothing()) { + aResult.set(JS::UndefinedValue()); + } else { + aResult.set(JS::DoubleValue(static_cast<double>(optresult.value()))); + } + return NS_OK; +} + +} // namespace mozilla::glean diff --git a/toolkit/components/glean/bindings/private/Quantity.h b/toolkit/components/glean/bindings/private/Quantity.h new file mode 100644 index 0000000000..81ff694fba --- /dev/null +++ b/toolkit/components/glean/bindings/private/Quantity.h @@ -0,0 +1,70 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_glean_GleanQuantity_h +#define mozilla_glean_GleanQuantity_h + +#include "nsIGleanMetrics.h" +#include "nsTString.h" +#include "nsIScriptError.h" + +namespace mozilla::glean { + +namespace impl { + +class QuantityMetric { + public: + constexpr explicit QuantityMetric(uint32_t id) : mId(id) {} + + /** + * Set to the specified value. + * + * @param aValue the value to set. + */ + void Set(int64_t aValue) const; + + /** + * **Test-only API** + * + * Gets the currently stored value. + * + * This function will attempt to await the last parent-process task (if any) + * writing to the the metric's storage engine before returning a value. + * This function will not wait for data from child processes. + * + * This doesn't clear the stored value. + * Parent process only. Panics in child processes. + * + * @param aPingName The (optional) name of the ping to retrieve the metric + * for. Defaults to the first value in `send_in_pings`. + * + * @return value of the stored metric. + */ + Result<Maybe<int64_t>, nsCString> TestGetValue( + const nsACString& aPingName = nsCString()) const; + + private: + const uint32_t mId; +}; + +} // namespace impl + +class GleanQuantity final : public nsIGleanQuantity { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIGLEANQUANTITY + + explicit GleanQuantity(uint32_t id) : mQuantity(id){}; + + private: + virtual ~GleanQuantity() = default; + + const impl::QuantityMetric mQuantity; +}; + +} // namespace mozilla::glean + +#endif /* mozilla_glean_GleanQuantity.h */ diff --git a/toolkit/components/glean/bindings/private/Rate.cpp b/toolkit/components/glean/bindings/private/Rate.cpp new file mode 100644 index 0000000000..6bc6ad61c9 --- /dev/null +++ b/toolkit/components/glean/bindings/private/Rate.cpp @@ -0,0 +1,105 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/glean/bindings/Rate.h" + +#include "jsapi.h" +#include "nsString.h" +#include "mozilla/Components.h" +#include "mozilla/ResultVariant.h" +#include "mozilla/glean/bindings/Common.h" +#include "mozilla/glean/bindings/ScalarGIFFTMap.h" +#include "mozilla/glean/fog_ffi_generated.h" +#include "nsIClassInfoImpl.h" + +namespace mozilla::glean { + +namespace impl { + +void RateMetric::AddToNumerator(int32_t aAmount) const { + auto scalarId = ScalarIdForMetric(mId); + if (scalarId && aAmount >= 0) { + Telemetry::ScalarAdd(scalarId.extract(), u"numerator"_ns, aAmount); + } + fog_rate_add_to_numerator(mId, aAmount); +} + +void RateMetric::AddToDenominator(int32_t aAmount) const { + auto scalarId = ScalarIdForMetric(mId); + if (scalarId && aAmount >= 0) { + Telemetry::ScalarAdd(scalarId.extract(), u"denominator"_ns, aAmount); + } + fog_rate_add_to_denominator(mId, aAmount); +} + +Result<Maybe<std::pair<int32_t, int32_t>>, nsCString> RateMetric::TestGetValue( + const nsACString& aPingName) const { + nsCString err; + if (fog_rate_test_get_error(mId, &err)) { + return Err(err); + } + if (!fog_rate_test_has_value(mId, &aPingName)) { + return Maybe<std::pair<int32_t, int32_t>>(); + } + int32_t num = 0; + int32_t den = 0; + fog_rate_test_get_value(mId, &aPingName, &num, &den); + return Some(std::make_pair(num, den)); +} + +} // namespace impl + +NS_IMPL_CLASSINFO(GleanRate, nullptr, 0, {0}) +NS_IMPL_ISUPPORTS_CI(GleanRate, nsIGleanRate) + +NS_IMETHODIMP +GleanRate::AddToNumerator(int32_t aAmount) { + mRate.AddToNumerator(aAmount); + return NS_OK; +} + +NS_IMETHODIMP +GleanRate::AddToDenominator(int32_t aAmount) { + mRate.AddToDenominator(aAmount); + return NS_OK; +} + +NS_IMETHODIMP +GleanRate::TestGetValue(const nsACString& aPingName, JSContext* aCx, + JS::MutableHandle<JS::Value> aResult) { + auto result = mRate.TestGetValue(aPingName); + if (result.isErr()) { + aResult.set(JS::UndefinedValue()); + LogToBrowserConsole(nsIScriptError::errorFlag, + NS_ConvertUTF8toUTF16(result.unwrapErr())); + return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; + } + auto optresult = result.unwrap(); + if (optresult.isNothing()) { + aResult.set(JS::UndefinedValue()); + } else { + // Build return value of the form: { numerator: n, denominator: d } + JS::Rooted<JSObject*> root(aCx, JS_NewPlainObject(aCx)); + if (!root) { + return NS_ERROR_FAILURE; + } + auto pair = optresult.extract(); + int32_t num = pair.first; + int32_t den = pair.second; + if (!JS_DefineProperty(aCx, root, "numerator", static_cast<double>(num), + JSPROP_ENUMERATE)) { + return NS_ERROR_FAILURE; + } + if (!JS_DefineProperty(aCx, root, "denominator", static_cast<double>(den), + JSPROP_ENUMERATE)) { + return NS_ERROR_FAILURE; + } + aResult.setObject(*root); + } + return NS_OK; +} + +} // namespace mozilla::glean diff --git a/toolkit/components/glean/bindings/private/Rate.h b/toolkit/components/glean/bindings/private/Rate.h new file mode 100644 index 0000000000..85e8b4e1d6 --- /dev/null +++ b/toolkit/components/glean/bindings/private/Rate.h @@ -0,0 +1,77 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_glean_GleanRate_h +#define mozilla_glean_GleanRate_h + +#include "mozilla/Maybe.h" +#include "mozilla/Result.h" +#include "nsIGleanMetrics.h" +#include "nsString.h" + +namespace mozilla::glean { + +namespace impl { + +class RateMetric { + public: + constexpr explicit RateMetric(uint32_t aId) : mId(aId) {} + + /* + * Increases the numerator by `amount`. + * + * @param aAmount The amount to increase by. Should be positive. + */ + void AddToNumerator(int32_t aAmount = 1) const; + + /* + * Increases the denominator by `amount`. + * + * @param aAmount The amount to increase by. Should be positive. + */ + void AddToDenominator(int32_t aAmount = 1) const; + + /** + * **Test-only API** + * + * Gets the currently stored value as a pair of integers. + * + * This function will attempt to await the last parent-process task (if any) + * writing to the the metric's storage engine before returning a value. + * This function will not wait for data from child processes. + * + * This doesn't clear the stored value. + * Parent process only. Panics in child processes. + * + * @param aPingName The (optional) name of the ping to retrieve the metric + * for. Defaults to the first value in `send_in_pings`. + * + * @return value of the stored metric, or Nothing() if there is no value. + */ + Result<Maybe<std::pair<int32_t, int32_t>>, nsCString> TestGetValue( + const nsACString& aPingName = nsCString()) const; + + private: + const uint32_t mId; +}; +} // namespace impl + +class GleanRate final : public nsIGleanRate { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIGLEANRATE + + explicit GleanRate(uint32_t id) : mRate(id){}; + + private: + virtual ~GleanRate() = default; + + const impl::RateMetric mRate; +}; + +} // namespace mozilla::glean + +#endif /* mozilla_glean_GleanRate_h */ diff --git a/toolkit/components/glean/bindings/private/String.cpp b/toolkit/components/glean/bindings/private/String.cpp new file mode 100644 index 0000000000..bc191a7400 --- /dev/null +++ b/toolkit/components/glean/bindings/private/String.cpp @@ -0,0 +1,77 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/glean/bindings/String.h" + +#include "Common.h" +#include "jsapi.h" +#include "js/String.h" +#include "nsString.h" +#include "mozilla/Components.h" +#include "mozilla/ResultVariant.h" +#include "mozilla/glean/bindings/ScalarGIFFTMap.h" +#include "mozilla/glean/fog_ffi_generated.h" +#include "nsIClassInfoImpl.h" + +namespace mozilla::glean { + +namespace impl { + +void StringMetric::Set(const nsACString& aValue) const { + auto scalarId = ScalarIdForMetric(mId); + if (scalarId) { + Telemetry::ScalarSet(scalarId.extract(), NS_ConvertUTF8toUTF16(aValue)); + } + fog_string_set(mId, &aValue); +} + +Result<Maybe<nsCString>, nsCString> StringMetric::TestGetValue( + const nsACString& aPingName) const { + nsCString err; + if (fog_string_test_get_error(mId, &err)) { + return Err(err); + } + if (!fog_string_test_has_value(mId, &aPingName)) { + return Maybe<nsCString>(); + } + nsCString ret; + fog_string_test_get_value(mId, &aPingName, &ret); + return Some(ret); +} + +} // namespace impl + +NS_IMPL_CLASSINFO(GleanString, nullptr, 0, {0}) +NS_IMPL_ISUPPORTS_CI(GleanString, nsIGleanString) + +NS_IMETHODIMP +GleanString::Set(const nsACString& aValue) { + mString.Set(aValue); + return NS_OK; +} + +NS_IMETHODIMP +GleanString::TestGetValue(const nsACString& aStorageName, JSContext* aCx, + JS::MutableHandle<JS::Value> aResult) { + auto result = mString.TestGetValue(aStorageName); + if (result.isErr()) { + aResult.set(JS::UndefinedValue()); + LogToBrowserConsole(nsIScriptError::errorFlag, + NS_ConvertUTF8toUTF16(result.unwrapErr())); + return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; + } + auto optresult = result.unwrap(); + if (optresult.isNothing()) { + aResult.set(JS::UndefinedValue()); + } else { + const NS_ConvertUTF8toUTF16 str(optresult.ref()); + aResult.set( + JS::StringValue(JS_NewUCStringCopyN(aCx, str.Data(), str.Length()))); + } + return NS_OK; +} + +} // namespace mozilla::glean diff --git a/toolkit/components/glean/bindings/private/String.h b/toolkit/components/glean/bindings/private/String.h new file mode 100644 index 0000000000..8c3c6ae05e --- /dev/null +++ b/toolkit/components/glean/bindings/private/String.h @@ -0,0 +1,73 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_glean_GleanString_h +#define mozilla_glean_GleanString_h + +#include "mozilla/Maybe.h" +#include "mozilla/Result.h" +#include "nsIGleanMetrics.h" +#include "nsString.h" + +namespace mozilla::glean { + +namespace impl { + +class StringMetric { + public: + constexpr explicit StringMetric(uint32_t aId) : mId(aId) {} + + /* + * Set to the specified value. + * + * Truncates the value if it is longer than 100 bytes and logs an error. + * See https://mozilla.github.io/glean/book/user/metrics/string.html#limits. + * + * @param aValue The string to set the metric to. + */ + void Set(const nsACString& aValue) const; + + /** + * **Test-only API** + * + * Gets the currently stored value as a string. + * + * This function will attempt to await the last parent-process task (if any) + * writing to the the metric's storage engine before returning a value. + * This function will not wait for data from child processes. + * + * This doesn't clear the stored value. + * Parent process only. Panics in child processes. + * + * @param aPingName The (optional) name of the ping to retrieve the metric + * for. Defaults to the first value in `send_in_pings`. + * + * @return value of the stored metric, or Nothing() if there is no value. + */ + Result<Maybe<nsCString>, nsCString> TestGetValue( + const nsACString& aPingName = nsCString()) const; + + private: + const uint32_t mId; +}; +} // namespace impl + +class GleanString final : public nsIGleanString { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIGLEANSTRING + + explicit GleanString(uint32_t aId) : mString(aId){}; + + private: + virtual ~GleanString() = default; + + const impl::StringMetric mString; +}; + +} // namespace mozilla::glean + +#endif /* mozilla_glean_GleanString_h */ diff --git a/toolkit/components/glean/bindings/private/StringList.cpp b/toolkit/components/glean/bindings/private/StringList.cpp new file mode 100644 index 0000000000..8882922551 --- /dev/null +++ b/toolkit/components/glean/bindings/private/StringList.cpp @@ -0,0 +1,92 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/glean/bindings/StringList.h" + +#include "Common.h" +#include "mozilla/Components.h" +#include "mozilla/ResultVariant.h" +#include "mozilla/dom/ToJSValue.h" +#include "mozilla/glean/bindings/ScalarGIFFTMap.h" +#include "mozilla/glean/fog_ffi_generated.h" +#include "nsIClassInfoImpl.h" +#include "nsString.h" +#include "nsTArray.h" + +namespace mozilla::glean { + +namespace impl { + +void StringListMetric::Add(const nsACString& aValue) const { + auto scalarId = ScalarIdForMetric(mId); + if (scalarId) { + Telemetry::ScalarSet(scalarId.extract(), NS_ConvertUTF8toUTF16(aValue), + true); + } + fog_string_list_add(mId, &aValue); +} + +void StringListMetric::Set(const nsTArray<nsCString>& aValue) const { + // Calling `Set` on a mirrored labeled_string is likely an error. + // We can't remove keys from the mirror scalar and handle this 'properly', + // so you shouldn't use this operation at all. + (void)NS_WARN_IF(ScalarIdForMetric(mId).isSome()); + fog_string_list_set(mId, &aValue); +} + +Result<Maybe<nsTArray<nsCString>>, nsCString> StringListMetric::TestGetValue( + const nsACString& aPingName) const { + nsCString err; + if (fog_string_list_test_get_error(mId, &err)) { + return Err(err); + } + if (!fog_string_list_test_has_value(mId, &aPingName)) { + return Maybe<nsTArray<nsCString>>(); + } + nsTArray<nsCString> ret; + fog_string_list_test_get_value(mId, &aPingName, &ret); + return Some(std::move(ret)); +} + +} // namespace impl + +NS_IMPL_CLASSINFO(GleanStringList, nullptr, 0, {0}) +NS_IMPL_ISUPPORTS_CI(GleanStringList, nsIGleanStringList) + +NS_IMETHODIMP +GleanStringList::Add(const nsACString& aValue) { + mStringList.Add(aValue); + return NS_OK; +} + +NS_IMETHODIMP +GleanStringList::Set(const nsTArray<nsCString>& aValue) { + mStringList.Set(aValue); + return NS_OK; +} + +NS_IMETHODIMP +GleanStringList::TestGetValue(const nsACString& aStorageName, JSContext* aCx, + JS::MutableHandle<JS::Value> aResult) { + auto result = mStringList.TestGetValue(aStorageName); + if (result.isErr()) { + aResult.set(JS::UndefinedValue()); + LogToBrowserConsole(nsIScriptError::errorFlag, + NS_ConvertUTF8toUTF16(result.unwrapErr())); + return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; + } + auto optresult = result.unwrap(); + if (optresult.isNothing()) { + aResult.set(JS::UndefinedValue()); + } else { + if (!dom::ToJSValue(aCx, optresult.ref(), aResult)) { + return NS_ERROR_FAILURE; + } + } + return NS_OK; +} + +} // namespace mozilla::glean diff --git a/toolkit/components/glean/bindings/private/StringList.h b/toolkit/components/glean/bindings/private/StringList.h new file mode 100644 index 0000000000..6b7b9358e2 --- /dev/null +++ b/toolkit/components/glean/bindings/private/StringList.h @@ -0,0 +1,84 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_glean_GleanStringList_h +#define mozilla_glean_GleanStringList_h + +#include "mozilla/Maybe.h" +#include "nsIGleanMetrics.h" +#include "nsString.h" +#include "nsTArray.h" + +namespace mozilla::glean { + +namespace impl { + +class StringListMetric { + public: + constexpr explicit StringListMetric(uint32_t aId) : mId(aId) {} + + /* + * Adds a new string to the list. + * + * Truncates the value if it is longer than 50 bytes and logs an error. + * + * @param aValue The string to add. + */ + void Add(const nsACString& aValue) const; + + /* + * Set to a specific list of strings. + * + * Truncates any values longer than 50 bytes and logs an error. + * Truncates the list if it is over 20 items long. + * See + * https://mozilla.github.io/glean/book/user/metrics/string_list.html#limits. + * + * @param aValue The list of strings to set the metric to. + */ + void Set(const nsTArray<nsCString>& aValue) const; + + /** + * **Test-only API** + * + * Gets the currently stored value. + * + * This function will attempt to await the last parent-process task (if any) + * writing to the the metric's storage engine before returning a value. + * This function will not wait for data from child processes. + * + * This doesn't clear the stored value. + * Parent process only. Panics in child processes. + * + * @param aPingName The (optional) name of the ping to retrieve the metric + * for. Defaults to the first value in `send_in_pings`. + * + * @return value of the stored metric, or Nothing() if there is no value. + */ + Result<Maybe<nsTArray<nsCString>>, nsCString> TestGetValue( + const nsACString& aPingName = nsCString()) const; + + private: + const uint32_t mId; +}; +} // namespace impl + +class GleanStringList final : public nsIGleanStringList { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIGLEANSTRINGLIST + + explicit GleanStringList(uint32_t aId) : mStringList(aId){}; + + private: + virtual ~GleanStringList() = default; + + const impl::StringListMetric mStringList; +}; + +} // namespace mozilla::glean + +#endif /* mozilla_glean_GleanStringList_h */ diff --git a/toolkit/components/glean/bindings/private/Text.cpp b/toolkit/components/glean/bindings/private/Text.cpp new file mode 100644 index 0000000000..942055bb3b --- /dev/null +++ b/toolkit/components/glean/bindings/private/Text.cpp @@ -0,0 +1,72 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/glean/bindings/Text.h" + +#include "Common.h" +#include "jsapi.h" +#include "js/String.h" +#include "nsString.h" +#include "mozilla/Components.h" +#include "mozilla/ResultVariant.h" +#include "mozilla/glean/bindings/ScalarGIFFTMap.h" +#include "mozilla/glean/fog_ffi_generated.h" +#include "nsIClassInfoImpl.h" + +namespace mozilla::glean { + +namespace impl { + +void TextMetric::Set(const nsACString& aValue) const { + fog_text_set(mId, &aValue); +} + +Result<Maybe<nsCString>, nsCString> TextMetric::TestGetValue( + const nsACString& aPingName) const { + nsCString err; + if (fog_text_test_get_error(mId, &err)) { + return Err(err); + } + if (!fog_text_test_has_value(mId, &aPingName)) { + return Maybe<nsCString>(); + } + nsCString ret; + fog_text_test_get_value(mId, &aPingName, &ret); + return Some(ret); +} + +} // namespace impl + +NS_IMPL_CLASSINFO(GleanText, nullptr, 0, {0}) +NS_IMPL_ISUPPORTS_CI(GleanText, nsIGleanText) + +NS_IMETHODIMP +GleanText::Set(const nsACString& aValue) { + mText.Set(aValue); + return NS_OK; +} + +NS_IMETHODIMP +GleanText::TestGetValue(const nsACString& aStorageName, JSContext* aCx, + JS::MutableHandle<JS::Value> aResult) { + auto result = mText.TestGetValue(aStorageName); + if (result.isErr()) { + aResult.set(JS::UndefinedValue()); + LogToBrowserConsole(nsIScriptError::errorFlag, + NS_ConvertUTF8toUTF16(result.unwrapErr())); + return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; + } + auto optresult = result.unwrap(); + if (optresult.isNothing()) { + aResult.set(JS::UndefinedValue()); + } else { + const NS_ConvertUTF8toUTF16 str(optresult.ref()); + aResult.set( + JS::StringValue(JS_NewUCStringCopyN(aCx, str.Data(), str.Length()))); + } + return NS_OK; +} +} // namespace mozilla::glean diff --git a/toolkit/components/glean/bindings/private/Text.h b/toolkit/components/glean/bindings/private/Text.h new file mode 100644 index 0000000000..242555ce11 --- /dev/null +++ b/toolkit/components/glean/bindings/private/Text.h @@ -0,0 +1,47 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_glean_GleanText_h +#define mozilla_glean_GleanText_h + +#include "mozilla/Maybe.h" +#include "mozilla/Result.h" +#include "nsIGleanMetrics.h" +#include "nsString.h" + +namespace mozilla::glean { + +namespace impl { + +class TextMetric { + public: + constexpr explicit TextMetric(uint32_t aId) : mId(aId) {} + + void Set(const nsACString& aValue) const; + + Result<Maybe<nsCString>, nsCString> TestGetValue( + const nsACString& aPingName = nsCString()) const; + + private: + const uint32_t mId; +}; + +} // namespace impl + +class GleanText final : public nsIGleanText { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIGLEANTEXT + + explicit GleanText(uint32_t aId) : mText(aId){}; + + private: + virtual ~GleanText() = default; + + const impl::TextMetric mText; +}; +} // namespace mozilla::glean +#endif diff --git a/toolkit/components/glean/bindings/private/Timespan.cpp b/toolkit/components/glean/bindings/private/Timespan.cpp new file mode 100644 index 0000000000..e8377c8fcf --- /dev/null +++ b/toolkit/components/glean/bindings/private/Timespan.cpp @@ -0,0 +1,133 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/glean/bindings/Timespan.h" + +#include "Common.h" +#include "nsString.h" +#include "mozilla/Components.h" +#include "mozilla/ResultVariant.h" +#include "mozilla/glean/bindings/ScalarGIFFTMap.h" +#include "mozilla/glean/fog_ffi_generated.h" +#include "nsIClassInfoImpl.h" + +namespace mozilla::glean { + +namespace impl { + +void TimespanMetric::Start() const { + auto optScalarId = ScalarIdForMetric(mId); + if (optScalarId) { + auto scalarId = optScalarId.extract(); + GetTimesToStartsLock().apply([&](auto& lock) { + (void)NS_WARN_IF(lock.ref()->Remove(scalarId)); + lock.ref()->InsertOrUpdate(scalarId, TimeStamp::Now()); + }); + } + fog_timespan_start(mId); +} + +void TimespanMetric::Stop() const { + auto optScalarId = ScalarIdForMetric(mId); + if (optScalarId) { + auto scalarId = optScalarId.extract(); + GetTimesToStartsLock().apply([&](auto& lock) { + auto optStart = lock.ref()->Extract(scalarId); + if (!NS_WARN_IF(!optStart)) { + double delta = (TimeStamp::Now() - optStart.extract()).ToMilliseconds(); + uint32_t theDelta = static_cast<uint32_t>(delta); + if (delta > std::numeric_limits<uint32_t>::max()) { + theDelta = std::numeric_limits<uint32_t>::max(); + } else if (MOZ_UNLIKELY(delta < 0)) { + theDelta = 0; + } + Telemetry::ScalarSet(scalarId, theDelta); + } + }); + } + fog_timespan_stop(mId); +} + +void TimespanMetric::Cancel() const { + auto optScalarId = ScalarIdForMetric(mId); + if (optScalarId) { + auto scalarId = optScalarId.extract(); + GetTimesToStartsLock().apply( + [&](auto& lock) { lock.ref()->Remove(scalarId); }); + } + fog_timespan_cancel(mId); +} + +void TimespanMetric::SetRaw(uint32_t aDuration) const { + auto optScalarId = ScalarIdForMetric(mId); + if (optScalarId) { + auto scalarId = optScalarId.extract(); + Telemetry::ScalarSet(scalarId, aDuration); + } + fog_timespan_set_raw(mId, aDuration); +} + +Result<Maybe<uint64_t>, nsCString> TimespanMetric::TestGetValue( + const nsACString& aPingName) const { + nsCString err; + if (fog_timespan_test_get_error(mId, &err)) { + return Err(err); + } + if (!fog_timespan_test_has_value(mId, &aPingName)) { + return Maybe<uint64_t>(); + } + return Some(fog_timespan_test_get_value(mId, &aPingName)); +} + +} // namespace impl + +NS_IMPL_CLASSINFO(GleanTimespan, nullptr, 0, {0}) +NS_IMPL_ISUPPORTS_CI(GleanTimespan, nsIGleanTimespan) + +NS_IMETHODIMP +GleanTimespan::Start() { + mTimespan.Start(); + return NS_OK; +} + +NS_IMETHODIMP +GleanTimespan::Stop() { + mTimespan.Stop(); + return NS_OK; +} + +NS_IMETHODIMP +GleanTimespan::Cancel() { + mTimespan.Cancel(); + return NS_OK; +} + +NS_IMETHODIMP +GleanTimespan::SetRaw(uint32_t aDuration) { + mTimespan.SetRaw(aDuration); + return NS_OK; +} + +NS_IMETHODIMP +GleanTimespan::TestGetValue(const nsACString& aStorageName, + JS::MutableHandle<JS::Value> aResult) { + auto result = mTimespan.TestGetValue(aStorageName); + if (result.isErr()) { + aResult.set(JS::UndefinedValue()); + LogToBrowserConsole(nsIScriptError::errorFlag, + NS_ConvertUTF8toUTF16(result.unwrapErr())); + return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; + } + auto optresult = result.unwrap(); + if (optresult.isNothing()) { + aResult.set(JS::UndefinedValue()); + } else { + aResult.set(JS::DoubleValue(static_cast<double>(optresult.value()))); + } + return NS_OK; +} + +} // namespace mozilla::glean diff --git a/toolkit/components/glean/bindings/private/Timespan.h b/toolkit/components/glean/bindings/private/Timespan.h new file mode 100644 index 0000000000..bcc4b6c6ba --- /dev/null +++ b/toolkit/components/glean/bindings/private/Timespan.h @@ -0,0 +1,100 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_glean_GleanTimespan_h +#define mozilla_glean_GleanTimespan_h + +#include "mozilla/Maybe.h" +#include "mozilla/Result.h" +#include "nsIGleanMetrics.h" +#include "nsTString.h" + +namespace mozilla::glean { + +namespace impl { + +class TimespanMetric { + public: + constexpr explicit TimespanMetric(uint32_t aId) : mId(aId) {} + + /** + * Start tracking time for the provided metric. + * + * This records an error if it’s already tracking time (i.e. start was already + * called with no corresponding [stop]): in that case the original + * start time will be preserved. + */ + void Start() const; + + /** + * Stop tracking time for the provided metric. + * + * Sets the metric to the elapsed time, but does not overwrite an already + * existing value. + * This will record an error if no [start] was called or there is an already + * existing value. + */ + void Stop() const; + + /** + * Abort a previous Start. + * + * No error will be recorded if no Start was called. + */ + void Cancel() const; + + /** + * Explicitly sets the timespan value + * + * This API should only be used if you cannot make use of + * `start`/`stop`/`cancel`. + * + * @param aDuration The duration of this timespan, in units matching the + * `time_unit` of this metric's definition. + */ + void SetRaw(uint32_t aDuration) const; + + /** + * **Test-only API** + * + * Gets the currently stored value as an integer. + * + * This function will attempt to await the last parent-process task (if any) + * writing to the the metric's storage engine before returning a value. + * This function will not wait for data from child processes. + * + * This doesn't clear the stored value. + * Parent process only. Panics in child processes. + * + * @param aPingName The (optional) name of the ping to retrieve the metric + * for. Defaults to the first value in `send_in_pings`. + * + * @return value of the stored metric, or Nothing() if there is no value. + */ + Result<Maybe<uint64_t>, nsCString> TestGetValue( + const nsACString& aPingName = nsCString()) const; + + private: + const uint32_t mId; +}; +} // namespace impl + +class GleanTimespan final : public nsIGleanTimespan { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIGLEANTIMESPAN + + explicit GleanTimespan(uint32_t aId) : mTimespan(aId){}; + + private: + virtual ~GleanTimespan() = default; + + const impl::TimespanMetric mTimespan; +}; + +} // namespace mozilla::glean + +#endif /* mozilla_glean_GleanTimespan_h */ diff --git a/toolkit/components/glean/bindings/private/TimingDistribution.cpp b/toolkit/components/glean/bindings/private/TimingDistribution.cpp new file mode 100644 index 0000000000..78aad6d4cd --- /dev/null +++ b/toolkit/components/glean/bindings/private/TimingDistribution.cpp @@ -0,0 +1,195 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/glean/bindings/TimingDistribution.h" + +#include "Common.h" +#include "mozilla/Components.h" +#include "mozilla/ResultVariant.h" + +#include "mozilla/dom/ToJSValue.h" +#include "mozilla/glean/bindings/HistogramGIFFTMap.h" +#include "mozilla/glean/fog_ffi_generated.h" +#include "nsIClassInfoImpl.h" +#include "nsJSUtils.h" +#include "nsPrintfCString.h" +#include "nsString.h" +#include "js/PropertyAndElement.h" // JS_DefineProperty + +// Called from within FOG's Rust impl. +extern "C" NS_EXPORT void GIFFT_TimingDistributionStart( + uint32_t aMetricId, mozilla::glean::TimerId aTimerId) { + auto mirrorId = mozilla::glean::HistogramIdForMetric(aMetricId); + if (mirrorId) { + mozilla::glean::GetTimerIdToStartsLock().apply([&](auto& lock) { + auto tuple = std::make_tuple(aMetricId, aTimerId); + // It should be all but impossible for anyone to have already inserted + // this timer for this metric given the monotonicity of timer ids. + (void)NS_WARN_IF(lock.ref()->Remove(tuple)); + lock.ref()->InsertOrUpdate(tuple, mozilla::TimeStamp::Now()); + }); + } +} + +// Called from within FOG's Rust impl. +extern "C" NS_EXPORT void GIFFT_TimingDistributionStopAndAccumulate( + uint32_t aMetricId, mozilla::glean::TimerId aTimerId) { + auto mirrorId = mozilla::glean::HistogramIdForMetric(aMetricId); + if (mirrorId) { + mozilla::glean::GetTimerIdToStartsLock().apply([&](auto& lock) { + auto optStart = lock.ref()->Extract(std::make_tuple(aMetricId, aTimerId)); + // The timer might not be in the map to be removed if it's already been + // cancelled or stop_and_accumulate'd. + if (!NS_WARN_IF(!optStart)) { + AccumulateTimeDelta(mirrorId.extract(), optStart.extract()); + } + }); + } +} + +// Called from within FOG's Rust impl. +extern "C" NS_EXPORT void GIFFT_TimingDistributionAccumulateRawMillis( + uint32_t aMetricId, uint32_t aMS) { + auto mirrorId = mozilla::glean::HistogramIdForMetric(aMetricId); + if (mirrorId) { + Accumulate(mirrorId.extract(), aMS); + } +} + +// Called from within FOG's Rust impl. +extern "C" NS_EXPORT void GIFFT_TimingDistributionCancel( + uint32_t aMetricId, mozilla::glean::TimerId aTimerId) { + auto mirrorId = mozilla::glean::HistogramIdForMetric(aMetricId); + if (mirrorId) { + mozilla::glean::GetTimerIdToStartsLock().apply([&](auto& lock) { + // The timer might not be in the map to be removed if it's already been + // cancelled or stop_and_accumulate'd. + (void)NS_WARN_IF( + !lock.ref()->Remove(std::make_tuple(aMetricId, aTimerId))); + }); + } +} + +namespace mozilla::glean { + +namespace impl { + +TimerId TimingDistributionMetric::Start() const { + return fog_timing_distribution_start(mId); +} + +void TimingDistributionMetric::StopAndAccumulate(const TimerId&& aId) const { + fog_timing_distribution_stop_and_accumulate(mId, aId); +} + +// Intentionally not exposed to JS for lack of use case and a time duration +// type. +void TimingDistributionMetric::AccumulateRawDuration( + const TimeDuration& aDuration) const { + fog_timing_distribution_accumulate_raw_nanos( + mId, uint64_t(aDuration.ToMicroseconds() * 1000.00)); +} + +void TimingDistributionMetric::Cancel(const TimerId&& aId) const { + fog_timing_distribution_cancel(mId, aId); +} + +Result<Maybe<DistributionData>, nsCString> +TimingDistributionMetric::TestGetValue(const nsACString& aPingName) const { + nsCString err; + if (fog_timing_distribution_test_get_error(mId, &err)) { + return Err(err); + } + if (!fog_timing_distribution_test_has_value(mId, &aPingName)) { + return Maybe<DistributionData>(); + } + nsTArray<uint64_t> buckets; + nsTArray<uint64_t> counts; + uint64_t sum; + fog_timing_distribution_test_get_value(mId, &aPingName, &sum, &buckets, + &counts); + return Some(DistributionData(buckets, counts, sum)); +} + +} // namespace impl + +NS_IMPL_CLASSINFO(GleanTimingDistribution, nullptr, 0, {0}) +NS_IMPL_ISUPPORTS_CI(GleanTimingDistribution, nsIGleanTimingDistribution) + +NS_IMETHODIMP +GleanTimingDistribution::Start(JSContext* aCx, + JS::MutableHandle<JS::Value> aResult) { + if (!dom::ToJSValue(aCx, mTimingDist.Start(), aResult)) { + return NS_ERROR_FAILURE; + } + return NS_OK; +} + +NS_IMETHODIMP +GleanTimingDistribution::StopAndAccumulate(uint64_t aId) { + mTimingDist.StopAndAccumulate(std::move(aId)); + return NS_OK; +} + +NS_IMETHODIMP +GleanTimingDistribution::Cancel(uint64_t aId) { + mTimingDist.Cancel(std::move(aId)); + return NS_OK; +} + +NS_IMETHODIMP +GleanTimingDistribution::TestGetValue(const nsACString& aPingName, + JSContext* aCx, + JS::MutableHandle<JS::Value> aResult) { + auto result = mTimingDist.TestGetValue(aPingName); + if (result.isErr()) { + aResult.set(JS::UndefinedValue()); + LogToBrowserConsole(nsIScriptError::errorFlag, + NS_ConvertUTF8toUTF16(result.unwrapErr())); + return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; + } + auto optresult = result.unwrap(); + if (optresult.isNothing()) { + aResult.set(JS::UndefinedValue()); + } else { + // Build return value of the form: { sum: #, values: {bucket1: count1, + // ...} + JS::Rooted<JSObject*> root(aCx, JS_NewPlainObject(aCx)); + if (!root) { + return NS_ERROR_FAILURE; + } + uint64_t sum = optresult.ref().sum; + if (!JS_DefineProperty(aCx, root, "sum", static_cast<double>(sum), + JSPROP_ENUMERATE)) { + return NS_ERROR_FAILURE; + } + JS::Rooted<JSObject*> valuesObj(aCx, JS_NewPlainObject(aCx)); + if (!valuesObj || + !JS_DefineProperty(aCx, root, "values", valuesObj, JSPROP_ENUMERATE)) { + return NS_ERROR_FAILURE; + } + auto& data = optresult.ref().values; + for (const auto& entry : data) { + const uint64_t bucket = entry.GetKey(); + const uint64_t count = entry.GetData(); + if (!JS_DefineProperty(aCx, valuesObj, + nsPrintfCString("%" PRIu64, bucket).get(), + static_cast<double>(count), JSPROP_ENUMERATE)) { + return NS_ERROR_FAILURE; + } + } + aResult.setObject(*root); + } + return NS_OK; +} + +NS_IMETHODIMP +GleanTimingDistribution::TestAccumulateRawMillis(uint64_t aSample) { + mTimingDist.AccumulateRawDuration(TimeDuration::FromMilliseconds(aSample)); + return NS_OK; +} + +} // namespace mozilla::glean diff --git a/toolkit/components/glean/bindings/private/TimingDistribution.h b/toolkit/components/glean/bindings/private/TimingDistribution.h new file mode 100644 index 0000000000..7c2e69d89e --- /dev/null +++ b/toolkit/components/glean/bindings/private/TimingDistribution.h @@ -0,0 +1,109 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_glean_GleanTimingDistribution_h +#define mozilla_glean_GleanTimingDistribution_h + +#include "mozilla/glean/bindings/DistributionData.h" +#include "mozilla/Maybe.h" +#include "mozilla/Result.h" +#include "mozilla/TimeStamp.h" +#include "nsIGleanMetrics.h" +#include "nsTArray.h" + +namespace mozilla::glean { + +typedef uint64_t TimerId; + +namespace impl { +class TimingDistributionMetric { + public: + constexpr explicit TimingDistributionMetric(uint32_t aId) : mId(aId) {} + + /* + * Starts tracking time for the provided metric. + * + * @returns A unique TimerId for the new timer + */ + TimerId Start() const; + + /* + * Stops tracking time for the provided metric and associated timer id. + * + * Adds a count to the corresponding bucket in the timing distribution. + * This will record an error if no `Start` was called on this TimerId or + * if this TimerId was used to call `Cancel`. + * + * @param aId The TimerId to associate with this timing. This allows for + * concurrent timing of events associated with different ids. + */ + void StopAndAccumulate(const TimerId&& aId) const; + + /* + * Adds a duration sample to a timing distribution metric. + * + * Adds a count to the corresponding bucket in the timing distribution. + * Prefer Start() and StopAndAccumulate() where possible. + * Users of this API are responsible for ensuring the timing source used + * to calculate the TimeDuration is monotonic and consistent accross + * platforms. + * + * NOTE: Negative durations are not handled and will saturate to INT64_MAX + * nanoseconds. + * + * @param aDuration The duration of the sample to add to the distribution. + */ + void AccumulateRawDuration(const TimeDuration& aDuration) const; + + /* + * Aborts a previous `Start` call. No error is recorded if no `Start` was + * called. + * + * @param aId The TimerId whose `Start` you wish to abort. + */ + void Cancel(const TimerId&& aId) const; + + /** + * **Test-only API** + * + * Gets the currently stored value as a DistributionData. + * + * This function will attempt to await the last parent-process task (if any) + * writing to the the metric's storage engine before returning a value. + * This function will not wait for data from child processes. + * + * This doesn't clear the stored value. + * Parent process only. Panics in child processes. + * + * @param aPingName The (optional) name of the ping to retrieve the metric + * for. Defaults to the first value in `send_in_pings`. + * + * @return value of the stored metric, or Nothing() if there is no value. + */ + Result<Maybe<DistributionData>, nsCString> TestGetValue( + const nsACString& aPingName = nsCString()) const; + + private: + const uint32_t mId; +}; +} // namespace impl + +class GleanTimingDistribution final : public nsIGleanTimingDistribution { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIGLEANTIMINGDISTRIBUTION + + explicit GleanTimingDistribution(uint64_t aId) : mTimingDist(aId){}; + + private: + virtual ~GleanTimingDistribution() = default; + + const impl::TimingDistributionMetric mTimingDist; +}; + +} // namespace mozilla::glean + +#endif /* mozilla_glean_GleanTimingDistribution_h */ diff --git a/toolkit/components/glean/bindings/private/Url.cpp b/toolkit/components/glean/bindings/private/Url.cpp new file mode 100644 index 0000000000..b86c724e17 --- /dev/null +++ b/toolkit/components/glean/bindings/private/Url.cpp @@ -0,0 +1,77 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/glean/bindings/Url.h" + +#include "Common.h" +#include "jsapi.h" +#include "js/String.h" +#include "nsString.h" +#include "mozilla/Components.h" +#include "mozilla/ResultVariant.h" +#include "mozilla/glean/bindings/ScalarGIFFTMap.h" +#include "mozilla/glean/fog_ffi_generated.h" +#include "nsIClassInfoImpl.h" + +namespace mozilla::glean { + +namespace impl { + +void UrlMetric::Set(const nsACString& aValue) const { + auto scalarId = ScalarIdForMetric(mId); + if (scalarId) { + Telemetry::ScalarSet(scalarId.extract(), NS_ConvertUTF8toUTF16(aValue)); + } + fog_url_set(mId, &aValue); +} + +Result<Maybe<nsCString>, nsCString> UrlMetric::TestGetValue( + const nsACString& aPingName) const { + nsCString err; + if (fog_url_test_get_error(mId, &err)) { + return Err(err); + } + if (!fog_url_test_has_value(mId, &aPingName)) { + return Maybe<nsCString>(); + } + nsCString ret; + fog_url_test_get_value(mId, &aPingName, &ret); + return Some(ret); +} + +} // namespace impl + +NS_IMPL_CLASSINFO(GleanUrl, nullptr, 0, {0}) +NS_IMPL_ISUPPORTS_CI(GleanUrl, nsIGleanUrl) + +NS_IMETHODIMP +GleanUrl::Set(const nsACString& aValue) { + mUrl.Set(aValue); + return NS_OK; +} + +NS_IMETHODIMP +GleanUrl::TestGetValue(const nsACString& aStorageName, JSContext* aCx, + JS::MutableHandle<JS::Value> aResult) { + auto result = mUrl.TestGetValue(aStorageName); + if (result.isErr()) { + aResult.set(JS::UndefinedValue()); + LogToBrowserConsole(nsIScriptError::errorFlag, + NS_ConvertUTF8toUTF16(result.unwrapErr())); + return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; + } + auto optresult = result.unwrap(); + if (optresult.isNothing()) { + aResult.set(JS::UndefinedValue()); + } else { + const NS_ConvertUTF8toUTF16 str(optresult.ref()); + aResult.set( + JS::StringValue(JS_NewUCStringCopyN(aCx, str.Data(), str.Length()))); + } + return NS_OK; +} + +} // namespace mozilla::glean diff --git a/toolkit/components/glean/bindings/private/Url.h b/toolkit/components/glean/bindings/private/Url.h new file mode 100644 index 0000000000..115eb073f5 --- /dev/null +++ b/toolkit/components/glean/bindings/private/Url.h @@ -0,0 +1,70 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_glean_GleanUrl_h +#define mozilla_glean_GleanUrl_h + +#include "mozilla/Maybe.h" +#include "mozilla/Result.h" +#include "nsIGleanMetrics.h" +#include "nsString.h" + +namespace mozilla::glean { + +namespace impl { + +class UrlMetric { + public: + constexpr explicit UrlMetric(uint32_t aId) : mId(aId) {} + + /* + * Set to the specified value. + * + * @param aValue The stringified Url to set the metric to. + */ + void Set(const nsACString& aValue) const; + + /** + * **Test-only API** + * + * Gets the currently stored value as a string. + * + * This function will attempt to await the last parent-process task (if any) + * writing to the the metric's storage engine before returning a value. + * This function will not wait for data from child processes. + * + * This doesn't clear the stored value. + * Parent process only. Panics in child processes. + * + * @param aPingName The (optional) name of the ping to retrieve the metric + * for. Defaults to the first value in `send_in_pings`. + * + * @return value of the stored metric, or Nothing() if there is no value. + */ + Result<Maybe<nsCString>, nsCString> TestGetValue( + const nsACString& aPingName = nsCString()) const; + + private: + const uint32_t mId; +}; +} // namespace impl + +class GleanUrl final : public nsIGleanUrl { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIGLEANURL + + explicit GleanUrl(uint32_t aId) : mUrl(aId){}; + + private: + virtual ~GleanUrl() = default; + + const impl::UrlMetric mUrl; +}; + +} // namespace mozilla::glean + +#endif /* mozilla_glean_GleanUrl_h */ diff --git a/toolkit/components/glean/bindings/private/Uuid.cpp b/toolkit/components/glean/bindings/private/Uuid.cpp new file mode 100644 index 0000000000..205dc94ec7 --- /dev/null +++ b/toolkit/components/glean/bindings/private/Uuid.cpp @@ -0,0 +1,89 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/glean/bindings/Uuid.h" + +#include "Common.h" +#include "jsapi.h" +#include "mozilla/Components.h" +#include "mozilla/ResultVariant.h" +#include "mozilla/glean/bindings/ScalarGIFFTMap.h" +#include "mozilla/glean/fog_ffi_generated.h" +#include "nsIClassInfoImpl.h" +#include "nsString.h" + +namespace mozilla::glean { + +namespace impl { + +void UuidMetric::Set(const nsACString& aValue) const { + auto scalarId = ScalarIdForMetric(mId); + if (scalarId) { + Telemetry::ScalarSet(scalarId.extract(), NS_ConvertUTF8toUTF16(aValue)); + } + fog_uuid_set(mId, &aValue); +} + +void UuidMetric::GenerateAndSet() const { + // We don't have the generated value to mirror to the scalar, + // so calling this function on a mirrored metric is likely an error. + (void)NS_WARN_IF(ScalarIdForMetric(mId).isSome()); + fog_uuid_generate_and_set(mId); +} + +Result<Maybe<nsCString>, nsCString> UuidMetric::TestGetValue( + const nsACString& aPingName) const { + nsCString err; + if (fog_uuid_test_get_error(mId, &err)) { + return Err(err); + } + if (!fog_uuid_test_has_value(mId, &aPingName)) { + return Maybe<nsCString>(); + } + nsCString ret; + fog_uuid_test_get_value(mId, &aPingName, &ret); + return Some(ret); +} + +} // namespace impl + +NS_IMPL_CLASSINFO(GleanUuid, nullptr, 0, {0}) +NS_IMPL_ISUPPORTS_CI(GleanUuid, nsIGleanUuid) + +NS_IMETHODIMP +GleanUuid::Set(const nsACString& aValue) { + mUuid.Set(aValue); + return NS_OK; +} + +NS_IMETHODIMP +GleanUuid::GenerateAndSet() { + mUuid.GenerateAndSet(); + return NS_OK; +} + +NS_IMETHODIMP +GleanUuid::TestGetValue(const nsACString& aStorageName, JSContext* aCx, + JS::MutableHandle<JS::Value> aResult) { + auto result = mUuid.TestGetValue(aStorageName); + if (result.isErr()) { + aResult.set(JS::UndefinedValue()); + LogToBrowserConsole(nsIScriptError::errorFlag, + NS_ConvertUTF8toUTF16(result.unwrapErr())); + return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; + } + auto optresult = result.unwrap(); + if (optresult.isNothing()) { + aResult.set(JS::UndefinedValue()); + } else { + const NS_ConvertUTF8toUTF16 str(optresult.value()); + aResult.set( + JS::StringValue(JS_NewUCStringCopyN(aCx, str.Data(), str.Length()))); + } + return NS_OK; +} + +} // namespace mozilla::glean diff --git a/toolkit/components/glean/bindings/private/Uuid.h b/toolkit/components/glean/bindings/private/Uuid.h new file mode 100644 index 0000000000..941ce42540 --- /dev/null +++ b/toolkit/components/glean/bindings/private/Uuid.h @@ -0,0 +1,75 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_glean_GleanUuid_h +#define mozilla_glean_GleanUuid_h + +#include "mozilla/Maybe.h" +#include "mozilla/Result.h" +#include "nsIGleanMetrics.h" +#include "nsString.h" + +namespace mozilla::glean { + +namespace impl { + +class UuidMetric { + public: + constexpr explicit UuidMetric(uint32_t aId) : mId(aId) {} + + /* + * Sets to the specified value. + * + * @param aValue The UUID to set the metric to. + */ + void Set(const nsACString& aValue) const; + + /* + * Generate a new random UUID and set the metric to it. + */ + void GenerateAndSet() const; + + /** + * **Test-only API** + * + * Gets the currently stored value as a hyphenated string. + * + * This function will attempt to await the last parent-process task (if any) + * writing to the the metric's storage engine before returning a value. + * This function will not wait for data from child processes. + * + * This doesn't clear the stored value. + * Parent process only. Panics in child processes. + * + * @param aPingName The (optional) name of the ping to retrieve the metric + * for. Defaults to the first value in `send_in_pings`. + * + * @return value of the stored metric, or Nothing() if there is no value. + */ + Result<Maybe<nsCString>, nsCString> TestGetValue( + const nsACString& aPingName = nsCString()) const; + + private: + const uint32_t mId; +}; +} // namespace impl + +class GleanUuid final : public nsIGleanUuid { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIGLEANUUID + + explicit GleanUuid(uint32_t aId) : mUuid(aId){}; + + private: + virtual ~GleanUuid() = default; + + const impl::UuidMetric mUuid; +}; + +} // namespace mozilla::glean + +#endif /* mozilla_glean_GleanUuid_h */ |