Instrumentation of soft navigation elements in web page applications

Abstract

The disclosed technology relates to instrumenting an application. In one example, the method includes providing a web page application having a tracer application. The method further includes accessing the source of the web page application. The method further includes detecting references to elements of the web page application within the source. The method further includes detecting user interactions with the web page application. The method further includes automatically logging the start of a span based on the detection of user interactions. The logging includes associating the span with the tracer application. The method further includes performing actions related to the element. The method further includes determining that the element is ready for additional user interactions. The method further includes automatically logging the end of a span based on the determination.

Description

Technical Field

[0001] Cross - reference to Related Applications This application claims the benefit and priority of U.S. Patent Application No. 18 / 364,333, filed on August 2, 2023, entitled "INSTRUMENTATION OF SOFT NAVIGATION ELEMENTS OF WEB PAGE APPLICATIONS", which is hereby incorporated by reference in its entirety.

[0002] Technical Field This application generally relates to the instrumentation of web page applications, and more particularly, but not limited to, the instrumentation of priority elements associated with soft navigation within web page applications.

Background Art

[0003] Background As web - based applications become more sophisticated, conventional tracer applications may not be able to obtain accurate telemetry data within web page applications that have dynamically loaded elements. The disclosed solutions facilitate improved telemetry functions and analytics to overcome these deficiencies.

Summary of the Invention

[0004] Summary In one embodiment, the method includes providing a web page application, including a tracer application, to a web browser on a client device. The method further includes accessing the source of the web page application via the tracer application. The method further includes detecting references to elements of the web page application within the source via the tracer application. The elements can be triggered by user interaction with the web page application and have priority designations. The method further includes detecting user interaction with the web page application via the tracer application. The method further includes automatically logging the start of a span based on the detection of user interaction. The logging includes associating the span with the tracer application. The method further includes performing actions related to the element. The method further includes determining that the element is ready for additional user interaction. The method further includes automatically logging the end of a span based on the determination.

[0005] In one embodiment, the method further includes automatically starting an additional span associated with a subset of behaviors. The subset of behaviors is associated with the rendering of an element. The additional span is a child span of the span. The method further includes automatically logging the end of the additional span based on the completion of the subset of behaviors.

[0006] In one embodiment, detecting references to elements of a web page application includes running a mutation observer within a tracing application to parse the source of the web page, and determining, via the mutation observer, that the source has been modified.

[0007] In one embodiment, automatically logging the end of a span includes determining one or more of the number of processing cycles corresponding to the execution of an action, or the execution time of the action.

[0008] In one embodiment, the method further includes determining from the source of a web page application that an additional element is triggered by a user interaction. The method further includes automatically logging the start of an additional span in response to the determination that the additional element is triggered by a user interaction, the logging including associating the additional span with a tracer application. The method further includes performing additional actions related to the additional element in response to the determination that the additional element is triggered by a user interaction. The method further includes determining that the additional element is ready for user interaction in response to the determination that the additional element is triggered by a user interaction, based on the determination, automatically logging the end of the additional span and outputting a combined span representing the completion of the span and the additional span.

[0009] In one embodiment, it is determined that an element has a priority designation by identifying one or more attributes associated with the element within the source code of a web page application.

[0010] In one embodiment, the actions related to an element include sending a request to an external server for the element. The actions related to the element further include creating a child span based on the transmission. The actions related to the element further include receiving the element from the external server. The actions related to the element further include automatically logging the termination of the child span in response to receiving the element. The actions related to the element further include associating the child span with the span.

[0011] The above method can be implemented as a tangible computer-readable medium and / or as operating within a computer processor and connected memory. [Brief explanation of the drawing]

[0012] [Figure 1] This figure shows an example of a system for automatically instrumenting enterprise applications having priority elements, according to one aspect of the present disclosure. [Figure 2] This figure shows an example of a method used to collect telemetry data according to one aspect of the present disclosure. [Figure 3] This figure shows an example of an instrumented application for generating a span context according to one aspect of the present disclosure. [Figure 4] This figure shows an example of a span hierarchy for hard navigation and soft navigation according to one aspect of the present disclosure. [Figure 5] This figure shows an example of a method used to collect telemetry data of priority elements according to one aspect of the present disclosure. [Figure 6] Figures 6A and 6B are included, and show an example of a web page application having priority elements according to one aspect of the present disclosure. [Figure 7] This figure shows a tracer component in an instrumented application used to generate span contexts and logs, according to one aspect of the present disclosure. [Figure 8] This figure shows various runtime components of an instrumented application according to one aspect of the present disclosure. [Figure 9] This is a simplified block diagram of a distributed system for implementing one of the embodiments. [Figure 10] This is a simplified block diagram of the components of a system environment in which the services provided by the components of the system in one embodiment may be provided as cloud services. [Figure 11] This figure shows an exemplary computing subsystem in which various embodiments of the present invention can be implemented. [Modes for carrying out the invention]

[0013] Detailed explanation The technologies disclosed herein include solutions for automatically providing telemetry capabilities for enterprise applications. Telemetry refers to the collection of performance data relating to the runtime execution of software. Examples of such data include how often a particular feature on a web page or application is used, measurements of startup or execution time, whether a process crashed, failure information, and user experience.

[0014] Telemetry data can be collected at the application level or at a more granular level, such as runtime metrics regarding the time it took for each process on a web page to complete. The disclosed solution enables access to telemetry data using application programmer interface (API) functionality.

[0015] Telemetry can be performed on web-based applications, such as the time it takes to load a web page application (e.g., "hard navigation"). However, web page applications typically include dynamically loaded elements. Dynamically loaded elements may include images, links, or other elements that load or become available after the user has navigated within the web page, or "soft navigation." The readiness of these dynamically loaded elements is crucial to the user experience. However, existing solutions cannot instrument these dynamically loaded elements, making it difficult to track client-side performance.

[0016] In contrast, the disclosed technology provides an improved instrumentation for single webpage applications that include dynamically loaded elements. For example, the disclosed technology can instrument complex, modern webpages in a platform-independent manner. Dynamically loaded elements can be identified as priority (or "hero") elements during page development. Then, at runtime, the progress of these priority elements can be tracked independently.

[0017] To facilitate telemetry, one or more spans are created within an enterprise application. As used herein, a span refers to a set of named operations that represent a unit of work. A particular span can refer to a process. A span has a span context. As used herein, a span context can include a trace identifier and a span identifier. Thus, a first process can have a first span, and a second process can have a second span. If the second process is called by the first process, the first span and the second span are associated by a parent-child relationship, with the first span being the parent and the second span being the child. Tracking spans of different processes facilitates more detailed instrumentation.

[0018] Spans corresponding to when a priority element is rendered on a web page and when the priority element is available or ready can be obtained and output. An element is ready when the asynchronous process associated with the element has completed, indicating when the full experience is available to the user. Additionally, additional metrics regarding when all such priority elements are ready can be collected. Thus, the disclosed technique can output spans that encompass the overall logical navigation of a single-page web application, including priority metrics indicators related to the loading of artifacts, timing details, and the loading of prioritized page elements.

[0019] The following non-limiting examples are introduced for purposes of discussion. During web page development, a web page developer marks each user interface element considered to be a priority element with a specific attribute indicating that the element is a priority element. Examples of such elements include, but are not limited to, elements that rely on soft navigation within the page. The web page is ultimately loaded on a server, and the server provides the web page as appropriate.

[0020] Continuing with the example, at runtime, the web page is downloaded from the server. The marking of the instrumented page is processed by the browser in conjunction with the tracer application. This processing results in, for each priority element, a first metric being output via the tracer application when the element is rendered, and a second metric being output when the corresponding element is ready. Each metric corresponds to a span and can include the execution time or cycle of the corresponding span. This process continues for each priority element. Further, metrics can be output when all priority elements are ready.

[0021] FIG. 1 shows an example of a system 100 for automatically instrumenting an enterprise application having priority elements, according to one aspect of the present disclosure. FIG. 1 shows a developer computing device 110, an instrumented application 120, telemetry data 122, an end-user computing device 130, servers 150a-n, and a network 160.

[0022] In the example shown in FIG. 1, the developer computing device 110 constructs the instrumented application 120 and deploys the instrumented application 120 to server 150a. Server 150a then provides the application to the end-user computing device 150. During or in relation to the execution of the instrumented application 120, the end-user computing device 150 can connect to one or more servers 150b-n to obtain different resources (e.g., images, scripts, etc.) and / or execute instrumentation functions. After or during the execution of the instrumented application 120, the telemetry data 122 is communicated back to the developer computing device 110 for analysis.

[0023] The developer computing device 110 includes one or more of the following: a developer integrated development environment (IDE) 112, backend developer tools 114, a console 116, and telemetry data 122. The developer IDE 112 is a graphical development tool that provides compilation, linking, debugging, tracing, or other functions. The backend developer tools 114 may include one or more compilers, linkers, debuggers, simulators, etc. The console 116 is used to display telemetry data 122 acquired by the execution of the instrumented application 120.

[0024] Servers 150a-n can be configured to perform the same, similar, or different functions. For example, servers 150a-n can operate as a distributed server system. In another example, servers 150a-n may be a web server, file server, or other server that provides one or more components from a web page or receives database queries and provides results. In some cases, servers 150a-n may be under the control of different entities (companies or individuals) and / or may be located in different places. Thus, certain aspects described herein relate to obtaining telemetry data across different servers via span context propagation. The developer computing device 110, the end-user computing device 130, the network 160, and servers 150a-n can be connected via one or more connections such as the network 160. Examples of the network 160 include wired networks, wireless networks, and the internet.

[0025] The end-user computing device 130 includes a web page application 134 (e.g., a web page), a web browser 132, and a tracer application 136. The web page application 134 may include an instrumented application 120 received from a server 150a. The web page application 134 can be rendered by the web browser 132. The web browser 134 includes elements 140 and 142. Two elements are shown, but any number of elements are possible. In the example shown, element 140 is displayed after the web page application 134 has loaded, for example, following a "hard navigation". When the user interacts with element 140, for example via click, drag, or mouseover (soft navigation), the web page application 134 loads element 142. Thus, spans and metrics related to the rendering and / or readiness state of element 142 can be obtained.

[0026] The tracer application 136 can be part of the web page application 134 and provide instrumentation functions. For example, the tracer application 136 collects telemetry data, which can be exported to an external device periodically or on demand. Examples of telemetry data include how often a certain function is used, measurements of startup or execution time, whether a process crashed, failure information, and user type.

[0027] In one example, a software developer builds a custom web-based application using a developer IDE 112 and backend developer tools 114. Specifically, the software tools running on the developer computing device 110 insert code that provides telemetry functionality (e.g., tracer code) and generate an instrumented application 120. In some cases, the instrumented application 120 can be sent directly from the developer computing device 110 to an end-user computing device 130. In other cases, the instrumented application 120 is sent directly to servers 150a-n, where it is hosted and then downloaded by the end-user computing device 130.

[0028] The end-user computing device 130 accesses the application from server 140a, for example, via network 160. The user operating the end-user computing device 130 interacts with the application, thereby causing the end-user computing device 130 to access one or more of the servers 140a-n, which then provide all or part of the application to the end-user computing device 130. The end-user computing device 130 performs telemetry functions, thereby instrumenting actions directly triggered by user interaction with the application (e.g., clicks, reloads) or indirectly triggered actions (e.g., loading of linked images from a page). In this way, more detailed telemetry information is available than in previous solutions. Telemetry data 122 is collected by one or more servers 140a-n.

[0029] In a more specific example, the instrumented application 120 consists of one or more priority element markings. At runtime, the instrumented application 120, for example, a web page application 134, sends one or more metrics representing one or more spans back to the developer computing device via the server 150a along with telemetry data 122. A mutation observer can be used to analyze the source of the web page and determine the priority elements.

[0030] For example, as shown in the figure, telemetry data 122 includes data indicating that the hard navigation required loading two elements, element #1 and element #2, each taking 0.5 seconds to load. Element #2 had an accompanying span of 0.4 seconds, representing the loading of an image from the image server. Console 116 also displays information about soft button clicks that caused the soft page navigation, specifically element #3 (e.g., element 142), to render in 0.2 seconds and become ready in 0.3 seconds. Console 116 also displays information indicating that all priority elements became ready in 1.0 second.

[0031] Certain figures and related descriptions further illustrate certain aspects. For example, Figure 2 shows an example of a process used by an instrumented application to acquire telemetry data. An example of an instrumented application is shown in Figure 3, an example of a navigation span is shown in Figure 4, an example of a process used by an instrumented application to acquire telemetry data from priority elements in a single-page web application is shown in Figure 5, an example of a web page with dynamically loaded elements is shown in Figure 6, an example of a tracer component in an instrumented application is shown in Figure 7, and examples of various runtime components of an instrumented application are shown in Figure 8. Examples of computing devices suitable for developer computing device 110 and end-user computing device 130 include those shown in client computing devices 902, 904, 906, and 908, and an example of a suitable server includes server 912 shown in Figure 9.

[0032] Figure 2 shows an example of a method 200 used to collect telemetry data according to one aspect of the present disclosure. Method 200 can be performed by a developer computing device 110 and one or more of servers 150a to n.

[0033] It should be understood that Method 200 provides a specific method for collecting telemetry data. Other sequences of operations may also be performed according to alternative examples. For example, alternative examples may perform the operations outlined below in a different order. Furthermore, each operation illustrated by Method 200 may include multiple sub-operations that can be performed in various sequences suitable for the individual operation. In addition, additional operations may be added or removed depending on the specific application. Furthermore, the operations described in Method 200 may be performed by different devices.

[0034] In block 202, method 200 includes providing a web page application to a web browser on a client device. For example, server 150a provides web page application 134 to web browser 132. Web page application 134 includes tracer application 136 which provides instrumentation. Web page application 134 is instrumented by tracer application 136 before method 200.

[0035] In block 204, method 200 includes detecting the start of a web page application. The web browser 132 starts execution of the web page application 134 and the tracer application 136. Server 150a can detect the start of execution by determining that the web browser 132 has requested one or more resources.

[0036] In block 206, method 200 includes instantiating a tracer application based on the start of a web page application. The tracer application 136 is configured to log trace data of the web page application 134.

[0037] In block 208, method 200 includes detecting events initiated by interaction with a web page application. The web page application 134 continues execution, and events are triggered. Examples of events include user interface interactions, clicks, navigation, mouseovers, refreshes, etc. Furthermore, events may be Representation State Transfer (REST).

[0038] In block 210, method 200 includes automatically logging the start of a span based on detection, and the logging associates the span with a tracer application. The tracer application 136 triggers logging of the span corresponding to the event.

[0039] In block 212, method 200 includes performing an action in response to an event. The web browser 132 executes code in response to the event, such as loading an image or resource.

[0040] In block 214, method 200 includes automatically logging the end of a span based on the completion of an action corresponding to an event. Upon completion of the code mentioned in block 212, the tracer application 136 logs the end of the span. The data collected may include the processing cycles used, the time taken to execute the span, memory consumption, etc.

[0041] As described herein, certain embodiments can measure data related to spans that span multiple servers, processing threads, or multiple individually identifiable operations. For example, the execution of block 210 can create additional spans, each providing more detailed information. For example, tracer application 136 can create a first child span corresponding to a first operation and a second child span corresponding to a second operation. The first and second child spans may be children of a span.

[0042] Continuing the example, the tracer application 136 automatically logs the end of the first child span based on the completion of the first operation, and automatically logs the end of the first child span based on the completion of the first operation. Therefore, the tracer application 136 obtains more detailed information than the span alone. The first child span and the second child span are associated with the span.

[0043] The following example shows code for inserting a client-side span context using Javascript®. define(["@oracle / trace-client / trace", "@oracle / trace-client / trace_utils"], (Trace, TraceUtils) => { / / Create a tracer const tracer = Trace.initTracer({ url: getCollectorUrl() / / Domain-specific }); / / Create a root span tracer.span({ operationName: "rootSpan" }, (span) => { / / Log a simple message rootSpan.info("Here's a message"); / / Log a message with custom fields rootSpan.info({messageStatus: 'lit'}, "This message is lit."); / / Create a child span (if desired) tracer.span({ operationName: "childSpan2", }, (childSpan) => { / / Create a fetch request let request = new Request("http: / / ... / myService / endpoint"); / / Inject the child span's context request = tracer.inject(childSpan, request); / / Make the fetch call fetch(request).then((response) => { / / ... process the response / / Close the child span childSpan.finish(); }); }); / / end child / / Close up root span when we're done rootSpan.finish(); }); / / end root }); / / end process response }); / / end define Figure 3 shows an example of an instrumented application for generating span context according to one aspect of the present disclosure. The instrumented application can be built and instrumented by a software development tool such as a developer IDE 112 and can be run in a browser running on a computing device. Figure 3 shows a web application environment 300, which includes a web application 302, a server 340, queries 350, and responses 352. In the example shown in Figure 3, the web application 302, instrumented with tracer functionality, runs on a web browser and communicates with the server 340 to provide one or more web pages. The web application 302 sends one or more queries 350 and receives one or more responses 352 as responses. Although Figure 3 describes web pages, it should be understood that the flow and components can be executed by a mobile application or other application.

[0044] The web application 302 represents a flow 310, which includes a web page 312 having components 314, 316, and 318. The components may be a mobile application, a web application, a service connection, a business object, or a process. Each component can perform a different function, such as being part of a web page. Each of components 314, 316, and 318 can trigger component events 315, 317, and 318, respectively. Each of component events 315, 317, and 318 triggers one or more occurrences in the telemetry runtime 320, which in turn triggers one or more actions while logging the events.

[0045] Modules in flow 310 or web page 312 can interact with or relate to one another. For example, for a particular web page, components could be user interface (UI) components, variables, action chains, web page flows, page navigation, and data access via REST endpoints. Variables could be mechanisms used to store and manage the state of browser settings, client device settings, user settings, or other parameters. Components of a web page can interact with a telemetry runtime that handles various events for each component.

[0046] The telemetry runtime 320 can generate actions or action changes corresponding to component events 315, 317, and 319. For example, a user may click on a specific visual element of a web page displayed in the browser, triggering a component event. The telemetry runtime 320 can determine that the web browser should navigate to a new web page (330). The telemetry runtime 320 can determine that the action associated with the user click is to update a part of the user interface (UI) of the web page 312.

[0047] In another example, the telemetry runtime 320 may initiate an action chain 334 corresponding to a step that updates a part of the UI. For example, an action chain can be a set of one or more individual actions 336 that are related or sequential. Each action chain can be triggered by an event. For example, a user click may trigger navigation to a page corresponding to the location in the browser where the user click was received (e.g., a hyperlink, navigation button, etc.). An action chain can define input parameters and local variables available within the scope of that action chain and may include application-scope parameters and variables. The telemetry runtime may determine that one or more REST calls 338 to a server are required to update a part of the UI.

[0048] In response to the REST call 338, the web application 302 sends query 350 to the server 340's REST service endpoint 342. Query 350 may include an injected span context. Server 340, in return, sends back response 352, which may include additional HTTP headers. The web application 302 then uses the response to complete the action triggered by the component event.

[0049] The flow and navigation of a web page define the communication of information from one page to another. Each web page, like every application running in a browser, has a predefined lifecycle. Each lifecycle event, such as entering or leaving a page, can provide a trigger for an action chain. All data entering a mobile or web application can be based on the REST protocol. This data can come from custom business objects and business objects provided by service connections. Actions and variables control how data is sent and received to and from REST endpoints within a mobile or web application. An action chain has a clearly defined context and contract, and it coordinates its underlying actions, harmonizing the state flow and execution path. An action chain can define input parameters and local variables that are only available within its context. An example of an action chain is making a REST call (first action), then retrieving the result and storing it in a variable (second action). An action can export new state to its context, but it is only available for future actions along the same action chain. An action chain can be created in the context of a page or application and resides within the scope of that page or application. An action chain has a defined interface and contract, and can be invoked by event triggers using its ID.

[0050] The telemetry application programmer interface (API) 322 can enable programmer access to telemetry runtime activities, arbitrary actions or action chains, component events, and other related activities (e.g., server responses to actions). The telemetry API 322 can output span logs to a database, storage medium, or another server or browser for additional processing. For example, the telemetry API may be a REST API. The telemetry API 322 can store cloud infrastructure objects such as audit logs, application flow logs, or other log files. The telemetry API 322 can periodically sample the stored cloud infrastructure objects and output telemetry data to a common analysis ingestion 324 or a client log ingestion endpoint 326.

[0051] Common Analysis Ingestion 324 can ingest log data from the telemetry API 322. For example, Common Analysis Ingestion 324 can ingest log data from cloud infrastructure object storage using a REST API. For example, Common Analysis Ingestion 324 can determine the storage location of collected log data. Common Analysis Ingestion 324 can ingest various log data at the user, group, or organization level. In some examples, Common Analysis Ingestion 324 can convert log data into visualizations for the analysis console.

[0052] The client log ingestion endpoint 326 can also be configured to receive log data from the telemetry API 322. The client log ingestion endpoint 326 can store the log data, transform the log data into various visualizations, or perform additional processing on the log data.

[0053] Generally, distributed tracing can be performed using the Trace-Client API within a distributed tracing architecture. The Trace-Client API consists of tracers used to create spans around behavior within an application. A span can have child spans that represent behavior at a smaller granularity than each parent span, and a child span can then have children that represent behavior at a smaller granularity than the first child span. A set of spans originating from a single parent can be considered a trace. A span contains metadata about the behavior being measured, along with some identifying information. For applications with behavior that makes out-of-process calls (e.g., a client application making calls to a REST service), the span context can be propagated with the outgoing request (e.g., in the form of a special HTTP header). An incoming application or server can extract the span context and use it to create child spans of the parent span on the client. The Trace-Client API has the ability to output span information to various backend servers in the form of log messages (one for each of the span's start and end).

[0054] An example of application span is a simple application flow. For example, a user navigates to a web page and clicks a button. The button click triggers an event, which causes the application to invoke an event handler. The event handler makes a REST(definition) request, which is handled by a REST service. The service returns a response, which updates the application's user interface.

[0055] As described, one aspect relates to improved instrumentation of a single webpage application, including hard and soft hierarchies and dynamically loaded elements. Figure 4 illustrates a hierarchy with various spans that can be retrieved, including various metrics related to priority (hero) elements.

[0056] Figure 4 shows an example of a hard navigation span hierarchy and a soft navigation span hierarchy according to one aspect of the present disclosure. Figure 4 shows a hard navigation span hierarchy 400 and a soft navigation span hierarchy 450. As described, hard navigation includes actions taken as a result of browser navigation. Browser navigation can be triggered by the user navigating to a uniform resource locator (URL) or accessing bookmarks. Thus, the hard navigation span hierarchy 400 includes all necessary loading of elements on the page. In contrast, soft navigation is triggered by user interaction with the page. Thus, the soft navigation hierarchy 450 includes actions taken as a result of soft navigation, including loading of necessary elements.

[0057] As can be seen, below the hard navigation span hierarchy 400 are several separate hierarchies related to initial user navigation. As can be seen, the hard navigation span 402 includes bootstrap 404, application load 406, application enter 408, page load 410, and all hero rendered 412. Bootstrap 404 is a span that represents loading the application via the bootstrap process. Application load 406 represents the loading of the application. Application enter 408 represents entering the application. Page load 410 represents the loading of a web page. Next, bootstrap 404 includes resources 420, application load 406 includes application resource fetch 422, and page load 410 includes flow enter 424, flow resource fetch 426, page enter 428, and page resource fetch 430. Bootstrap 404 is related to additional telemetry.

[0058] Continuing the example, the soft navigation hierarchy 440 includes the user idle time span 452, the component event span 454, the soft navigation span 456, the data fetch provider span 460, and other spans 462. The soft navigation span 456 also includes the page load span 410 and the all hero rendered span 412.

[0059] One or more of the spans and span hierarchies shown in Figure 4 can be instrumented. For example, navigation-related spans can be instrumented. A span represents the length of time between a user action and the time when all page elements are loaded and rendered. Soft navigation also includes resource child spans for any resources that are loaded and retrieved asynchronously. Examples of soft navigation span attributes are shown below.

[0060] [Table 1]

[0061] In some cases, a root span encompassing the overall logical navigation of a web page application (for example, as shown in Figure 4) can be obtained and output. Thus, the root span can include metrics related to artifact loading (FlowLoad, pageLoad, etc.), runtime events for each container (runtimeEvents such as vbEnter for each of Flow, Page, AppPackage, etc.), page activation (pageActivate), low-level resource timing (resource), and priority elements, if available. The root span is a child of the componentEvent that triggered the navigation (if available).

[0062] Priority span instrumentation To obtain detailed telemetry data, the web page application is instrumented. Generally, web page developers tag various elements in the web page source with one or more attributes.

[0063] For example, developers can mark user interface (UI) elements with a specific attribute to cause a metric to be output when a priority (or "hero") element is rendered (metric / heroRendered). Priority elements can be specified by application developers by adding a configurable attribute (which can default to data-hotel-hero) to any HTML element, and this attribute indicates a label to identify the element. This approach works for both JavaScript Extension Toolkit (JET) custom HTML elements (oj-*, oj-sp-* elements) and standard DOM elements rendered by Preact.

[0064] Developers can also instrument their applications in a way that an additional metric (metric / allHeroesRendered) is output when all priority elements have been rendered, and this metric may hold a timestamp of the most recent arrival of a priority element. Alternatively, developers can mark user interface (UI) elements with metrics to output a metric when a priority element is ready. For example, the metrics (metric / heroReady) and (metric / allHeroesReady) can be added in addition to the rendered metrics described above.

[0065] Examples of attributes are shown below.

[0066] [Table 2]

[0067] [Table 3]

[0068] [Table 4]

[0069] As illustrated in Figure 5, priority (hero) element instrumentation can be achieved via mutation observers for elements with specified attributes. A metric heroRendered message can be output upon detection of each element. The metric allHeroesRendered can be output before the navigation span closes and indicates the time of the most recent hero element (the same time and duration as the metric heroRendered span for the last hero metric arrived at the end of the navigation). The metrics heroReady and allHeroesReady can be output for any hero element that also possesses the JET data-oj-context attribute. The metric heroReady can be output when the element's Context busy state is resolved (via BusyContext.whenReady()), and the metric allHeroesReady is output when the navigation is complete and indicates the time of the most recent metric heroReady event. Child spans with the operationName metrics heroRendered and allHeroesRendered can be output for both hard and soft navigation. Such metrics are based on the arrival of priority elements within the application.

[0070] [Table 5]

[0071] Before deployment, the web page application is instrumented, including instructions for any priority elements. Figure 5 shows an example of a method used to perform analysis of the instrumented web page application.

[0072] Figure 5 shows an example of a method 500 used to collect telemetry data of priority elements according to one aspect of the present disclosure. Method 500 can be performed by one or more of the developer computing device 110 and servers 140a to n. For illustrative purposes, Figure 6 will be described with respect to Figure 6. Figure 6 shows an example of a web page application.

[0073] It should be understood that Method 500 provides a specific method for collecting telemetry data. Other sequences of operations can also be performed according to alternative examples. For example, alternative examples may perform the operations outlined below in a different order. Furthermore, each operation illustrated by Method 500 may include multiple sub-operations that can be performed in various sequences suitable for the individual operation. In addition, additional operations may be added or removed depending on the specific application. Furthermore, the operations described in Method 500 may be performed by different devices.

[0074] Figure 6, including Figures 6A and 6B, shows an example of a webpage application 600 having a priority element according to one aspect of the present disclosure. Figure 6 shows a webpage application 600 related to expense reporting. For example, by navigating within webpage 600, a user can view previously submitted expense reports, view expense policies, and / or submit a new expense report.

[0075] Returning to Figure 5, in block 502, method 500 includes providing a web page application, which includes a tracer application, to a web browser on a client device. For example, server 150a provides web application 600 to web browser 132. Web application 600 includes tracer application 136 which provides instrumentation. Web application 600 is instrumented by tracer application 136 before method 500.

[0076] Figure 6A shows a web page application 600 having two elements, element 612 and element 614. Elements 612 and 614 are loaded when navigating to the web page application 600 (e.g., hard navigation). In the example shown, the user interacts with element 614, for example, by clicking on element 614. As described below, Figure 6B includes elements that are loaded during soft navigation.

[0077] Method 500 may include detecting the start of a web page application. The web browser 132 starts execution of the web application 600 and the tracer application 136. The server 150a may detect the start of execution by determining that the web browser 132 has requested one or more resources. Method 500 may also include instantiating the tracer application based on the start of the web page application. The tracer application 136 is configured to log trace data of the web application 600.

[0078] In block 504, method 500 includes accessing the source of a web page application via a tracer application. As described above, the source of the web page application 600 is instrumented with one or more attributes to facilitate analysis. Continuing the example, the web page application 600 is instrumented with the "heroReady" attribute.

[0079] In block 506, method 500 includes detecting references to elements of a web page application within the source via a tracer application. Continuing the example, the user navigates to element 614 of web page application 600.

[0080] In some cases, the source code of a web page application is accessed by a mutation observer. The mutation observer runs within the tracer application 136 or the web page application 600 and determines whether any source code has been modified. For example, the mutation observer analyzes the attributes of elements within the web page to detect the priority (hero) attribute. For instance, if the mutation observer detects a priority element, i.e., an element with the "hero" attribute, it notifies the tracer application 136.

[0081] Tracer application 136 analyzes the source code of web page application 600. Tracer application 136 detects element 614 that has a priority designation.

[0082] In block 508, method 500 includes detecting user interactions with a web page application via a tracer application. Examples of user interactions are events. Examples of events include user interface interactions, clicks, navigation, mouseovers, refreshes, etc. Furthermore, events may be Representation State Transfer (REST).

[0083] Continuing the example, Figure 6B shows a web page application 600 having elements 612, 614, and soft elements 620, 622, and 624. These elements, associated with a previously submitted expense report, are soft elements because they are not loaded until the user interacts with element 614. Once the user does so, the user cannot effectively use the web page application 600 until elements 620, 622, and 624 are loaded. Therefore, a developer could designate elements 620, 622, and 624 as priority elements because they represent the first tasks that the user is most likely to want to complete.

[0084] Returning to Figure 5, in block 510, method 500 includes automatically logging the start of a span based on the detection of a user interaction, and the logging includes associating the span with a tracer application. The tracer application 136 detects the user interaction with element 614.

[0085] When a user interaction is detected, the tracer application 136 begins logging one or more spans corresponding to the user interaction. For example, the tracer application 136 may log a first span corresponding to the rendering of an element and a second span corresponding to the element being ready.

[0086] In block 512, method 500 includes performing an action related to an element. An example of such action includes loading an image or resource.

[0087] The actions may include a subset of actions associated with rendering element 522. In some cases, an additional span can be obtained when the element is rendered, separate from when the element is ready (as determined in block 514 below). For example, tracer application 136 may automatically start an additional span associated with a subset of actions associated with rendering the element. The additional span may be a child span of the span associated with the ready state (as determined in block 514 below). Tracer application 136 may automatically log the end of the additional span based on the completion of the subset of actions associated with rendering.

[0088] Continuing with the example and referring again to Figure 6, the soft element 522 may require an image to be loaded. In that case, the corresponding image is loaded, which requires various operations. Once the image is received, it is rendered on the web page application, which requires additional computational operations. As explained, in some cases, metrics can be output when the element is rendered.

[0089] In some embodiments, images or resources can be hosted remotely, for example, on an external server. In that case, detailed instrumentation can be obtained in relation to the operations performed on that server. For example, a web browser 132 can send a request to the external server for an element and create a child span based on the request. The web browser 132 can then receive the element from the external server and automatically log the end of the child span based on the receipt of the element. The web browser 132 can associate the child span with a span associated with soft navigation (for example, the span obtained in block 516 below).

[0090] In block 514, method 500 includes determining that an element is ready for additional user interaction. Preparing an element generally requires additional actions beyond rendering. For example, an element may need to complete certain actions, such as being configured to receive input or to transition between states, in order to ensure that it can be interacted with by a user.

[0091] In block 516, method 500 includes automatically logging the end of a span based on a determination. Tracer application 136 automatically logs the end of a span based on the completion of the action corresponding to the element. Therefore, automatically logging the end of a span may include determining the number of processing cycles and / or the execution time of the action corresponding to the execution of the action.

[0092] Method 500 may continue for additional priority elements. For example, Method 500 may include determining from the source of a web page application that an additional element is triggered by a user interaction. In response to the determination that an additional element is triggered by a user interaction, blocks 508-516 are executed for the additional element. Alternatively, a combined span can be calculated to represent the completion of all spans associated with the element's readiness state.

[0093] The telemetry data 122 provided by the tracer application 136 and the web application 134 may include an output stream containing spans related to any priority metric. In this way, developers can match hero element metric data with screenshots taken during a profiling session (i.e., in Chrome Devtools, etc.).

[0094] Figure 7 shows various runtime components 700 of an instrumented application according to one aspect of the present disclosure. Figure 7 shows a context provider 702, a navigation generator plugin 704, a tracer 706, a field decorator 708, a runtime 710, a JET runtime 712, and application code 714. The components 700 are described for illustrative purposes only, and other arrangements are possible.

[0095] Context provider 702 tracks the application's current execution context. For example, context provider 702 tracks the current container as it is output during pageLoad and runtimeEvent spans (such as "enter" and "exit"). Context provider 702 can also output events indicating that the container has changed, which can trigger the start of a new soft navigation.

[0096] The navigation generator plugin 704 subscribes to container change events from the context provider 702 to trigger soft navigation. This can be extended under JetNavigationGenerator. JetNavigationGenerator can support soft navigation for JET-only applications, but this requires telemetry to be output by the JET router. Add the ability to terminate navigation based on the resolution of the JET BusyContext.whenReady promise.

[0097] An example of tracer 706 is tracer application 136. An example of adding a tracer is shown in Figure 78. Application code 714 reflects a web page application, i.e., web page application 134 or web page application 600.

[0098] Field decorator 708 is a plug-in to tracers that adds attributes to telemetry spans based on runtime context. Runtime 710 is an application framework that executes application code and outputs telemetry and context events. JET runtime 712 is an example of an application framework (coexisting with 710) that outputs a "BusyContext whenReady" event based on the readiness of a page or element to determine the readiness of soft navigation and / or hero elements.

[0099] Figure 8 shows a tracer component in an instrumented application used to generate span context and logs, according to one aspect of this disclosure. In the example shown in Figure 8, an end-user computing device 820 running a web application 822 communicates with a server 860 via various commands and / or API calls. The web application 822 can be developed by the developer IDE 112 and may be customer-developed software. Code to support instrumentation is automatically added by the developer IDE 112.

[0100] The end-user computing device 820 includes one or more modules, such as a web application 822 (or any other consuming client), a trace module 824, a tracer interface 826, a span interface 828, a tracer 830, a span 832, a span logging library 834 (i.e., Bunyan Logger), a span stack 836, a browser console 838, a compression layer 844, a tracer server stream 846, a sender task 848, a message queue 842, and a tracer console stream 882. The tracer 830 then operates to perform instrumentation on the web application, creating one or more spans 832 and adding active spans to the span stack 836. The server 860 includes one or more modules, such as a trace-collector servlet 862.

[0101] Subsequently, the web application 822 receives or detects user interactions (e.g., user clicks). The web application 822 interacts with the trace module 824 and / or the tracer interface 826 to start one or more tracers 830. Next, the span logging library 834 logs information and metadata such as event type, event name, URL of the server request, return status code, errors, warnings, etc., via the span interface 828.

[0102] Various API calls are available. The API call initTracer() initializes and returns a global tracer object. The API call initTracer is called once per application context and returns a TracerOptions object. The API call activeTracer returns a global tracer object. For example, the API call inject() injects a span into a request (e.g., a request to a server). Upon return, the API call extract() can be used to extract the span.

[0103] Multiple spans may be generated. For example, tracer 830 may create a span representing an event or thread of the web application 822. Tracer 830 may create child spans as appropriate (for example, as described with respect to Figure 4) based on the specific action by which the tracer created the span. As further described herein, an instrumented application may obtain information from different threads and / or different servers serving requests triggered by events within the application.

[0104] The web application 822 can control the tracer or receive span injections using the tracer interface 826. The tracer can also monitor parent spans or insert span contexts into newly created spans such as span 832 by monitoring, writing to, or reading from the span stack 836, where one or more spans are cached or can be accessed by the tracer. The web application 822 can communicate span-related information to the span logging library 834 using the span interface 828. The compression layer 844 can compress the span-related information to minimize it before sending it to the trace-collector servlet 862. Examples of compression techniques used by the compression layer 844 include zip and gzip. In one example, the tracer console stream 882 can output a stream of span logs to a browser console presented on the end-user computing device 130. Next, server 860 can run trace-collector servlet 862, which is a stream of span logs and collects traces from sender task 848 on end-user computing device 820.

[0105] Figure 9 shows a simplified block diagram of a distributed system 900 for implementing one of the embodiments. In the illustrated embodiment, the distributed system 900 includes one or more client computing devices 902, 904, 906, and 908, which are configured to run and operate client applications such as web browsers and proprietary clients (e.g., Oracle Forms®) via one or more networks 910. A server 912 can be coupled to communicate with the client computing devices 902, 904, 906, and 908 via the network 910. In various embodiments, server 912 can be adapted to run one or more services or software applications provided by one or more components of the system. These services or software applications may include non-virtual and virtual environments. Virtual environments may include virtual events, trade shows, simulators, classrooms, shopping exchanges, and those used in enterprises, whether they are two-dimensional or three-dimensional (4D) representations, page-based logical environments, or otherwise. In some embodiments, these services may be provided to users of client computing devices 902, 904, 906, and / or 908 as web-based or cloud services, or under a Software as a Service (SaaS) model. Users operating client computing devices 902, 904, 906, and / or 908 can then interact with server 912 using one or more client applications and utilize the services provided by these components.

[0106] In the configuration shown in the figure, the software components 918, 920, and 922 of the distributed system 900 are shown as running on server 912. In other embodiments, one or more of the components of the distributed system 900 and / or the services provided by these components may also be run by one or more of the client computing devices 902, 904, 906, and / or 908. A user operating a client computing device can then use one or more client applications to access the services provided by these components. These components can be run in hardware, firmware, software, or a combination thereof. It should be understood that various different system configurations are possible, which may differ from the distributed system 900. Therefore, the embodiments shown in the figure are just one example of a distributed system for implementing the system of the embodiment and are not intended to be limiting.

[0107] Client computing devices 902, 904, 906, and / or 908 may be portable handheld devices (e.g., iPhone®, mobile phones, iPad®, computing tablets, personal digital assistants (PDAs)) or wearable devices (e.g., Google Glass® head-mounted displays) running software such as Microsoft Windows Mobile® and / or various mobile operating systems such as iOS®, Windows Phone, Android, BlackBerry 10, Palm OS, and with the Internet, email, short message service (SMS), Blackberry®, or other communication protocols enabled. Client computing devices may be general-purpose personal computers, including, for example, personal computers and / or laptop computers running various versions of Microsoft Windows®, Apple Macintosh®, and / or Linux® operating systems. Client computing devices may also be workstation computers running any of various commercially available UNIX® or UNIX-like operating systems, including, but not limited to, various GNU / Linux operating systems such as Google Chrome OS. Alternatively or additionally, client computing devices 902, 904, 906, and 908 may be any other electronic devices that can communicate via network 910, such as thin client computers, internet-enabled gaming systems (e.g., Microsoft Xbox game consoles with or without Kinect® gesture input devices), and / or personal messaging devices.

[0108] The distributed system 900 is shown with four client computing devices, but any number of client computing devices may be supported. Other devices, such as devices with sensors, may interact with the server 912.

[0109] Network 910 in distributed system 900 can be any type of network well known to those skilled in the art, capable of supporting data communication using any of the various commercially available protocols, including but not limited to TCP / IP (transmission control protocol / Internet protocol), SNA (systems network architecture), IPX (Internet packet exchange), AppleTalk®, etc. For example, network 910 could be a local area network (LAN), such as a local area network (LAN) based on Ethernet®, Token Ring, and / or similar technologies. Network 910 could also be a wide area network or the Internet. Network 910 may include virtual networks, including but not limited to virtual private networks (VPNs), intranets, extranets, public switched telephone networks (PSTNs), infrared networks, wireless networks (for example, networks operating according to any of the IEEE 802.9 protocols, Bluetooth®, and / or any other wireless protocols), and / or any combination of these and / or other networks.

[0110] Server 912 can consist of one or more general-purpose computers, specialized server computers (including, for example, PC (personal computer) servers, UNIX® servers, medium-sized servers, mainframe computers, rack-mount servers, etc.), server farms, server clusters, or any other suitable arrangement and / or combination. Server 912 may include one or more virtual machines running a virtual operating system, or other computing architectures with virtualization. One or more flexible pools of logical storage devices can be virtualized to maintain the server's virtual storage devices. Virtual networks can be controlled by Server 912 using software-defined networking. In various embodiments, Server 912 can be adapted to run one or more services or software applications described in the foregoing disclosure. For example, Server 912 can correspond to a server for performing the processing described above according to aspects of this disclosure.

[0111] Server 912 can run any commercially available server operating system, in addition to any of the aforementioned operating systems. Server 912 can also run any of a variety of additional server applications and / or mid-tier applications, including HTTP (hypertext transport protocol) servers, FTP (file transfer protocol) servers, CGI (common gateway interface) servers, JAVA® servers, database servers, etc. Examples of exemplary database servers include, but are not limited to, those commercially available from Oracle®, Microsoft®, Sybase®, IBM (International Business Machines), and others.

[0112] In some embodiments, the server 912 may include one or more applications for analyzing and integrating data feeds and / or event updates received from users of client computing devices 902, 904, 906, and 908. For example, the data feeds and / or event updates may include, but are not limited to, real-time updates received from one or more third-party sources and continuous data streams, including Twitter® feeds, Facebook® updates, or real-time events related to sensor data applications, financial tickers, network performance measurement tools (e.g., network monitoring and traffic management applications), clickstream analysis tools, automotive traffic monitoring, etc. The server 912 may also include one or more applications for displaying the data feeds and / or real-time events via one or more display devices of client computing devices 902, 904, 906, and 908.

[0113] The distributed system 900 may also include one or more databases 914 and 916. Databases 914 and 916 can reside in various locations. For example, one or more of databases 914 and 916 may reside on a non-temporary storage medium local to (and / or residing on) server 912. Alternatively, databases 914 and 916 may be remote from server 912 and may communicate with server 912 via a network-based connection or a dedicated connection. In one embodiment, databases 914 and 916 may reside on a storage area network (SAN). Similarly, any files necessary to perform functions originating from server 912 may be stored locally on and / or remotely on server 912, as appropriate. In one embodiment, databases 914 and 916 may include relational databases, such as those provided by Oracle, adapted to store, update, and retrieve data in response to SQL-formatted commands.

[0114] Figure 10 is a simplified block diagram of one or more components of a system environment 1000, in which services provided by one or more components of the system in the embodiment may be provided as cloud services. In the embodiment shown, the system environment 1000 includes one or more client devices 1004, 1006, and 1008 that can be used by a user to interact with a cloud infrastructure system 1002 that provides cloud services. The client computing devices can be configured to operate client applications such as a web browser, a proprietary client application (e.g., Oracle Forms), or any other application that can be used by a user of the client computing device to interact with the cloud infrastructure system 1002 and use services provided by the cloud infrastructure system 1002.

[0115] It should be understood that the cloud infrastructure system 1002 shown in the figure may include components other than those shown. Furthermore, the embodiment shown in the figure is merely one example of a cloud infrastructure system that may incorporate embodiments of the present invention. In some other embodiments, the cloud infrastructure system 1002 may include more or fewer components than those shown in the figure, may combine two or more components, or may have different configurations or arrangements of components.

[0116] Client devices 1004, 1006, and 1008 may be similar to the devices described above with respect to 902, 904, 906, and 908.

[0117] An exemplary system environment 1100 is shown with three client computing devices, but any number of client computing devices may be supported. Other devices, such as devices with sensors, may interact with the cloud infrastructure system 1002.

[0118] Network 910 can facilitate data communication and exchange between client devices 1004, 1006, and 1008 and the cloud infrastructure system 1002. Each network may be any type of network well known to those skilled in the art, capable of supporting data communication using any of a variety of commercially available protocols, including the protocols described above with respect to network 910.

[0119] The cloud infrastructure system 1002 may comprise one or more computers and / or servers, including the computers and / or servers described above with respect to server 912.

[0120] In some embodiments, services provided by a cloud infrastructure system may include hosting services that are made available on demand to users of the cloud infrastructure system, such as online data storage and backup solutions, web-based email services, hosted office suites and document collaboration services, database processing, and managed technical support services. Services provided by a cloud infrastructure system can be dynamically scaled to meet user needs. A specific instance of a service provided by a cloud infrastructure system is referred to herein as a “service instance.” Generally, any service made available to users from a cloud service provider’s system via a communication network such as the Internet is referred to as a “cloud service.” Typically, in a public cloud environment, the servers and systems that make up the cloud service provider’s system are different from the customer’s own on-premises servers and systems. For example, a cloud service provider’s system can host applications, and users can order and use applications on demand via a communication network such as the Internet.

[0121] In some examples, services in a computer network cloud infrastructure may include secure computer network access to storage, hosted databases, hosted web servers, software applications, or other services provided to users by the cloud vendor, or otherwise services as known in the art. For example, a service may include password-protected access to remote storage on the cloud over the internet. Another example is a service which may include a web service-based hosted relational database and scripting language middleware engine for private use by networked developers. Yet another example is a service which may include access to an email software application hosted on the cloud vendor's website.

[0122] In some embodiments, the cloud infrastructure system 1002 may include the provision of a set of applications, middleware, and database services delivered to customers in a self-service, subscription-based, elastically scalable, reliable, highly available, and secure manner. An example of such a cloud infrastructure system is the Oracle Public Cloud provided by the Assignee.

[0123] Large amounts of data (sometimes called big data) can be hosted and / or manipulated by infrastructure systems at many levels and different scales. Such data can include datasets that are so large and complex that they may be difficult to process using typical database management tools or conventional data processing applications. For example, terabytes of data may be difficult to store, retrieve, and process using personal computers or their rack-based counterparts. Data of this size may be difficult to work with using most current relational database management systems as well as desktop statistics and visualization packages. They may require massive parallel processing software running thousands of server computers, going beyond the structure of commonly used software tools, in order to retrieve, curate, manage, and process the data within an acceptable timeframe.

[0124] Extremely large datasets can be stored and manipulated by analysts and researchers to visualize vast amounts of data, detect trends, and / or interact with the data. Dozens, hundreds, or thousands of parallel-linked processors can act on such data to present it or to simulate external forces on the data or what it represents. These datasets can include structured data, such as those in databases or organized according to structured models, and / or unstructured data (e.g., emails, images, data blobs (binary large objects), web pages, complex event processing). By leveraging the ability to concentrate more (or less) computing resources relatively quickly for a given purpose, cloud infrastructure systems can become better available to perform tasks on large datasets based on demand from enterprises, government agencies, research institutions, private individuals, like-minded groups of individuals or organizations, or other entities.

[0125] In various aspects, the cloud infrastructure system 1002 can be adapted to automatically provision, manage, and track customer enrollment in services provided by the cloud infrastructure system 1002. The cloud infrastructure system 1002 can provide cloud services through various deployment models. For example, the service may be provided according to a public cloud model, where the cloud infrastructure system 1002 is owned by an organization that sells cloud services (e.g., owned by Oracle), and the service is made available to the general public or various industrial enterprises. As another example, the service may be provided according to a private cloud model, where the cloud infrastructure system 1002 operates independently for only one organization, and the service can be provided to one or more entities within that organization. The cloud service may also be provided according to a community cloud model, where the cloud infrastructure system 1002 and the services provided by the cloud infrastructure system 1002 are shared by multiple organizations within a relevant community. The cloud service may also be provided according to a hybrid cloud model, which is a combination of two or more different models.

[0126] In some embodiments, the services provided by the cloud infrastructure system 1002 may include one or more services provided according to the categories of SaaS (Software as a Service), PaaS (Platform as a Service), IaaS (Infrastructure as a Service), or other categories of services including hybrid services. A customer can order one or more services provided by the cloud infrastructure system 1002 by placing a subscription order. The cloud infrastructure system 1002 then performs processing to provide the services in response to the customer's subscription order.

[0127] In some embodiments, the services provided by the cloud infrastructure system 1002 may include, but are not limited to, application services, platform services, and infrastructure services. In some examples, application services may be provided by the cloud infrastructure system via a SaaS platform. The SaaS platform may be configured to provide cloud services that fall under the SaaS category. For example, the SaaS platform may provide the ability to build and deliver a set of on-demand applications on an integrated development and deployment platform. The SaaS platform may manage and control the underlying software and infrastructure for providing SaaS services. By using the services provided by the SaaS platform, customers can utilize applications that run on the cloud infrastructure system. Customers can obtain application services without having to purchase separate licenses and support. A variety of different SaaS services may be provided. Examples include, but are not limited to, services that provide sales performance management, enterprise integration, and business flexibility solutions for large organizations.

[0128] In some forms, platform services can be provided by a cloud infrastructure system via a PaaS platform. A PaaS platform can be configured to provide cloud services categorized as PaaS. Examples of platform services, but not limited to, include services that enable organizations (such as Oracle) to integrate existing applications into a shared, common architecture, and the ability to build new applications that leverage the shared services provided by the platform. A PaaS platform can manage and control the underlying software and infrastructure for providing PaaS services. Customers can obtain PaaS services provided by the cloud infrastructure system without needing to purchase separate licenses and support. Examples of platform services, but not limited to, Oracle Java Cloud Service (JCS) and Oracle Database Cloud Service (DBCS), include Oracle Java Cloud Service (JCS), Oracle Database Cloud Service (DBCS), and others.

[0129] By utilizing the services provided by the PaaS platform, customers can also control the deployed services by employing programming languages ​​and tools supported by the cloud infrastructure system. In some embodiments, the platform services provided by the cloud infrastructure system can include database cloud services, middleware cloud services (e.g., Oracle Fusion Middleware services), and Java cloud services. In one embodiment, database cloud services can support a shared services deployment model that enables organizations to pool database resources and provide Database as a Service to customers in the form of a database cloud. Middleware cloud services can provide a platform for customers to develop and deploy various business applications, and Java cloud services can provide a platform for customers to deploy Java applications to the cloud infrastructure system.

[0130] In a cloud infrastructure system, an IaaS platform may provide a variety of different infrastructure services. These infrastructure services facilitate the management and control of underlying computing resources, such as storage, networking, and other basic computing resources, for customers using services provided by SaaS and PaaS platforms.

[0131] In one embodiment, the cloud infrastructure system 1002 may also include infrastructure resources 1030 for providing resources used to deliver various services to customers of the cloud infrastructure system. In one embodiment, the infrastructure resources 1030 may include a pre-integrated and optimized combination of hardware, such as servers, storage, and networking resources, for running services provided by the PaaS platform and SaaS platform.

[0132] In some embodiments, resources in the cloud infrastructure system 1002 may be shared by multiple users and dynamically reallocated according to demand. Furthermore, resources may be allocated to users in different time zones. For example, the cloud infrastructure system 1002 may make resources of the cloud infrastructure system available to a first set of users in a first time zone for a specified number of hours, and then allow the same resources to be reallocated to another set of users located in a different time zone, thereby maximizing resource utilization.

[0133] In some embodiments, multiple internally shared services 1032 may be provided, which are shared by different components or modules of the cloud infrastructure system 1002 and by services provided by the cloud infrastructure system 1002. These internally shared services may include, but are not limited to, security and identity services, integration services, enterprise repository services, enterprise manager services, virus scanning and whitelisting services, high availability, backup and recovery services, services to enable cloud support, email services, notification services, file transfer services, and the like.

[0134] In one embodiment, the cloud infrastructure system 1002 can provide comprehensive management of cloud services (e.g., SaaS, PaaS, and IaaS services) within the cloud infrastructure system. In one embodiment, the cloud management function may include functions for provisioning, managing, and tracking customer enrollments received by the cloud infrastructure system 1002.

[0135] In one embodiment, as shown in the figure, the cloud management functionality may be provided by one or more modules, such as an order management module 1020, an order adjustment module 1022, an order provisioning module 1024, an order management and monitoring module 1026, and an identity management module 1028. These modules may include, or be provided by, one or more computers and / or servers, which may be general-purpose computers, specialized server computers, server farms, server clusters, or any other suitable arrangement and / or combination.

[0136] In operation 1034, a customer using a client device such as client device 1004, 1006, or 1008 can interact with the cloud infrastructure system 1002 by requesting one or more services provided by the cloud infrastructure system 1002 and ordering a subscription to one or more services provided by the cloud infrastructure system 1002. In one embodiment, the customer can access a cloud user interface (UI) (cloud UI 1012, cloud UI 1014, and / or cloud UI 1016) and order a subscription through these UIs. In response to the customer's order, the order information received by the cloud infrastructure system 1002 may include information identifying the customer and one or more services provided by the cloud infrastructure system 1002 that the customer intends to subscribe to.

[0137] After an order is placed by the customer, the order information is received via the cloud UI 1012, 1014, and / or 1016.

[0138] In operation 1036, the order is stored in the order database 1018. The order database 1018 is operated by the cloud infrastructure system 1002 and may be one of several databases operated together with other system elements.

[0139] In operation 1038, order information is transferred to the order management module 1020. In some cases, the order management module 1020 may be configured to perform order-related invoice sending and accounting functions, such as order verification and reservation of orders during verification.

[0140] In operation 1040, information about the order is transmitted to the order adjustment module 1022. The order adjustment module 1022 can use the order information to coordinate the provisioning of services and resources related to the order placed by the customer. In some cases, the order adjustment module 1022 may use the services of the order provisioning module 1024 to coordinate the provisioning of resources to support the subscribed services.

[0141] In one embodiment, the order adjustment module 1022 enables the management of business processes associated with each order and applies business logic to determine whether the order should proceed to provisioning. In operation 1042, upon receiving a new enrollment order, the order adjustment module 1022 sends a request to the order provisioning module 1024 to allocate resources and constitute those resources required to fulfill the enrollment order. The order provisioning module 1024 enables the allocation of resources for the services ordered by the customer. The order provisioning module 1024 provides a level of abstraction between the cloud services provided by the system environment 1000 and the physical implementation layer used to provision resources to provide the requested services. Thus, the order adjustment module 1022 can be decoupled from implementation details such as whether services and resources are actually provisioned during execution or pre-provisioned and simply allocated / allocated upon request.

[0142] In operation 1042, after the services and resources have been provisioned, the order provisioning module 1024 of the cloud infrastructure system 1002 can send a notification of the provided services to customers on client devices 1004, 1006, and / or 1008.

[0143] In operation 1046, customer subscription orders can be managed and tracked by the order management and monitoring module 1026. In some cases, the order management and monitoring module 1026 may be configured to collect service usage statistics for subscription orders, such as the amount of storage used, the amount of data transferred, the number of users, and the amount of system uptime and system downtime.

[0144] In some embodiments, the cloud infrastructure system 1002 may include an identity management module 1028. The identity management module 1028 may be configured to provide identity services, such as access management and authorization services, within the cloud infrastructure system 1002. In some embodiments, the identity management module 1028 may control information about customers who wish to use the services provided by the cloud infrastructure system 1002. Such information may include information that authenticates the identity of such customers, and information that represents the actions that those customers are permitted to perform on various system resources (e.g., files, directories, applications, communication ports, memory segments, etc.). The identity management module 1028 may also include managing descriptive information about each customer, and managing how, by whom, and how that descriptive information may be accessed and modified.

[0145] Figure 11 shows an exemplary computer system 1100 in which various embodiments of the present invention can be implemented. Any of the computer systems described above can be implemented using computer system 1100. As shown in the figure, computer system 1100 includes a processing unit 1104 that communicates with a number of peripheral subsystems via a bus subsystem 1102. These peripheral subsystems may include a processing acceleration unit 1106, an I / O subsystem 1108, a storage subsystem 1118, and a communication subsystem 1124. The storage subsystem 1118 includes a tangible computer-readable storage medium 1120 and system memory 119.

[0146] The bus subsystem 1102 provides a mechanism for various components and subsystems of the computer system 1100 to communicate with each other as intended. Although the bus subsystem 1102 is schematically shown as a single bus, alternative embodiments of the bus subsystem may utilize multiple buses. The bus subsystem 1102 can be one of several types of bus structures, including a memory bus or memory controller, a peripheral bus, and a local bus using any of the various bus architectures. For example, such architectures may include the ISA (Industry Standard Architecture) bus, the MCA (Micro Channel Architecture) bus, the EISA (Enhanced ISA) bus, the VESA (Video Electronics Standards Association) local bus, and the PCI (Peripheral Component Interconnect) bus, which can be implemented as a mezzanine bus manufactured according to the IEEE P1186.1 standard.

[0147] A processing unit 1104, which can be implemented as one or more integrated circuits (e.g., conventional microprocessors or microcontrollers), controls the operation of the computer system 1100. One or more processors may be included in the processing unit 1104. These processors may include single-core processors or multi-core processors. In one embodiment, the processing unit 1104 may also be implemented as one or more independent processing units 1132 and / or 1134, each processing unit containing a single-core processor or a multi-core processor. In another embodiment, the processing unit 1104 may also be implemented as a quad-core processing unit formed by integrating two dual-core processors onto a single chip.

[0148] In various embodiments, the processing unit 1104 can execute various programs in response to program code and can maintain multiple programs or processes running simultaneously. At any given time, some or all of the program code to be executed may reside in the processing unit 1104 and / or the storage subsystem 1118. With appropriate programming, the processing unit 1104 can provide the various functions described above. The computer system 1100 may further include a processing acceleration unit 1106 which may include a digital signal processor (DSP), a dedicated processor, and / or similar.

[0149] The I / O subsystem 1108 may include user interface input devices and user interface output devices. User interface input devices may include pointing devices such as keyboards, mice or trackballs, touchpads or touchscreens integrated into displays, scroll wheels, click wheels, dials, buttons, switches, keypads, voice input devices with voice command recognition systems, microphones, and other types of input devices. User interface input devices may also include motion detection devices and / or gesture recognition devices, such as Microsoft Kinect® motion sensors, which enable users to control and interact with input devices such as Microsoft Xbox® 460 game controllers through a natural user interface using gestures and spoken commands. User interface input devices may also include eye gesture recognition devices, such as Google Glass® blink detectors, which detect the user's eye activity (e.g., blinking when taking pictures and / or selecting menus) and translate eye gestures into input to an input device (e.g., Google Glass®). Furthermore, the user interface input device may include a voice recognition detection device that allows the user to interact with a voice recognition system (e.g., Siri® Navigator) via voice commands.

[0150] User interface input devices may include, but are not limited to, three-dimensional (4D) mice, joysticks or pointing sticks, gamepads and graphic tablets, as well as audio / visual devices such as speakers, digital cameras, digital video cameras, portable media players, webcams, image scanners, fingerprint scanners, barcode readers, 4D scanners, 4D printers, laser rangefinders, and eye-tracking devices. Furthermore, user interface input devices may include medical imaging input devices such as computed tomography, magnetic resonance imaging, positional emission tomography, and medical ultrasound imaging devices. User interface input devices may also include audio input devices such as MIDI keyboards and digital musical instruments.

[0151] User interface output devices may include non-visual displays such as display subsystems, indicator lights, or audio output devices. Display subsystems may include flat panel devices using cathode ray tubes (CRTs), liquid crystal displays (LCDs), or plasma displays, projection devices, touchscreens, etc. Generally, the use of the term “output device” is intended to include all possible types of devices and mechanisms for outputting information from the computer system 1100 to a user or another computer. For example, user interface output devices may include, but are not limited to, various display devices that visually convey text information, graphics information, and audio / video information, such as monitors, printers, speakers, headphones, car navigation systems, plotters, audio output devices, and modems.

[0152] The computer system 1100 may include a storage subsystem 1118 containing software elements that are indicated to be currently located in the system memory 1110. The system memory 119 can store program instructions that can be loaded and executed by the processing unit 1104, as well as data generated during the execution of these programs.

[0153] Depending on the configuration and type of the computer system 1100, the system memory 119 may be volatile (e.g., random-access memory (RAM)) and / or non-volatile (e.g., read-only memory (ROM), flash memory). RAM typically includes data and / or program modules that are immediately accessible to the processing unit 1104 and / or currently being operated and executed by the processing unit 1104. In some embodiments, the system memory 119 may include several different types of memory, such as static random-access memory (SRAM) or dynamic random-access memory (DRAM). In some embodiments, a basic input / output system (BIOS), which includes basic routines that help transfer information between elements within the computer system 1100 during startup, etc., may typically be stored in ROM. As an example, and not an limitation, system memory 119 also shows application programs 1112, program data 119, and operating system 1116, which may include client applications, web browsers, mid-tier applications, relational database management systems (RDBMS), etc.For example, Operating System 1116 may include various versions of Microsoft Windows®, Apple Macintosh®, and / or Linux® operating systems, various commercially available UNIX® or UNIX-like operating systems (including, but not limited to, various GNU / Linux operating systems, Google Chrome® OS, etc.), and / or mobile operating systems such as iOS, Windows® Phone, Android® OS, BlackBerry® 10 OS, and Palm® OS.

[0154] The storage subsystem 1118 may also provide a tangible computer-readable storage medium for storing basic programming and data configurations that provide several embodiments of functionality. Software (programs, code modules, instructions) that provides the aforementioned functionality when executed by the processor may be stored in the storage subsystem 1118. These software modules or instructions can be executed by the processing unit 1104. The storage subsystem 1118 may also provide a repository for storing data used in accordance with the present invention.

[0155] The storage subsystem 1118 may also include a computer-readable storage medium reader 1120 which may be further connected to the computer-readable storage medium 1142. Together with the system memory 119, and optionally in combination with the system memory 119, the computer-readable storage medium 1142 can comprehensively represent storage media for temporarily and / or more permanently containing, storing, transmitting, and retrieving computer-readable information, in addition to remote, local, fixed, and / or removable storage devices.

[0156] The computer-readable storage medium 1142 containing code or a portion of code may also include, but is not limited to, any suitable medium known or used in the art, including storage and communication media, such as volatile and non-volatile, removable and non-removable media, implemented in any way or technique for storing and / or transmitting information. The computer-readable storage medium 1142 may include tangible non-temporary computer-readable storage media, such as RAM, ROM, electronically erasable programmable ROM (EEPROM), flash memory or other memory technologies, CD-ROM, digital versatile disk (DVD), or other optical storage, magnetic cassette, magnetic tape, magnetic disk storage or other magnetic storage devices, or other tangible computer-readable media. When specified, the computer-readable storage medium 1142 may also include non-tangible temporary computer-readable media, such as data signals, data transmissions, or any other media, which can be used to transmit desired information and can be accessed by the computer system 1100.

[0157] For example, the computer-readable storage medium 1122 may include a hard disk drive that reads from or writes to a non-removable non-volatile magnetic medium, a magnetic disk drive that reads from or writes to a removable non-volatile magnetic disk, and an optical disk drive that reads from or writes to a removable non-volatile optical disk such as a CD-ROM, DVD, or Blu-ray® disc, or other optical medium. The computer-readable storage medium 1120 may include, but is not limited to, a Zip® drive, a flash memory card, a Universal Serial Bus (USB) flash drive, a Secure Digital (SD) card, a DVD disc, a digital videotape, and the like. The computer-readable storage medium 1120 may include solid-state drives (SSDs) based on non-volatile memory such as flash memory-based SSDs, enterprise flash drives, and solid-state ROMs; SSDs based on volatile memory such as solid-state RAM, dynamic RAM, static RAM, DRAM-based SSDs, and magnetoresistive RAM (MRAM) SSDs; and hybrid SSDs using a combination of DRAM and flash memory-based SSDs. The disk drive and associated computer-readable medium can provide non-volatile storage for computer-readable instructions, data structures, program modules, and other data of the computer system 1100.

[0158] The communication subsystem 1124 provides interfaces to other computer systems and networks. It functions as an interface for receiving data from other systems and for transmitting data from computer system 1100 to other systems. For example, the communication subsystem 1124 can enable computer system 1100 to connect to one or more devices via the Internet. In some embodiments, the communication subsystem 1124 may include radio frequency (RF) transceiver components for accessing wireless voice and / or data networks (e.g., using cellular technology, 4G, 4G, or EDGE (enhanced data rates for global evolution) advanced data network technologies, WiFi (IEEE 802.28 group standards), or other mobile communication technologies, or any combination thereof), global positioning system (GPS) receiver components, and / or other components. In some embodiments, the communication subsystem 1124 may provide wired network connectivity (e.g., Ethernet) in addition to, or instead of, wireless interfaces.

[0159] In some embodiments, the communication subsystem 1124 may also receive input communications in the form of structured and / or unstructured data feeds 1126, event streams 1128, event updates 1130, etc., on behalf of one or more users who may be using the computer system 1100.

[0160] For example, the communication subsystem 1124 can be configured to receive unstructured data feeds 1126 in real time from users of social media networks and / or other communication services such as Twitter® feeds and Facebook® updates, web feeds such as Rich Site Summary (RSS) feeds, and / or real-time updates from one or more third-party sources.

[0161] Furthermore, the communication subsystem 1124 may also be configured to receive data in the form of a continuous data stream, which may include an event stream 1128 and / or event update 1130 of real-time events that are inherently continuous or boundaryless, without an explicit end. Examples of applications that generate continuous data may include, for example, sensor data applications, financial tickers, network performance measurement tools (e.g., network monitoring and traffic management applications), clickstream analysis tools, and automotive traffic monitoring.

[0162] The communication subsystem 1124 can also be configured to output structured and / or unstructured data feeds 1126, event streams 1128, event updates 1130, etc., to one or more databases that can communicate with one or more streaming data source computers coupled to the computer system 1100.

[0163] The computer system 1100 may be one of a variety of types, including handheld portable devices (e.g., iPhone® mobile phones, iPad® computing tablets, PDAs), wearable devices (e.g., Google Glass® head-mounted displays), PCs, workstations, mainframes, automated ticket machines, server racks, or any other data processing systems.

[0164] Due to the constantly changing nature of computers and networks, the description of the computer system 1100 shown in the figure is intended to be merely a concrete example. Many other configurations are possible, having more or fewer components than the system shown in the figure. For example, customized hardware may be used, and / or certain elements may be implemented in hardware, firmware, software (including applets), or a combination thereof. Furthermore, connections to other computing devices, such as network input / output devices, may be employed. Based on the disclosures and teachings provided herein, those skilled in the art will understand other ways and / or methods for carrying out various embodiments.

[0165] While embodiments of the invention have been described in the foregoing specification with reference to specific embodiments herein, those skilled in the art will recognize that the invention is not limited thereto. The various features and embodiments of the invention described herein can be used individually or in combination. Furthermore, embodiments can be used in any number of environments and applications beyond those described herein, without departing from the broader spirit and scope herein. Accordingly, this specification and the drawings should be considered illustrative rather than restrictive.

Claims

1. A method for instrumenting an application, To provide a web page application, including a tracer application, to a web browser on a client device, Accessing the source of the web page application via the aforementioned tracer application, The tracer application includes detecting references to elements of the webpage application within the source, wherein the elements are (i) triggered by user interaction with the webpage application, and (ii) have a priority designation. The aforementioned method, The user interaction with the web page application is detected via the tracer application, The further includes automatically logging the start of a span based on the detection of the user interaction, wherein the logging includes associating the span with the tracer application. The aforementioned method, Performing an operation related to the aforementioned element, The element is determined to be ready for additional user interaction, Based on the above determination, the end of the span is automatically logged, Methods that further include the following.

2. The aforementioned method, The further includes automatically initiating an additional span associated with a subset of the aforementioned actions, wherein the subset of the aforementioned actions is associated with the rendering of the element, and the additional span is a child span of the aforementioned span. The aforementioned method, The method according to claim 1, further comprising automatically logging the end of the additional span based on the completion of the subset of the operations.

3. Detecting references to elements of the aforementioned web page application means Within the tracing application, a mutation observer is executed to analyze the source of the web page, The mutation observer determines that the source has been modified, The method according to claim 1, including the method described in claim 1.

4. The method according to claim 1, wherein automatically logging the end of the span includes determining one or more of (i) the number of processing cycles corresponding to the execution of the operation, or (ii) the execution time of the operation.

5. The aforementioned method, From the source of the web page application, determine that additional elements are triggered by the user interaction. In response to the determination that the additional element was triggered by the user interaction, This further includes automatically logging the start of adding additional spans, the logging of which includes associating the additional spans with the tracer application, Performing additional actions related to the aforementioned additional elements, The aforementioned additional elements determine whether the user interaction is ready, Based on the above determination, the end of the additional span is automatically logged, It further includes, The aforementioned method, The method according to claim 1, further comprising outputting a combined span representing the completion of the span and the additional span.

6. The method according to claim 1, further comprising determining that an element has the priority designation by identifying one or more attributes associated with the element within the source of the web page application.

7. The operation related to the aforementioned element is, Sending a request to an external server for the aforementioned elements, Based on the aforementioned transmission, a child span is created, Receiving the element from the external server, In response to receiving the aforementioned element, the termination of the child span is automatically logged, Associating the aforementioned child span with the aforementioned span, The method according to claim 1, including the method described in claim 1.

8. It is a system, A non-temporary computer-readable medium for storing computer executable program instructions, The processing device is communicatively coupled to the non-temporary computer-readable medium in order to execute the computer executable program instructions, and executing the computer executable program instructions means that the processing device To provide a web page application, including a tracer application, to a web browser on a client device, Accessing the source of the web page application via the aforementioned tracer application, The tracer application includes detecting references to elements of the webpage application within the source, wherein the elements are (i) triggered by user interaction with the webpage application, and (ii) have a priority designation. The user interaction with the web page application is detected via the tracer application, Based on the detection of the user interaction, the process includes automatically logging the start of a span, and the logging includes associating the span with the tracer application. Performing an operation related to the aforementioned element, The element is determined to be ready for additional user interaction, Based on the above determination, the end of the span is automatically logged, A system configured to perform actions that include the following.

9. Executing the aforementioned computer executable program instructions means that the processing device This includes automatically initiating an additional span associated with a subset of the aforementioned actions, wherein the subset of the aforementioned actions is associated with the rendering of the element, and the additional span is a child span of the aforementioned span. The system according to claim 8, configured to perform an operation that includes automatically logging the end of the additional span based on the completion of the subset of the operation.

10. Detecting references to elements of the aforementioned web page application means Within the aforementioned tracing application, a mutation observer is executed to analyze the source of the web page, The mutation observer determines that the source has been modified, The system according to claim 8, including the above.

11. The system according to claim 8, wherein automatically logging the end of the span includes determining one or more of (i) the number of processing cycles corresponding to the execution of the operation, or (ii) the execution time of the operation.

12. Executing the aforementioned computer executable program instructions means that the processing device This includes determining from the source of the web page application that additional elements are triggered by the user interaction, In response to the determination that the additional element was triggered by the user interaction, This includes automatically logging the start of adding an additional span, and the logging includes associating the additional span with the tracer application. Performing additional actions related to the aforementioned additional elements, The aforementioned additional elements determine whether the user interaction is ready, Based on the above determination, the end of the additional span is automatically logged, Includes, The system according to claim 8, configured to perform an operation including outputting a combined span representing the completion of the span and the additional span.

13. The system according to claim 8, wherein the execution of the computer executable program instructions is configured to perform an operation which includes determining whether an element has the priority designation by identifying one or more attributes associated with the element within the source of the web page application.

14. The operation related to the aforementioned element is, Sending a request to an external server for the aforementioned elements, Based on the aforementioned transmission, a child span is created, Receiving the element from the external server, In response to receiving the aforementioned element, the termination of the child span is automatically logged, Associating the aforementioned child span with the aforementioned span, The system according to claim 8, including the above.

15. A non-temporary computer-readable storage medium for storing computer executable program instructions, wherein when executed by a processing device, the computer executable program instructions are transmitted to the processing device. To provide a web page application, including a tracer application, to a web browser on a client device, Accessing the source of the web page application via the aforementioned tracer application, The tracer application includes detecting references to elements of the webpage application within the source, wherein the elements are (i) triggered by user interaction with the webpage application, and (ii) have a priority designation. The user interaction with the web page application is detected via the tracer application, Based on the detection of the user interaction, the process includes automatically logging the start of a span, and the logging includes associating the span with the tracer application. Performing an operation related to the aforementioned element, The element is determined to be ready for additional user interaction, Based on the above determination, the end of the span is automatically logged, A non-temporary computer-readable storage medium that enables the execution of operations including [specific actions].

16. When executed by a processing device, the computer executable program instructions are sent to the processing device. This includes automatically initiating an additional span associated with a subset of the aforementioned actions, wherein the subset of the aforementioned actions is associated with the rendering of the element, and the additional span is a child span of the aforementioned span. A non-temporary computer-readable storage medium according to claim 15, which causes an operation to be performed that includes automatically logging the end of the additional span based on the completion of the subset of the operation described above.

17. Detecting the aforementioned reference to an element of the web page application means that Within the aforementioned tracing application, a mutation observer is executed to analyze the source of the web page, The mutation observer determines that the source has been modified, A non-temporary computer-readable storage medium according to claim 15, including the following:

18. The non-temporary computer-readable storage medium according to claim 15, wherein automatically logging the end of the span includes determining one or more of (i) the number of processing cycles corresponding to the execution of the operation, or (ii) the execution time of the operation.

19. When executed by a processing device, the computer executable program instructions are sent to the processing device. From the source of the web page application, determine that additional elements are triggered by the user interaction. In response to the determination that the additional element was triggered by the user interaction, This includes automatically logging the start of adding an additional span, and the logging includes associating the additional span with the tracer application. Performing additional actions related to the aforementioned additional elements, The aforementioned additional elements determine whether the user interaction is ready, Based on the above determination, the end of the additional span is automatically logged, Includes, A non-temporary computer-readable storage medium according to claim 15, which causes the medium to perform an operation including outputting a combined span representing the completion of the span and the additional span.

20. The non-temporary computer-readable storage medium according to claim 15, wherein, when executed by a processing device, the computer executable program instruction causes the processing device to perform an operation including determining that an element has the priority designation by identifying one or more attributes associated with the element within the source of the web page application.

Images