Telemetry Definition System

By communicating with the telemetry system and instrumentation applications, the performance analysis challenge of mobile applications in variable environments was solved, achieving low-latency and high-efficiency data collection and analysis, and improving the accuracy and richness of application performance tracking.

CN108139961BActive Publication Date: 2024-11-05MICROSOFT TECHNOLOGY LICENSING LLC
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN201680059600.2
Authority / Receiving Office
CN · China
Patent Type
Patents(China)
Current Assignee / Owner
Priority Date
2015-10-16
Filing Date
2016-10-10
Publication Date
2024-11-05
Estimated Expiration
2036-10-10

AI Technical Summary

Technical Problem

Existing technologies struggle to effectively simulate and analyze the performance issues of mobile applications in varying environments under laboratory conditions, particularly the impact of network connectivity, GPS signal quality, and device hardware differences on user experience, making it difficult to analyze crash logs and performance tracking data.

Method used

The system uses telemetry and instrumentation to communicate, collects and analyzes field data, and declares and populates data through event definition and pattern part declaration. It utilizes strongly typed shared patterns to support rich analysis, achieving low-latency data transmission and efficient data collection.

Benefits of technology

It provides a low-overhead way to quickly create instrumentation points, enabling efficient data collection across multiple platforms, simplifying the analysis of application performance and user behavior, and improving the richness and analyzability of the data.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN108139961B_ABST
    Figure CN108139961B_ABST
Patent Text Reader

Abstract

A method of operating a telemetry system includes using a log repository of the telemetry system to automatically populate a first set of fields in a schema defined by an event and to populate a second set of fields in the schema and / or selected by an event author.
Need to check novelty before this filing date? Find Prior Art

Description

Background Art

[0001] In order to improve the quality of software applications, software developers try to understand how applications perform in the hands of users, including customers and clients. Although laboratory or development testing such as debugging and logging during application development is important for improving quality, laboratory testing alone is not enough for many modern applications. Modern software applications (especially mobile applications) are highly interactive, and it is difficult to simulate comprehensive user interactions in the laboratory or during development. In addition, several environmental conditions affect the user's experience of the application. For example, network connectivity, GPS signal quality, and device hardware are all very different. Some platform APIs can even change behavior depending on the amount of power remaining in the device battery. These different environmental conditions are difficult to reproduce in the laboratory. Therefore, many software developers are committed to collecting diagnostic and performance tracking data from the field.

[0002] However, platform support for tracking app performance in the field is often inadequate. Major platforms, including mobile platforms, provide app crash logs to developers, but developers report difficulty identifying crash causes from the multitude of logs. Furthermore, this data, which may also include unresponsive events and exceptions, does not provide much help in detecting performance issues. Analytics frameworks are designed to collect usage analytics such as user demographics rather than performance data. This information often does not effectively provide information about specific user activities within the app.

[0003] Instead, developers seeking meaningful information about app performance will include custom tracing code in their apps, which is not an easy task. For example, even a simple user request in an app triggers multiple asynchronous calls with complex synchronization between threads, and identifying performance bottlenecks in such code requires properly tracing causal relationships across asynchronous boundaries. This challenging task is made more difficult because tracing overhead is best kept to a minimum to avoid impact on app performance and limit consumption of scarce resources such as battery and network bandwidth. Summary of the invention

[0004] The present invention summary is provided to introduce in a simplified form a selection of concepts that will be further described in the detailed description below. The present invention summary is not intended to identify the key features or essential features of the claimed technical solution, nor is it intended to be used to limit the scope of the claimed technical solution.

[0005] A telemetry system including an implementation process is described. The telemetry system can communicate with one or more instrumented applications to collect data about events from the field and forward the relevant and consolidated data to an analysis application for rich analysis. The telemetry system is configured to operate using an event definition having one or more schema portions, the one or more schema portions being used to declare and populate data from an event, an event being an instantiation of an event definition. An event definition can capture actions or interactions that an event author (such as an application developer) wishes to track. The present disclosure also includes several aspects of systems, methods, and computer-readable media for use with the telemetry system, which can include using a logging library to automatically (i.e., explicitly) populate a first set of fields in a schema of an event definition. The event author can select a second set of fields from another schema.

[0006] An event definition may include multiple schema parts configured to include data from an event. In an example, an event definition includes a first portion of a schema having fields that are automatically populated by a log library without input from an event author (such as an application developer). For example, a first portion of a schema may include a system schema for data that is common to all events, such as system data. An event may also include a second portion of a schema that includes fields selected by the event author. For example, a domain portion of a schema includes fields with wide applicability. In one example, an event author may select zero or more domain portion of a schema, but the event author does not control the name of the field or the data type of the field. Instead, the log library predefines the fields and types in the selected domain schema and populates the fields with data. The second portion of a schema may also include a custom schema with fields and types defined by the event author that may be applicable to an event but are not originally included in the system schema and domain schema. In one example, the first portion of a schema and the domain portion of a schema are not defined using an event definition; they are common to all event definitions.

[0007] The instrumented application may include a telemetry layer. The telemetry layer includes an automatically captured first partial schema or system schema that automatically captures common relevant data and may capture information injected with an event ingestion component of a telemetry pipeline. Event authors may include a second partial schema that aligns with the event domain or meaning in a custom schema and create fields in the custom schema to include application specific information related to the event.

[0008] In one example, the telemetry system includes a high-volume, low-latency event and telemetry platform. The telemetry system can be applied to drive one or more client and service ecosystems. The example system or process of the present disclosure is able to unify real-time, interactive, event-driven workflows from customers to the cloud or computer network with comprehensive batch telemetry and return it to the customer. A powerful common model with strongly typed fixed and flexible data fields for fully describing the data supports rich analysis. The described system and process provide application developers with a way to quickly and easily create new instrumentation points with relatively low overhead. The powerful common model provides data that is efficiently collected across multiple platforms. BRIEF DESCRIPTION OF THE DRAWINGS

[0009] The accompanying drawings are included to provide a further understanding of the embodiments and are incorporated into and constitute a part of this specification. The accompanying drawings illustrate the embodiments and are used together with the description to explain the principles of the embodiments. It will be easy to understand other embodiments and many expected advantages of the embodiments because they become better understood by reference to the following detailed description. The elements of the accompanying drawings are not necessarily to scale with respect to each other. The same reference numerals represent corresponding similar parts.

[0010] Figure 1 is a block diagram illustrating an example of a computing device.

[0011] Figure 2 is a block diagram illustrating an example telemetry system incorporating a computing device.

[0012] Figure 3 It's a picture. Figure 2 A block diagram of an example process for a telemetry system.

[0013] Figure 4 It's a picture. Figure 2 A block diagram of an example schema of a telemetry system. DETAILED DESCRIPTION

[0014] In the following specific embodiments, reference is made to the accompanying drawings, which form a part of this document, and in which specific embodiments of the present invention can be practiced are shown by way of illustration. It should be understood that other embodiments may be utilized and structural or logical changes may be made without departing from the scope of the present invention. Therefore, the following specific embodiments should not be considered to have a limiting meaning, and the scope of the present invention is defined by the appended claims. It should be understood that, unless otherwise specifically noted, the features of the various exemplary embodiments described herein may be combined with each other.

[0015] Figure 1An exemplary computer system is illustrated that can be employed in an operating environment and used to host or run a computer application included on one or more computer-readable storage media storing computer-executable instructions for controlling a computer system (such as a computer device) to perform a process. An example of a computer-implemented process includes generating telemetry data using a telemetry pattern that can be stored in a computer memory.

[0016] An exemplary computer system includes a computing device such as computing device 100. In a basic hardware configuration, computing device 100 typically includes a processor system having memory 104 and one or more processing units (i.e., processor 102). As an example, the processing unit may include two or more processing cores on a chip or two or more processor chips. In some examples, the computing device may also have one or more additional processing or special-purpose processors (not shown), such as a graphics processor for general-purpose computing on a graphics processor unit, to perform processing functions offloaded from processor 102. Memory 104 may be arranged in a hierarchical structure and may include one or more levels of cache. Depending on the configuration and type of the computing device, memory 104 may be volatile (such as random access memory (RAM)), non-volatile (such as read-only memory (ROM), flash memory, etc.), or some combination of the two. Computing device 100 may take one or more of several forms. Such forms include tablet computers, personal computers, workstations, servers, handheld devices, consumer electronic devices (such as video game consoles or digital video recorders), or other devices, and may be stand-alone devices or configured as part of a computer network, computer cluster, cloud service infrastructure, or other.

[0017] The computing device 100 may also have additional features or functions. For example, the computing device 100 may also include additional storage devices. Such storage devices may be removable and / or non-removable, and may include magnetic or optical disks, solid-state memory, or flash memory devices, such as removable storage devices 108 and non-removable storage devices 110. Computer storage media include volatile and non-volatile, removable and non-removable media implemented in any suitable method or technology for storage of information, such as computer-readable instructions, data structures, program modules, or other data. Memory 104, removable storage devices 108, and non-removable storage devices 110 are examples of computer storage media. Computer storage media include RAM, ROM, EEPROM, flash memory or other storage technology, CD-ROM, digital versatile disk (DVD) or other optical storage devices, cassettes, magnetic tapes, magnetic disk storage devices or other magnetic storage devices, universal serial bus (USB) flash drives, flash memory cards or other flash storage devices, or any other storage medium that can be used to store the desired information and can be accessed by the computing device 100. Therefore, the propagation signal itself does not qualify as a storage medium. Any such computer storage media may be part of computing device 100 .

[0018] The computing device 100 typically includes one or more input and / or output connections, such as USB connections, display ports, proprietary connections, and others, to connect to various devices to provide input and output to the computing device. Input devices 112 may include devices such as keyboards, pointing devices (e.g., mice), pens, voice input devices, touch input devices, or others. Output devices 111 may include devices such as displays, speakers, printers, and the like.

[0019] The computing device 100 typically includes one or more communication connections 114 that allow the computing device 100 to communicate with other computers / applications 115. Example communication connections may include Ethernet interfaces, wireless interfaces, bus interfaces, storage area network interfaces, and proprietary interfaces. The communication connections may be used to couple the computing device 100 to a computer network, which may be classified according to a variety of characteristics such as topology, connection method, and scale. A network is a collection of computing devices and possibly other devices interconnected by communication channels that support communication, and allow sharing of resources and information between the interconnected devices. Examples of computer networks include local area networks, wide area networks, the Internet, or other networks.

[0020] Figure 2An example telemetry system 200 is illustrated in a computer network 202, which may include one or more computing devices such as computing device 100. For illustration, the example telemetry system 200 may communicate with one or more client computing devices (e.g., client devices 204a-204c) executing instrumented software applications 206a-206c, and may also communicate with one or more subscriber devices (e.g., subscriber computing devices 208a-208b) executing analytical software applications 210a-210b. In one example, the client devices 204a-204c and the instrumented applications 206a-206c initiate communications with the telemetry system 200 over the network 202.

[0021] Instrumentation refers to enhancing an application with code that generates data that can be used to monitor or measure the performance and usage of the application, diagnose errors, write trace information, etc. Programmers implement instrumentation in the form of code instructions to monitor specific components in the system. When an application contains instrumented code, it can be managed using management tools to examine the performance of the application. Applications can be instrumented for logging and telemetry, which is usually located around the internal structure of the application during development and collects data when the application is released to actual users.

[0022] Telemetry is automated remote measurement and data collection. For example, telemetry data can represent information that is not discoverable during application development, such as which configurations customers prefer, how customers use features in the application, what the circumstances surrounding errors or crashes are, and other information. Telemetry data can include anonymous software version information, resource usage, memory access, operating systems in use, and many other examples. Telemetry system 200 provides tools to collect data and condense the collected data into analysis or human-readable reports.

[0023] In some examples, users of instrumented applications 206a-206c can determine which telemetry information is provided to telemetry system 200. For example, a user can choose to retain certain information locally, such as personal or sensitive information, and allow other information to be provided to the analysis software application. The user can choose not to upload such information as telemetry data, and telemetry system 200 will not be able to access personal or sensitive data.

[0024] Telemetry design results in instrumentation of events or actions to be tracked, and applications are typically instrumented to track a series of different actions of the application or interactions with the application. Telemetry instrumentation is provided by event authors such as application developers or component developers, and is applied to event handlers in some examples. In one example, an application developer may want to track dozens of events in an application. An event definition is a description of a specific event and includes a list of fields spelled out in a contract called a schema, in which a schema can provide a system for declaring and populating structured data. An event includes an actual instantiation of a set of data described in an event definition, and the set of data is logged and transmitted to the telemetry system 200. Events are emitted in response to selected actions or interactions, and the data payload or event payload of the event describes the properties and semantics of the stimulus that triggered its creation, the event impact, or both. Event authors create event definitions and instrumentation code to populate events and transmit them to the telemetry system 200.

[0025] The telemetry system 200 includes, for example, a receiving / formatting system 220, a log library 222, a processing system 224, a real-time system 226, and an event store 228. Telemetry data sent by client devices 204a-204c is received at the telemetry system 200, which can then forward events to subscriber devices 208a-208b with low latency. Subscribers use analysis applications 210a-210b to declare filters to receive relevant data. The telemetry system 200 can be configured to operate using one or more modes in declaring and filling structured or unstructured data. In one example, the receiving / formatting system 220 can be a web service that accepts events provided by client devices 204a-204c over the Internet. The log library 222 uploads data to the receiving / formatting system 220. The receiving / forwarding system 220 can provide data to the processing system 224 for rich analysis, batch processing, and reporting. The receiving / forwarding system 220 may also or alternatively provide data to a real-time system 226 for real-time or near real-time indexing, querying, monitoring, and alarming. For example, the real-time system 226 may include an operational period greater than instantaneous from an event to a system response. The event storage 228 may provide reference information about the event to the telemetry system 200.

[0026] Figure 3An event ingestion pipeline 300 is illustrated that shuttles events through multiple components of a telemetry system 200. The event payload may vary depending on its stage within the pipeline 300. The event ingestion pipeline may be implemented as a process in one or more computing devices 100 in the telemetry system 200. In this example, at 302, an instrumented software application such as an application 206a-206c issues an application event format to a log library 222. The log library 222 may include a code library that may, for example, accept events, serialize data for transmission, and upload events to a receiving / formatting system 220. The log library 222 may include log libraries for multiple platforms, such as a Java log library for a Java platform, an Android log library for an Android platform, and other telemetry clients. The first portion of the event definition schema includes a set of fields that are automatically populated with data using the log library. In some examples, other aspects of the telemetry system 200 may also populate the first set of fields. The event author may select a second set of fields from another schema that are also populated in the pipeline.

[0027] At 304, the log library 222 sends the client event format to the receiving / formatting system 220. In one example, different log libraries depending on the platform may include a common file format for describing event definitions and a format for serialization. In one example, the format for describing event definitions may include a serialization framework for graphical data, such as Bond available from Microsoft Corporation. The file format for payload serialization may include a data exchange format such as JavaScript Object Notation or JSON. At 306, the receiving / formatting system 220 emits the ingested event format. The fields of the pattern can continue to be filled with data as it is ingested. For example, the ingested data can be provided to the first partial pattern to determine the quality of the pipeline. The ingested events can be formatted in JSON and provided to a real-time system at 308, or provided to a batch system at 310, for example to allow analysis applications 210a-210b to query the data.

[0028] Figure 4An example event definition 400 used as a schema or contract in the telemetry system 200 is illustrated, which defines a list of fields that are composed into the event definition 400. In this example, the event definition includes fields that are composed into multiple schema parts, which are referred to as first part schema 402 and second part schema 404 in the event definition 400. In one example, the first part schema 402 includes a system schema 412 with system fields 422, while the second part schema 404 can further include multiple parts, such as a domain schema 414 with domain fields 424 and a custom schema 416 with custom fields 426, which are described in more detail below. However, in alternative examples, the event can include only fields from the first part 402, and can optionally include fields from the second part 404. In this example, the event definition can optionally include fields from the domain schema 414, optionally include fields from the custom schema 416, or include fields from both the domain schema 414 and the custom schema 416 as indicated in the event definition 400. Event definition 400 may also include annotations that may not appear in the actual event data, such as descriptions, ownership information, and field data types. In addition, fields may include default values.

[0029] The field definition in the example includes a name and a type. Types can include basic data types (such as Boolean, various integer types, floating point numbers, strings), containers (lists, vectors, sets, mappings), and complex types. In one example, the type can be selected from those types supported in the serialization framework. However, not all complex types supported in the serialization framework are supported in the data exchange format. In this case, the complex type in the serialization format can be converted to a string type.

[0030] Examples of events represented in JSON include:

[0031]

[0032] The first portion of the schema 402 includes fields 422 defined and automatically populated by the logging library 222 present on the local system, where the event is sent in a pipeline such as in the pipeline 300. In one example, the first portion of the schema 402 captures common related fields and can relate to a system of instrumented software applications such as applications 206a-206c, and can represent system data. The first portion of the schema 402 can also capture information injected by the event ingestion component in the pipeline 300. The first portion of the schema 402 includes fields that are generally applicable to all events from the instrumented application, and can include items such as event time, event name, and the Internet Protocol address of the sender. In some examples, in addition to the values ​​that are automatically populated, the first portion of the schema 402 can also include fields 422 that the logging library obtains from the calling program. In one example, all events use the same first portion of the schema.

[0033] The first portion of the schema 402 includes fields 422 that are common and applied to all events flowing through the telemetry system 200, and the design of the schema 402, including the selection of specific fields 422 to include, can be guided by various principles, such as consistent identifiers across a wide variety of applications and platforms (such as operating systems) and consideration of the impact on application overhead. The first portion of the schema enables correlation and can be used for automatic instrumentation using the log library 222. In one example, the first portion of the schema 402 can include event envelope semantics and ingestion sections.

[0034] The event envelope includes a data payload for transmitting event information between components of the pipeline 300. The payload may include the original event and a defined set of event parts. The event envelope semantics may include fields 422 such as a schema version, event name, time (including date), sampling rate, sequence to track the order in which events were uploaded, instrumentation key, flags, device identifier that can be resilient to system builds or hardware replacements, operating system, operating system version including branch and build information, application identifier, application version, user identifier, and a property bag for custom log library fields in some examples.

[0035] The ingestion section may be populated at the ingestion time. Fields for the ingestion section may include the time the event was received by the receiving / formatting system 220, the remote address seen by the receiving / formatting system 220 when the event was received, event authentication, and event quality.

[0036] The second part of the schema 404 includes an optional domain schema 414, a custom schema 416, or both. The second part of the schema 404 includes fields 424, 426 that are filled by code written by the event author instead of the log library 222. In one example, the second part of the schema 404 includes a domain schema 414 with predefined fields 424, such as defined by the telemetry system 200 or other centralized group, and the event author does not control the name of the field 424 or the data type of the field 424. The custom schema 416 is created by the event author and can be used for scenarios or aspects of events that are application-specific and for which no domain field 424 exists. Templates can be applied to the second part of the schema 404 to support the reuse of fields 424, 426 that are usually defined across several events. In one example, templates are used for domain schema 414. Templates support defining a set of fields that can be consistently reused across multiple event definitions, and in some examples support doing so when multiple event definitions include different domain fields 424.

[0037] In one example, domain schema 414 is related to specific scenarios or event aspects that are shared across many different applications. For example, fields 424 in domain schema 414 may include logging errors, application start events, application end events, web service API (application program interface) call successes, API call failures, and many other examples. A wide variety of applications and events may define events from domain schema fields 424, and therefore include similar fields and data. Thus, a set of common reports and analyses may be built to consume all events from all applications on a platform using the same domain schema 414. Event templates are similar to abstract classes that allow, for example, a centralized group to share a set of fields included in several related events. In one example, domain fields 424 may be lazily bound and selected when an event is defined.

[0038] The domain schema 414 is generalized to achieve broad applicability. For example, instead of more specific domain schemas such as play song, stop song, play video, stop video, etc., there can be a domain schema MediaUsage, which is more specific but, for example, in terms of media player usage patterns. The following includes a Bond representation of the domain schema structure for the MediaUsage example. In the following examples, field names are in camelCasing, while structures (records for storing more than one value), namespaces, and event abbreviations are in PascalCasing. Types include strings, 32-bit unsigned integers, and 64-bit unsigned integers.

[0039]

[0040]

[0041] Custom schema 416 is created and defined by the event author. In one example, the event author can determine the name and data type of custom field 426. The event author is also responsible for filling in custom field 426 when the event is instantiated.

[0042] The following example portion of an event includes a domain pattern 414 and a custom pattern 416:

[0043]

[0044] In this example, Played is the telemetry data, which uses the MediaUsage template extended to add a custom field sessionDurationSec.

[0045] In the following example, a portion of an event is defined to include domain schema 414 but without custom schema 416 to take advantage of empty field declarations that reference only Microsoft.Telemetry.Data <t>Domain mode in:

[0046] namespace Ms.Media;

[0047] struct Played:Microsoft.Telemetry.Data<Ms.Media.MediaUsage>

[0048] {

[0049] };

[0050] In the following example, a portion of an event is defined to include a custom pattern 416 but without a domain pattern 414. In this example, the event fires when the user sets the volume to the maximum level, and the event author defines the custom pattern 416 as:

[0051]

[0052] In the example above, an event may be defined without a domain schema, and may be inherited from Base to give the event only the custom fields 426 .

[0053] Although specific embodiments have been illustrated and described herein, it will be appreciated by those skilled in the art that various alternatives and / or equivalent implementations may be substituted for the specific embodiments shown and described without departing from the scope of the invention. This application is intended to cover any modifications or variations of the specific embodiments discussed herein. Therefore, it is intended that the present invention be limited only by the claims and their equivalents.< / t>

Claims

1. A method of operating a telemetry system for collecting telemetry data of an instrumented application, the method comprising: implementing an event ingestion pipeline to shuttle events through multiple components of the telemetry system; determining a quality of the event ingestion pipeline by ingesting the telemetry data into a first partial schema of a schema in an event definition; automatically populating a first set of fields in the first partial schema with the telemetry data from the instrumented application using a log repository of the telemetry system, the first set of fields comprising fields common to events flowing through the telemetry system, the instrumented application being enhanced with code subsequent to development of the instrumented application to generate data for monitoring or measuring performance of specific user activities of the instrumented application; as well as A second set of fields in a second portion of the schema selected by an application developer during the development of the instrumented application is populated. 2 . The method of claim 1 , wherein populating the second set of fields comprises pre-selected fields from the telemetry system. The method of claim 2 , wherein the pre-selected fields are populated with data that is common to multiple applications. The method of claim 2 , wherein the pre-selected fields include pre-defined names and data types. The method of claim 1 , wherein populating the second set of fields includes custom fields from the application developer. The method according to claim 5 , wherein the custom field includes a custom name and a custom data type. The method of claim 1 , wherein the first set of fields are automatically populated with data common to all events. The method of claim 7 , wherein the data common to all events comprises client system data.

9. The method of claim 1, wherein the first set of fields in the schema comprises event envelope semantics.

10. The method of claim 1, wherein populating the second set of fields includes pre-selected fields from the telemetry system and custom fields from the application developer.

11. A telemetry system for collecting telemetry data of an instrumented application, comprising: A computing device comprising a processor and a memory, the computing device being configured to: implementing an event ingestion pipeline to shuttle events through multiple components of the telemetry system; determining a quality of the event ingestion pipeline by ingesting the telemetry data into a first partial schema of a schema in an event definition; automatically populating a first set of fields in the first partial schema with the telemetry data from the instrumented application using a log repository of the telemetry system, the first set of fields comprising fields common to events flowing through the telemetry system, the instrumented application being enhanced with code subsequent to development of the instrumented application to generate data for monitoring or measuring performance of specific user activities of the instrumented application; as well as A second set of fields in a second portion of the schema selected by an application developer during the development of the instrumented application is populated.

12. The telemetry system of claim 11, wherein populating the second set of fields comprises pre-selected fields from the telemetry system.

13. The telemetry system of claim 11, wherein populating the second set of fields includes custom fields from the application developer.

14. The telemetry system of claim 11, wherein the telemetry system communicates with the instrumentation application via a computer network.

15. The telemetry system of claim 14, wherein the instrumentation application initiates communications with the telemetry system.

16. The telemetry system of claim 14, wherein the log library comprises a code library corresponding to a platform of the instrumented application.

17. A computer-readable storage medium, excluding transient propagating signals, the computer-readable storage medium storing computer-executable instructions for controlling a computing device to perform a method, the method comprising: Implementing an event ingestion pipeline to shuttle events through multiple components of the telemetry system; determining the quality of the event ingestion pipeline by ingesting telemetry data into a first partial schema of a schema in an event definition; automatically populating a first set of fields in the first partial schema with telemetry data using a log repository of a telemetry system, the telemetry system being used to collect the telemetry data from an instrumented application, the first set of fields comprising fields common to events flowing through the telemetry system, the instrumented application being enhanced with code after development of the instrumented application to generate data for monitoring or measuring performance of specific user activities of the instrumented application; as well as A second set of fields in a second portion of the schema selected by an application developer during the development of the instrumented application is populated.

18. The computer-readable storage medium of claim 17, wherein the events are represented in a data interchange format.

19. The computer-readable storage medium of claim 17, wherein the first set of fields in the schema comprises event envelope semantics.

20. The computer-readable storage medium of claim 17, wherein populating the second set of fields includes pre-selected fields from the telemetry system and custom fields from the application developer.