emtr_event_recorder_get_default ()

EmtrEventRecorder *
emtr_event_recorder_get_default (void);

Gets the event recorder object that you should use to record all metrics.

emtr_event_recorder_new ()

EmtrEventRecorder *
emtr_event_recorder_new (void);

Testing function for creating a new EmtrEventRecorder in the C API. You only need to use this if you are creating an event recorder for use in unit testing.

For all normal uses, you should use emtr_event_recorder_get_default() instead.

emtr_event_recorder_record_event ()

void
emtr_event_recorder_record_event (EmtrEventRecorder *self,
                                  const gchar *event_id,
                                  GVariant *auxiliary_payload);

Make a best-effort to record the fact that an event of type event_id happened at the current time. Optionally, associate arbitrary data, auxiliary_payload , with this particular instance of the event. Under no circumstances should personally-identifiable information be included in the auxiliary_payload or event_id . Large auxiliary payloads dominate the size of the event and should therefore be used sparingly. Events for which precise timing information is not required should instead be recorded using emtr_event_recorder_record_events() to conserve bandwidth.

At the discretion of the metrics system, the event may be discarded before being reported to the metrics server. The event may take arbitrarily long to reach the server and may be persisted unencrypted on the client for arbitrarily long. There is no guarantee that the event is delivered via the network; for example, it may instead be delivered manually on a USB drive. No indication of successful or failed delivery is provided, and no application should rely on successful delivery. The event will not be aggregated with other events before reaching the server.

emtr_event_recorder_record_event_sync ()

void
emtr_event_recorder_record_event_sync (EmtrEventRecorder *self,
                                       const gchar *event_id,
                                       GVariant *auxiliary_payload);

Make a best-effort to record the fact that an event of type event_id occurred at the current time. Behaves like emtr_event_recorder_record_event() but executes synchronously, blocking until either a timeout expires or the event recorder daemon has received the event. Generally prefer emtr_event_recorder_record_event() in UI threads, but use emtr_event_recorder_record_event_sync() instead for the sake of reliability when recording an event from a process that is about to close.

Since: 0.4

emtr_event_recorder_record_events ()

void
emtr_event_recorder_record_events (EmtrEventRecorder *self,
                                   const gchar *event_id,
                                   gint64 num_events,
                                   GVariant *auxiliary_payload);

Make a best-effort to record the fact that num_events events of type event_id happened between the current time and the previous such recording. Optionally, associate arbitrary data, auxiliary_payload , with these particular instances of the event. Under no circumstances should personally-identifiable information be included in the auxiliary_payload , the event_id , or num_events . Large auxiliary payloads dominate the size of the event and should therefore be used sparingly. Events for which precise timing information is required should instead be recorded using emtr_event_recorder_record_event().

At the discretion of the metrics system, the events may be discarded before being reported to the metrics server. The events may take arbitrarily long to reach the server and may be persisted unencrypted on the client for arbitrarily long. There is no guarantee that the events are delivered via the network; for example, they may instead be delivered manually on a USB drive. No indication of successful or failed delivery is provided, and no application should rely on successful delivery. To conserve bandwidth, the events may be aggregated in a lossy fashion with other events with the same event_id before reaching the server.

emtr_event_recorder_record_events_sync ()

void
emtr_event_recorder_record_events_sync
                               (EmtrEventRecorder *self,
                                const gchar *event_id,
                                gint64 num_events,
                                GVariant *auxiliary_payload);

Make a best-effort to record the fact that num_events events of type event_id happened between the current time and the previous such recording. Behaves like emtr_event_recorder_record_events() but executes synchronously, blocking until either a timeout expires or the event recorder daemon has received the event. Generally prefer emtr_event_recorder_record_events() in UI threads, but use emtr_event_recorder_record_events_sync() instead for the sake of reliability when recording events from a process that is about to close.

Since: 0.4

emtr_event_recorder_record_start ()

void
emtr_event_recorder_record_start (EmtrEventRecorder *self,
                                  const gchar *event_id,
                                  GVariant *key,
                                  GVariant *auxiliary_payload);

Make a best-effort to record the fact that an event of type event_id started at the current time. The event's stop must be reported using emtr_event_recorder_record_stop() or memory will be leaked. If starts and stops of events of type event_id can be nested, then key should be used to disambiguate the stop and any progress that corresponds to this start. For example, if one were recording how long processes remained open, process IDs would be a suitable choice for the key . Within the lifetime of each process, process IDs are unique within the scope of PROCESS_OPEN events. If starts and stops of events of type event_id can not be nested, then key can be NULL.

Optionally, associate arbitrary data, auxiliary_payload , with this particular instance of the event. Under no circumstances should personally-identifiable information be included in the auxiliary_payload or event_id . Large auxiliary payloads dominate the size of the event and should therefore be used sparingly. Events for which precise timing information is not required should instead be recorded using emtr_event_recorder_record_events() to conserve bandwidth.

At the discretion of the metrics system, the event may be discarded before being reported to the metrics server. However, an event start, the corresponding stop, and any corresponding progress either will be delivered or dropped atomically. The event may take arbitrarily long to reach the server and may be persisted unencrypted on the client for arbitrarily long. There is no guarantee that the event is delivered via the network; for example, it may instead be delivered manually on a USB drive. No indication of successful or failed delivery is provided, and no application should rely on successful delivery. The event will not be aggregated with other events before reaching the server.

emtr_event_recorder_record_progress ()

void
emtr_event_recorder_record_progress (EmtrEventRecorder *self,
                                     const gchar *event_id,
                                     GVariant *key,
                                     GVariant *auxiliary_payload);

Make a best-effort to record the fact that an event of type event_id progressed at the current time. May be called arbitrarily many times between a corresponding start and stop. Behaves like emtr_event_recorder_record_start().

emtr_event_recorder_record_stop ()

void
emtr_event_recorder_record_stop (EmtrEventRecorder *self,
                                 const gchar *event_id,
                                 GVariant *key,
                                 GVariant *auxiliary_payload);

Make a best-effort to record the fact that an event of type event_id stopped at the current time. Behaves like emtr_event_recorder_record_start().

emtr_event_recorder_record_stop_sync ()

void
emtr_event_recorder_record_stop_sync (EmtrEventRecorder *self,
                                      const gchar *event_id,
                                      GVariant *key,
                                      GVariant *auxiliary_payload);

Make a best-effort to record the fact that an event of type event_id stopped at the current time. Behaves like emtr_event_recorder_record_stop() but executes synchronously, blocking until a timeout expires or the event recorder daemon has received the event sequence. Generally prefer emtr_event_recorder_record_stop() in UI threads, but use emtr_event_recorder_record_stop_sync() instead for the sake of reliability when recording an event sequence from a process that is about to close.

Since: 0.4

emtr_event_recorder_start_aggregate_timer ()

EmtrAggregateTimer *
emtr_event_recorder_start_aggregate_timer
                               (EmtrEventRecorder *self,
                                const gchar *event_id,
                                GVariant *auxiliary_payload);

Requests the metrics daemon to create an aggregate timer.

emtr_event_recorder_start_aggregate_timer_with_uid ()

EmtrAggregateTimer *
emtr_event_recorder_start_aggregate_timer_with_uid
                               (EmtrEventRecorder *self,
                                uid_t uid,
                                const gchar *event_id,
                                GVariant *auxiliary_payload);

Requests the metrics daemon to create an aggregate timer.

struct EmtrEventRecorder

struct EmtrEventRecorder;

This instance structure contains no public members.

struct EmtrEventRecorderClass

struct EmtrEventRecorderClass {
};

This class structure contains no public members.