Struct xpcom::interfaces::nsITelemetry

#[repr(C)]
pub struct nsITelemetry { /* fields omitted */ }

interface nsITelemetry : nsISupports

Methods

impl nsITelemetry

pub fn coerce<T: nsITelemetryCoerce>(&self) -> &T

Cast this nsITelemetry to one of its base interfaces.

impl nsITelemetry

pub const HISTOGRAM_EXPONENTIAL: i64

HISTOGRAM_EXPONENTIAL: i64 = 0

/**
   * Histogram types:
   * HISTOGRAM_EXPONENTIAL - buckets increase exponentially
   * HISTOGRAM_LINEAR - buckets increase linearly
   * HISTOGRAM_BOOLEAN - For storing 0/1 values
   * HISTOGRAM_FLAG - For storing a single value; its count is always == 1.
   * HISTOGRAM_COUNT - For storing counter values without bucketing.
   * HISTOGRAM_CATEGORICAL - For storing enumerated values by label.
   */

pub const HISTOGRAM_LINEAR: i64

HISTOGRAM_LINEAR: i64 = 1

pub const HISTOGRAM_BOOLEAN: i64

HISTOGRAM_BOOLEAN: i64 = 2

pub const HISTOGRAM_FLAG: i64

HISTOGRAM_FLAG: i64 = 3

pub const HISTOGRAM_COUNT: i64

HISTOGRAM_COUNT: i64 = 4

pub const HISTOGRAM_CATEGORICAL: i64

HISTOGRAM_CATEGORICAL: i64 = 5

pub const SCALAR_TYPE_COUNT: i64

SCALAR_TYPE_COUNT: i64 = 0

/**
   * Scalar types:
   * SCALAR_TYPE_COUNT - for storing a numeric value
   * SCALAR_TYPE_STRING - for storing a string value
   * SCALAR_TYPE_BOOLEAN - for storing a boolean value
   */

pub const SCALAR_TYPE_STRING: i64

SCALAR_TYPE_STRING: i64 = 1

pub const SCALAR_TYPE_BOOLEAN: i64

SCALAR_TYPE_BOOLEAN: i64 = 2

pub const DATASET_RELEASE_CHANNEL_OPTOUT: i64

DATASET_RELEASE_CHANNEL_OPTOUT: i64 = 0

/**
   * Dataset types:
   * DATASET_RELEASE_CHANNEL_OPTOUT - the basic dataset that is on-by-default on all channels
   * DATASET_RELEASE_CHANNEL_OPTIN - the extended dataset that is opt-in on release,
   *                                 opt-out on pre-release channels.
   */

pub const DATASET_RELEASE_CHANNEL_OPTIN: i64

DATASET_RELEASE_CHANNEL_OPTIN: i64 = 1

pub unsafe fn GetLastShutdownDuration(
    &self,
    aLastShutdownDuration: *mut uint32_t
) -> nsresult

/**
   * The amount of time, in milliseconds, that the last session took
   * to shutdown.  Reads as 0 to indicate failure.
   */

readonly attribute uint32_t lastShutdownDuration;

pub unsafe fn GetFailedProfileLockCount(
    &self,
    aFailedProfileLockCount: *mut uint32_t
) -> nsresult

/**
   * The number of failed profile lock attempts that have occurred prior to
   * successfully locking the profile
   */

readonly attribute uint32_t failedProfileLockCount;

pub unsafe fn GetMaximalNumberOfConcurrentThreads(
    &self,
    aMaximalNumberOfConcurrentThreads: *mut uint32_t
) -> nsresult

/**
   * A number representing the highest number of concurrent threads
   * reached during this session.
   */

readonly attribute uint32_t maximalNumberOfConcurrentThreads;

pub unsafe fn CaptureStack(&self, name: &nsACString) -> nsresult

void captureStack (in ACString name);

pub unsafe fn GetCanRecordBase(&self, aCanRecordBase: *mut bool) -> nsresult

/**
   * A flag indicating if Telemetry can record base data (FHR data). This is true if the
   * FHR data reporting service or self-support are enabled.
   *
   * In the unlikely event that adding a new base probe is needed, please check the data
   * collection wiki at https://wiki.mozilla.org/Firefox/Data_Collection and talk to the
   * Telemetry team.
   */

attribute boolean canRecordBase;

pub unsafe fn SetCanRecordBase(&self, aCanRecordBase: bool) -> nsresult

/**
   * A flag indicating if Telemetry can record base data (FHR data). This is true if the
   * FHR data reporting service or self-support are enabled.
   *
   * In the unlikely event that adding a new base probe is needed, please check the data
   * collection wiki at https://wiki.mozilla.org/Firefox/Data_Collection and talk to the
   * Telemetry team.
   */

attribute boolean canRecordBase;

pub unsafe fn GetCanRecordExtended(
    &self,
    aCanRecordExtended: *mut bool
) -> nsresult

/**
   * A flag indicating if Telemetry is allowed to record extended data. Returns false if
   * the user hasn't opted into "extended Telemetry" on the Release channel, when the
   * user has explicitly opted out of Telemetry on Nightly/Aurora/Beta or if manually
   * set to false during tests.
   *
   * Set this to false in tests to disable gathering of extended telemetry statistics.
   */

attribute boolean canRecordExtended;

pub unsafe fn SetCanRecordExtended(&self, aCanRecordExtended: bool) -> nsresult

/**
   * A flag indicating if Telemetry is allowed to record extended data. Returns false if
   * the user hasn't opted into "extended Telemetry" on the Release channel, when the
   * user has explicitly opted out of Telemetry on Nightly/Aurora/Beta or if manually
   * set to false during tests.
   *
   * Set this to false in tests to disable gathering of extended telemetry statistics.
   */

attribute boolean canRecordExtended;

pub unsafe fn GetCanRecordReleaseData(
    &self,
    aCanRecordReleaseData: *mut bool
) -> nsresult

/**
   * A flag indicating whether Telemetry is recording release data, which is a
   * smallish subset of our usage data that we're prepared to handle from our
   * largish release population.
   *
   * This is true most of the time.
   *
   * This does not indicate whether Telemetry will send any data. That is
   * governed by user preference and other mechanisms.
   *
   * You may use this to determine if it's okay to record your data.
   */

readonly attribute boolean canRecordReleaseData;

pub unsafe fn GetCanRecordPrereleaseData(
    &self,
    aCanRecordPrereleaseData: *mut bool
) -> nsresult

/**
   * A flag indicating whether Telemetry is recording prerelease data, which is
   * a largish amount of usage data that we're prepared to handle from our
   * smallish pre-release population.
   *
   * This is true on pre-release branches of Firefox.
   *
   * This does not indicate whether Telemetry will send any data. That is
   * governed by user preference and other mechanisms.
   *
   * You may use this to determine if it's okay to record your data.
   */

readonly attribute boolean canRecordPrereleaseData;

pub unsafe fn GetIsOfficialTelemetry(
    &self,
    aIsOfficialTelemetry: *mut bool
) -> nsresult

/**
   * A flag indicating whether Telemetry can submit official results (for base or extended
   * data). This is true on official, non-debug builds with built in support for Mozilla
   * Telemetry reporting.
   */

readonly attribute boolean isOfficialTelemetry;

pub unsafe fn SetHistogramRecordingEnabled(
    &self,
    id: &nsACString,
    enabled: bool
) -> nsresult

/**
   * Enable/disable recording for this histogram at runtime.
   * Recording is enabled by default, unless listed at kRecordingInitiallyDisabledIDs[].
   * Name must be a valid Histogram identifier, otherwise an assertion will be triggered.
   *
   * @param id - unique identifier from histograms.json
   * @param enabled - whether or not to enable recording from now on.
   */

void setHistogramRecordingEnabled (in ACString id, in boolean enabled);

pub unsafe fn AsyncFetchTelemetryData(
    &self,
    aCallback: *const nsIFetchTelemetryDataCallback
) -> nsresult

/**
   * Read data from the previous run. After the callback is called, the last
   * shutdown time is available in lastShutdownDuration and any late
   * writes in lateWrites.
   */

void asyncFetchTelemetryData (in nsIFetchTelemetryDataCallback aCallback);

pub unsafe fn MsSinceProcessStart(&self, _retval: *mut c_double) -> nsresult

/**
   * Return the number of milliseconds since process start using monotonic
   * timestamps (unaffected by system clock changes).
   * @throws NS_ERROR_NOT_AVAILABLE if TimeStamp doesn't have the data.
   */

double msSinceProcessStart ();

pub unsafe fn MsSystemNow(&self, _retval: *mut c_double) -> nsresult

/**
   * Time since the system wide epoch. This is not a monotonic timer but
   * can be used across process boundaries.
   */

double msSystemNow ();

pub unsafe fn ClearScalars(&self) -> nsresult

/**
   * Resets all the stored scalars. This is intended to be only used in tests.
   */

void clearScalars ();

pub unsafe fn FlushBatchedChildTelemetry(&self) -> nsresult

/**
   * Immediately sends any Telemetry batched on this process to the parent
   * process. This is intended only to be used on process shutdown.
   */

void flushBatchedChildTelemetry ();

pub unsafe fn SetEventRecordingEnabled(
    &self,
    aCategory: &nsACString,
    aEnabled: bool
) -> nsresult

/**
   * Enable recording of events in a category.
   * Events default to recording disabled. This allows to toggle recording for all events
   * in the specified category.
   *
   * @param aCategory The category name.
   * @param aEnabled Whether recording is enabled for events in that category.
   */

void setEventRecordingEnabled (in ACString aCategory, in boolean aEnabled);

pub unsafe fn ClearEvents(&self) -> nsresult

/**
   * Resets all the stored events. This is intended to be only used in tests.
   */

void clearEvents ();

Methods from Deref<Target = nsISupports>

pub fn coerce<T: nsISupportsCoerce>(&self) -> &T

Cast this nsISupports to one of its base interfaces.

pub unsafe fn QueryInterface(
    &self,
    uuid: &nsIID,
    result: *mut *mut c_void
) -> nsresult

void QueryInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result);

pub unsafe fn AddRef(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt AddRef ();

pub unsafe fn Release(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt Release ();

Trait Implementations

impl XpCom for nsITelemetry

const IID: nsIID

IID: nsIID = nsID(658320848, 27747, 18266, [184, 100, 203, 101, 22, 10, 25, 9])

fn query_interface<T: XpCom>(&self) -> Option<RefPtr<T>>

Perform a QueryInterface call on this object, attempting to dynamically cast it to the requested interface type. Returns Some(RefPtr) if the cast succeeded, and None otherwise.

impl RefCounted for nsITelemetry

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsITelemetry

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.