US 12,373,497 B1Grant

Dynamic generation of performance state tree

Issue Date:2025-07-29

•20 Claims

•43 Drawing Sheets

Abstract

Embodiments described herein are directed to dynamic generation of performance state trees. In embodiments, a performance metric for determining a performance state for components is received. A query is dynamically generated based on the performance metric. A performance state is determined for components based on an associated value according to an identified performance metric. Architectural information including relationships between components is retrieved. Thereafter, a visual output, including a tree, is dynamically generated based on the architectural information. The individual nodes in the tree are displayed with respective graphical indications of the performance states of the respective represented components.

Metadata

Assignee

Splunk Inc.

Inventors

Tristan Fletcher
Cary Glen Noel

Application Information

Application Number:US 18/453,184

Filing Date:2023-08-21

Priority Date:2013-04-30

Art Unit:2161

Classifications

IPC:

G06F16/9038G06F3/0482G06F3/0488G06F9/455G06F11/32G06F16/2458G06F16/26G06F16/901G06F16/903G06F16/9032G06F11/34

Field of Search:

G06F 16/9038G06F 16/2471G06F 16/26G06F 16/90335G06F 16/90328G06F 16/9017G06F 3/0482G06F 3/0488G06F 9/45533G06F 11/323G06F 11/3409G06F 2201/815

Patent Drawings (43 sheets)

Description

Cross-Reference to Related Applications

[0001] This application is a Continuation-in-Part of U.S. patent application Ser. Nos. 16/412,310 and 17/670,773, filed May 14, 2019 and Feb. 14, 2022, respectively. The contents of which are incorporated by reference herein in their entirety.

[0002] U.S. patent application Ser. No. 16/412,310 is a Continuation of U.S. patent application Ser. No. 15/215,430 filed Jul. 20, 2016 (now issued as U.S. Pat. No. 10,310,708), which is itself a Continuation of U.S. patent application Ser. No. 14/609,080 filed Jan. 29, 2015 (now issued as U.S. Pat. No. 9,417,774), which is itself a Continuation of U.S. patent application Ser. No. 14/253,697 filed Apr. 15, 2014 (now issued as U.S. Pat. No. 9,015,716) is itself a Continuation-in-Part of U.S. patent application Ser. No. 14/167,316 filed Jan. 29, 2014; Ser. No. 13/874,423, filed Apr. 30, 2013 (now issued as U.S. Pat. No. 8,904,389); Ser. No. 13/874,434, filed Apr. 30, 2013 (now issued as U.S. Pat. No. 8,683,467); Ser. No. 13/874,441, filed Apr. 30, 2013 (now issued as U.S. Pat. No. 9,164,786); and Ser. No. 13/874,448, filed Apr. 30, 2013 (now issued as U.S. Pat. No. 9,495,187). U.S. patent application Ser. No. 14/253,697 also claims the benefit of U.S. Provisional Application No. 61/979,484, filed Apr. 14, 2014; 61/900,700, filed Nov. 6, 2013; and 61/883,869, filed Sep. 27, 2013. The contents of each of the foregoing applications are incorporated by reference herein in their entirety.

[0003] U.S. patent application Ser. No. 17/670,773 is a Continuation of U.S. patent application Ser. No. 16/460,423, filed Jul. 2, 2019 (now issued as U.S. Pat. No. 11,250,068), which is itself a Continuation of Ser. No. 15/421,370, filed Jan. 31, 2017 (now issued as U.S. Pat. No. 10,353,957), which is itself a Continuation-in-Part of U.S. patent application Ser. No. 14/167,316, filed Jan. 29, 2014, and U.S. patent application Ser. No. 14/801,721, filed Jul. 16, 2015 (now issued as U.S. Pat. No. 9,754,395). U.S. patent application Ser. No. 14/801,721 is itself a Continuation of U.S. patent application Ser. No. 14/253,548, filed Apr. 15, 2014 (now issued as U.S. Pat. No. 9,142,049), which is itself a Continuation-in-Part of U.S. patent application Ser. No. 14/167,316 filed Jan. 29, 2014; Ser. No. 13/874,423, filed Apr. 30, 2013 (now issued as U.S. Pat. No. 8,904,389); Ser. No. 13/874,434, filed Apr. 30, 2013 (now issued as U.S. Pat. No. 8,683,467); Ser. No. 13/874,441, filed Apr. 30, 2013 (now issued as U.S. Pat. No. 9,164,786); and Ser. No. 13/874,448, filed Apr. 30, 2013 (now issued as U.S. Pat. No. 9,495,187). U.S. patent application Ser. No. 14/253,697 also claims the benefit of U.S. Provisional Application No. 61/979,484, filed Apr. 14, 2014; 61/900,700, filed Nov. 6, 2013; and 61/883,869, filed Sep. 27, 2013. The contents of each of the foregoing applications are incorporated by reference herein in their entirety.

[0004] U.S. patent application Ser. No. 14/167,316, filed Jan. 29, 2014 is itself also a Continuation-in-Part of U.S. patent application Ser. No. 13/874,423, filed Apr. 30, 2013 (now issued as U.S. Pat. No. 8,904,389); Ser. No. 13/874,434, filed Apr. 30, 2013 (now issued as U.S. Pat. No. 8,683,467); Ser. No. 13/874,441, filed Apr. 30, 2013 (now issued as U.S. Pat. No. 9,164,786); and Ser. No. 13/874,448, filed Apr. 30, 2013 (now issued as U.S. Pat. No. 9,495,187). U.S. patent application Ser. No. 14/167,316 also claims the benefit of U.S. Provisional Application No. 61/979,484, filed Apr. 14, 2014; 61/900,700, filed Nov. 6, 2013; and 61/883,869, filed Sep. 27, 2013. The contents of each of the foregoing applications are incorporated by reference herein in their entirety.

Technical Field/Related Art

[0005] The disclosed embodiments generally relate to techniques for monitoring and analyzing performance in a computer system. More specifically, the disclosed embodiments relate to the design of a performance-monitoring system that provides a user interface with a proactive monitoring tree that facilitates visualizing performance information for virtual machines and associated host systems in a hierarchically structured computing environment.

[0006] The present disclosure relates generally to techniques for processing log data and/or performance data relating to components in an information technology (IT) environment.

Background

[0007] Organizations are increasingly relying on cloud-based computing systems to perform large-scale computational tasks. Such cloud-based computing systems are typically operated by hosting companies that maintain a sizable computational infrastructure, often comprising thousands of servers sited in geographically distributed data centers. Customers typically buy or lease computational resources from these hosting companies. The hosting companies in turn provision computational resources according to the customer's requirements and then enable the customers to access these resources.

[0008] Along with the advancement in computing technology, users' expectations of computational capabilities are similarly increasing. Users are constantly seeking resources that can provide the ability to achieve a computational result quickly and appropriately. Attending to users' requests is complicated by the fact that user projects vary in terms of required processing power, memory allocation, software capabilities, rights licensing, etc. Recently, systems have been organized to include a plurality of virtual machines. Tasks can then be assigned to virtual machines based on the task requirements, the machines' capabilities and the system load. However, given the dynamic nature of assignments and the many components in these systems, monitoring the systems' performance is difficult.

[0009] In many cases, cloud-based computing systems provide a virtualized computing environment, wherein tasks run on “virtual machines” that execute on underlying physical host systems. Such virtualized computing environments enable computational tasks to be easily moved among host systems to facilitate load balancing and fault tolerance. However, they also complicate the process of diagnosing and resolving performance problems because bottlenecks can arise at both the virtual-machine level and the host-system level.

[0010] Existing performance-monitoring tools do not provide an easy way to diagnose performance problems in such computing systems.

Summary

[0011] In accordance with the teachings provided herein, systems and methods for monitoring a hypervisor system are provided. A hypervisor system can coordinate operations of a set of virtual machines (VM) and/or hosts. Characterizing the overall operation of the system and/or operation of various system components can be complicated by the coordinated operation of the system components and the potential architecture flexibility of the system.

[0012] According to some embodiments, an architecture of a hypervisor structure is represented to a reviewer, along with indications characterizing how well individual components of the system are performing. In one instance, the architecture (which may be defined by an architecture provider and flexible in its structure) is represented as a tree with individual nodes corresponding to system components. For individual VMs, a performance number is calculated based on task completions and/or resource utilization of the VM, and a performance state is assigned to the component based on the number and state criteria. For higher-level components (e.g., hosts, host clusters, and/or a Hypervisor), another performance number is calculated based on the states of the underlying components. A performance state is assigned to the higher-level components using different state criteria and the respective performance number.

[0013] A reviewer is presented with a performance indicator (which can include a performance statistic or state) of one or more high-level components. At this point, lower level architecture and/or corresponding performance indicators are hidden from the reviewer. The reviewer can then select a component and “drill down” into performance metrics of underlying components. That is, upon detecting a reviewer's selection of a component, low-level architecture beneath the selected component is presented along with corresponding performance indicators.

[0014] In some instances, a performance event can be generated based on one or more performance assessments. Each performance event can correspond to one or more specific hypervisor components and/or a Hypervisor in general. Each performance event can include performance data for the component(s) and/or Hypervisor, such as a performance metric (e.g., CPU usage), performance statistic or performance state. In some instances, performance is assessed using different types of assessments (e.g., CPU usage versus memory usage). Multiple types of performance data can be represented in a single event or split across events.

[0015] A time stamp can be determined for each performance event. The time stamp can identify a time at which a performance was assessed. The events can then be stored in a time-series index, such that events are stored based on their time stamps. Subsequently, the index can be used to generate a result responsive to a query. In one instance, upon receiving a query, performance events with time stamps within a time period associated with the query are first retrieved. A late-binding schema is then applied to extract values of interest (e.g., identifiers of hypervisor components, or a type of performance). The values can then be used to identify query-responsive events (e.g., such that only performance events for component #1 are further considered) or identify values of interest (e.g., to determine a mode CPU usage).

[0016] Time stamped events can also be stored for other types of information. Events can identify tasks (e.g., collecting, storing, retrieving, and/or processing of big-data) assigned to and/or performed by hypervisor components and/or data received and/or processed by a hypervisor component. For example, a stream of data (e.g., log files, big data, machine data, and/or unstructured data) can be received from one or more data sources. The data can be segmented, time stamped and stored as data events (e.g., including machine data, raw data and/or unstructured data) in a time-series index (e.g., a time-series data store). Thus, rather than extracting field values at an intake time and storing only the field values, the index can retain the raw data or slightly processed versions thereof and extraction techniques can be applied at query time (e.g., by applying an iteratively revised schema).

[0017] While it can be advantageous to retain relatively unprocessed data, it will be appreciated that data events can include any or all of the following: (1) time stamped segments of raw data unstructured data, or machine data (or transformed versions of such data); (2) the kinds of events analyzed by vendors in the Security Information and Event Management (“SIEM”) field; (3) any other logical piece of data (such as a sensor reading) that was generated at or corresponds to a fixed time (thereby enabling association of that piece of data with a time stamp representing the fixed time); and (4) occurrences where some combination of one or more of any of the foregoing types of events either meets specified criteria or was manually selected by a data analyst as notable or a cause for an alert.

[0018] Data events can be used to generate a response to a received query. Select data events (e.g., matching a time period and/or field constraint in a query) can be retrieved. A defined or learned schema can be applied to extract field values from the retrieved events, which can be processed to generate a statistical query result (e.g., a count or unique identification) and/or selection (e.g., selecting events with particular field values). A query event can include information from the query and/or from the result and can also be time stamped and indexed.

[0019] Thus, one or more time-series indices can store a variety of time stamped events. This can allow a reviewer to correlate (e.g., based on a manual sampling or larger scale automated process) poor performance characteristics with processing tasks (e.g., data being indexed).

[0020] Particular embodiments of the subject matter described in this specification can be implemented to realize one or more of the following advantages. Techniques disclosed herein provide for the capability to characterize an operation of a hypervisor system at a variety of levels. By presenting the performance in a top-down manner, are viewer can identify a level at which a system is experiencing problems and how an architecture may be modified to alleviate the problems. Further, by classifying different types of performance metrics (for various levels in the hierarchy) into one of a same set of states, a reviewer can easily understand how each portion of the system is performing.

[0021] The details of one or more embodiments of the disclosure are set forth in the accompanying drawings and the description below. Other features, aspects, and advantages of the disclosure will become apparent from the description, the drawings, and the claims.

Brief Description of the Drawings

[0022] The present disclosure is described in conjunction with the appended figures:

[0023] FIG. 1 illustrates a performance-monitoring tool that displays a proactive monitoring tree in accordance with the disclosed embodiments.

[0024] FIG. 2A illustrates an exemplary proactive monitoring tree in accordance with the disclosed embodiments.

[0025] FIG. 2B illustrates how nodes in a proactive monitoring tree can be selectively expanded in accordance with the disclosed embodiments.

[0026] FIG. 3 illustrates a system that facilitates executing virtual machines in accordance with the disclosed embodiments.

[0027] FIG. 4A presents a flowchart illustrating how performance metrics can be collected in accordance with the disclosed embodiments.

[0028] FIG. 4B presents a flowchart illustrating how a proactive monitoring tree can be generated in accordance with the disclosed embodiments.

[0029] FIG. 5A illustrates a sorted proactive monitoring tree in accordance with the disclosed embodiments.

[0030] FIG. 5B presents a flowchart illustrating how nodes in a proactive monitoring tree can be sorted and displayed in accordance with the disclosed embodiments.

[0031] FIG. 6A illustrates an exemplary state distribution ring in accordance with the disclosed embodiments.

[0032] FIG. 6B presents a flowchart illustrating how a state distribution ring can be displayed in accordance with the disclosed embodiments.

[0033] FIG. 7A presents a performance graph for a branch of the tree overlaid on a distribution of the performance metric over nodes in the tree in accordance with the disclosed embodiments.

[0034] FIG. 7B presents a flowchart illustrating how the graph illustrated in FIG. 7A can be generated in accordance with the disclosed embodiments.

[0035] FIG. 8A illustrates a system that facilitates node pinning in accordance with the disclosed embodiments.

[0036] FIG. 8B presents a flowchart illustrating the process of displaying a pin board for a proactive monitoring tree in accordance with the disclosed embodiments.

[0037] FIG. 9A illustrates a metric-selection screen in accordance with the disclosed embodiments.

[0038] FIG. 9B illustrates a tree with parent nodes that are colored based on the performance states of their child nodes in accordance with the disclosed embodiments.

[0039] FIG. 9C illustrates a tree with state distribution rings in accordance with the disclosed embodiments.

[0040] FIG. 9D illustrates a tree with sorted nodes in accordance with the disclosed embodiments.

[0041] FIG. 9E illustrates another example of the graph illustrated in FIG. 9D in accordance with the disclosed embodiments.

[0042] FIG. 9F illustrates an exemplary pin board in accordance with the disclosed embodiments.

[0043] FIG. 10 shows a block diagram of an embodiment of a virtual-machine interaction system;

[0044] FIG. 11 shows a block diagram of an embodiment of task assigner;

[0045] FIG. 12 shows a block diagram of an embodiment of a VM monitoring;

[0046] FIG. 13 illustrates an example of a representation of an architecture for a Hypervisor;

[0047] FIGS. 14A-14B illustrate an example of sequential presentations conveying an architecture and system performance that can be presented to a reviewer;

[0048] FIGS. 15A-15C illustrate example detailed information that can be presented to characterize performance of a hypervisor system, a host and a VM, respectively;

[0049] FIGS. 16A-16C further illustrate example detailed information that can be presented to characterize performance of a hypervisor system, a host and a VM, respectively;

[0050] FIG. 17 illustrates a flowchart of an embodiment of a process for using a VM machine to complete user tasks;

[0051] FIG. 18A illustrates a flowchart of an embodiment of a process for characterizing VM-system components' performance;

[0052] FIG. 18B illustrates a flowchart of an embodiment of a process for generating and using time stamped events to establish structure characteristics associated with a performance level;

[0053] FIG. 19 illustrates a flowchart of an embodiment of a process for assigning a performance state to a low-level component in a Hypervisor;

[0054] FIG. 20 illustrates a flowchart of an embodiment of a process for assigning a performance state to a high-level component in a Hypervisor;

[0055] FIG. 21 illustrates a flowchart of an embodiment of a process for using a VM machine to complete user tasks;

[0056] FIG. 22 illustrates a flowchart of an embodiment of a process for analyzing the performance of a Hypervisor using historical data;

[0057] FIG. 23 illustrates an example a block diagram of a data intake and query systems in accordance with the disclosed embodiments.

[0058] FIG. 24 illustrates a flowchart of a process that indexers may use to process, index, and store data received from forwarders in accordance with the disclosed embodiments.

[0059] FIG. 25 illustrates a flowchart of a process that a search head and indexers perform during a typical search query in accordance with the disclosed embodiments.

[0060] FIG. 26 illustrates an example of a search query received from a client that the search head can split into two parts in accordance with the disclosed embodiments.

[0061] FIG. 27 illustrates a flowchart of an embodiment of a process for using intermediate information summaries to accelerate generation a query result;

[0062] FIG. 28 illustrates a flowchart of an embodiment of a process for displaying performance measurements and log data over a selected time range;

[0063] FIGS. 29A-29F illustrate examples of ways to select a time range for retrieving performance measurements and log data;

[0064] FIGS. 30A-30B illustrate examples of detailed performance measurements and log data that can be presented; and

[0065] FIG. 31 illustrates an example of a presentation of log data that is associated with performance measurements.

[0066] Like reference numbers and designations in the various drawings indicate like elements.

Detailed Description

User Interface that Facilitates Node Pinning for a Proactive Monitoring Tree

Overview

[0067] The disclosed embodiments relate to a performance-monitoring system that provides a user interface that displays a proactive monitoring tree in accordance with the disclosed embodiments. This proactive monitoring tree enables a user to easily view and understand relationships among various factors that affect performance of a hierarchically structured computing system. More specifically, a user can navigate the proactive monitoring tree to gain a better understanding of the performance of an associated computing system by examining values for a selected performance metric across a set of entities (e.g., virtual machines and host systems) that comprise the computing system, wherein the entities are represented as nodes in the proactive monitoring tree. Values for the selected metric can be aggregated for each of the entities over a selected time range and then compared against a set of thresholds to determine performance states for the entities. These performance states can be represented by using different colors to display associated nodes of the proactive monitoring tree. For example, performance states in a virtual machine environment can indicate whether the performance for a specific entity (virtual machine or host system) is in a critical state (red), a warning state (orange), a normal state (green), or an unknown/offline state (gray).

[0068] The proactive monitoring tree enables a user to easily navigate the hierarchy by selectively expanding nodes representing sets of entities (e.g., computing clusters) to view performance information for lower-level nodes associated with lower-level entities (e.g., virtual machines or host systems.) This ease of navigation enables a user to quickly diagnose the root cause of a performance problem.

[0069] An exemplary performance-monitoring system that provides a proactive monitoring tree system is illustrated in FIG. 1. This system includes a performance-monitoring tool 108 comprising a software application that enables a user to monitor and analyze a set of performance data 110.

[0070] This performance data 110 can originate from various data sources 112. In general, performance data 110 can comprise any type of data associated with entities that can be hierarchically organized with a one-to-many relationship between entities. For example, performance data 110 can originate from a virtual machine system and can specify utilization rates for various resources, such as central-processing unit (CPU) capacity, memory capacity and communication bandwidth for individual virtual machines or underlying host systems that comprise the virtual machine system. In another example, performance data 110 can originate from a database containing economic data. In this example, the data can relate to economic indicators such as per capita GDP, unemployment rates, and income distribution for the different states, counties and cities. In another example, performance data 110 can originate from a database containing census data. In this example, the data can relate to racial, religious and ethnic compositions of various states, counties and cities. In yet another example, performance data 110 can originate from a database containing information on communicable diseases. In this example, the data can relate to the number of cases of specific diseases and associated rates of mortality for different countries, states and cities. In another example, performance data 110 can originate from a database containing financial information for a corporation. In this example, the data can relate to financial performance for various subsidiaries, divisions and departments within the corporation.

[0071] Performance data 110 can also be collected using time windows that vary in size. For example, the data sources 112 can provide data values collected over time windows that range in size from microseconds, to seconds, to years.

[0072] Moreover, performance data 110 can comprise real-time data that is collected periodically (e.g., every three minutes) from an active system. Alternatively, performance data 110 can comprise non-real-time data, such as census data, that is collected every ten years.

[0073] Performance data 110 can also include values for many different types of performance metrics. For example, the performance metrics for a virtual machine system can include: (1) CPU-related performance metrics, such as utilization per host, virtual machine, resource pool or compute resource; (2) disk-related performance metrics, such as disk utilization per host, virtual machine, or datastore, wherein the disk metrics can include I/O performance (such as latency and read/write speeds), and utilization metrics for storage as a finite resource; (3) memory-related performance metrics, such as memory utilization per host, virtual machine, resource pool, or compute resource; (4) network-related performance metrics, such as network utilization for both physical and virtual network interface controllers (NICs) and other network devices, such as virtual switches that support connectivity among system components, such as hosts, virtual machines and virtual machine kernels; (5) energy-usage statistics, such as energy usage per host; (6) data traffic-related performance metrics, such as storage path data traffic statistics and storage adapter data traffic statistics; (7) overall system availability performance metrics, such as uptime and system heartbeat statistics; (8) cluster-related performance metrics, such as cluster utilization; and (9) virtual machine performance statistics, such as statistics related to virtual machine power and provisional operations. For more details on possible performance metrics, please see U.S. patent Ser. No. 14/167,316 filed 29 Jan. 2014 that provides a list of such performance metrics and is hereby incorporated by reference herein. Also, see “vSphere Monitoring and Performance” Update 1, vSphere 5.5, EN-001357-00, http://pubs.vmware.com/vsphere-55/topic/com.vmware.ICbase/PDF/vsphere-esxi-vcenter-server-551-monitoring-performance-guide.pdf.

[0074] During operation, performance-monitoring tool 108 displays a user interface 104 to a user 102. User interface 104 displays a proactive monitoring tree 106 comprising nodes associated with specific entities, such as a virtual machine or a host system, or a set of entities, such as a cluster of host systems or multiple clusters. These nodes provide a visual indicator (e.g., a color) to indicate performance states (associated with a specific performance metric) for each entity. For example, a red-colored node may indicate that a value of a performance metric for the node is in a critical range. Note that a user 102 is able to navigate the nodes of proactive monitoring tree 106 by selectively expanding lower-level nodes to view performance information for entities represented by the nodes. This enables the user to determine the root cause of a performance problem by quickly identifying an entity (e.g., virtual machine) that is causing a performance bottleneck for the system.

Proactive Monitoring Tree

[0075] FIG. 2A illustrates an exemplary proactive monitoring tree 106 in accordance with the disclosed embodiments. A proactive monitoring tree 106 can generally be used to represent data values for any entities that have one-to-many relationships (e.g., parent-child relationships) and are hierarchically structured to form one or more trees. For example, in a computing system that supports execution of virtual machines, each node in the proactive monitoring tree 106 can represent: (1) a virtual machine; (2) a host system that executes one or more virtual machines; (3) a cluster comprising one or more host systems; or (4) a virtual center comprising one or more clusters. Hence, in FIG. 2A nodes 222-228 can represent virtual machines, nodes 217-221 can represent host systems that execute virtual machines, nodes 215-216 can represent computing clusters comprising multiple host systems, and node 214 can represent a virtual center comprising multiple clusters.

[0076] Each node in proactive monitoring tree 106 can be colored to indicate a performance state for the associated entity. For example, if the performance metric is memory utilization, a node for a virtual machine can be colored: red to indicate that memory utilization for the virtual machine is in a critical range (e.g., over 99%); orange to indicate a warning range (e.g., 90% to 99%); green to indicate a normal range (e.g., 0% to 90%); and gray to indicate that memory utilization is unknown for the virtual machine. Note that performance states, and the associated ranges of values for the performance states, can be fixed or may be configurable by a user.

[0077] Performance states can alternatively be indicated in different ways (instead of by using colors), such as by using different patterns (e.g., cross-hatching or dots), through different levels of gray-shading, or through textual labels that explicitly announce the performance state.

[0078] Moreover, the performance state for a parent node can depend on the performance states of the parent's children. For example, the performance state for a host node can depend on the worst-case performance state for any virtual machine that executes on the host node, the performance state for a cluster node can depend on the worst-case performance state for any host node in the cluster, and the performance state for a virtual center node can depend on the worst-case performance state for any cluster in the virtual center.

[0079] More specifically, referring to FIG. 2A, the performance state for node 215 is red because the worst-case performance state for child nodes 219-221 is red; the performance state for node 217 is orange because the worst-case performance state for child nodes 222-225 is orange; the performance state for node 218 is green because the worst-case performance state for child nodes 226-228 is green; the performance state for node 216 is orange because the worst-case performance state for child nodes 217-218 is orange; and finally, the performance state for node 214 is red because the worst-case performance state for child nodes 215-216 is red.

[0080] Note that assigning performance states to a parent node based on the worst-case states for associated child nodes enables a viewer to determine quickly which branches of the tree are likely to have performance problems. However, performance states can be assigned to parent nodes in alternative ways. For example, a performance state for a parent node can depend on the average performance state (or most-common performance state) of its child nodes.

[0081] Proactive monitoring tree 106 also supports navigational operations to facilitate analyzing performance problems. While displaying a large system comprising hundreds or thousands of entities, it may be impractical to display nodes for all of the entities at the same time. (Note that it may simply be impossible to fit hundreds or thousands of nodes on a single display screen.) Even if it is possible to display a large number of nodes in a single display screen, the large number of displayed nodes can obscure performance problems for a small subset of the nodes that have performance problems.

[0082] To facilitate viewing systems with a large number of nodes, proactive monitoring tree 106 enables the user to selectively expand parent nodes to display underlying child nodes. For example, FIG. 2B illustrates how nodes in the proactive monitoring tree can be selectively expanded by a user. On the left-hand side of FIG. 2B, the proactive monitoring tree is initially displayed with three nodes 214-216. At this point, lower-level nodes are hidden from the user. When the user selects (e.g., uses a mouse to click on) node 216, node 216 expands to reveal underlying child nodes 217-218. When the user selects node 217, node 217 expands to reveal underlying child nodes 222-225. Note that if an expanded tree does not completely fit on the screen, the user can grab and move the tree to change which portion of the expanded tree is displayed on the screen. These navigational operations enable a user to quickly “drill down” into a branch of interest to explore the performance states of nodes in the branch. (Note that an expanded node can be selected again to hide its underlying children.)

[0083] By presenting performance information in this top-down manner, the proactive monitoring tree enables a user to identify where a computing system is experiencing performance problems, and to determine how the computing system can be modified to alleviate these problems. Furthermore, by associating performance values with a set of performance states, a user can easily understand how different portions of the computing system are performing.

[0084] We next describe how such performance data can be collected in a server system that supports execution of virtual machines.

Exemplary Performance-Monitoring System

[0085] FIG. 3 illustrates an exemplary server system 300 that monitors the performance of a virtual machine environment comprising a set of virtual machines and associated host systems in accordance with the disclosed embodiments. As illustrated in FIG. 3, server system 300 is accessed by local systems 303 and 304 through network 301. Server system 300 can generally include a set of computational resources, such as a cloud-based computer system comprising one or more geographically distributed data centers. Local systems 303 and 304 can generally include any type of computer system that can interact with server system 300. For example, local systems 303 and 304 can include a personal computer system, a server computer system, a laptop computer system, or a smartphone. Network 301 can generally include any type of network for connecting computer systems. For example, network 301 can be a private network with dedicated communication links; a public network, such as the Internet, or a virtual-private network (VPN) that operates over a public network.

[0086] Local systems 303 and 304 include applications (not shown) which are operated by users 305 and 306, respectively. (Note that these applications can be native applications or browser-based applications.) During operation, these applications in local systems 303 and 304 can offload computational tasks to server system 300 through interactions with a hypervisor 302. Hypervisor 302 controls the operation of a set of virtual machines 321-336 that execute computational tasks on a set of underlying physical host systems 341-356. Host systems 341-356 can generally include any type of single-core or multi-core computer system including associated memory resources that can be used to execute computational tasks.

[0087] Hypervisor 302 assigns tasks to be executed on specific virtual machines or sets of virtual machines based on the task's requirements, the virtual machine's capabilities, and the load on the virtual machines. Hypervisor 302 also assigns virtual machines to be executed on underlying physical host systems based on the load on the underlying host systems and computational requirements of the virtual machines.

[0088] During operation, hypervisor 302 records values for a number of performance metrics for virtual machines 321-336 and host systems 341-356 and makes these performance metric values available through an application programming interface (API) 308.

[0089] Virtual machine (VM) monitoring system 310 periodically makes calls through API 308 to retrieve values for these performance metrics and then stores them in a database containing performance data 110. More specifically, referring to the flowchart illustrated in FIG. 4A, VM monitoring system 310 retrieves values for a set of performance metrics by making calls through API 308 (step 402). Note that API 308 provides various methods or functions to retrieve values for the performance metrics. In one embodiment, API 308 is an API provided as part of the vSphere Hypervisor™ system distributed by VMware, Inc. of Palo Alto, California. While retrieving values for the performance metrics from hypervisor 302 through API 308, VM monitoring system 310 also retrieves architectural information specifying one-to-many relationships between entities in the computing environment. For example, this architectural information can specify which virtual machines execute on each host, which hosts belong to each cluster, and which clusters belong to each virtual cluster.

[0090] Next, VM monitoring system 310 stores the retrieved values for the performance metrics and associated timestamps along with the architectural information in database 110 (step 404). Then, VM monitoring system 310 waits for a specified amount of time (406), and returns to step 402 to retrieve the next set of performance metric values.

Process of Generating a Proactive Monitoring Tree

[0091] FIG. 4B presents a flowchart illustrating how a proactive monitoring tree 106 is generated by a performance-monitoring tool 108 in accordance with the disclosed embodiments. Performance-monitoring tool 108 starts with a database containing performance data 110 for a set of entities (e.g., virtual machines and hosts), where database 110 was previously generated as described above with reference to FIG. 4A.

[0092] First, the system receives a number of selections from a user, including: an entity type (e.g., virtual machine or host), a performance metric (e.g., CPU utilization) and a time range (e.g., the past 24 hours) (step 412). Next, the system accesses database 110 and retrieves values for the selected performance metric, entity type and time range (step 414). For example, if database 110 includes fields for performance metric, entity type, entity identifier, and measurement time, the retrieval process can involve executing a query against database 110. This query retrieves values for the selected metric (and associated entity identifiers) that match the specific entity type and time range. In one embodiment, database 110 is optimized to quickly return metric values for a specific time range. For example, database 110 can store events for the performance metric in a time-series index, wherein events are stored and can be accessed based on their timestamps.

[0093] Next, the system uses the obtained metric values to determine performance states for the associated entities. This can be accomplished by comparing the metric values against a set of threshold values for the performance states (step 416).

[0094] The system also retrieves the architectural information specifying the many-to-one relationships between the entities at the time the performance metric values were gathered (step 417).

[0095] The system then generates the proactive monitoring tree based on the determined performance states. This process can involve starting from the leaf nodes and constructing successive levels of parent nodes from child nodes (step 418). For example, the system can start with the leaf nodes, wherein each leaf node is associated with a performance state for its associated entity (e.g., virtual machine or host system). Next, the performance state for each parent node can be determined based on the worst-case performance state for each of its child nodes. This process is repeated until the root node of the tree is reached.

[0096] Finally, the system displays the proactive monitoring tree to the user and allows the user to navigate the proactive monitoring tree to analyze performance problems (step 420).

Proactive Monitoring Tree Features

[0097] In some embodiments, proactive monitoring tree 106 provides a number of features, including: (1) severity state sorting, (2) a state distribution ring, (3) a distribution stream chart with branch overlay, and (4) a pin board that displays detail panels for nodes. These features are described in more detail below.

Severity State Sorting

[0098] In some embodiments, branches of the proactive monitoring tree are sorted based a count of the most severe nodes in that branch. Hence, the branch with the highest number of the highest severity leaf nodes will be displayed on the far left-hand side of the tree. For example, in a system that associates entities with a critical state, a warning state, a normal state and an unknown state, the branch with the highest number of leaf nodes in the critical state will be displayed at the far left-hand side of the tree. If there are no leaf nodes in the critical state, the branch with the highest number of leaf nodes in the warning state will displayed at the far left-hand side of the tree.

[0099] This sorting process is performed top down. Hence, branches of the root node of the tree are first sorted based on the highest count of highest severity leaf nodes. Then, branches of each branch node are sorted in the same way. Hence, branches with the highest number of high severity leaf nodes are always displayed on the far left-hand side of the tree.

[0100] For example, in FIG. 5A, the tree 500 comprises nodes 514-528, wherein node 514 is the root node. The most severe branch node 515 under root node 514 is displayed on the far left-hand side of root node 514. This means that branch node 515 is associated with the most leaf nodes having the highest severity state. Similarly, leaf node 519 has the highest severity state of all leaf nodes under branch node 515. Sorting the branches in this way enables a user to easily determine which branches in the tree are experiencing the most performance problems.

[0101] FIG. 5B presents a flowchart illustrating how tree nodes are displayed in sorted order in accordance with the disclosed embodiments. During operation, the system first determines performance states for a plurality of entities that comprise the computing environment (step 532). This can involve first determining values for a performance metric of each of the entities and then comparing the determined values against thresholds to determine the performance states for the entities. Next, the system displays the computing environment as a tree with nodes representing the plurality of entities and edges representing parent-child relationships between the plurality of entities (step 534). While displaying the tree, the system displays the child nodes for each parent in sorted order based on values of the performance states associated with the child nodes (step 536).

State Distribution Ring

[0102] The state distribution ring can be implemented as a ring surrounding parent nodes of the tree. This ring provides an indicator of the distribution of performance states for the leaf nodes that fall under the parent node in the tree. More specifically, the ring is divided into visually distinct sections associated with different performance states, wherein the visually distinct sections are sized proportionately with the determined counts of leaf nodes with the associated performance states. Note that the visually distinct sections can be displayed using different colors or different patterns. In this way, the user can get a sense of the proportion of leaf nodes in a particular performance state for a particular branch of the hierarchy. This can help a user in determining which nodes they might be interested in clicking on to investigate. A node with a higher proportion of leaf nodes in a more severe state is probably more interesting to investigate.

[0103] For example, FIG. 6A illustrates a state distribution ring 630, which surrounds a node for a cluster (CL) associated with a number of descendant nodes 635, including branch nodes and leaf nodes. State distribution ring 630 is divided into visually distinct sections 631-634 which are sized proportionately with the counts of leaf nodes with the associated performance states.

[0104] More specifically, FIG. 6B presents a flowchart illustrating how a state distribution ring is displayed in accordance with the disclosed embodiments. During operation, the system determines performance states for a plurality of entities that comprise the computing environment based on values of a performance metric for the entities (step 662). In some embodiments, the system determines the performance states for the plurality of entities by comparing the values of the performance metric for the plurality of entities against one or more state-specific threshold values to determine the associated performance states for the plurality of entities.

[0105] Next, the system displays the computing environment as a tree comprising nodes representing the plurality of entities and edges representing parent-child relationships between the plurality of entities (step 664). For each leaf node in the tree, the system displays an indicator for a performance state associated with the leaf node (step 666). For each parent node in the tree, the system determines counts of one or more performance states for descendants of the parent node in the tree and then displays a graphical representation of the determined counts while displaying the parent node. In some embodiments, displaying this graphical representation involves displaying a circular ring comprising visually distinct sections associated with different performance states, wherein the visually distinct sections are sized proportionately with the determined counts for the associated performance states (step 668).

Distribution Stream Chart with Branch Overlay

[0106] In some embodiments, when a user hovers a cursor over a node in the tree, a special distribution stream chart appears as is illustrated in FIG. 7A. In the foreground, this chart displays a line for the selected node 740 that represents the average values for the selected metric for the node. If the node is a leaf node, the line represents the average for the leaf node. If the selected node is a parent node, the line represents the average values of the metric over all leaf nodes under the parent node. (Alternatively, instead of displaying a line for the average value of the leaf nodes, the system can allow the user to scroll through lines for each of the leaf nodes under the parent.)

[0107] The background of the chart represents the distribution of the selected metric's values over a reference set of nodes in the tree. This reference set of nodes can include the entire tree or merely a subset of nodes in the tree. This distribution is represented by a number of shaded regions. The interior, cross-hatched region represents the middle 50% of the data. This interior region is therefore defined as having edges representing the 25^thpercentile of the data and the 75^thpercentile of the data. (Note that this is analogous to the box portion of a box-and-whisker plot.) The lower exterior, darker-shaded region has a lower bound of the minimum value of the data, the 0^thpercentile if you will, and an upper bound at the 25^thpercentile line. The upper exterior region is upper-bounded by the 95^thpercentile line and lower-bounded by the 75^thpercentile line. Note that the upper bound in a box-and-whisker plot is typically the maximum value of the data. However, this can be greatly affected by outliers; hence, the illustrated embodiment limits the upper region to the 95^thpercentile of the data. Note that the boundaries in the distribution are not meant to be limited to the 0^th, 25^th, 75^thand 95^thpercentiles. In general, the maximum value, other percentile values and other measures, such as standard deviations, can be used.

[0108] In a variation on this embodiment, if the selected node is a parent node, instead of displaying the average value of the metric over all leaf nodes under the parent, the system can display a foreground distribution for the leaf nodes under the parent. This foreground distribution is overlaid on a background distribution for the selected metric over all nodes in the tree. (This overlaying process may involve using different colors or different levels of transparency and translucency.)

[0109] The value of this chart is that a user can see how performance for a particular branch of the hierarchy compares to the entirety of the tree. This enables the user to make inferences based on the behavior of a particular branch deviating from the distribution of the computing environment as a whole, and these inferences can help the user optimize performance of the computing environment.

[0110] More specifically, FIG. 7B presents a flowchart illustrating how the graph illustrated in FIG. 7A is generated in accordance with the disclosed embodiments. First, the system determines values for a performance metric for a plurality of entities that comprise the computing environment (step 772). Next, the system displays the computing environment as a tree comprising nodes representing the plurality of entities and edges representing parent-child relationships between the plurality of entities (step 774). Then, for a selected node in the tree, the system displays a chart with a line illustrating how a value of the performance metric for the selected node varies over time against a background illustrating how a distribution of the performance metric for a reference set of nodes in the tree varies over time (step 776). Note that if the selected node is a parent node, the value of the performance metric for the selected node is an average value for the performance metric across descendant nodes of the selected node in the tree. Moreover, the background includes a stream chart comprising regions associated with percentile ranges, wherein borders between the regions represent one or more of the following: a minimum value line, a 25^thpercentile line, a 50^thpercentile line, a 75^thpercentile line, a 95^thpercentile line, a maximum value line, and a line associated with a standard deviation.

Node Pinning

[0111] FIG. 8A illustrates how a performance state of a node in the tree can be “pinned” onto a pin board to facilitate comparisons with the states of other nodes in the tree in accordance with the disclosed embodiments. For example, when a user hovers a cursor over a node (say node 814), a pin icon is displayed in a tooltip. If the user clicks on the pin icon, a detail panel for the node is displayed on a pin board 850 located on the far right-hand side of the screen. Note that the state of this detail panel is frozen at the time of pinning. This means that the user can manipulate the tree, for example by changing the performance metric, time range or entity type, and this pinned detail panel remains unchanged. The user can then pin another node, or can pin the same node for a different metric to pin board 850. This enables the user to compare different performance metrics simultaneously. An exemplary node detail panel 841 can include configuration information 842 for the entity associated with the node, and can also display a graph 843 for the selected metric, such as a graph of CPU utilization over time.

[0112] The content of the pinned detail panel 841 can vary as a function of the type of node pinned. For example, the detail panel for a host system can show information specifying that host's manufacturer and the number of network interface cards and processors, while a detail panel for a virtual machine can show information associated with provisioning of the virtual machine, the guest OS running on it, etc. As mentioned above, the second portion of the pinned detail panel can display a graph for a selected metric. However, if the pinned node is a branch node, instead of showing a distribution stream chart for the node, the system can display a table with the top 50 most critical children in the branch, wherein each entry in the table includes an indicator of the performance state of the node, the name of the node, and a sparkline for the selected metric value for that node over the selected time range.

[0113] FIG. 8B presents a flowchart illustrating how a pin board is displayed in accordance with the disclosed embodiments. During operation, the system determines performance states for a plurality of entities that comprise the computing environment based on values of a performance metric for the entities (step 882). Next, the system displays the computing environment as a tree comprising nodes representing the plurality of entities and edges representing parent-child relationships between the plurality of entities (step 884). Then, in response to the user selecting a first node in the tree to be pinned, the system displays a first detail panel for the first node, wherein the first detail panel displays state information for the first node, wherein the state information is frozen at the time of pinning (step 886). Next, in response to the user selecting a second node in the tree to be pinned, the system displays a second detail panel for the second node, wherein the second detail panel displays state information for the second node, wherein the state information is frozen at the time of pinning (step 888). Note that displaying the first detail panel concurrently with the second detail panel facilitates comparing state information between the first and second nodes.

Monitoring Tree for a Virtual Machine Environment

[0114] We next present some exemplary screen shots for a proactive monitoring tree representing a virtual machine environment. This monitoring tree includes nodes for various entities in the virtual machine environment. More specifically, these entities include: a physical host system (HS), a virtual machine (VM); a cluster comprising one or more host systems (CL); and a virtual center comprising one or more clusters (VC). In some embodiments, the virtual machines are automatically load-balanced among hosts in a cluster, wherein virtual machines assigned to stand-alone hosts remain on the stand-alone hosts permanently.

[0115] Before the proactive monitoring tree can be displayed, the user selects a number of parameters for the tree as is illustrated in FIG. 9A. The illustrated parameters include: (1) an entity type of “virtual machine;” (2) a performance type of “CPU;” (3) an associated metric of “average CPU usage;” and (4) a time range of “last 24 hours.” This causes the system to aggregate the selected performance metric over the selected time range for all matching entities of the selected entity type in the virtual machine environment. For example, this can involve taking an average (or some other aggregation) of performance metric values for each entity over the selected time range. Moreover, in a virtual-machine environment, the selected entity type can be a “virtual machine” or a “host system,” and the selection changes whether the leaf nodes represent virtual machines or host systems. This is significant, because the system gathers direct performance measurements for the leaf nodes whose states bubble up to parent nodes and are displayed in the parent nodes' associated rings. Next, the system compares the aggregated values against a set of user-defined thresholds to determine “performance states” for the entities, wherein the performance states are displayed using different colors. More specifically, the performance states for a specific entity can be: a critical state (red), a warning state (orange), a normal state (green), or an unknown/offline state (gray).

[0116] The system then displays a proactive monitoring tree for the selected performance metric as is illustrated in FIG. 9B. The highest-level node in the tree illustrated in FIG. 9B is a cluster node 901, which is colored red to indicate that the ultimate children (leaf nodes) of cluster node 901 contain at least one node in the critical state. Cluster node 901 has a number of child nodes representing physical host systems, including: node 902, colored red to indicate that at least one of its child nodes is red; node 903, colored orange to indicate that its worst child node is orange and none of its child nodes are red; and node 904, colored green to indicate that its worst child node is green and none of its child nodes are red or orange. Note that when the user clicks on a node, the node expands to reveal its child nodes at a lower level of the tree.

[0117] For each parent node in the tree, the system computes counts of the performance states for all of the leaf nodes under the parent node. This can involve maintaining an array for each node containing counts of states of the leaf nodes associated with each node or branch in the tree [red, orange, green, gray]. In the case of a leaf node, the array for a leaf node includes a single “1” value for the performance state of the leaf node. The array for a parent node is computed by adding the arrays for all immediate descendants of the parent node.

[0118] Around each node in the tree, the system displays a state distribution ring comprising visually distinct sections associated with different performance states, wherein the visually distinct sections are sized proportionately with the determined counts for the associated performance states. For example, in FIG. 9C, node 905 is the root node of a tree, which is surrounded by a ring with colored sections that represent the proportions of states of the leaf nodes in the tree. Note that 15-20% of this ring is red, which indicates that 15-20% of the leaf nodes in the tree are red. Nodes 907-908 are surrounded by rings that are completely green, which indicates that all of their descendant nodes are green. Node 906 actually has a higher proportion of red nodes than its siblings or parent. However, it does not have the largest number of red nodes of its siblings and hence does not appear on the far left-hand side of the tree in the sorted ordering of the siblings. Nevertheless, node 906 may be interesting to examine because of its higher proportion of red nodes.

[0119] As mentioned above, the nodes of the proactive monitoring tree are organized in sorted order based on the states of the nodes. This sorting can be accomplished as follows. We first look at virtual centers (if there are more than one), and the virtual center with the most reds is displayed on the far left-hand side of the display. Then, within that virtual center, we look at the clusters, and the cluster with the most reds in its branch goes on the far left. Then, within that cluster, we go to the host system level, and the host system with the most reds within that cluster goes on the far left. Finally, within the leaves we sort the leaves red to orange to green to gray. If a branch has no reds, it is always sorted after a node with at least one red, and then its count of oranges is compared against the other siblings with no reds; if a branch has no oranges, it always falls behind anything with at least one orange. This sorting system works in conjunction with the rings mentioned above to allow the user to quickly determine where to look for performance problems. The branches with the most reds and the highest proportion of reds are typically the most interesting to investigate. For example, the sorted ordering for an exemplary set of sibling nodes is illustrated in FIG. 9D. The sibling with the most reds appears on the far left. The sibling with no reds appears to the far right and all the nodes in between are sorted based on the number of reds they represent.

[0120] FIG. 9E presents an exemplary distribution stream chart with a branch overlay. In this chart, the white line illustrates an average value for the selected branch or entity, the middle light-shaded region represents the middle 50% of the entities in the tree, the lower dark-shaded region represents the lower 25% of the entities, and the upper dark-shaded region represents the 20% of the entities below the top 5% of the entities.

[0121] Finally, FIG. 9F illustrates an exemplary pin board 909 with two detail panels. The lower detail panel represents a leaf node. It displays various configuration information for the leaf node, such as the power state and number of CPUs. It also displays a graph for the selected metric, which is overlaid on a distribution for the selected metric across all nodes in the tree. In contrast, the upper detail panel represents a parent node. This parent panel displays configuration information, such as the average effective CPU frequency in megahertz and the average effective memory, for all leaf nodes under the parent node. It also displays a sparkline for the selected performance metric for each of the leaf nodes under the parent node. These sparklines illustrate how the selected performance metric varies over time.

Processing of Performance Data and Raw Log Data from an Information Technology Environment Using Search Criterion Input Via a Graphical User Interface

[0122] The ensuing description provides preferred exemplary embodiment(s) only and is not intended to limit the scope, applicability or configuration of the disclosure. Rather, the ensuing description of the preferred exemplary embodiment(s) will provide those skilled in the art with an enabling description for implementing a preferred exemplary embodiment. It is understood that various changes can be made in the function and arrangement of elements without departing from the spirit and scope as set forth in the appended claims.

[0123] Each of the following U.S. Patent applications is incorporated by reference herein in its entirety: U.S. patent application Ser. No. 13/874,423; U.S. patent application Ser. No. 13/874,434; U.S. patent application Ser. No. 13/874,441; U.S. patent application Ser. No. 13/874,448; U.S. patent application Ser. No. 14/167,316; and U.S. patent application Ser. No. 14/801,721. Additionally, each of U.S. provisional patent applications Nos. 61/883,869 and 61/900,700 is incorporated by reference herein in its entirety.

[0124] Referring first to FIG. 10, a block diagram of an embodiment of a virtual-machine interaction system 1000 is shown. An architecture provider 1005, user 1015 and/or performance reviewer 1025 can interact with a task scheduler 1040 and/or virtual-machine (VM) monitoring system 1055 via respective devices 1010, 1020 and/or 1030 and a network 1035, such as the Internet, a wide area network (WAN), local area network (LAN) or other backbone. In some embodiments, VM monitoring system 1055 is made available to one or more of architecture provider 1005, user 1015 and/or performance reviewer 1025 via an app (that can be downloaded to and executed on a respective portable electronic device) or a website. It will be understood that, although only one of each of an architecture provider 1005, a user 1015 and/or a performance reviewer 1025 is shown, system 1000 can include multiple architecture providers 1005, users 1015 and/or performance reviewers 1025.

[0125] Architecture-provider device 1010, user device 1020 and/or reviewer device 1030 can each be a single electronic device, such as a hand-held electronic device (e.g., a smartphone). It will be understood that architecture-provider device 1010, user device 1020 and/or reviewer device 1030 can also include a system that includes multiple devices and/or components. The device(s) 1010, 1020 and/or 1030 can comprise a computer, such as the desktop computer, a laptop computer or a tablet. In some instances, a provider 1005, user 1015 and/or performance reviewer 1025 uses different devices at different times to interact with task scheduler 1040 and/or VM monitoring system 1055.

[0126] An architecture provider 1005 can communicate with VM monitoring system 1055 to provide input defining at least part of an architecture that sets forth a structure of a Hypervisor. The input can include identification of components of the Hypervisor, such as VMs, hosts or host clusters. The input can also include identification of relationships between system components, which can include parent-child relationships. For example, a host can be identified as being a parent of five specific VMs. In some instances, identifying the relationships includes defining a hierarchy.

[0127] Architecture provider 1005 can identify characteristics of particular hypervisor components, such as a CPU count, CPU type, memory size, operating system, name, an address, an identifier, a physical location and/or available software. The architecture can also identify restrictions and/or rules applicable to VM-system components. For example, select resources may be reserved such that they can only be assigned high-priority tasks or tasks from particular users. As another example, architecture provider 1005 can identify that particular resources are only to be assigned tasks of a particular type or that all tasks of a particular type are to be assigned to a particular resource.

[0128] The input can include text entered into a field, an uploaded file, arrangement and/or selection of visual icons, etc. Defining the architecture can include defining a new structure or modifying an existing structure.

[0129] Based on the architecture, a task scheduler 1040 can utilize a set of hosts 1045 and/or VMs 1050 to complete computational tasks. In some instances, task scheduler 1040 assigns tasks to a host 1045 and/or VM 1050 (e.g., the host providing computing resources that support the VM operation and the VM being an independent instance of an operating system (“OS”) and software). The VM can then, e.g., store data, perform processing and/or generate data. As described in further detail herein, task assignments can include collecting data (e.g., log files, machine data, or unstructured data) from one or more sources, segmenting the data into discrete data events, time stamping the data events, storing data events into a time-series data store, retrieving particular data events (e.g., responsive to a query), and/or extracting values of fields from data events or otherwise processing events. Task scheduler 1040 can monitor loads on various system components and adjust assignments accordingly. Further, the assignments can be identified to be in accordance with applicable rules and/or restrictions.

[0130] A VM monitoring system 1055 can monitor applicable architecture, task assignments, task-performance characteristics and resource states. For example, VM monitoring system 1055 can monitor: task completion time, a percentage of assigned tasks that were completed, a resource power state, a CPU usage, a memory usage and/or network usage. VM monitoring system 1055 can use these monitored performance metrics to determine performance indicators (as described further below) to present to a reviewer 1025. Reviewer 1025 can interact with an interface provided by VM monitoring system 1055 to control which performance indicators are presented. For example, reviewer 1025 can specify a type of performance indicator (e.g., by defining a set of performance states) or can specify specific components, component types or levels for which the indicators are presented.

[0131] As used in this disclosure, a “performance metric” may refer to a category of some type of performance being measured or tracked for a component (e.g., a virtual center, cluster, host, or virtual machine) in an IT environment, and a “performance measurement” may refer to a particular measurement or determination of performance at a particular time for that performance metric.

[0132] Performance metrics may include a CPU performance metric, a memory performance metric, a summary performance metric, a performance metric based on a max CPU usage, a performance metric based on a max memory usage, a performance metric based on a ballooned memory, a performance metric based on a swapped memory, a performance metric based on an average memory usage percentage, a performance metric based on the total amount of memory that is reclaimed from all of the VMs on a host, a performance metric based on the total amount of memory that is being swapped from all of the VMs on a host, a performance metric that changes state based on the remaining disk space on a data store, a performance metric that changes state based on how much space is overprovisioned (i.e., negative numbers are a representation of an under-provisioned data store), a performance metric based on a VM's average CPU usage in percent, a performance metric based on a VM's average memory usage in percent, a performance metric based on a VM's state waiting for CPU time, a performance metric based on a VM's memory that is actively in use, a performance metric based on a VM's memory saved by memory sharing, a performance metric based on a VM's memory used to power the VM, a performance metric based on physical memory that is mapped to a VM (i.e., memory not including overhead memory), a performance metric based on an amount of physical memory that is being reclaimed by a host through a ballooning driver, a performance metric based on memory that is being read by a VM from a host's swap file, a performance metric based on an amount of memory a VM has had to write to a swap file, a performance metric based on an amount of memory from a VM that has been swapped by a host. This is a host swapping and is always a sign of the host being in stress, a performance metric based on an average read rate to virtual disks attached, a performance metric based on an average write rate to virtual disks attached, a performance metric based on an average input/output (I/O) rate to a virtual disk, a performance metric based on a number of times a VM wrote to its virtual disk, a performance metric based on a number of times a VM read from its virtual disk, a performance metric based on a time taken to process a SCSI command by a VM, a performance metric based on a number of commands that were aborted on a VM, a performance metric based on a number of SCSI-bus reset commands that were issued, a performance metric based on an average amount of bytes read across a VM's virtual network interface card (NIC), a performance metric based on an average amount of bytes broadcasted across a VM's virtual NIC, a performance metric based on a combined broadcast and received rates across all virtual NIC instances, a performance metric based on an average usage of a host's CPU in percent, a performance metric based on an amount of time a host waited for CPU cycles, a performance metric based on an average usage of a host's CPU in percent, a performance metric based on an average amount of all memory in active state by all VMs and Virtual Provisioning X Daemon services, a performance metric based on an average amount of memory being consumed by a host, which includes all VMs and an overhead of a VM kernel, a performance metric based on an average overhead of all VMs and an overhead of a vSphere, a performance metric based on an average memory granted to all VMs and vSphere, a performance metric based on a sum of all VM's memory control values for all powered-on VM, a performance metric based on a combined sum of all swap-in values for all powered-on VMs, a performance metric based on a combined sum of all swap-off values for all powered-on VMs, a performance metric based on an amount of memory from all VMs that has been swapped by a host, a performance metric based on an average amount of bytes read from each logical unit number (LUN) on a host, a performance metric based on an average amount of bytes written to each LUN on a host, a performance metric based on an average aggregated disk I/O for all VMs running on a host, a performance metric based on a total number of writes to a target LUN, a performance metric based on a total number of reads from a target LUN, a performance metric based on a sum of kernel requests to a device, a performance metric based on a sum of kernel requests spent in a queue state, a performance metric based on a number of commands that were aborted on a host, a performance metric based on a number of Small Computers System Interface (SCSI) bus reset commands that were issued, a performance metric based on an average amount of data received across a host's physical adapter, a performance metric based on an average amount of data broadcasted across a host's physical adapter, a performance metric based on a combined broadcast and received rates across all physical NIC instances, a performance metric based on an amount of CPU resources a VM would use if there were no CPU contention or CPU limit, a performance metric based on an aggregate amount of CPU resources all VMs would use if there were no CPU contention or CPU limit, a performance metric based on a CPU usage, which is an amount of actively used virtual CPUs, a performance metric based on a CPU usage, which is an aggregate of CPU usage across all VMs on a host, and/or a performance metric based on an average CPU usage percentage.

[0133] Included below is a non-exhaustive list of known performance metrics that may be monitored by default by VM monitoring system 155. PercentHighCPUVm, PercentHighMemVm, PercentHighSumRdyVm, VMInvCpuMaxUsg, VMInvMemMaxUsg, PercentHighBalloonHosts, PercentHighSwapHosts, PercentHighCPUHosts, BalloonedMemory_MB, swappedMemory_MB, RemainingCapacity_GB, Overprovisioned_GB, p_average_cpu_usage_percent, p_average_mem_usage_percent, p_summation_cpu_ready_millisecond, p_average_mem_active_kiloBytes, p_average_mem_consumed_kiloBytes, p_average_mem_overhead_kiloBytes, p_average_mem_granted_kiloBytes, p_average_mem_vmmemctl_kiloBytes, p_average_mem_swapin_kiloBytes, p_average_mem_swapout_kiloBytes, p_average_mem_swapped_kiloBytes, p_average_disk_read_kiloBytesPerSecond, p_average_disk_write_kiloBytesPerSecond, p_average_disk_usage_kiloBytesPerSecond, p_summation_disk_numberWrite_number, p_summation_disk_numberRead_number, p_latest_disk_maxTotalLatency_millisecond, p_summation_disk_commandsAborted_number, p_summation_disk_bus Resets_number, p_average_net_received_kiloBytesPerSecond, p_average_net_transmitted_kiloBytesPerSecond, p_average_net_usage_kiloBytesPerSecond, p_average_cpu_usage_percent, p_summation_cpu_ready_millisecond, p_average_mem_usage_percent, p_average_mem_active_kiloBytes, p_average_mem_consumed_kiloBytes, p_average_mem_overhead_kiloBytes, p_average_mem_granted_kiloBytes, p_average_mem_vmmemctl_kiloBytes, p_average_mem_swapin_kiloBytes, p_average_mem_swapout_kiloBytes, p_average_mem_llSwapUsed_kiloBytes, p_average_disk_numberReadAveraged_number, p_average_disk_numberWriteAveraged_number, p_average_disk_usage_kiloBytesPerSecond, p_summation_disk_numberWrite_number, p_summation_disk_numberRead_number, p_latest_disk_maxTotalLatency_millisecond, p_average_disk_queueLatency_millisecond, p_summation_disk_commandsAborted_number, p_summation_disk_busResets_number, p_average_net_received_kiloBytesPerSecond, p_average_net_transmitted_kiloBytesPerSecond, p_average_net_usage_kiloBytesPerSecond, p_average_cpu_demand_megaHertz, p_average_cpu_demand_megaHertz, p_average_cpu_usagemhz_megaHertz, p_average_cpu_usagemhz_megaHertz and/or AvgUsg_pctPercentHighCPUVm, PercentHighMemVm, PercentHighSumRdyVm, VMInvCpuMaxUsg, VMInvMemMaxUsg, PercentHighBalloonHosts, PercentHighSwapHosts, PercentHighCPUHosts, BalloonedMemory_MB, swappedMemory_MB, RemainingCapacity_GB, Overprovisioned_GB, p_average_cpu_usage_percent, p_average_mem_usage_percent, p_summation_cpu_ready_millisecond, p_average_mem_active_kiloBytes, p_average_mem_consumed_kiloBytes, p_average_mem_overhead_kiloBytes, p_average_mem_granted_kiloBytes, p_average_mem_vmmemctl_kiloBytes, p_average_mem_swapin_kiloBytes, p_average_mem_swapout_kiloBytes, p_average_mem_swapped_kiloBytes, p_average_disk_read_kiloBytesPerSecond, p_average_disk_write_kiloBytesPerSecond, p_average_disk_usage_kiloBytesPerSecond, p_summation_disk_numberWrite_number, p_summation_disk_numberRead_number, p_latest_disk_maxTotalLatency_millisecond, p_summation_disk_commandsAborted_number, p_summation_disk_bus Resets_number, p_average_net_received_kiloBytesPerSecond, p_average_net_transmitted_kiloBytesPerSecond, p_average_net_usage_kiloBytesPerSecond, p_average_cpu_usage_percent, p_summation_cpu_ready_millisecond, p_average_mem_usage_percent, p_average_mem_active_kiloBytes, p_average_mem_consumed_kiloBytes, p_average_mem_overhead_kiloBytes, p_average_mem_granted_kiloBytes, p_average_mem_vmmemctl_kiloBytes, p_average_mem_swapin_kiloBytes, p_average_mem_swapout_kiloBytes, p_average_mem_llSwapUsed_kiloBytes, p_average_disk_numberReadAveraged_number, p_average_disk_numberWriteAveraged_number, p_average_disk_usage_kiloBytesPerSecond, p_summation_disk_numberWrite_number, p_summation_disk_numberRead_number, p_latest_disk_maxTotalLatency_millisecond, p_average_disk_queueLatency_millisecond, p_summation_disk_commandsAborted_number, p_summation_disk_busResets_number, p_average_net_received_kiloBytesPerSecond, p_average_net_transmitted_kiloBytesPerSecond, p_average_net_usage_kiloBytesPerSecond, p_average_cpu_demand_megaHertz, p_average_cpu_demand_megaHertz, p_average_cpu_usagemhz_megaHertz, p_average_cpu_usagemhz_megaHertz and/or AvgUsg_pct.

[0134] Of course any of the above listed performance metrics could also or alternatively be monitored and reported in any of: bytes, megaBytes, gigaBytes and/or any other byte or memory amount. Any performance metrics could also or alternatively be monitored and reported in any of: hertz, megaHertz, gigaHertz and/or any hertz amount. Moreover, any of the performance metrics disclosed herein may be monitored and reported in any of percentage, relative, and/or absolute values.

[0135] Other performance metrics that may be collected may include any type of cluster performance metrics, such as: latest_clusterServices_cpufairness_number, average_clusterServices_effectivecpu_megaHertz, average_clusterServices_effectivemem_megaBytes, latest_clusterServices_failover_number and/or latest_clusterServices_memfairness_number. Of course any performance metrics could also be monitored and reported in any of: bytes, megaBytes, gigaBytes and/or any byte amount. Any performance metrics could also be in hertz, megaHertz, gigaHertz and/or any hertz amount.

[0136] CPU performance metrics that may be collected may include any of: average_cpu_capacity.contention_percent, average_cpu_capacity.demand_megaHertz, average_cpu_capacity.entitlement_megaHertz, average_cpu_capacity.provisioned_megaHertz, average_cpu_capacity.usage_megaHertz, none_cpu_coreUtilization_percent, average_cpu_coreUtilization_percent, maximum_cpu_coreUtilization_percent, minimum_cpu_coreUtilization_percent, average_cpu_corecount.contention_percent, average_cpu_corecount.provisioned_number, average_cpu_corecount.usage_number, summation_cpu_costop_millisecond, latest_cpu_cpuentitlement_megaHertz, average_cpu_demand_megaHertz, latest_cpu_entitlement_megaHertz, summation_cpu_idle_millisecond, average_cpu_latency_percent, summation_cpu_maxlimited_millisecond, summation_cpu_overlap_millisecond, summation_cpu_ready_millisecond, average_cpu_reservedCapacity_megaHertz, summation_cpu_run_millisecond, summation_cpu_swapwait_millisecond, summation_cpu_system_millisecond, average_cpu_totalCapacity_megaHertz, average_cpu_totalmhz_megaHertz, none_cpu_usage_percent, average_cpu_usage_percent, minimum_cpu_usage_percent, maximum_cpu_usage_percent, none_cpu_usagemhz_megaHertz, average_cpu_usagemhz_megaHertz, minimum_cpu_usagemhz_megaHertz, maximum_cpu_usagemhz_megaHertz, summation_cpu_used_millisecond, none_cpu_utilization_percent, average_cpu_utilization_percent, maximum_cpu_utilization_percent, minimum_cpu_utilization_percent and/or summation_cpu_wait_millisecond. Of course any performance metrics could also be monitored and reported in any of: hertz, megaHertz, gigaHertz and/or any hertz amount.

[0137] Database and data store performance metrics that may be collected may include any of: summation_datastore_busResets_number, summation_datastore_commandsAborted_number, average_datastore_datastorelops_number, latest_datastore_datastoreMaxQueueDepth_number, latest_datastore_datastoreNormalReadLatency_number, latest_datastore_datastoreNormalWriteLatency_number, latest_datastore_datastoreReadBytes_number, latest_datastore_datastoreReadlops_number, latest_datastore_datastoreReadLoadMetric_number, latest_datastore_datastoreRead010_number, latest_datastore_datastoreVMObseryedLatency_number, latest_datastore_datastoreWriteBytes_number, latest_datastore_datastoreWritelops_number, latest_datastore_datastoreWriteLoadMetric_number, latest_datastore_datastoreWrite010_number, latest_datastore_maxTotalLatency_millisecond, average_datastore_numberReadAveraged_number, average_datastore_numberWriteAveraged_number, average_datastore_read_kiloBytesPerSecond, average_datastore_sioc ActiveTime Percentage_percent, average_datastore_sizeNormalizedDatastoreLatency_microsecond, average_datastore_throughput.contention_millisecond, average_datastore_throughput. usage_kiloBytesPerSecond, average_datastore_total Read Latency_millisecond, average_datastore_totalWriteLatency_millisecond and/or average_datastore_write_kiloBytesPerSecond. Of course any performance metrics could also be monitored and reported in any of: bytes, megaBytes, gigaBytes and/or any byte amount.

[0138] Disk performance metrics that may be collected may include any of: summation_disk_busResets_number, latest_disk_capacity_kiloBytes, average_disk_capacity.contention_percent, average_disk_capacity.proyisioned_kiloBytes, average_disk_capacity.usage_kiloBytes, summation_disk_commands_number, summation_disk_commandsAborted_number, average_disk_commandsAveraged_number, latest_disk_deltaused_kiloBytes, average_disk_deviceLatency_millisecond, average_disk_deviceReadLatency_millisecond, average_disk_deviceWriteLatency_millisecond, average_disk_kernelLatency_millisecond, average_disk_kernelReadLatency_millisecond, average_disk_kernelWriteLatency_millisecond, average_disk_maxQueueDepth_number, latest_disk_maxTotalLatency_millisecond, summation_disk_numberRead_number, average_disk_numberReadAveraged_number, summation_disk_numberWrite_number, average_disk_numberWriteAveraged_number, latest_disk_provisioned_kiloBytes, average_disk_queueLatency_millisecond, average_disk_queueReadLatency_millisecond, average_disk_queueWriteLatency_millisecond, average_disk_read_kiloBytesPerSecond, average_disk_scsi ReservationCnflctsPct_percent, summation_disk_scsi ReservationConflicts_number, average_disk_throughput.contention_millisecond, average_disk_throughput.usage_kiloBytesPerSecond, average_disk_totalLatency_millisecond, average_disk_totalReadLatency_millisecond, average_disk_totalWriteLatency_millisecond, latest_disk_unshared_kiloBytes, none_disk_usage_kiloBytesPerSecond, average_disk_usage_kiloBytesPerSecond, minimum_disk_usage_kiloBytesPerSecond, maximum_disk_usage_kiloBytesPerSecond, latest_disk_used_kiloBytes and/or average_disk_write_kiloBytesPerSecond. Of course any performance metrics could also be monitored and reported in any of: bytes, megaBytes, gigaBytes and/or any byte amount.

[0139] Host-based replication (“hbr”) performance metrics that may be collected may include any of: average_hbr_hbrNetRx_kiloBytesPerSecond, average_hbr_hbrNetTx_kiloBytesPerSecond and/or average_hbr_hbrNumVms_number. Of course any performance metrics could also be monitored and reported in any of: bytes, megaBytes, gigaBytes and/or any byte amount.

[0140] Management Agent performance metrics that may be collected may include any of: average_managementAgent_cpuUsage_megaHertz, average_managementAgent_memUsed_kiloBytes, average_managementAgent_swapin_kiloBytesPerSecond, average_managementAgent_swapOut_kiloBytesPerSecond and/or average_managementAgent_swapUsed_kiloBytes. Of course any performance metrics could also be monitored and reported in any of: bytes, megaBytes, gigaBytes and/or any byte amount.

[0141] Memory performance metrics that may be collected may include any of: none_mem_active_kiloBytes, average_mem_active_kiloBytes, minimum_mem_active_kiloBytes, maximum_mem_active_kiloBytes, average_mem_activewrite_kiloBytes, average_mem_capacity.contention_percent, average_mem_capacity.entitlement_kiloBytes, average_mem_capacity.provisioned_kiloBytes, average_mem_capacity.usable_kiloBytes, average_mem_capacity.usage_kiloBytes, average_mem_capacity.usage. userworld_kilo Bytes, average_mem_capacity.usagemm_kiloBytes, average_mem_capacity.usagemmOvrhd_kiloBytes, average_mem_capacity.usagemmkamhd_kiloBytes, average_mem_compressed_kiloBytes, average_mem_compression Rate_kiloBytesPerSecond, none_mem_consumed_kiloBytes, average_mem_consumed_kiloBytes, minimum_mem_consumed_kiloBytes, maximum_mem_consumed_kiloBytes, average_mem_consumed.userworlds_kiloBytes, average_mem_consumed.vms_kiloBytes, average_mem_decompression Rate_kiloBytesPerSecond, average_mem_entitlement_kiloBytes, none_mem_granted_kiloBytes, average_mem_granted_kiloBytes, minimum_mem_granted_kiloBytes, maximum_mem_granted_kiloBytes, none_mem_heap_kiloBytes, average_mem_heap_kiloBytes, minimum_mem_heap_kiloBytes, maximum_mem_heap_kiloBytes, none_mem_heapfree_kiloBytes, average_mem_heapfree_kiloBytes, minimum_mem_heapfree_kiloBytes, maximum_mem_heapfree_kiloBytes, average_mem_latency_percent, none_mem_11Swapin_kiloBytes, average_mem_11Swapin_kiloBytes, maximum_mem_11Swapin_kiloBytes, minimum_mem_11Swapin_kiloBytes, average_mem_11SwapInRate_kiloBytesPerSecond, none_mem_IISwapOut_kiloBytes, average_mem_IISwapOut_kiloBytes, maximum_mem_IISwapOut_kiloBytes, minimum_mem_IISwapOut_kiloBytes, average_mem_11SwapOutRate_kiloBytesPerSecond, none_mem_IISwapUsed_kiloBytes, average_mem_IISwapUsed_kiloBytes, maximum_mem_IISwapUsed_kiloBytes, minimum_mem_IISwapUsed_kiloBytes, average_mem_lowfreethreshold_kiloBytes, latest_mem_mementitlement_megaBytes, none_mem_overhead_kiloBytes, average_mem_overhead_kiloBytes, minimum_mem_overhead_kiloBytes, maximum_mem_overhead_kiloBytes, average_mem_overheadMax_kiloBytes, average_mem_overheadTouched_kiloBytes, average_mem_reservedCapacity_megaBytes, average_mem_reservedCapacity.userworld_kiloBytes, average_mem_reservedCapacity.vm_kiloBytes, average_mem_reservedCapacity.vmOvhd_kiloBytes, average_mem_reservedCapacity.vmkOvrhd_kiloBytes, average_mem_reservedCapacityPct_percent, none_mem_shared_kiloBytes, average_mem_shared_kiloBytes, minimum_mem_shared_kiloBytes, maximum_mem_shared_kiloBytes, none_mem_sharedcommon_kiloBytes, average_mem_sharedcommon_kiloBytes, minimum_mem_sharedcommon_kiloBytes, maximum_mem_sharedcommon_kiloBytes, latest_mem_state_number, none_mem_swapin_kiloBytes, average_mem_swapin_kiloBytes, minimum_mem_swapin_kiloBytes, maximum_mem_swapin_kiloBytes, none_mem_swapOut_kiloBytes, average_mem_swapOut_kiloBytes, minimum_mem_swapOut_kiloBytes, maximum_mem_swapOut_kiloBytes, none_mem_swapin_kiloBytes, average_mem_swapin_kiloBytes, maximum_mem_swapin_kiloBytes, minimum_mem_swapin_kiloBytes, average_mem_swapinRate_kiloBytesPerSecond, none_mem_swapout_kiloBytes, average_mem_swapout_kiloBytes, maximum_mem_swapout_kiloBytes, minimum_mem_swapout_kiloBytes, average_mem_swapoutRate_kiloBytesPerSecond, none_mem_swapped_kiloBytes, average_mem_swapped_kiloBytes, minimum_mem_swapped_kiloBytes, maximum_mem_swapped_kiloBytes, none_mem_swaptarget_kiloBytes, average_mem_swaptarget_kiloBytes, minimum_mem_swaptarget_kiloBytes, maximum_mem_swaptarget_kiloBytes, none_mem_swapunreserved_kiloBytes, average_mem_swapunreserved_kiloBytes, minimum_mem_swapunreserved_kiloBytes, maximum_mem_swapunreserved_kiloBytes, none_mem_swapused_kiloBytes, average_mem_swapused_kiloBytes, minimum_mem_swapused_kiloBytes, maximum_mem_swapused_kiloBytes, none_mem_sysUsage_kiloBytes, average_mem_sysUsage_kiloBytes, maximum_mem_sys Usage_kiloBytes, minimum_mem_sysUsage_kiloBytes, average_mem_totalCapacity_megaBytes, average_mem_totalmb_megaBytes, none_mem_unreserved_kiloBytes, average_mem_unreserved_kiloBytes, minimum_mem_unreserved_kiloBytes, maximum_mem_unreserved_kiloBytes, none_mem_usage_percent, average_mem_usage_percent, minimum_mem_usage_percent, maximum_mem_usage_percent, none_mem_vmmemctl_kiloBytes, average_mem_vmmemctl_kiloBytes, minimum_mem_vmmemctl_kiloBytes, maximum_mem_vmmemctl_kiloBytes, none_mem_vmmemctItarget_kiloBytes, average_mem_vmmemctItarget_kiloBytes, minimum_mem_vmmemctItarget_kiloBytes, maximum_mem_vmmemctItarget_kiloBytes, none_mem_zero_kiloBytes, average_mem_zero_kiloBytes, minimum_mem_zero_kiloBytes, maximum_mem_zero_kiloBytes, latest_mem_zipSaved_kiloBytes and/or latest_mem_zipped_kiloBytes. Of course any performance metrics could also be monitored and reported in any of: bytes, megaBytes, gigaBytes and/or any byte amount.

[0142] Network performance metrics that may be collected may include any of: summation_net_broadcastRx_number, summation_net_broadcastTx_number, average_net_bytesRx_kiloBytesPerSecond, average_net_bytes Tx_kiloBytesPerSecond, summation_net_droppedRx_number, summation_net_droppedTx_number, summation_net_errorsRx_number, summation_net_errorsTx_number, summation_net_multicastRx_number, summation_net_multicastTx_number, summation_net_packetsRx_number, summation_net_packetsTx_number, average_net_received_kiloBytesPerSecond, summation_net_throughput.contention_number, average_net_throughput. packetsPerSec_number, average_net_throughput. provisioned_kiloBytesPerSecond, average_net_throughput. usable_kiloBytesPerSecond, average_net_throughput.usage_kiloBytesPerSecond, average_net_throughput. usage.ft_kiloBytesPerSecond, average_net_throughput.usage.hbr_kiloBytesPerSecond, average_net_throughput.usage.iscsi_kiloBytesPerSecond, average_net_throughput.usage.nfs_kiloBytesPerSecond, average_net_throughput. usage.vm_kiloBytesPerSecond, average_net_throughputusagemmotion_kiloBytesPerSecond, average_net_transmitted_kiloBytesPerSecond, summation_net_unknownProtos_number, none_net_usage_kiloBytesPerSecond, average_net_usage_kiloBytesPerSecond, minimum_net_usage_kiloBytesPerSecond and/or maximum_net_usage_kiloBytesPerSecond. Of course any performance metrics could also be monitored and reported in any of: bytes, megaBytes, gigaBytes and/or any byte amount.

[0143] Power performance metrics that may be collected may include any of: average_power_capacity.usable_watt, average_power_capacity.usage_watt, average_power_capacity.usagePct_percent, summation power_energy_joule, average_power_power_watt and/or average_power_powerCap_watt.

[0144] Rescpu performance metrics that may be collected may include any of: latest_rescpu_actay1_percent, latest_rescpu_actay15_percent, latest_rescpu_actav5_percent, latest_rescpu_actpk1_percent, latest_rescpu_actpk15_percent, latest_rescpu_actpk5_percent, latest_rescpu_maxLimitedl_percent, latest_rescpu_maxLimited15_percent, latest_rescpu_maxLimited5_percent, latest_rescpu_runavl_percent, latest_rescpu_runay15_percent, latest_rescpu_runay5_percent, latest_rescpu_runpkl_percent, latest_rescpu_runpk15_percent, latest_rescpu_runpk5_percent, latest_rescpu_sampleCount_number and/or latest_rescpu_samplePeriod_millisecond.

[0145] Storage Adapter performance metrics that may be collected may include any of: average_storageAdapter_010sPct_percent, average_storageAdapter_commandsAveraged_number, latest_storageAdapter_maxTotalLatency_millisecond, average_storageAdapter_numberReadAveraged_number, average_storageAdapter_numberWriteAveraged_number, average_storageAdapter_outstandinglOs_number, average_storageAdapter_queueDepth_number, average_storageAdapter_queueLatency_millisecond, average_storageAdapter_queued_number, average_storageAdapter_read_kiloBytesPerSecond, average_storageAdapter_throughput.cont_millisecond, average_storageAdapter_throughput.usag_kiloBytesPerSecond, average_storageAdapter_totalReadLatency_millisecond, average_storageAdapter_totalWriteLatency_millisecond and/or average_storageAdapter_write_kiloBytesPerSecond. Of course any performance metrics could also be monitored and reported in any of: bytes, megaBytes, gigaBytes and/or any byte amount.

[0146] Storage path performance metrics that may be collected may include any of: summation_storagePath_busResets_number, summation_storagePath_commandsAborted_number, average_storagePath_commandsAveraged_number, latest_storagePath_maxTotalLatency_millisecond, average_storagePath_numberReadAveraged_number, average_storagePath_numberWriteAveraged_number, average_storagePath_read_kiloBytesPerSecond, average_storagePath_throughputcont_millisecond, average_storage Path_throughput.usage_kiloBytesPerSecond, average_storage Path_total Read Latency_millisecond, average_storagePath_totalWriteLatency_millisecond and/or average_storagePath_write_kiloBytesPerSecond. Of course any performance metrics could also be monitored and reported in any of: bytes, megaBytes, gigaBytes and/or any byte amount.

[0147] System performance metrics that may be collected may include any of: latest_sys_diskUsage_percent, summation_sys_heartbeat_nurnber, latest_sys_osUptime_second, latest_sys_resourceCpuActl_percent, latest_sys_resourceCpuAct5_percent, latest_sys_resourceCpuAllocMax_megaHertz, latest_sys_resourceCpuAllocMin_megaHertz, latest_sys_resourceCpuAllocShares_number, latest_sys_resourceCpuMaxLimitedl_percent, latest_sys_resourceCpuMaxLimited5_percent, latest_sys_resourceCpuRunl_percent, latest_sys_resourceCpuRun5_percent, none_sys_resourceCpuUsage_megaHertz, average_sys_resourceCpuUsage_megaHertz, maximum_sys_resourceCpuUsage_megaHertz, minimum_sys_resourceCpuUsage_megaHertz, latest_sys_resourceMemAllocMax_kiloBytes, latest_sys_resourceMemAllocMin_kiloBytes, latest_sys_resourceMemAllocShares_number, latest_sys_resourceMemConsumed_kiloBytes, latest_sys_resourceMemCow_kiloBytes, latest_sys_resourceMemMapped_kiloBytes, latest_sys_resourceMemOverhead_kiloBytes, latest_sys_resourceMemShared_kiloBytes, latest_sys_resourceMemSwapped_kiloBytes, latest_sys_resourceMemTouched_kiloBytes, latest_sys_resourceMemZero_kiloBytes and/or latest_sys_uptime_second. Of course any performance metrics could also be monitored and reported in any of: bytes, megaBytes, gigaBytes and/or any byte amount.

[0148] Debug performance metrics that may be collected may include any of: maximum_vcDebugInfo_activationlatencystats_millisecond, minimum_vcDebugInfo_activationlatencystats_millisecond, summation_vcDebugInfo_activationlatencystats_millisecond, maximum_vcDebugInfo_activationstats_number, minimum_vcDebugInfo_activationstats_number, summation_vcDebugInfo_activationstats_number, maximum_vcDebugInfo_hostsynclatencystats_millisecond, minimum_vcDebugInfo_hostsynclatencystats_millisecond, summation_vcDebugInfo_hostsynclatencystats_millisecond, maximum_vcDebugInfo_hostsyncstats_number, minimum_vcDebugInfo_hostsyncstats_number, summation_vcDebugInfo_hostsyncstats_number, maximum_vcDebugInfo_inventorystats_number, minimum_vcDebugInfo_inventorystats_number, summation_vcDebugInfo_inventorystats_number, maximum_vcDebugInfo_lockstats_number, minimum_vcDebugInfo_lockstats_number, summation_vcDebugInfo_lockstats_number, maximum_vcDebugInfo_Irostats_number, minimum_vcDebugInfo_Irostats_number, summation_vcDebugInfo_Irostats_number, maximum_vcDebugInfo_miscstats_number, minimum_vcDebugInfo_miscstats_number, summation_vcDebugInfo_miscstats_number, maximum_vcDebugInfo_morefregstats_number, minimum_vcDebugInfo_morefregstats_number, summation_vcDebugInfo_morefregstats_number, maximum_vcDebug Info_scoreboard_number, minimum_vcDebugInfo_scoreboard_number, summation_vcDebug Info_scoreboard_number, maximum_vcDebugInfo_sessionstats_number, minimum_vcDebugInfo_sessionstats_number, summation_vcDebugInfo_sessionstats_number, maximum_vcDebugInfo_systemstats_number, minimum_vcDebugInfo_systemstats_number, summation_vcDebugInfo_systemstats_number, maximum_vcDebugInfo_vcservicestats_number, minimum_vcDebugInfo_vcservicestats_number and/or summation_vcDebugInfo_ycseryicestats_number.

[0149] Resource performance metrics that may be collected may include any of: average_vcResources_cpuqueuelength_number, average_ycResources_ctxswitchesrate_number, average_vcResources_diskqueuelength_number, average_ycResources_diskreadbytesrate_number, average_ycResources_diskreadsrate_number, average_ycResources_diskwritebytesrate_number, average_ycResources_diskwritesrate_number, average_vcResources_netqueuelength_number, average_ycResources_packetrate_number, average_ycResources_packetrecyrate_number, average_ycResources_packetsentrate_number, average_ycResources_pagefaultrate_number, average_vcResources_physicalmemusage_kiloBytes, average_vcResources_poolnonpagedbytes_kiloBytes, average_ycResources_poolpagedbytes_kiloBytes, average_vcResources_priviledgedcpuusage_percent, average_ycResources_processcpuusage_percent, average_vcResources_processhandles_number, average_ycResources_processthreads_number, average_ycResources_syscallsrate_number, average_ycResources_systemcpuusage_percent, average_ycResources_systemnetusage_percent, average_ycResources_systemthreads_number, average_vcResources_usercpuusage_percent and/or average_vcResources_virtualmemusage_kiloBytes. Of course any performance metrics could also be monitored and reported in any of: bytes, megaBytes, gigaBytes and/or any byte amount.

[0150] Virtual disk performance metrics that may be collected may include any of: summation_virtualDisk_busResets_number, summation_virtualDisk_commandsAborted_number, latest_virtualDisk_largeSeeks_number, latest_virtualDisk_mediumSeeks_number, average_virtualDisk_numberReadAveraged_number, average_virtualDisk_numberWriteAveraged_number, average_virtualDisk_read_kiloBytesPerSecond, latest_virtualDisk_readlOSize_number, latest_virtualDisk_readLatencyUS_microsecond, latest_virtualDisk_readLoadMetric_number, latest_virtualDisk_readOlO_number, latest_virtualDisk_smallSeeks_number, average_virtualDisk_throughput.cont_millisecond, average_virtualDisk_throughput. usage_kiloBytesPerSecond, average_virtualDisk_totalReadLatency_millisecond, average_virtualDisk_totalWriteLatency_millisecond, average_virtualDisk_write_kiloBytesPerSecond, latest_virtualDisk_writelOSize_number, latest_virtualDisk_writeLatencyUS_microsecond, latest_yirtualDisk_writeLoadMetric_number and/or latest_virtualDisk_write010_number. Of course any performance metrics could also be monitored and reported in any of: bytes, megaBytes, gigaBytes and/or any byte amount.

[0151] VM operation performance metrics that may be collected may include any of: latest_vmop_numChangeDS_number, latest_vmop_numChangeHost_number, latest_vmop_numChangeHostDS_number, latest_vmop_numClone_number, latest_vmop_numCreate_number, latest_ymop_numDeploy_number, latest_ymop_numDestroy_number, latest_ymop_numPoweroff_number, latest_ymop_numPoweron_number, latest_ymop_numRebootGuest_number, latest_ymop_numReconfigure_number, latest_ymop_numRegister_number, latest_ymop_numReset_number, latest_vmop_numSVMotion_number, latest_vmop_numShutdownGuest_number, latest_vmop_numStandbyGuest_number, latest_vmop_numSuspend_number, latest_vmop_numUnregister_number and/or latest_vmop_numVMotion_number.

[0152] In an embodiment of the disclosure, the IT environment performance metrics for which performance measurements can be collected include any of the published performance metrics that is known to be collected for IT systems and virtual-machine environments in software made and produced by VMWare, Inc.; individual performance measurements at specific times for these performance metrics may be made available by the software producing the measurements (e.g. VMWare software) through application programming interfaces (APIs) in the software producing the measurements. In embodiments of the present disclosure, these performance measurements made by software in an IT or virtual-machine environment (e.g., VMWare software) may be constantly retrieved through the software's API and stored in persistent storage, either as events (in a manner as described later in this specification) or in some other format in which they can be persisted and retrieved through a time-correlated search (the correlation being the time at which the performance measurements were made or the time to which the performance measurements correspond). These performance measurements could alternatively be stored in any of the ways described herein by the software producing them without making them available through an API or retrieving them through an API. While VMWare software has been referenced as a potential source of performance measurements in an IT or virtual-machine environment, it should be recognized that such performance measurements could be produced or collected by software produced by any company that is capable of providing such environments or measuring performance in such environments.

[0153] Referring next to FIG. 11, a block diagram of an embodiment of task scheduler 1040 is shown. Task scheduler 1040 can be, in part or in its entirety, in a cloud. Task scheduler 1040 includes a user account engine 1105 that authenticates a user 1015 attempting to access a Hypervisor. User account engine 1105 can collect information about user 1015 and store the information in an account in a user-account data store 11101110. The account can identify, e.g., a user's name, position, employer, subscription level, phone number, email, access level to the Hypervisor and/or login information (e.g., a username and password). Information can be automatic ally detected, provided by user 1015, provided by an architecture provider 1005 (e.g., to specify which users can have access to a system defined by a provided architecture) and/or provided by a reviewer 1025 (e.g., who may be identifying employees within a company or organization who are to be allowed to access the Hypervisor).

[0154] In some instances, user account engine 1105 determines whether a user 1005 is authorized to access the system by requesting login information (e.g., a username and password) from user 1015 and attempting to match entered login information to that of an account stored in user-account data store 1110. In some instances, user account engine 1105 determines whether user 1015 is authorized by comparing automatically detected properties (e.g., an IP address and/or a characteristic of user device 1020) to comparable properties stored in an account. User account engine 1105 can further, in some instances, determine which Hypervisors and/or which hypervisor components user 1015 is authorized to use (e.g., based on a user-provided code or stored information identifying access permissions).

[0155] Authorized users can then be granted access to a task definer 1115, which receives a task definition from user 1015. User 1015 can define a task by, e.g., uploading a program code, entering a program code, defining task properties (e.g., a processing to be done, a location of data to be processed, and/or a destination for processed data), or defining task restrictions or preferences (e.g., requirements of resources to be used or task-completion deadlines). In some instances, defining a task includes uploading data to be processed. In some instances, a task is defined by executing a code provided by user 1015 and defining portions of the codes (e.g., during specific iterations) as distinct tasks. Task definer 1115 can verify that the task definition is acceptable (e.g., being of an appropriate format, having restrictions that can be met and being estimated to occupy an acceptable amount of resources). This verification can include fixed assessments and/or assessments that are specific to user 1015 or a user group.

[0156] Defined tasks, in some instances, relate to data collection processes. Task definer 1115 can identify data to be collected based on user input (e.g., identifying a source, a type of data to be collected and/or a time period during which data is to be collected) or through other means. Task definer 1115 can then define data-collection tasks. Each task can pertain to a portion of the overall data-collection process. For example, when data is to be continuously collected from multiple sources, task definer 1115 can define individual tasks, each relating to a subset of the sources and each involving a defined time period. These tasks can be assigned to machines identified as forwarders.

[0157] Tasks can further or alternatively include parsing collected data into individual data events, identifying a time stamp for each data event (e.g., by extracting a time stamp from the data) and/or storing time stamped data events in a time-series data store. These efforts are described in further detail below.

[0158] In some instances, task definer 1115 defines tasks related to a query. The query can be received from a search engine via a search-engine interface 1117. The query can identify events of interest. The query can be for one or more types of events, such as data events or performance events (e.g., searching for performance events with below-threshold performance values of a performance metric). The query may, e.g., specify a time period, a keyword (present anywhere in the event) and/or a value of a field constraint (e.g., that a value for a “method” field be “POST”). Task definer 1115 can define one or more retrieval, field-extraction and/or processing tasks based on the query. For example, multiple retrieval tasks can be defined, each involving a different portion of the time period. Task definer 1115 can also define a task to apply a schema so as to extract particular value of fields or a task to search for a keyword. Values extracted can be for fields identified in the query and/or for other fields (e.g., each field defined in the schema). Those retrieved events with query-matching values of fields or keywords can then be selected (e.g., for further processing or for a query response).

[0159] Task definer 1115 can further define a task to process retrieved events. For example, a task can include counting a number of events meeting a criteria (e.g., set forth in the query or otherwise based on the query); identifying unique values of a field identified in a query; identifying a statistical summary (e.g., average, standard deviation, median, etc.) of a value of a field identified in a query.

[0160] It will be appreciated that, while the retrieval, field extraction of a value, and/or processing tasks are referred to separately, any two or more of these tasks can be combined into a single task. Further, in instances where different components act on different portions of data retrieved for a given query, a task may include combining results of the task actions.

[0161] Upon determining that the task definition is acceptable, task definer 1115 generates a queue entry. The queue entry can include an identifier of the task, a characteristic of the task (e.g., required resource capabilities, estimated processing time, and/or estimated memory use), an identification of user 1015, a characteristic of user 1015 (e.g., an employer, a position, a level-of-service, or resources which can be used) and/or when the task was received. In some instances, the queue entry includes the task definition, while in other instances, the queue entry references a location (e.g., of and/or in another data store) of the task definition.

[0162] A prioritizer 1125 can prioritize the task based on, e.g., a characteristic of the task, a characteristic of user 115 and/or when the task was received (e.g., where either new or old tasks are prioritized, depending on the embodiment). Prioritizer 1125 can also or alternatively prioritize the task based on global, company-specific or user-specific usage of part or all of Hypervisor. For example, if many queue items require that a processing VM be running Operating System (OS) #1 (and/or if few resources run the OS), prioritizer 1125 may prioritize queue items permissive of or requiring a different OS being run. Similarly, prioritizations can depend on a current load on part or all of a Hypervisor. For example, tasks that can be assigned to a VM currently having a small CPU usage can be assigned high priority. Thus, a load monitor 1130 can communicate with prioritizer 1125 to identify a load (e.g., a processing and/or memory load) on specific resources and/or specific types of resources.

[0163] In some instances, a task is prioritized based on data involved in the task. Collection, storage, retrieval and/or processing of valuable data can be prioritized over other tasks or over other corresponding tasks. Prioritization can also be performed based on a source identification or data Prioritization can also be performed based on task types. For example, data-collection and event-storage tasks (e.g., intake tasks) may be prioritized over event-retrieval and event-processing tasks (e.g., query-response tasks).

[0164] Prioritizing a task can include assigning a score (e.g., a numeric or categorical score) to the task, which may include identifying some tasks that are “high” priority. Prioritizing a task can include ranking the task relative to tasks. The prioritization of a task can be performed once or it can be repeatedly performed (e.g., at regular intervals or upon having received a specific number of new tasks). The prioritization can be performed before, while or after a queue item identifying the task is added to the queue. The queue item can then be generated or modified to reflect the prioritization.

[0165] An assigner 1135 can select a queue entry (defining a task) from queue 1120 and assign it to one or more resources (e.g., a host cluster, a host and/or a VM). The selection can be based on a prioritization of queue entries in queue 1120 (e.g., such that a highest priority task is selected). The selection can also or alternatively depend on real-time system loads. For example, load monitor 1130 can identify to assigner 1135 that a particular VM recently completed a task or had low CPU usage. Assigner 1135 can then select a queue entry identifying a task that can be performed by the particular VM. The assignment can include a pseudo-random element, depend on task requirements or preferences and/or depend on loads of various system components. For example, assigner 1135 can determine that five VMs have a CPU usage below a threshold, can determine that three of the five have capabilities aligned with a given task, and can then assign the task to one of the three VMs based on a pseudo-random selection between the three. The assignment can further and/or alternatively reflect which Hypervisors and/or system components a user from whom a task originated is allowed to access. Assigner 1135 can update queue 1120 to reflect the fact that a task is/was assigned to identify the assigned resource(s).

[0166] A task monitor 1140 can then monitor performance of the tasks and operation states (e.g., processing usage, CPU usage, etc.) of assigned resources. Task monitor 1140 can update queue 1120 reflect performance and/or resource-operation states. In some instances, if a performance state and/or resource-operation state is unsatisfactory (e.g., is not sufficiently progressing), assigner 1135 can reassign the task.

[0167] Referring next to FIG. 12, a block diagram of an embodiment of VM monitoring system 1055 is shown. VM monitoring system 1055 can be, in part or in its entirety, in a cloud. VM monitoring system 1055 includes a reviewer account engine 1205, which authenticates a reviewer attempting to access information characterizing performance of a Hypervisor. Reviewer account engine 1205 can operate similarly to user account engine 1105. For example, reviewer account engine 1205 can generate reviewer accounts stored in a reviewer-account data store 1210 where the account includes information such as the reviewer's name, employer, level-of-service, which Hypervisors/components can be reviewed, a level of permissible detail for reviews, and/or login information. Reviewer account engine 1205 can then determine whether detected or reviewer-entered information (e.g., login information) matches corresponding information in an account.

[0168] VM monitoring system 1055 also includes an activity monitor 1215, which monitors activity of hypervisor components. The activity can include, for example, when tasks were assigned, whether tasks were completed, when tasks were completed, what tasks were assigned (e.g., required processing), users that requested the task performance, whether the task was a new task or transferred from another component (in which case a source component and/or transfer time can be included in the activity), CPU usage, memory usage, characteristics of any memory swapping or ballooning (e.g., whether it occurred, when it occurred, an amount of memory, and the other component(s) involved), and/or any errors.

[0169] Activity monitor 1215 can store the monitored activity (e.g., as or in an activity record) in an activity data store 1220. In one instance, one, more or each VM component is associated with a record. Performance metrics of the component (e.g., CPU usage and/or memory usage) can be detected at routine intervals. The record can then include an entry with a time stamp and performance metrics. Task assignments (including, e.g., a time of assignment, a source user, whether the task was transferred from another component, a type of task, requirements of the task, whether the task was completed, and/or a time of completion) can also be added to the record. In some instances, performance metrics are detected (and a corresponding record entry is generated and stored) upon detecting a task action (e.g., assignment, transfer, or completion) pertaining to the VM component. Thus, activity data store 1220 can maintain an indexed or organized set of metrics characterizing historical and/or current performance of hypervisor components.

[0170] An aggregator 1225 can collect performance metrics from select activity records. The performance metrics can include, e.g., CPU usage, memory usage, tasks assignments, task completions and/or any of the above mentioned performance metrics. The desired values of performance metrics can also include values generated from entries with time stamps within a particular time period. In some instances, performance metrics are collected from one or more entries having a most recent time stamp (e.g., a most recent entry or all entries within a most-recent 24-hour period).

[0171] The activity records can be selected based on an architecturestored in an architecture data store 1230, the architecture defining a structure (e.g., components and component relationships) of a Hypervisor. Architectures can also specify which specific users or types of users can use some or all of the Hypervisor and/or which specific reviewer or types of reviewers can access (some or all available) performance indicators.

[0172] The architecture can be one provided by an architecture provider 1005. For example, architecture provider 1005 can interact with an architecture manager 1235 to define resources in a Hypervisor and relationships between components of the system. These definitions can be provided, e.g., by entering text, manipulating graphics or uploading a file. It will be appreciated that, while not shown, VM monitoring system 1055 can further include an architecture-provider account engine and architecture-provider account data store that can be used to authenticate an architecture provider. Architecture-provider accounts can include information similar to that in user accounts and/or reviewer accounts, and the architecture-provider account engine can authenticate an architecture provider in a manner similar to a user or reviewer authentication technique as described herein.

[0173] FIG. 13 illustrates an example of a representation of an architecture for a Hypervisor. The depicted architecture is hierarchical and includes a plurality of nodes arranged in a plurality of levels. Each node corresponds to a component in the Hypervisor. The hierarchy defines a plurality of familial relationships. For example, VM 6 is a child of Host 2 and a grandchild of the Host Cluster. The top level is the virtual center where tasks are assigned. The second level is a host-cluster level, which indicates which underlying hosts have task-transferring arrangements with each other (the same-level interaction being represented by the dashed line). The third level is a host level that provides computing resources that support VM operation. The fourth level is a VM level. Thus, based on the depicted architecture, an assignment to VM 7 would also entail an assignment to Host 2 and to the Host Cluster; an assignment to VM 3 would also entail an assignment to Host 1.

[0174] Returning to FIG. 12, aggregator 1225 can aggregate performance metrics from records pertaining to a particular component in the architecture. As will be described in further detail below, performance indicators (determined based on performance metrics) associated with components at different levels can be sequentially presented to a reviewer (e.g., in a top-down manner and responsive to reviewer selection of components). Thus, VM monitoring system 1055 can, in some instances, also sequentially determine performance indicators (determining lower level indicators following a presentation of higher-level indicators and/or to reviewer selection of a component). VM monitoring system 1055 can first determine performance indicators for higher-level components and subsequently for each of a subset or all of lower-level components. Thus, aggregator 1225 can first aggregate performance metrics in activity records for each of one or more higher-level components and later aggregate performance metrics in activity records for each of one or more lower-level components. It will be appreciated that other sequences can be utilized (e.g., repeatedly cycling through components in a sequence).

[0175] A statistics generator 1240 can access the collection of performance metrics and generate one or more performance statistics based on the values of one or more performance metrics. A performance statistic can pertain to any of the various types of performance metrics, such as a CPU usage, a memory usage, assigned tasks, a task-completion duration, etc. The statistic can include, e.g., an average, a median, a mode, a variance, a distribution characteristic (e.g., skew), a probability (which may be a percentage), a conditional probability (e.g., conditioned on recent assignment of a task), a skew, and/or an outlier presence. The statistic can include one or more numbers (e.g., an error and a standard deviation). In some instances, the statistic includes a series of numbers, such as histogram values. Statistics generator 1240 can store the statistic (in association with an identifier of a respective component and time period) in a statistics data store 1245. Statistics generator 1240 can identify which component and/or time period are to be associated with the statistic based on what aggregation was performed.

[0176] A state engine 1250 can access one or more state criteria from state-criteria data store 355 and use the state criteria and the generated statistic to assign a state (e.g., to a component and/or time period). The state can then be stored (e.g., in association with a respective component and/or time period) in a state data store 1260. State engine 1250 can identify which component and/or time period are to be associated with the state based on what aggregation was performed.

[0177] The state criteria can include one or more thresholds, a function and/or an if-statement. In one instance, two thresholds are set to define three states: if a statistic is below the first threshold, then a first state (e.g., a “normal” state) is assigned; if a statistic is between the thresholds, then a second state (e.g., a “warning” state) is assigned; if a statistic is above the second threshold, then a third state (e.g., a “critical state”) is assigned. The state criteria can pertain to multiple statistics (e.g., having a function where a warning state is assigned if any of three statistics are below a respective threshold or if a score generated based on multiple statistics is below a threshold).

[0178] A state of a node corresponding to a component in an IT environment may be based on performance measurements (corresponding to a performance metric) made directly for that component, or it may depend on the states of child nodes (corresponding to child components) of the node (e.g., a warning state if any of the child nodes are in a warning state, or a warning state if at least 50% of the child nodes are in a warning state). A component in an IT environment may include a virtual center, a cluster (of hosts), a host, or virtual machines running in a host, where a cluster is a child component of a virtual center, a host is a child component of a cluster, and a virtual machine is a child component of a host.

[0179] The state criteria can include a time-sensitive criteria, such as a threshold based on a past statistic (e.g., indicating that a warning state should be assigned if the statistic has increased by 10-20% since a previous comparable statistic and a warning state should be assigned if it has increased by 20+%), a derivative (calculated based on a current and one or more past statistics) and/or an extrapolation (calculated based on a current and one or more past statistics).

[0180] In some instances, multiple states are defined. For example, an overall state can be assigned to the component, and other specific states pertaining to more specific performance qualities (e.g., memory usage, processor usage and/or processing speed) can also be assigned.

[0181] The state criteria can be fixed or definable (e.g., by an architecture provider 105 or reviewer 1025). The state criteria can be the same across all components and/or time periods or they can vary. For example, criteria applicable to VM components can differ from criteria applicable to higher level components.

[0182] In some instances, the state criteria are determined based on a results-oriented empirical analysis. That is, a state engine 1250 can use an analysis or model to determine which values of performance metrics (e.g., a range of values) are indicative of poor or unsatisfactory performance of the Hypervisor. Thus, a result could be a performance metric for a higher level component or a population user satisfaction rating.

[0183] An alarm engine 1265 can access one or more alarm criteria from alarm-criteria data store 370 and use the alarm criteria and an assigned state to determine whether an alarm is to be presented. In one instance, an alarm criterion indicates that an alarm is to be presented if one or more states are assigned. In one instance, an alarm criterion includes a time-sensitive assessment, such as a criterion that is satisfied when the state has changed to (or below) a specific state and/or has changed by a particular number of states since a last time point.

[0184] Alarm engine 1265 can present the alarm by, e.g., presenting a warning on an interface (e.g., a webpage or app page), transmitting an email, sending a message (e.g., a text message), making a call or sending a page. A content of the alarm (e.g., email, message, etc.) can identify a current state and/or statistic, a previous state and/or statistic, a trend in the state and/or statistic, an applicable component, an applicable time period, and/or an applicable Hypervisor.

[0185] VM monitoring system 1055 can include an interface engine 1275 that enables a reviewer 1015 to request a performance report and/or receive a performance report. The report can include one or more statistics, states, and/or alarm statuses. The report can identify which component and/or time period are associated with the statistic, state and/or alarm status. Interface engine 1275 can present most-recent or substantially real-time values (e.g., numerical statistics or states) and/or historical values. In some instances, interface engine accesses a set of values for a given component, and generates and presents a table, list, or graph to illustrate a change in a performance. The report can also include activity pertaining to a component and/or time period (e.g., tasks assigned, task statuses, etc.).

[0186] Interface engine 1275 can receive input from reviewer 1015, which can cause different information to be presented to the user. In some instances, interface engine 1275 merely accesses different data (e.g., states, statistics, alarm statuses and/or activities) from data store 1220, 1245, and/or 1260. Interface engine 1275 can then present the accessed data itself or generate and present a representation of the data (e.g., generate and present a graph). In some instances, the input causes interface engine 1275 to request that aggregator 1225 aggregate different performance metrics, that statistics generator 1240 generate different statistics, that state engine 1250 generate different states and/or that alarm engine 1265 re-assess alarm criteria. The new data can then be presented to reviewer 1015. Thus, the report can be dynamic.

[0187] In some instances, the input can include selection of a component. The selection can lead to a presentation (and potentially a generation of) more detailed data pertaining to the component and/or to a presentation of data pertaining to components that are children of the selected component. This former strategy can encourage a user to follow branches down an architecture tree to find, e.g., a source of a high-level problem or to understand best-performing branches.

[0188] While activity data store 1220, statistics data store 1245 and states data store 1260 are shown separately, it will be appreciated that two or more of the data stores can be combined in a single data store. Each of one, more or all of the data stores can include a time-series data store. In one instance, a performance event can be generated to identify one or more of each of a value or values of a performance metric, statistic or state. For example, a performance event can include a task-completion rate for a single VM over the past hour. A single event can be generated to include performance values for an individual hypervisor component, performance values for each of multiple hypervisor components, or performance values for each hypervisor component in a Hypervisor.

[0189] The performance event can identify one or more multiple components. For example, when a performance event includes performance values for multiple components, the performance event can identify the component and/or other multiple components with particular familial relationships (e.g., parent, grandparent, child) to the component in a Hypervisor environment.

[0190] Each performance event can be time stamped or can otherwise be associated with a time. The time stamp or time can indicate a time or time period for which performance data identified in the event applies. Performance events (e.g., timestamped performance events) can be stored in one or more time-series data stores. Thus, select performance events corresponding to a time period of interest (of a reviewer) can be retrieved and analyzed.

[0191] As described, statistics generator 1240 can generate statistics and/or state engine 1250 can generate states based on collected values of one or more performance metrics. In one instance, the statistic and/or state generation is performed in real-time subsequent to collection of values (i.e., performance measurements) of one or more performance metrics. Alternatively or additionally, statistics and/or states can be determined retrospectively. For example, time stamped performance events can include raw values for performance metrics. Periodically, or in response to receiving a query, performance events within a time period be retrieved and one or more statistics and/or one or more states can be generated based on the retrieved events. This retrospective analysis can allow for dynamic definitions of states and/or statistics. For example, a reviewer can define a statistic to facilitate a particular outlier detection or a reviewer can adjust a stringency of a “warning” state.

[0192] FIGS. 14A-14B illustrate an example of sequential presentations conveying an architecture and system performance that can be presented to a reviewer 1025. In FIG. 14A, three relatively high-level nodes are presented. Specifically a highest-level node is presented along with its children. In this instance, the children are at different levels in order to ensure that each presented node has multiple children. It will be appreciated that in other embodiments, the depicted children nodes are in the same level (e.g., such that another “Host Cluster” would be a parent of “Host 1” and have no other children).

[0193] As shown, this architecture includes 12 nodes that are hidden in the representation in FIG. 14A The node hiding can help a user focus on a most likely lower-level cause of an overall sub-par performance.

[0194] An overall state of the represented components is indicated based on whether the node is surrounded by a diamond. In this case, nodes in a warning state are surrounded by a diamond. It will be appreciated that other state indicators (e.g., colors, text, icon presence or a number) can be used instead of or in addition to the surrounding indicator.

[0195] In this example, a reviewer 1025 can select a node by clicking on it. FIG. 14B shows a representation of the architecture and system performance after reviewer 1025 selected the Host 1 node (having a warning-state indicator). At this point, the children of Host 1 appear. Two of the child VM nodes also have a warning-state indicator.

[0196] FIG. 14B also illustrates how presentations can indicate which nodes are parent nodes. In this case, “fills” or patterns of the node convey this characteristic, with pattern nodes indicating that the nodes are not parents.

[0197] The structure-based and concise presentations shown in FIGS. 14A and 14B allow a reviewer to drill down into sub-optimal system performance, to easily understand which system components are properly operating and to easily understand architecture underlying a Hypervisor. However, more detailed performance information can also be presented to a reviewer. For example, detailed information can appear as a transient pop-up when a reviewer 1025 hovers a cursor over a component and/or can appear as a report when a reviewer 1025 double clicks on a node.

[0198] In some instances, an architecture provider 1005 and reviewer 1025 are a same party. The reviewer 1025 can then review a representation, such as one shown in FIGS. 14A-14B and access performance indicators of specific system components. In the same-party instances, reviewer 1025 can use the same representation to modify an architecture. For example, reviewer 1025 can add, move or delete connections, move child components, add and/or remove components. Reviewer 1025 can also select a particular component (e.g., by double clicking a node) and change its properties.

[0199] FIGS. 15A-15C illustrate example detailed information that can be presented to characterize performance of a Hypervisor, a host and a VM, respectively. These graphics can be presented in response to a reviewer 1025 hovering over a specific hypervisor component. FIG. 15A shows gauges presenting information pertaining to an overall Hypervisor. The gauges identify a percentage of VMs in a Hypervisor having undesirable states. The left gauge shows a percentage of VMs with a state for CPU usage in a “high” category. The middle gauge shows a percentage of VMs with a state for memory usage in a “high” category. The right gauge shows a percentage of VMs within a state for an amount of time a VM is waiting to use a processor that is in a “high” category. Thus, 33% of VMs are seemingly affected in their processing capabilities based on overloading of 2% of VMs. Thus, it would be useful to identify which VMs are within the 2% and/or 4.2% and a source of the problem for those VMs.

[0200] It will be appreciated that other high-level performance indicators can be presented (e.g., ones related to memory. For example, other gauges could identify memory performance indicators. For example, a gauge could identify a percentage of hosts with a “high” amount of memory being used, having a “high” amount of memory ballooning (during which a host is requesting memory be returned from a VM to the host), or having a “high” amount of memory swapping (during which a host is forcefully taking back memory from a VM). Host processing characteristics (e.g., a percentage of hosts with “high” CPU usage) can also be presented for hosts.

[0201] These same gauges could be associated with a node representation of an IT system component (e.g., a node representing a virtual center, cluster (of hosts), a host, or a virtual machine) to indicate a performance measurement (relative to a maximum for the corresponding metric) for the component or to indicate the percentage of child components of the component that are in various states. In such an embodiment, the gauge could partially surround the representation of the node, sitting (e.g.) just above the representation of the node. Where the gauge shows states of child component, each color of the gauge takes up a percentage of the gauge corresponding to the percentage of child components having a state corresponding to the color.

[0202] FIG. 15B shows information pertaining to a particular host in a Hypervisor. The presented data compares performance characteristics of the host's children to more global comparable characteristics. The left bar graph shows a histogram across VMs assigned to the host identifying a sum-ready performance metric (identifying a time that the VM must wait before using a processor). The right bar graph is comparable but characterizes all VMs within a Hypervisor. In this instance, the right histogram is highly skewed to the left, while the left histogram does not exhibit a similar skew. The histogram thus suggests that the sub-network of the host and its children is not operating as well as is possible.

[0203] FIG. 15C shows a time-graph of the same waiting-time metrics for a VM across period of times (in the lighter line). Specifically, each point in the graph represents the performance value of waiting-time metrics for a period of time. A comparable average for the performance values of the waiting-time metrics across all VMs is simultaneously presented (in the darker line). The higher values underscore suboptimal performance, as the processor is experiencing higher than average wait times. This presentation allows a reviewer 1025 to understand whether a VM's performance is particularly poor relative to other VMs' performances, to identify whether and when any substantial changes in the performance occurred, and to identify and when poor performance is becoming a consistent problem. Further, the historical plot may allow a reviewer 1025 to notice a positive or negative trend in the values of one or more performance metrics, such that a problem can be remedied before it becomes serious.

[0204] The historical presentation in FIG. 15C thus offers valuable insight as to a component's performance, when a change in performance occurred, and whether the performance warrants a change in the VM architecture. The historical presentation, however, requires that historical performance characteristics be stored and indexed (e.g., by time and/or component). This is complicated by the fact that this can be a very large amount of data. Storing all raw values of performance metrics involves not only storing a very large amount of data, but also repeatedly re-aggregating the values of the performance metrics and repeatedly recalculating the historical performance statistics and/or states. This can result in a delay of a presentation to a reviewer 1025, which can be particularly noticeable if the presentation is supposed to be presented transiently and quickly as the reviewer hovers his cursor over a particular depiction. Meanwhile, storing only statistics and/or states and not the values of the performance metrics limits the ability to customize which statistics and/or states are presented (e.g., by fixing time periods instead of allowing statistics to be calculated on a flexible basis depending on a reviewer's interest and reviewing time) and can itself even lead to a large amount of data to store, due to many types of performance variables being calculated at many levels (meaning that a single value of a performance metric may, in combination with other values of performance metrics, give rise to several values of performance statistics and/or states).

[0205] FIGS. 16A-16C further illustrate example detailed information that can be presented to characterize the performance of a Hypervisor, a host and a VM, respectively. These reports can be presented in response to a reviewer 1025 selecting (e.g., by double clicking) a specific VM-system component. FIG. 16A illustrates a report for a Hypervisor. The report can include information about hosts in the system and VMs in the system. The report can identify system properties, such as a number and type of components within the system. In the illustrated example, the system includes 4 hosts and 74 VMs. The report can also characterize provider-initiated or automatic architecture changes, such as a number of times a VM automatically migrated to another host (e.g., based on a host-clustering architecture defined by an architecture provider). It will be appreciated that more and/or more detailed information can be presented regarding architecture changes, such as identifying whether the change was automatic, identifying a time of the change, and/or identifying involved components.

[0206] In this example, a host-status section identifies hosts by name and storage capacity. A current status of each host is also indicated by showing an amount of the host's capacity that is committed to serve VMs and an amount by which the host is overprovisioned. High commitment and overprovisioning numbers can be indicative of poor performance. It will be appreciated that the host information could be expanded to include, e.g., an overall or host-specific memory-ballooning or memory-swapping statistic, host-clustering arrangements, and/or an overall or host-specific CPU usage.

[0207] The report can also identify past alarms in an alarm-history section. For each alarm, an applicable component can be identified, a time of the alarm can be identified and a substance or meaning of an alarm can be identified. These alarms can identify state changes for particular components.

[0208] FIG. 16B illustrates a report for a host. Overall performance statistics and corresponding states are presented in a host-statistics section. These statistics can be recent or real-time statistics and can be equivalent to instantaneous values of one or more performance metrics or can be calculated using values of one or more performance metrics from a recent time period. A host-configurations section identifies the equipment and capabilities of the host. A connected-datastores section identifies which other hosts in the Hypervisor the instant host is connected to (e.g., via a clustering arrangement). In some instances, the section is expanded to identify a type of connection or a length of time that the connection has existed.

[0209] A VM-information section identifies VMs assigned to the host. In the illustrated example, the report identified a number of VMs that are assigned and a number of those in a power-on state. The report also identifies the number of VMs that migrated to or from the host (e.g., via a host-clustering arrangements). The report can list recent VM tasks, events and/or log entries, and can identify an applicable time, VM and description. For example, tasks can include changing a resource configuration for a VM, adding a VM to a host, and establishing a remote connection. Events can include presented alarms, VM migrations (from host to host), task migrations (from VM to VM), and warnings potential architecture problems (e.g., based on actual or predicted insufficiency of resources to support assigned child components or tasks). Log entries can include identifications of unrecognized URI versions and software warnings.

[0210] A historical-host-performance section shows how a performance statistic has been changing over time. In the depicted instance, the historical statistics (which can include a final real-time statistic) are shown graphically, along with a “normal” threshold (shown as the bottom, dark dashed line) and a “critical” threshold (shown as the top, gray dashed line). Reviewer 1025 is able to set settings to control the statistical presentation. For example, reviewer 1025 can identify a performance metric of interest (e.g., CPU usage, memory usage, etc.), whether data is to be aggregated across VMs to derive the statistic, a statistic type (e.g., average, median, maximum, minimum, mode, variance, etc.), and a time period (e.g., 24 hours). Other settings may further be presented, such as time discretization during the time period and graph-formatting options (e.g., marker presence, marker size, line style, axis-tick settings, etc.).

[0211] FIG. 16C illustrates a report for a VM. A VM-configurations section identifies the resources allocated to the VM and other VM and/or relationship characteristics (e.g., a name, assigned host and/or assigned cluster). A connected-datastores section identifies which hosts are, per an existing architecture, responsible for providing resources to the VM. A configuration-change-history section identifies a time and type of a past change to the configuration of the VM and a party initiating the change.

[0212] A migration-request-history identifies any attempts and/or successes for migrating the VM from one host to the next. Thus, in this case, it appears as though the VM was attempting to migrate off of the host but failed. This report also includes a historical-performance section, which can have similar presentation and setting-changing abilities as the similar section from the host report. It will be appreciated that, e.g., thresholds can differ between the two. For example, a warning threshold can be stricter for a host, since more VMs contribute to the statistic and diminish the probability of observing extreme values.

[0213] It will also be appreciated that reports can include links to other reports. For example, in the report in FIG. 16C, a reviewer 1025 can click on “Host1” to move to the report shown in FIG. 16B for that component. Thus, reviewer 1025 can navigate via the reports to access performance and configuration details for related hypervisor components.

[0214] Thus, the presentations shown from FIGS. 14A-16C show a variety of ways by which a reviewer 1025 can understand how a Hypervisor is structured and performing. By tying together structural and performance information, a reviewer 1025 can begin to understand what architecture elements may be giving rise to performance problems and can appropriately improve the architecture. Further, the presentations show how a given performance measure compares to other performance measures. One such comparison is an inter-system-component comparison, which can enable a reviewer 1025 to identify a reasonableness of a performance metric and determine a level at which a problem could best be addressed. Another such comparison is a historical comparison, which can allow reviewer 1025 to identify concerning trends and/or to pinpoint times at which substantial performance changes occurred. Reviewer 1025 can then review configuration-change or task histories to determine whether any events likely gave rise to the performance change.

[0215] It will be appreciated that alternative detailed information can be presented to characterize performance of a hypervisor component. The detailed information can identify information about particular tasks or types of tasks assigned to the component. The information can include events related to the tasks. For example, a reviewer 1025 can click on a component assigned to index data (or a component above the indexing component in a hierarchy), and information about the events (e.g., a number of events, unique field values, etc.) and/or the events themselves can be presented. In one instance, clicking on a component can include a list of recently performed tasks. A reviewer 1025 can select an event-defining and storing task, and a number of the stored events can be presented. Upon a further selection or automatically (e.g., subsequently or simultaneously), details (e.g., field values and/or time stamps) of the events can be presented, and/or the full events can be presented.

[0216] As noted herein, initial indexing tasks can create events derived from raw data, unstructured data, semi-structured data, and/or machine data (or slightly transformed versions thereof) to be stored in data stores. This storage technique can allow a reviewer to deeply investigate potential causes for poor performance. For example, a reviewer may be able to hypothesize that a component's poor performance is likely due to a type of task performed (e.g., extracting fields from events with inconsistent patterns or needing to index events without a time stamp included therein).

[0217] FIG. 17 illustrates a flowchart of an embodiment of a process 1700 for using a VM machine to complete user tasks. Process 1700 begins at block 1710, where task definer 1115 defines a task. The task can be defined based on user input, a data-collection effort and/or a query. In one instance, input is received (e.g., from a user) that is indicative of a request to collect data (e.g., once or repeatedly). Task definer 1115 can then define one or more tasks to collect the data. When more than one task is defined, they may be simultaneously defined or defined at different times (e.g., the times relating to collection periods identified in the request). For any given collection effort, in some instances, task definer 1115 can parse the collection into sub-collections (e.g., each associated with a different portion of a collection time period), and a different task can be defined for each sub-collection.

[0218] In one instance, task definer 1115 defines data-segment and storage tasks, which may be defined as data is collected or otherwise received. In one instance, task definer 1115 defines one or more retrieval and/or processing tasks in response to receiving a query or determining that a query-response time is approaching. For example, a query may request a response at routine intervals, and tasks can be defined and performed in preparation for each interval's end. The query can be one defined by an authenticated user.

[0219] Prioritizer 1125 prioritizes the task request (e.g., based on characteristics of user 110, characteristics of the task, system load and/or when the request was received) at block 1715. The prioritization can include generating a score, assigning a priority class or assigning a ranking. Task definer 1115 places a queue item identifying the task in queue 1120 at block 1720. The priority of the task can be reflected within the queue item itself, by the queue item's placement within a ranking or by a priority indicator associated with the queue item. Load monitor 1130 monitors loads of virtual machines (e.g., and/or hosts) at block 1725. The monitoring can include detecting characteristics of tasks being processed (e.g., resource requirements, a current total processing time, and/or which user who submitted the task). Assigner 1135 selects the task from queue 1120 at block 1730. The selection can occur, e.g., once the task is at sufficiently high priority to be selected over other tasks and can further occur once appropriate resources are available to process the task. Assigner 1135 assigns the task to a VM at block 1735. The VM to which the task is assigned can be a VM with sufficient available resources to process the task. Assignment to a VM can further include assigning the task to a host and/or host cluster.

[0220] Task monitor 1140 monitors performance of the task at the assigned VM at block 1740. For example, task monitor 1140 can detect whether a VM appears to be stalled in that it has not completed the task for over a threshold duration of time. As another example, task monitor 1140 can monitor how much of the VM's processing power and/or memory appears to be being consumed by the task performance. As another example, task monitor 1140 can determine whether any errors are occurring during the task performance. In some instances, task monitor 1140 determines that the performance is unsatisfactory at block 1745 (e.g., based on too much consumption of the VM resources, too long of a processing time and/or too many errors), and assigner subsequently reassigns the task to a different VM at block 1750. The different VM can be one with more resources than the initial VM, one in a larger host-clustering network, and/or one currently processing fewer or less intensive tasks as compared to those otherwise being processed by the initial VM.

[0221] In some instances, process 1700 can further include generation and storage of individual task events. A task event can identify information defining a task, an identification of when a task was assigned (or reassigned) an identification of a VM to which the task was assigned and/or a performance characteristic for the task (e.g., a start and/or stop processing time, a processing-time duration and/or whether any errors occurred). The task event can be time stamped (e.g., with a time that the event was created, a time that task processing began or completed or an error time) and stored in a time-series data store.

[0222] FIG. 18A illustrates a flowchart of an embodiment of a process 1800 for characterizing hypervisor components' performance. Process 1800 begins at block 1805, where activity monitor 1215 monitors performance of VMs and hosts. Through this monitoring, activity monitor 1215 can detect values of performance metrics, such as CPU usage, memory usage, task assignment counts, task assignment types, task completion counts, and/or migrations to/from the VM or to/from the host. Activity monitor 1215 stores the detected values of performance metrics in activity data store 1220 at block 1810.

[0223] Aggregator 1225 accesses an applicable architecture from architecture data store 1230 at block 1815. The applicable architecture can be one associated with a reviewer, one randomly selected, or one defining a Hypervisor of interest. The architecture can identify some or all of the VMs and/or hosts monitored at block 1805. The architecture can identify relationships from the VM to other hypervisor components.

[0224] Aggregator 1225 identifies one of the components from the architecture and a time period. The time period can include a current time/time period (i.e., real-time or most recent time in activity data store 1220 for the component) or a previous time period. In some instances, process 1800 first characterizes performance of low-level components (e.g., VMs) before characterizing performance of high-level components.

[0225] Aggregator 1225 accesses appropriate values of one or more performance metrics or states at block 1820. In some instances, for low-level components, values of one or more performance metrics can be accessed from activity data store 1220. In some instances, for high-level components, states of children of the components can be accessed from state data store 1260. In some instances, values of one or more performance metrics are accessed from activity data store 1220 for all components.

[0226] Statistics generator 1240 generates a statistic based on the accessed metrics or states and stores the statistic in statistic data store 1245 at block 1825. The statistic can include, e.g., an average or extreme metric across the time period or a percentage of children components having been assigned to one or more specific states (e.g., any of states red, orange, or yellow).

[0227] State engine 1250 accesses one or more state criteria from state-criteria data store 1255 at block 1830. Which state criteria are accessed can depend on which component is being assessed. In one instance, different levels in an architecture have different criteria.

[0228] State engine 1250 assesses the criteria in view of the statistic to determine which state the component is in during the time period. State engine 1250 then assigns the component to that state (as a present state or a past state associated with the time period) at block 1835.

[0229] State engine 1250 stores the state in association with the component and time period in state data store 1260 at block 1840. Process 1800 can then return to block 1820 and repeat blocks 1820-1840 for a different component and/or a different time period. For example, process can repeat in this manner to continue to identify and store current statistics and/or states.

[0230] It will be appreciated that values of one or more performance metrics, one or more statistics and/or one or more states can be stored in a time-series data store. In one instance, one or more events are created and stored. Each event can include one or more performance-data variables (e.g., values of performance metric, statistic and/or state) and an identifier of a hypervisor component corresponding to the performance-data variable(s). A single event can correspond to a single hypervisor component or multiple hypervisor components.

[0231] Each event can include or can otherwise be associated with a time stamp. In one instance, the time stamp corresponds to the performance-data variable(s) (e.g., indicating when performance was monitored). Each event can then be stored in a bucket in a data store that corresponds to (e.g., includes) the time stamp. This storage technique can facilitate subsequent time-based searching.

[0232] FIG. 18B illustrates a flowchart of an embodiment of a process 1850 for generating and using time stamped events to establish structure characteristics associated with strong performance. Process 1850 begins at block 1855, where a structure or architecture of an information-technology environment (e.g., a Hypervisor environment) is monitored. The monitoring can include determining a number of components within the environment, a number of a particular type of component (e.g., VMs, hosts or clusters in the environment), and/or relationships between components in the environment (e.g., identifying which VMs are assigned to which hosts or identifying other parent-child relationships). This monitoring can, in some instances, be accomplished by detecting each change (e.g., initiated based on input from an architecture provider) made to the structure.

[0233] At block 1860, a time stamped event identifying a characteristic of the structure can be identified. The event can identify, e.g., one or more parent-child relationships and/or a number of total components (and/or components of a given type) in the environment. In one instance, the event identifies a portion or all of a hierarchy of the environment. The time stamp can be set to a time at which the characteristic was present (e.g., a time at which the structure was monitored at block 1805). In one instance, multiple events include information characterizing an environment operating at a given timepoint (e.g., each even pertaining to a different component operating in the environment and identifying any parent and/or child component in a hierarchy). One or more generated structure events can be stored in a time-series data store at block 1865 (e.g., by storing the event in a bucket including the time stamp of the event).

[0234] At block 1870, performance of each of one, more or all components in the environment can be monitored. For example, values of one or more performance metrics can be monitored for VMs and/or hosts. In some instances, a performance statistic and/or state are generated based on the monitored metrics.

[0235] A time stamped performance event can be generated at block 1875. The event can identify performance data (e.g., one or more values of metrics, statistics and/or states) for one or more components in the environment (e.g., and identifiers of the one or more components). The time stamp for the event can identify a time for which the performance data was accurate (e.g., a time of monitoring giving rise to the performance data). One or more performance events can be stored in a time-series data store at block 1880. The time-series data store at which the performance events are stored can be the same as or different from the performance events at which the structure events are stored (e.g., by storing the event in a bucket including the time stamp of the event).

[0236] At block 1885, performance characteristics can be correlated with characteristics of the information-technology (IT) environment. In one instance, a set of performance events and a set of structure events, each set corresponding to a time period, are retrieved from the time-series data store(s). Each of one or more performance events can be associated with structure characteristics of an information technology environment operating at that time. For example, a structure event with a time stamp most recently preceding a time stamp of a performance event can identify the structure.

[0237] After the events are retrieved, information from the events can be extracted from the events (e.g., using a late-binding schema). The information that is extracted can include performance data, component identifiers and/or structure information (e.g., parent-child relationships and/or components present in an environment).

[0238] A high-level statistic can be determined based on performance data for a set of components. For example, the high-level statistic can include an extrema (e.g., indicative of a worst or best performance), a mean, a median, a mode, a standard deviation or a range. The high-level statistic can be defined based on a fixed definition and/or input (e.g., such that a reviewer can define a high-level statistic of interest). A structure characteristic (which can be numeric) can also be determined based on extracted structure information. The structure characteristic can include, e.g., a number of total components (e.g., hosts and VMs) in an environment (e.g., Hypervisor environment); a number of a given type of components (e.g., a number of hosts or clusters) in the environment; and/or an average, median, minimum or maximum number of children of a particular type of parent (e.g., a maximum number of VMs supported by a single host or an average number of hosts assigned to a given cluster). In some instances, structure events identify changes in structure (e.g., addition of VM). In these instances, determining a structure characteristic can include modifying a previous characteristic (e.g., to identify a previous VM count and add one to the count).

[0239] Thus, a set of high-level statistics, each associated with a time, can be determined. For each statistic, a corresponding structure characteristic can be identified (e.g., by identifying a structure characteristic associated with a time most recent to a time associated with the high-level statistic; or by identifying a structure characteristic associated with a time matching a time associated with the high-level statistic). Thus, a matching set of structure characteristics can be identified. The set of high-level statistics and the set of structure characteristics can be analyzed (e.g., using a correlation analysis or model) to estimate influence of structure characteristics on performance

[0240] For example, using a set of structure events, a set of VMs supported by a particular host can be identified for multiple timepoints. Corresponding performance events can then be used to establish a relationship between a number of VMs assigned to the host and a “worst” performance statistic from amongst the set of VMs. As another example, a determination can be made as to whether assigning two hosts to a single cluster improved an average performance of the two hosts as compared to independent operation of the hosts. This determination can be performed by using performance and structure events to identify, for each timepoint in a set of timepoints, a performance metric for the hosts and whether the hosts were assigned to a cluster.

[0241] One or more performance events, structure events, performance data (or high-level performance statistics), structure characteristics, and/or correlation results can be presented to a reviewer. For example, structure characteristics identified as being correlated to poor or strong performance can be identified to a user, or a relationship between a characteristic and performance can be identified.

[0242] It will be appreciated that the performance influence of structure characteristics can be investigated using alternative techniques. For example, changes (e.g., improvements or degradations) in high-level performance statistics can be detected and structure changes preceding the changes can be identified. As another example, changes in structure characteristics can be detected, and subsequent high-level performance statistics can be identified. Averages, weighted on a type or magnitude of performance or structure change can be used to evaluate influence.

[0243] State determinations for higher-level components can depend on direct performance measurements for a performance metric for the higher-level component, or it may depend on performances of underlying children low-level components. One technique for arriving at the higher-level state would then be to aggregate performance metrics from all children components, generate a statistic based on the aggregated metrics, and identify a state based on the statistic. However, this approach could lead to a positive state assignment even in the case where a small number of children components were performing very poorly. The aggregate analysis could over-look this problem due to the mitigation of the poor data by other positive data from properly performing children components. Thus, another approach is to first identify a state for each child component, and then to determine a state for a parent component based on the states (not the direct metrics) of the child components. The state criteria can then set forth, e.g., a threshold number of child state assignments to a negative state that would cause the parent component also to be assigned to a negative state. FIGS. 19-20 illustrate example processes for state assignments determined using this approach.

[0244] FIG. 19 illustrates a flowchart of an embodiment of a process 1900 for assigning a performance state to a low-level component in a Hypervisor. Process 1900 begins at block 1905, where aggregator 1225 accesses an applicable architecture from architecture data store 1230. The architecture identifies a particular VM, and aggregator 1225 accesses values of one or more performance metrics characterizing the VM's performance during a time period from activity data store 1220 at block 1910. Based on the values of one or more performance metrics, statistic generator 340 generates a performance statistic (e.g., an average of the metrics) at block 1915.

[0245] State engine 1250 accesses one or more state criteria from state-criteria data store 1255 at block 1920. In some instances, state-criteria data store 1255 includes multiple criteria, which may apply to different component types (e.g., having different configurations or capabilities), different architecture levels, different architectures, and/or different reviewers. Thus, at block 1920, state engine 1250 can select the criteria that are applicable to the VM and/or to a reviewing reviewer. State engine 1250 evaluates the statistic in view of the accessed criteria, and, as a result of the evaluation, assigns a state to the VM at block 1925.

[0246] FIG. 20 illustrates a flowchart of an embodiment of a process 2000 for assigning a performance state to a high-level component in a Hypervisor. Process 2000 begins at block 2005, where aggregator 1225 accesses an applicable architecture from architecture data store 1230. This architecture can be the same architecture as accessed at block 1905 in process 1900. The architecture can include a component that is a parent of the VM from process 1900. Thus, the architecture can include a VM-group component (e.g., a host).

[0247] Aggregator 1225 accesses a state, from state data store 1260, for each VM in the VM group at block 2010. Statistics generator 1240 generates a performance statistic based on the accessed states at block 2015. The statistic can include, e.g., an average, a percentage of VMs being assigned to a particular state, a percentage of VMs being assigned to a particular state or a worse state, etc. State engine 1250 accesses state criteria from state-criteria data store 1255 at block 2020. As in process 1900, this access can include selecting the criteria that are applicable to the VM group and/or reviewing reviewer. It will be appreciated that the state criteria accessed at block 2020 can differ from the state criteria accessed at block 1920. State engine 1250 evaluates the statistic in view of the accessed criteria, and, as a result of the evaluation, assigns state to VM group at block 2025.

[0248] Despite the potential difference in the criteria used in processes 1900 and 2000, the types of potential states that can be assigned can be similar or the same. This can enable a reviewer 1025 to easily understand how well the component is performing without having to understand the different criteria used in the assessment.

[0249] FIG. 21 illustrates a flowchart of an embodiment of a process 2100 for using a VM machine to complete user tasks. Process 2100 begins at block 2105, where reviewer account engine 1205 authenticates a reviewer 1025.

[0250] At block 2110, interface engine 1275 presents, to reviewer 1025, a dynamic representation of at least part of an architecture of a Hypervisor and, for each of a set of components represented in the architecture, a performance state assigned to the component. In some instances, the architecture and performance states are simultaneously represented to reviewer 1025.

[0251] The architecture can be presented by displaying a series of nodes—each node representing a hypervisor component. The nodes can be connected to show relationships. Relationships can include, e.g., resource-providing relationships (e.g., between a host and VM), migration-enabling relationships (e.g., between two hosts in a cluster, which can be denoted via a direct connection or an indirect connection via an upper level host-cluster component). The nodes can be presented in a hierarchical manner, and relationships can include familial (e.g., parent-child) relationships. It will be appreciated that the architecture can be presented in a variety of other manners. For example, a series of lists can identify, for each of a set of components, respective “children” components. As another example, rows and columns in a matrix can identify columns, and cells in the matrix can identify relationship presence and/or a type of relationship.

[0252] The presentation of the architecture can include identifying all components and relationships in the architecture or a subset of the components and relationships. The subset can include, e.g., components in a highest level in the architecture or in the highest n levels (e.g., n being 2, 3, 4, etc.) and not components in the lower levels. Such a representation can encourage a reviewer 1025 to assess a Hypervisor's performance in a top-down manner, rather than requiring that a reviewer 1025 already know a lower-level source of sub-optimal performance.

[0253] A performance state can be represented by a color, word, pattern, icon, or line width. For example, nodes in a representation of an architecture can have an appearance characteristic (e.g., a line color, a line thickness, or a shading) that depends on the state of the represented component.

[0254] The performance state can include an overall performance state. The overall performance state can be determined based on a plurality of factors, such as CPU usage, memory usage, task-processing times, task-processing intake numbers, and/or received or transmitted task migrations. In some instances, a value for each factor is identified and weighted, and a sum of the weighted values is used to determine the overall performance state. In some instances, an overall performance state depends on whether any of one or more factors fail respective satisfaction criteria or fall into a particular state (e.g., a warning state).

[0255] In some instances, the performance state is not an overall performance state but instead relates to a particular performance factors. States pertaining to different performance factors can be simultaneously presented (e.g., via matrices or lists or via repeated presentation of a family tree with state distinguishers). In one instance, a single family tree is shown to represent the architecture, and each node can have a graphical element (e.g., a line width, line color, shading, icon presence, etc.) that represents a state for one performance factor. Thus, e.g., by looking at line width, a reviewer 1025 could evaluate CPU-usage performances, and, by looking at line color, reviewer 1025 could evaluate memory-usage performances.

[0256] In some instances, a reviewer 1025 can select a performance factor of interest. For example, a user can select “CPU usage” from a performance-factor menu, and nodes in a family tree can then be differentially represented based on their CPU-usage performance.

[0257] Interface engine 1275 detects a selection from reviewer 1025 of a first architecture component at block 2115. The selection can include, e.g., clicking on or hovering over a component representation (e.g., a node, column heading, or row heading).

[0258] Interface engine 1275 presents a detailed performance statistic, component characteristic and/or performance history for selected first component at block 2120. The statistic, characteristic and/or history can pertain to the first component or to a child or children of the first components. A performance statistic can include a recent or real-time performance statistic (e.g., average CPU usage). A component characteristic can include, e.g., resources assigned to the component or equipment of the component. A performance history can include a past performance statistic. In some instances, a statistic and/or performance history is presented with a threshold value or a comparison (e.g., population) value. The presentation can include a numerical, text and/or graphical presentation. For example, performance history can be shown in a line graph. In some instances, different statistics, characteristics and/or performance history is presented based on a selection characteristic. For example, hovering over a component node can cause an overall performance statistic for the component to be shown, while more detailed statistics and/or structure characteristics can be presented responsive to a clicking on the component node.

[0259] Also responsive to the reviewer's selection, interface engine 1275 presents identifications of one or more second architecture components related to the first architecture component at block 2125. This identification can include expanding a representation of the architecture to include representations of the second components (which may have been previously hidden). In some instances, part of the architecture that was initially presented is also hidden at block 2125. This can include, e.g., nodes of components along a non-selected branch in a family-tree architecture. The second components can include components that are children of the first architecture component. States assigned to the second architecture components can also be (e.g., simultaneously) presented.

[0260] Interface engine 1275 detects a reviewer's selection of one of the identified second architecture components at block 2130. The selection can include a same or similar type of selection as that detected at block 2115.

[0261] Interface engine 1275 presents a detailed performance statistic, component characteristic and/or performance history for the selected second component at block 2135. The presentation at block 2135 can mirror that at block 2120 or can be different. In some instances, the presentation at block 2120 relates to performances and/or characteristics of child components of the first component, and the presentation at block 2135 relates to a performance and/or characteristic of the second component (e.g., as the second component may not have child components).

[0262] FIG. 22 illustrates a flowchart of an embodiment of a process 2200 for analyzing the performance of a Hypervisor using historical data. Process 2200 begins at block 2205, where activity monitor 1215 stores the detected performance metrics in activity data store 1220. Block 2205 can parallel block 2810 from process 2800. Interface engine 1275 detects input from a reviewer 1025 at block 2210. The input can identify a time period. Identification of the time period can include identifying a duration of the time period and/or identifying one or both endpoints of the time period. Identification of an endpoint can include identifying an absolute date and/or time (e.g., Apr. 1, 2013, 1 pm) or a relative date and/or time (14 days ago). The input can include a discretization that can be used to define discrete time intervals within the time period. The input can include entry of a number and/or text and/or selection of an option (e.g. using a scroll-down menu, a sliding cursor bar, list menu options, etc.).

[0263] In some instances, a beginning and/or end endpoint of the time period can be at least 1, 2, 3, 7, 14, or 21 days or 1, 2, 3, 6, or 12 months prior to the detection of the input. The time period can have a duration that is at least, that is, or that is less than, 1, 4, 8 12 or 24 hours; 1, 2, or 4 weeks or 1, 2 or 3 months. Time periods for intra-time-period time intervals can be equal to or less than 1, 5, 15 or 30 seconds; 1, 5, 15 or 30 minutes; or 1, 2, 4 or 6 hours. The time period could be any time period going back as far as when performance measurements started to be collected.

[0264] Architecture manager 1235 identifies an applicable architecture at block 2215. The architecture can be one that characterized a structure of the Hypervisor during the identified time period. In some instances, the architecture differs from a current architecture. The architecture can be explicitly or implicitly identified. As an example of implicit identification, activity data store 1220 can index performance metrics according to direct and indirect components. Thus, a VM CPU usage can be associated with both an identifier of the respective VM and an identifier of a host connected to the VM at the time that the metric was obtained.

[0265] Process 2200 continues then to perform blocks 2220-2230 or 2225-2230 for each of one, more or all components in the architecture. In instances in which the time period is to be analyzed in a discretized manner, blocks 2220-2230 or 2225-2230 can also be repeated for each discrete time interval in the time period. In these latter cases, it will be appreciated that multiple applicable architectures can be identified to account for any architecture changes during the time period.

[0266] Statistics generator 1240 generates a historical statistic at block 2220. The historical statistic can be of a type similar or the same as a performance statistic described herein and can be determined in a similar manner as described herein. It will thus be appreciated that, e.g., depending on a component type, a historical statistic can be determined directly based on the performance metrics (e.g., to determine an average CPU usage) or can be determined based on lower-level component states (e.g., to determine a percentage of VMs with warning-level CPU usages).

[0267] State engine 1250 accesses an appropriate state criterion and evaluates the generated statistic in view of the criterion. Based on the evaluation, state engine 1250 assigns a historical state to the component at block 2230. Interface engine 1275 presents historical performance indicator(s), as shown at block 2235. The historical indicators can include historical statistics and/or historical states. As before, the performance indicators can be simultaneously presented along with a representation of the applicable architecture (e.g., by distinguishing appearances of nodes in an architecture family tree based on their states).

[0268] Thus, granular low-level performance data can be dynamically accessed and analyzed based on performance characteristics and time periods of interest to a reviewer 1025. By scanning through time periods, reviewer 1025 may be able to identify time points at which performance changed. Reviewer 1025 can then drill down into the component details to understand potential reasons for the change or note any time-locked architecture. Simultaneous presentation of performance indicators and architecture representations aid in the ability to detect temporal coincidence of architecture changes and performance changes.

Process of Gathering Data

[0269] Embodiments described herein in association with the process of gathering data can be used in connection with other aspects described herein. For example, as noted above, tasks assigned to components can include defining, storing, retrieving and/or processing events. Techniques described herein can then be used to gain an understanding about whether tasks can be defined and/or assigned in a different manner which would improve such operation (e.g., improve an overall efficiency or improve an efficiency pertaining to a particular type of event). Techniques can further be used to identify types of events that generally result in poor performance or that result in poor performance when assigned to particular components (or component types) in an information technology environment. Events involved in the tasks can include a variety of types of events, including those generated and used in SPLUNK® ENTERPRISE. Further details of underlying architecture of SPLUNK® ENTERPRISE are now provided.

[0270] FIG. 23 shows a block diagram of SPLUNK® ENTERPRISE's data intake and query system, which provides an example embodiment of a data intake and query system 2300. Data intake and query system 2300 can include Hypervisor components (e.g., a forwarder 2310 or indexer 2315), which are assigned tasks and monitored, as described in greater detail herein. For example, forwarders 2310 can be assigned data-collection tasks; indexers 2315 can be assigned tasks for segmenting collected data into time stamped data events, storing the data events in a time-series event data store, retrieving select events (e.g., data events, performance events, task events and/or structure events) and/or processing retrieved events. It will therefore be appreciated that the components identified in system 2300 are given a functional name. In some exemplary instances, distinct components are defined as forwarders and others as indexers. Nevertheless, in some instances, components are not rigidly functionally defined, such that a single component may be assigned two or more of data-collecting, indexing or retrieval tasks.

[0271] Generally, the system 2300 includes one or more forwarders 2301 that collect data from a variety of different data sources 2305, which can include one or more hosts, host clusters, and/or VMs discussed above, and forwards the data to one or more indexers 2315. The forwarders determine which indexer or indexers are to receive the data and forward the data to one or more indexers 2302. The data typically includes streams of time-series data. Time-series data refers to any data that can be segmented such that each segment can be associated with a time stamp. The data can be structured, unstructured, or semi-structured and can come from files and directories. Unstructured data is data that is not organized to facilitate the extraction of values for fields from the data, as is often the case with machine data and web logs, two popular data sources for SPLUNK® ENTERPRISE. Alternatively, heavy forwarders can strip out extraneous data and detect time stamps for the data. Based on the time stamps, the heavy forwarders can index and group the data into buckets that fall within a common time span. The heavy forwarders then determine which indexer or indexers are to receive each bucket of data and forward the data to one or more indexers 2302.

[0272] Tasks defined to a given forwarder can therefore identify a data source, a source type and/or a collection time. In some instances, tasks can further instruct a forwarder to tag collected data with metadata (e.g., identifying a source and/or source-type, such as the one or more hosts 1045 and VMs 1050 discussed above) and/or to compress the data.

[0273] Tasks can also relate to indexing of accessible (e.g., collected or received) data, which can be performed by one or more indexers 2315. FIG. 24 is a flowchart 2400 of a process that indexers 2302 may use to process, index, and store data received from the forwarders 2301. At block 2401, an indexer 2302 receives data (e.g. from a forwarder 2301). At block 2402, the data is segmented into data events. The data typically consists of many lines of text that are separated by a carriage return or line break. An event may consist of one or more of these lines. The data events can be broken at event boundaries, which can include character combinations and/or line breaks. The task of the indexer is to determine where an event begins and ends in the lines of data. The indexer can use heuristics that allow it to automatically determine how many lines constitute an event. The indexer may be informed of the source of the data and have a set of heuristic rules for the source. The indexer may also be able to examine a sampling of the data and automatically determine the source of the data and have a set of heuristic rules for that source. These heuristics allow the indexer to use regular expression-based rules, delimiter-based rules, etc., to examine the text in each line in order to combine lines of data to form an event. The indexer can examine the text for event boundaries within the text that include, but are not limited to: predefined characters, character strings, etc. These may include certain punctuation marks or special characters including, for example, carriage returns, tabs, spaces, line breaks, etc. In some instances, event boundaries are discovered automatically by the software, and in other instances, they may be configured by the user. In some instances, a user can fine tune or configure the rules that the indexers use to examine the text in order to adapt to the user's equipment.

[0274] The indexer determines a time stamp for each event at block 2403. The time stamp can be determined by extracting the time from data in the data event or by interpolating the time based on time stamps from other events. In alternative embodiments, a time stamp may be determined from the time the data was received or generated. The time stamp is associated with each data event at block 2404. For example, the time stamp may be stored as metadata for the data event.

[0275] At block 2405, the data included in a given data event may be transformed. Such a transformation can include such things as removing part of a data event (e.g., a portion used to define event boundaries) or removing redundant portions of an event. A user/client may specify a portion to remove using a regular expression or any similar method.

[0276] Optionally, a key word index can be built to facilitate fast keyword searching of data events. To build such an index, in block 2406, a set of keywords contained in the data events is identified. At block 2407, each identified keyword is included in an index, which associates with each stored keyword pointers to each data event containing that keyword (or locations within data events where that keyword is found). When a keyword-based query is received by an indexer, the indexer may then consult this index to quickly find those data events containing the keyword without having to examine again each individual event, thereby greatly accelerating keyword searches.

[0277] Data events are stored in an event data store at block 2408. The event data store can be the same as or different than a task data store, performance data store and/or structure data store. The data can be stored in working, short-term and/or long-term memory in a manner retrievable by query. The time stamp may be stored along with each event to help optimize searching the events by time range.

[0278] In some instances, the event data store includes a plurality of individual storage buckets, each corresponding to a time range. A data event can then be stored in a bucket associated with a time range inclusive of the event's time stamp. This not only optimizes time based searches, but it can allow events with recent time stamps that may have a higher likelihood of being accessed to be stored at preferable memory locations that lend to quicker subsequent retrieval (such as flash memory instead of hard drive memory).

[0279] As shown in FIG. 23, event data stores 2303 may be distributed across multiple indexers, each responsible for storing and searching a subset of the events generated by the system. By distributing the time-based buckets among them, they can find events responsive to a query in parallel using map-reduce techniques, each returning their partial responses to the query to a search head that combines the results together to answer the query. It will be appreciated that task events, performance events and/or structure events can also be stored in the same or different time-series data stores that are accessible to each of multiple indexers. Thus, queries pertaining to a variety of types of events (or combinations thereof) can be efficiently performed. This query handling is illustrated in FIG. 25.

[0280] FIG. 25 is a flowchart 2500 of a process that a search head 2304 and indexers 2302 may perform during a typical search query. At block 2501, a search head receives a query from a client. The query can include an automatic query (e.g., periodically executed to evaluate performance) or a query triggered based on input. The query can include an identification of a time period, a constraint (e.g., constraining which events are to be processed for the query, where the constraint can include a field value), and/or a variable of interest (e.g., a field and/or a statistic type). The query can pertain to a single type of event or multiple types of events. For example, a query may request a list of structure characteristics of an environment (e.g., number of VMs in a Hypervisor) during time periods of strong high-level performance (e.g., a minimum VM performance statistic above a threshold). As another example, a query can request data events indexed by a component during an hour of poorest performance over the last 24 hours. Processing this request can then include retrieving and analyzing performance events (to identify the poor-performance hour), task events (to identify tasks performed by the component in the hour), and the data events indexed according to the identified tasks. As another example, an automatic query that routinely evaluates performance correlations can request that structure events be evaluated to detect structure changes and that performance events be analyzed to determine any effect that the changes had on performance.

[0281] At block 2502, the search head is responsible for analyzing the search query to determine what part can be delegated for execution by indexers and what part needs to be executed by the search head. Streaming commands can be trivially delegated to the indexers. Conversely, aggregating commands are more complex to distribute.

[0282] The search head can perform optimization steps in order to make the search more efficient. As mentioned above, the indexers may create an index of keywords. In one optimization, before the search starts executing, the search head determines the time range required for the search and a set of common keywords that all matching events must have. The retrieval phase uses these parameters to query the indexers for a superset of the eventual results. The indexers return the superset of results that the search head can perform a filtering stage on. The filtering stage performs field extraction on the superset to arrive at a reduced set of search results.

[0283] In another optimization, to achieve better computation distribution and minimize the amount of data transferred between indexers and the search head, many aggregating commands implement a map operation which the search head can delegate to the indexers while executing the reduce operation locally. FIG. 26 shows an example of a search query 2601 received from a client that the search head can split into two parts: one part to be executed by indexers 2602 and one part to be executed by the search head 2603. Here, the search query 2602 makes the indexers responsible for counting the results by host and then sending their results to the search head. The search head then performs the merging 2603. This achieves both computation distribution and minimal data transfer.

[0284] At block 2502, the search head distributes the query to one or more distributed indexers. These indexers can include those with access to event data stores, performance data store and/or structure data stores having events responsive to the query. For example, the indexers can include those with access to events with time stamps within part or all of a time period identified in the query.

[0285] At block 2503, one or more indexers to which the query was distributed searches its data store for events responsive to the query. To determine events responsive to the query, a searching indexer finds events specified by the criteria in the query. Initially, a searching indexer can identify time buckets corresponding to a time period for the query. The searching indexer can then search for events within the buckets for those that, e.g. have particular keywords or contain a specified value or values for a specified field or fields (because this employs a late-binding schema, extraction of values from events to determine those that meet the specified criteria occurs at the time this query is processed). For example, the searching indexer can search for performance events with performance data corresponding to a particular host (e.g. by searching for an identifier of the host) or search for weblog events with an identifier of a particular user device.

[0286] It should be appreciated that, to achieve high availability and to provide for disaster recovery, events may be replicated in multiple event data stores, in which case indexers with access to the redundant events would not respond to the query by processing the redundant events. The indexers may either stream the relevant events back to the search head or use the events to calculate a partial result responsive to the query and send the partial result back to the search head.

[0287] At block 2504, the search head combines all the partial results or events received from the parallel processing together to determine a final result responsive to the query. In some instances, processing is performed, which can include extracting values of one or more particular fields corresponding to the query, analyzing the values (e.g. to determine a statistic for a field or to determine a relationship between fields).

[0288] A query result can be displayed to a reviewer. The query result can include extracted values from retrieved events, full retrieved events, a summary variable based on extracted values from retrieved events (e.g., a statistic, correlation result or model parameter) and/or a graphic (e.g., depicting a change in extracted field values over time or correspondences between values of one field and values of another field. In some instances, the display is interactive, such that more detailed information is iteratively presented in response to inputs. For example, a first performance indicator for a component can be presented. A selection input can cause information identifying a number of indexing events performed by the component during a time period. A further input can cause extracted values from indexed events to be presented. A further input can cause the events themselves to be presented.

[0289] One or more of the blocks in process 2400 and/or process 2500 can include an action defined in a task. The task can include appropriate information. For example, a task can indicate how events are to be transformed or whether keywords are to be identified or a keyword index is to be updated. As another example, a task can include a time period (e.g., such that a data-indexing or event-retrieving effort can be divided amongst indexers).

[0290] Data intake and query system 2300 and the processes described with respect to FIGS. 23-26 are further discussed and elaborated upon in Carasso, David. Exploring Splunk Search Processing Language (SPL) Primer and Cookbook. New York: CITO Research, 2012 and in Ledion Bitincka, Archana Ganapathi, Stephen Sorkin, and Steve Zhang. Optimizing data analysis with a semi-structured time series data store. In SLAML, 2010. Each of these references is hereby incorporated by reference in its entirety for all purposes.

[0291] Disclosures herein can therefore enable reviewers to directly review current or historic al performance data, to view performance data concurrently with other data (e.g., characteristics of a structure of a corresponding environment or characteristics of data indexed at a time corresponding to the performance data) and/or to identify relationships between types of information (e.g., determining which tasks, task assignments or structure characteristics are associated with strong performance). Based on a user-entered time range, it may also be possible to correlate performance measurements in the time range for a performance metric with log data from that same time range (where the log data and/or the performance measurements may both be stored in the form of time-stamped events).

[0292] SPLUNK® ENTERPRISE can accelerate some queries used to periodically generate reports that, upon each subsequent execution, are intended to include updated data. To accelerate such reports, a summarization engine periodically generates a summary of data responsive to the query defining the report for a defined, non-overlapping subset of the time period covered by the report. SPLUNK® ENTERPRISE can (also) accelerate queries building on overlapping data, by generating intermediate summaries of select events that can then be used in place of again retrieving and processing the events when the same query is repeatedly run but later repeats include newer events as well as the older events. This can be particularly useful when performance data is routinely evaluated (e.g., alone or in combination with other data types). For example, where the query is meant to identify events meeting specified criteria, a summary for a given time period may include (or may identify or may identify timepoints for) only those events meeting the criteria. Likewise, if the query is for a statistic calculated from events, such as the number of events meeting certain criteria, then a summary for a given time period may be the number of events in that period meeting the criteria.

[0293] New execution of a query identifying a query time period (e.g., last 24 hours) can then build on summaries associated with summary time periods fully or partly within the query time period. This processing can save the work of having to re-run the query on a time period for which a summary was generated, so only the newer data needs to be accounted for. Summaries of historical time periods may also be accumulated to save the work of re-running the query on each historical time period whenever the report is updated. A determination can be automatically made from a query as to whether generation of updated reports can be accelerated by creating intermediate summaries for past time periods. If it can, then at a given execution of a query, appropriate events can be retrieved and field values can be extracted. One or more intermediate summaries (associated with a time period not overlapping with another corresponding summary) can be created and stored.

[0294] A process for generating such a summary or report can begin by periodically repeating a query used to define a report. The repeated query performance may focus on recent events. The summarization engine determines automatically from the query whether generation of updated reports can be accelerated by creating intermediate summaries for past time periods. If it can, then a summarization engine can periodically create a non-overlapping intermediate summary covering new data obtained during a recent, non-overlapping time period and stores the summary in a summary data store.

[0295] At each subsequent execution of the query (or execution of another query building on the same data), a determination can be made as to whether intermediate summaries have been generated covering parts of the time period covered by the current query execution. If such summaries exist, then the report is based on the information from the summaries; optionally, if additional data has been received that has not yet been summarized but that is required to generate a complete report, then the query is run on this data and, together with the data from the intermediate summaries, the updated current report is generated. This process repeats each time an updated report is scheduled for creation.

[0296] Search and report acceleration methods are described in U.S. Pat. No. 8,589,403, issued on Nov. 19, 2013, and U.S. Pat. No. 8,412,696, issued on Apr. 2, 2011, both of which are hereby incorporated by reference in their entirety for all purposes.

[0297] FIG. 27 is a flow chart showing how to accelerate automatically query processing using intermediate summaries. At block 2705, a query is received. The query can include one generated based on reviewer input or automatically performed. For example, a query can be repeatedly performed to evaluate recent performance of a Hypervisor. The query may include a specification of an absolute time period (e.g., Jan. 5, 2013-Jan. 12, 2013) or relative time period (e.g., last week). The query can include, e.g., specification of a component of interest (e.g., VM #5), a component type of interest (e.g., host), a relationship of interest (e.g., number of child VMs supported by a single host) and/or a performance variable of interest (e.g., component-specific task-completion latency, average memory usage).

[0298] A time period for the query can be identified at block 2710. This time period can include an absolute time period, with a start and end time and date of the query. A determination can be made at block 2715 as to whether an intermediate summary applicable to the query exists for the query time period. Stored intermediate summaries can be scanned to identify those that are associated with summary time periods partly (or fully) within the query time period. Further, selection can be restricted to match data types pertinent to the query. For example, when a query relates purely to performance data, intermediate summaries relating only to structure data can be avoided.

[0299] When it is determined that there is not a pertinent intermediate summary associated with a summary time range that includes a portion (e.g., any portion or a new portion) of the query time range, process 2700 continues to block 2720 where new events pertaining to the query are retrieved from one or more data stores. At block 2725, a query result is generated using the events. In some situations, one or more intermediate summaries of retrieved events are generated at block 2730. Each summary can be associated with a summary time period (e.g., defined based on time stamps of the events), event type (e.g., performance, structure, data or task) and/or variable type (e.g., a type of performance variable).

[0300] When it is determined that one or more intermediate summaries exist that summarize query-pertinent data and that are associated with a summary time range that includes a summary time range that includes a portion (e.g., any portion or new portion) of the query time range, process 2700 continues to block 2735, where those identified summaries are collected. At block 2740, any new events not summarized in a collected summary yet pertinent to the query are retrieved. Information from the collected one or more summaries can be combined with information from the new events at block 2745. For example, values can be extracted from the new events and combined with values identified in the intermediate summary. A query result (e.g., including a population statistic, relationship or graph) can be generated using the grouped information at block 2750. Process 2700 can then continue to block 2730 to generate one or more intermediate summaries based on the new events.

[0301] It will be appreciated that process 2700 may be modified to omit blocks 2740, 2745 and 2730. This modification may be appropriate when existing summaries are sufficient for generating a complete and responsive query result.

[0302] An acceleration technique that can be used in addition to or instead of intermediate summaries is use of a lexicon. For each of one or more fields, a lexicon can identify the field, can identify one or more values for the field, and can identify (and/or point to) one or more events having each of the identified values for the field. Thus, for example, a first query execution can result in retrieval of a first set of events. Values for one or more fields (e.g., a performance metric) can be extracted from the events (e.g., using a learned or defined late-binding schema). A lexicon can be generated, accessed and/or modified that includes a set of values inclusive of the field values. The values in the lexicon can be a single number, a list of numbers or a range of numbers.

[0303] For each retrieved event, a representation of the event can be added to the lexicon. The representation can include an identifier, a pointer to the event, or an anonymous count increment. The lexicon can be associated with a time period that includes time stamps of events contributing to the lexicon. A lexicon may also or alternatively contain a set of keywords (or tokens) and pointers to events that contain those keywords. This enables fast keyword searching.

[0304] As described with reference to intermediate summaries, intermediate lexicons can be generated for non-overlapping time periods. Subsequent queries can then use and/or build on lexicons with relevant data to generate a result. For example, a number of events associated with a given lexicon value can be counted, an average field value can be determined or estimated (e.g., based on counts across multiple lexicon values), or correlations between multiple fields can be determined (e.g., since entries for multiple lexicon values can identify a single event). In one instance, correlations can also be determined based on data in multiple lexicons. For example, each point in a set of points analyzed for a correlation or model analysis can correspond to a lexicon and can represent frequencies of values of multiple fields in the lexicon (e.g., a first lexicon having an average value of X1 for field F1 and an average value of Y1 for field F2, and a second lexicon having an average value of X2 for field F1 and an average value of Y2 for field F2). U.S. application Ser. No. 13/475,798, filed on May 18, 2012 provides additional detail relating to lexicon, and the application is hereby incorporated by reference for all purposes.

[0305] Another acceleration technique that can be used in addition to or instead of intermediate summaries and/or a lexicon is a high performance analytics store, which may take the form of data model acceleration (i.e., automatically adding any fields in a data model into the high performance analytics store). Data model acceleration thus allows for the acceleration of all of the fields defined in a data model. When a data model is accelerated, any pivot or report generated by that data model may be completed much quicker than it would without the acceleration, even if the data model represents a significantly large dataset.

[0306] Two exemplary types of data model acceleration may include: ad hoc and persistent data model acceleration. Ad hoc acceleration may be applied to a single object, run over all time, and exist for the duration of a given session. By contrast, persistent acceleration may be turned on by an administrator, operate in the background, and scoped to shorter time ranges, such as a week or a month. Persistent acceleration may be used any time a search is run against an object in an acceleration-enabled data model.

[0307] Data model acceleration makes use of SPLUNK® ENTERPRISE's high performance analytics store (H PAS) technology, which builds summaries alongside the buckets in indexes. Also, like report acceleration discussed above, persistent data model acceleration is easy to enable by selecting a data model to accelerate and selecting a summary time range. A summary is then built that spans the indicated time range. When the summary is complete, any pivot, report, or dashboard panel that uses an accelerated data model object will run against the summary rather than the full array of raw data whenever possible. Thus, the result return time may be improved significantly.

[0308] Data model acceleration summaries take the form of a time-series index. Each data model acceleration summary contains records of the indexed fields in the selected dataset and all of the index locations of those fields. These data model acceleration summaries make up the high performance analytics store. Collectively, these summaries are optimized to accelerate a range of analytical searches involving a specific set of fields—the set of fields defined as attributes in the accelerated data model.

Data Correlation

[0309] FIG. 28 is a flow chart showing an exemplary process 2800 for correlating performance measurements/values of one or more of the performance metrics mentioned above of one or more hosts, host clusters, and/or VMs with machine data from the one or more hosts, host clusters, and/or VMs. Process 2800 begins at block 2805 where a set of performance measurements (i.e., values of one or more of the above-mentioned performance metrics) of one or more components of the IT environment are stored, as discussed above, for example, in regards to FIGS. 28A and 28B. The one or more components of the IT environment may include one or more of each of a host, a cluster, and/or a virtual machine (“VM”). The performance measurements may be obtained through an application programming interface (API) before being stored. The performance measurements may be determined by directly observing the performance of a component, or the performance measurements may be determined through any of the above-mentioned methods of monitoring performance measurements. Further, it is possible for the performance measurements to be determined without any reference (direct or indirect) to log data.

[0310] At block 2810, for each of the performance measurements in the set of performance measurements, a time at which the performance measurement was obtained (or a time to which the performance measurement relates) is associated with the performance measurement. Each performance measurement may be stored in any searchable manner, including as a searchable performance event associated with a time stamp. The time stamp for the performance event may be the associated time at which the performance measurement was obtained.

[0311] Process 2800 continues on to block 2815, in which portions of log data produced by the IT environment are stored. For each portion of log data, a time is associated with that portion. This block is similar to the process as discussed above in regards to FIG. 24. Each of the portions of log data may be stored as a searchable event associated with a time stamp. The time stamp for the event that includes the portion of log data may be the associated time for that portion of log data.

[0312] At block 2820, a graphical user interface is provided to enable the selection of a time range. (See FIGS. 29A-29F below). Then, at block 2825, through the graphical user interface, a selection of the time range is received. Optionally, the graphical user interface may allow a selection of a type of performance measurement to be retrieved at block 2830. If a selection of a type of performance measurement is received, only the one or more performance measurements of the selected type are retrieved.

[0313] The process 2800 then proceeds to block 2835 where one or more performance measurements of the set of performance measures stored at block 2805 are retrieved. Each of the performance measurements that are retrieved has an associated time that is within the selected time range received at block 2825. Also, if optional block 2830 is performed, each of the one or more performance measurements includes the performance measurement of the selected type. At block 2840, one or more portions of log data stored at block 2810 are retrieved. Each of these retrieved portions of log data has an associated time that is within the selected time range received at block 2825.

[0314] The retrieved one or more performance measurements and the retrieved one or more portions of log data may relate to the same host. The retrieved one or more performance measurements may relate to a cluster and the one or more portions of log data may relate to a host in the cluster. Further, the retrieved one or more performance measurements may relate to a virtual machine and the one or more portions of log data may relate to a host on which that virtual machine has run. A graphical user interface may be provided to allow a selection of a component. If a component is selected, the retrieved one or more performance measurements and the retrieved one or more portions of log data may relate to the same selected component.

[0315] Once the one or more performance measurements and one or more portions of log data are retrieved, the process proceeds to block 2845 where an indication is displayed for the retrieved performance measurements that have associated times within the selected time range. At block 2850, an indication of the retrieved portions of log data that have associated times within the selected time range is displayed. The displayed indication of the retrieved performance measurements may be displayed concurrently with the displaying of the indication of the retrieved portions of log data Alternatively, the displayed indication of the retrieved performance measurements may be displayed at a different time than the displaying of the indication of the retrieved portions of log data. Further, it is possible to display the indication of the retrieved performance measurements in a same window as the indication of the retrieved portions of log data. (See FIGS. 30A and 30B below). It is also possible to display the indication of the retrieved performance measurements in a different window than the indication of the retrieved portions of log data.

[0316] FIGS. 29A-29F illustrates examples of a graphical user interface that enables the selection of a time range as discussed above with respect to block 2820 of FIG. 28. FIG. 29A illustrates the selection of a preset time period. As shown in FIG. 29A, preset time periods that can be selected include: the last 15 minutes, the last 30 minutes, the last 60 minutes, the last 4 hours, the last 24 hours, the last 7 days, the last 30 days, last year, today, week to date, business week to date, month to date, year to date, yesterday, previous week, previous business week, previous month, previous year, and all time (since when performance measurements were first obtained and stored). Also shown in FIG. 29A is the corresponding display of an indication of the retrieved performance measurements that have associated times within the selected time range of block 2845, and indication of the retrieved portions of log data that have associated times within the selected time range of block 2850.

[0317] As shown in FIG. 29B, a reviewer, such as reviewer 1025, can select a custom time range. When a custom time setting is selected, a custom time range visualization may be presented, as shown in FIGS. 29C-29F. The custom time range visualization allows a reviewer to enter an earliest date for data of a report and a latest date for the data of the report through a variety of methods. A reviewer may enter actual dates to be used to generate the report, a relative time period to be used to generate the report, a time window for which the report is to provide real-time data, and may enter a custom time range by using a search language.

[0318] FIG. 29C illustrates one embodiment that allows the reviewer to generate a report by entering a time period by using a search language, such as Splunk Search Processing Language (SPL), as discussed above. The reviewer may enter an earliest time period of the report and a latest time period of the report in the search language, and the custom time range visualization may present the reviewer with the actual dates for the earliest date and latest date. The report will be generated from the entered search language.

[0319] As shown in FIG. 29D, a reviewer may request a real-time report that is generated based on the time window entered by the reviewer. The time window entered could be any number of seconds, minutes, hours, days, weeks, months, and/or years. Once the time window is entered, the custom time range visualization may present the reviewer with a search language equivalent of the time window requested. The report will be generated from the time window entered by the reviewer.

[0320] A reviewer may also enter a relative time range to generate a report as shown in FIG. 29E. In this embodiment, the reviewer would enter the earliest time desired for the report. The earliest time entered could be any number of seconds, minutes, hours, days, weeks, months, and/or years ago, and the latest time period would be the present. Once the time window is entered, the custom time range visualization may present the reviewer with a search language equivalent of the time range requested. The report will be generated from the relative time range entered by the reviewer.

[0321] FIG. 29F illustrates a custom time range visualization that allows a reviewer to enter an earliest time for a time range of the report and a latest time of a time range of the report directly. The reviewer may enter a specific earliest time for the report or request the earliest time to be the earliest date of the data available. The reviewer may also enter the specific latest time for the report or request to use the present. Once entered, the report will be generated based on the times entered.

[0322] FIGS. 30A and 30B illustrate a display of an indication of a retrieved performance measurements in a same window as an indication of the retrieved portions of log data. In alternative embodiments, the information about the performance measurements and the information about the log data could be displayed in separate windows or could be displayed sequentially rather than concurrently. FIG. 30A illustrates an example where the performance measurements of the set of performance measurements is an average CPU core utilization percent metric. Each of the performance measurements that are retrieved has an associated time that is within the selected time range received. Of course, the performance measurement may be any of the above-mentioned performance metrics. FIG. 30B illustrates an example where the graphical user interface may allow a selection of a type of performance measurement to be retrieved at block 2830 of FIG. 28. If a selection of a type of performance measurement is received, only the one or more performance measurements of the selected type are retrieved.

[0323] From the display of an indication of a retrieved performance measurements with an indication of the retrieved portions of log data, a reviewer may interact with the display to retrieve the raw log data associated with the portions of log data and performance measurements, as shown in FIG. 31. This allows a reviewer to easily access and view events directly.

Conclusion

[0324] The disclosed embodiments relate to a system that displays performance data for a computing environment. During operation, the system first determines values for a performance metric for a plurality of entities that comprise the computing environment. Next, the system displays the computing environment as a tree comprising nodes representing the plurality of entities and edges representing parent-child relationships between the plurality of entities. While displaying the tree, the system displays the child nodes for each parent in sorted order based on values of the performance metric associated with the child nodes.

[0325] In some embodiments, the system determines the values for the selected performance metric by receiving, from a user, a selection of the performance metric from a set of monitored performance metrics; and then obtaining the values for the selected performance metric for the plurality of entities from the performance data for the computing environment.

[0326] In some embodiments, while determining the sorted order for the child nodes, the system first determines a performance state for each child node based on a value of the performance metric for an entity associated with the child node, wherein the performance states can include a critical state, a warning state, a normal state, and an unknown state. Moreover, if a child node has descendants in the tree, the performance state associated with the child node includes performance states for the descendants of the child node. Next, the system sorts the child nodes based on the determined performance states, wherein the sorted order is determined based on the number of critical states associated with each child node.

[0327] In some embodiments, the system determines the performance states for the plurality of entities by comparing the values of the performance metric for the plurality of entities against one or more state-specific threshold values to determine the associated performance states for the plurality of entities.

[0328] In some embodiments, an entity can include: a host system; a virtual machine; a cluster comprising one or more host systems; and a virtual center comprising one or more clusters.

[0329] In some embodiments, the performance metric relates to one or more of: central-processing unit (CPU) utilization; memory utilization; disk utilization; and network utilization.

[0330] The disclosed embodiments also relate to a system that displays performance data for a computing environment. During operation, the system determines performance states for a plurality of entities that comprise the computing environment based on values of a performance metric for the entities. Next, the system displays the computing environment as a tree comprising nodes representing the plurality of entities and edges representing parent-child relationships between the plurality of entities. Then, for each parent node in the tree, the system determines counts of one or more performance states for descendants of the parent node in the tree. Finally, the system displays a graphical representation of the determined counts while displaying the parent node.

[0331] In some embodiments, displaying the graphical representation of the determined counts includes displaying a circular ring comprising visually distinct sections associated with different performance states, wherein the visually distinct sections are sized proportionately with the determined counts for the associated performance states.

[0332] In some embodiments, while displaying each leaf node in the tree, the system displays an indicator for a performance state associated with the leaf node.

[0333] In some embodiments, for a selected node in the tree, the system displays a chart with a line illustrating how a value of the performance metric for the selected node varies over time, wherein the line is displayed against a background illustrating how a distribution of the performance metric for a reference set of nodes in the tree varies over time.

[0334] In some embodiments, if the selected node is a parent node, the value of the performance metric for the selected node is an average value for the performance metric across descendant nodes of the selected node in the tree.

[0335] In some embodiments, the background includes a stream chart comprising regions associated with percentile ranges, wherein borders between the regions represent one or more of the following: a minimum value line, a 25^thpercentile line, a 50^thpercentile line, a 75^thpercentile line, a 95^thpercentile line, a maximum value line, and a line associated with a standard deviation.

[0336] In some embodiments, in response to the user selecting a first node in the tree to be pinned, the system displays a first detail panel for the first node, wherein the first detail panel displays state information for the first node, wherein the state information is frozen at the time of pinning. Moreover, in response to the user selecting a second node in the tree to be pinned, the system displays a second detail panel for the second node, wherein the second detail panel displays state information for the second node, wherein the state information is frozen at the time of pinning. Note that the first detail panel is displayed concurrently with the second detail panel to facilitate comparing state information between the first and second nodes.

[0337] In some embodiments, the state information for the first node displayed in the first detail panel includes: configuration information for the first node; and a graph displaying values of the first performance metric for the first node over a time interval.

[0338] In some embodiments, if the first node is a parent node in the tree, the state information for the first node displayed in the first detail panel includes: aggregated configuration information for one or more descendants of the first node; and one or more graphs displaying values of the first performance metric for the one or more descendants of the first node.

[0339] In some embodiments, if the first node and the second node are the same node, and if the user selects a second performance metric prior to selecting the second node to be pinned, while displaying the first detail panel the system displays state information for the first performance metric, and while displaying the second detail panel the system displays state information for the second performance metric. Note that the concurrent display of the first and second detail panels enables the user to view state for the first and second performance metrics for the same node at the same time.

[0340] The detailed description that appears above is presented to enable any person skilled in the art to make and use the disclosed embodiments, and is provided in the context of a particular application and its requirements. Various modifications to the disclosed embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be applied to other embodiments and applications without departing from the spirit and scope of the disclosed embodiments. Thus, the disclosed embodiments are not limited to the embodiments shown, but are to be accorded the widest scope consistent with the principles and features disclosed herein.

[0341] The data structures and code described in this detailed description are typically stored on a computer-readable storage medium, which may be any device or medium that can store code and/or data for use by a system. The computer-readable storage medium includes, but is not limited to, volatile memory, non-volatile memory, magnetic and optical storage devices such as disk drives, magnetic tape, CDs (compact discs), DVDs (digital versatile discs or digital video discs), or other media capable of storing code and/or data now known or later developed.

[0342] Hence, as disclosed above, methods and computer-program products are provided for storing a set of performance measurements relating to performance of a component in an IT environment, and associating with the performance measurement a time at which the performance measurement was obtained for each performance measurement in the set of performance measurements. The methods and computer-program products include storing portions of log data produced by the IT environment, wherein each portion of log data has an associated time; providing a graphical user interface enabling selection of a time range; and receiving through the graphical user interface a selection of a time range. The methods and computer-program products further comprise retrieving one or more performance measurements, wherein each of the retrieved performance measurements has an associated time in the selected time range; retrieving one or more portions of log data, wherein each of the retrieved portions of log data has an associated time in the selected time range; displaying an indication of the retrieved performance measurements having their associated times in the selected time range; and displaying an indication of the retrieved portions of log data having their associated times in the selected time range.

[0343] Embodiments of the subject matter and the functional operations described in this specification can be implemented in digital electronic circuitry, or in computer software, firmware, or hardware, including the structures disclosed in this specification and their structural equivalents, or in combinations of one or more of them. Embodiments of the subject matter described in this specification can be implemented as one or more computer program products, i.e., one or more modules of computer program instructions encoded on a computer readable medium for execution by, or to control the operation of, data processing apparatus.

[0344] The computer readable medium can be a machine readable storage device, a machine readable storage substrate, a memory device, a composition of matter effecting a machine readable propagated signal, or a combination of one or more of them. The term “data processing apparatus” encompasses all apparatus, devices, and machines for processing data, including by way of example a programmable processor, a computer, or multiple processors or computers. The apparatus can include, in addition to hardware, code that creates an execution environment for the computer program in question, e.g., code that constitutes processor firmware, a protocol stack, a data store management system, an operating system, or a combination of one or more of them, A propagated signal is an artificially generated signal, e.g., a machine generated electrical, optical, or electromagnetic signal, that is generated to encode information for transmission to suitable receiver apparatus.

[0345] A computer program (also known as a program, software, software application, script, or code), can be written in any form of programming language, including compiled or interpreted languages, and it can be deployed in any form, including as a standalone program or as a module, component, subroutine, or other unit suitable for use in a computing environment. A computer program does not necessarily correspond to a file in a file system. A program can be stored in a portion of a file that holds other programs or data (e.g., on or more scripts stored in a markup language document), in a single file dedicated to the program in question, or in multiple coordinated files (e.g., files that store one or more modules, sub programs, or portions of code). A computer program can be deployed to be executed on one computer or on multiple computers that are located at one site or distributed across multiple sites and interconnected by a communication network.

[0346] The methods and processes described in the detailed description section can be embodied as code and/or data, which can be stored on a non-transitory computer-readable storage medium as described above. When a system reads and executes the code and/or data stored on the non-transitory computer-readable storage medium, the system performs the methods and processes embodied as data structures and code and stored within the non-transitory computer-readable storage medium.

[0347] Furthermore, the methods and processes described in this specification can be included in hardware modules. For example, the hardware modules can include, but are not limited to, an FPGA (field programmable gate array) or an ASIC (application specific integrated circuit), and other programmable-logic devices now known or later developed. When the hardware modules are activated, the hardware modules perform the methods and processes included within the hardware modules.

[0348] Processors suitable for the execution of a computer program include, by way of example, both general and special purpose microprocessors, and any one or more processors of any kind of digital computer. Generally, a processor will receive instructions and data from a read only memory or a random access memory or both. The essential elements of a computer are a processor for performing instructions and one or more memory devices for storing instructions and data. Generally, a computer will also include, or be operatively coupled to receive data from or transfer data to, or both, one or more mass storage devices for storing data, e.g., magnetic, magneto optical disks, or optical disks. However, a computer need not have such devices. Moreover, a computer can be embedded in another device, e.g., a mobile telephone, a personal digital assistant (PDA), a mobile audio player, a Global Positioning System (GPS) receiver, to name just a few. Computer readable media suitable for storing computer program instructions and data include all forms of nonvolatile memory, media, and memory devices, including by way of example semiconductor memory devices, e.g., EPROM, EEPROM, and flash memory devices; magnetic disks, e.g., internal hard disks or removable disks; magneto optical disks; and CD ROM and DVD ROM disks. The processor and the memory can be supplemented by, or incorporated in, special purpose logic circuitry.

[0349] To provide for interaction with a user, architecture provider or reviewer, embodiments of the subject matter described in this specification can be implemented on a computer having a display device, e.g., a CRT (cathode ray tube) to LCD (liquid crystal display) monitor, for displaying information to the user and a keyboard and a pointing device, e.g., a mouse or a trackball, by which the user can provide input to the computer. Other kinds of devices can be used to provide for interaction with a user, architecture provider or reviewer as well; for example, feedback provided to the user can be any form of sensory feedback, e.g., visual feedback, auditory feedback, or tactile feedback; and input from the user, architecture provider or reviewer can be received in any from, including acoustic, speech, or tactile input.

[0350] Embodiments of the subject matter described in this specification can be implemented in a computing system that includes a back end component, e.g., as a data server, or that includes a middleware component, e.g., an application server, or that includes a front end component, e.g., a client computer having a graphical user interface or a Web browser through which a user can interact with an implementation of the subject matter described in this specification, or any combination of one or more such back end, middleware, or front end components. The components of the system can be interconnected by any form or medium of digital data communication, e.g., a communication network. Examples of communication networks include a local area network (“LAN”) and a wide area network (“WAN”), e.g., the Internet.

[0351] The computing system can include clients and servers. A client and server are generally remote from each other and typically interact through a communication network. The relationship of client and server arises by virtue of computer programs running on the respective computers and having a client server relationship to each other.

[0352] While this specification contains many specifics, these should not be construed as limitations on the scope of the invention or of what may be claimed, but rather as descriptions of features specific to particular embodiments of the invention. Certain features that are described in this specification in the context or separate embodiments can also be implemented in combination in a single embodiment. Conversely, various features that are described in the context of a single embodiment can also be implemented in multiple embodiments separately or in any suitable subcombination. Moreover, although features may be described above as acting in certain combinations and even initially claimed as such, one or more features from a claimed combination can in some cases be excised from the combination, and the claimed combination may be directed to a subcombination or variation of a subcombination.

[0353] Similarly, while operations are depicted in the drawings in a particular order, this should not be understood as requiring that such operations be performed in the particular order shown or in sequential order, or that all illustrated operations be performed, to achieve desirable results. In certain circumstances, multitasking and parallel processing may be advantageous. Moreover, the separation of various system components in the embodiments described above should not be understood as requiring such separation in all embodiments, and it should be understood that the described program components and systems can generally be integrated together in a single software product or packaged into multiple software products.

[0354] Thus, particular embodiments of the invention have been described. Other embodiments are within the scope of the following claims. For example, the actions recited in the claims can be performed in a different order and still achieve desirable results.

[0355] Moreover, the foregoing descriptions of disclosed embodiments have been presented only for purposes of illustration and description. They are not intended to be exhaustive or to limit the disclosed embodiments to the forms disclosed. Accordingly, many modifications and variations will be apparent to practitioners skilled in the art.

[0356] Additionally, the above disclosure is not intended to limit the disclosed embodiments. The scope of the disclosed embodiments is defined by the appended claims.

Claims

What is claimed is:

1. A computer-implemented method for displaying performance data for components of a computing environment, the method comprising:

receiving a performance metric for determining a performance state for each component operating in the computing environment;

dynamically generating a query for retrieving data based on the performance metric;

upon execution of the query, retrieving (i) a value for the identified performance metric aggregated over a selected time range for each component, and (ii) an identity for each component;

determining a performance state for each component based on the associated value according to the identified performance metric as compared to a set of state-specific threshold values;

retrieving architectural information including relationships between the components of the computing environment;

dynamically generating, based on the architectural information, a visual output including a tree comprising:

leaf nodes representing the components,

parent nodes representing parent components of the components, and

links representing parent-child relationships between the components represented by the leaf nodes and the parent nodes,

wherein individual nodes in the tree are displayed including respective visual indications of the determined performance states, wherein each performance state indicates a performance level of the respective represented component based on the associated value according to the identified performance metric as compared to one or more state-specific threshold values of the set of state-specific threshold values.

2. The method of claim 1, wherein:

the query is executed by an indexer,

prior to the execution of the query by the indexer, the indexer:

receives raw machine data;

segments the raw machine data into events;

determines timestamps for the events;

associates the timestamps with the events;

transforms data in the events; and

stores the events in a data store associated with the indexer, and

upon execution of the query, the indexer generates the value for the identified performance metric based on the stored events.

3. The method of claim 2, wherein, prior to the execution of the query by the indexer, the indexer identifies a set of keywords contained in the events and indexes the set of keywords.

4. The method of claim 1, wherein each parent node is represented in the visual output as a circular ring comprising visually distinct sections, each visually distinct section being associated with a different performance state and sized proportionately with a number of leaf nodes that are determined to be in the associated performance state.

5. The method of claim 4, wherein, for each parent node, information describing attributes of the parent node is within the circular ring.

6. The method of claim 4, wherein performance states are associated with different colors, and wherein each visually distinct section includes a colored portion having a color associated with the performance state associated the visually distinct section.

7. The method of claim 4, wherein performance states are associated with different colors, wherein each leaf node includes a colored portion having a color associated with the performance state of the component represented by the leaf node, and wherein each visually distinct section includes a colored portion having a color associated with the performance state associated the visually distinct section.

8. The method of claim 1, wherein the generation of the visual output includes:

determining a sorted order for leaf nodes of each parent node based on the values associated with the components represented by the leaf nodes, and

displaying the leaf nodes for each parent node in the sorted order.

9. The method of claim 1, wherein a component comprises a virtual machine, a host system that executes one or more virtual machines, a cluster comprising one or more host systems, or a virtual center comprising one or more clusters.

10. The method of claim 1, wherein a performance state comprises a critical state, a warning state, a normal state, or an unknown state.

11. The method of claim 1, further comprising receiving the selected time range, wherein the generated query is for retrieving data based on the identification of a component type, the performance metric, and the selected time range, and wherein the retrieved value is collected during the selected time range.

12. The method of claim 1, wherein the performance metric relates to one or more of:

a response time;

a central-processing unit (CPU) utilization;

a memory utilization;

a disk utilization;

a network utilization; and

a power consumption.

13. The method of claim 1, further comprising:

receiving an input command to pin a node of the tree; and

in response to receiving the input command, dynamically generating a second visual output including state information associated with the node to be pinned, wherein the state information includes a set of data associated with the component represented by the node and selected based on at least one of a component type of the component represented by the node and a node type of the node.

14. A system that displays performance data for a computing environment, the system comprising:

a computing cluster comprising a plurality of processors and associated memories; and

a performance-monitoring mechanism that executes on the computing cluster and is configured to:

receive a performance metric for determining a performance state for each component operating in the computing environment;

dynamically generate a query for retrieving data based on the performance metric;

upon execution of the query, retrieve (i) a value for the identified performance metric aggregated over a selected time range for each component, and (ii) an identity for each component;

determine a performance state for each component based on the associated value according to the identified performance metric is compared to a set of state-specific threshold values;

retrieve architectural information including relationships between the components of the computing environment;

dynamically generate, based on the architectural information, a visual output including a tree comprising:

leaf nodes representing the components,

parent nodes representing parent components of the components, and

links representing parent-child relationships between the components represented by the leaf nodes and the parent nodes,

15. The system of claim 14, wherein:

the query is executed by an indexer,

prior to the execution of the query by the indexer, the indexer:

receives raw machine data;

segments the raw machine data into events;

determines timestamps for the events;

associates the timestamps with the events;

transforms data in the events; and

stores the events in a data store associated with the indexer, and

upon execution of the query, the indexer generates the value for the identified performance metric based on the stored events.

16. The system of claim 14, wherein each parent node is represented in the visual output as a circular ring comprising visually distinct sections, each visually distinct section being associated with a different performance state and sized proportionately with a number of leaf nodes that are determined to be in the associated performance state.

17. The system of claim 16, wherein, for each parent node, information describing attributes of the parent node is within the circular ring.

18. The system of claim 14, wherein performance states are associated with different colors, and wherein each visually distinct section includes a colored portion having a color associated with the performance state associated the visually distinct section.

19. The system of claim 14, wherein performance states are associated with different colors, wherein each leaf node includes a colored portion having a color associated with the performance state of the component represented by the leaf node, and wherein each visually distinct section includes a colored portion having a color associated with the performance state associated the visually distinct section.

20. A non-transitory computer-readable medium comprising instructions that, when executed by one or more processors, cause the one or more processors to perform a method comprising:

receiving a performance metric for determining a performance state for each component operating in the computing environment;

dynamically generating a query for retrieving data based on the performance metric;

upon execution of the query, retrieving (i) a value for the identified performance metric aggregated over a selected time range for each component, and (ii) an identity for each component;

determining a performance state for each component based on the associated value according to the identified performance metric as compared to a set of state-specific threshold values;

retrieving architectural information including relationships between the components of the computing environment;

dynamically generating, based on the architectural information, a visual output including a tree comprising:

leaf nodes representing the components,

parent nodes representing parent components of the components, and

links representing parent-child relationships between the components represented by the leaf nodes and the parent nodes,

Patent Citations (506)

Patent	Date	Inventor	Cited By
US3681578(A)	1972-08-01	Stevens	Applicant
US4081611(A)	1978-03-01	Bovo et al.	Applicant
US4663704(A)	1987-05-01	Jones et al.	Applicant
US4707041(A)	1987-11-01	Kovit et al.	Applicant
US4876742(A)	1989-10-01	Vacon et al.	Applicant
US4922423(A)	1990-05-01	Koomey et al.	Applicant
US4956774(A)	1990-09-01	Shibamiya et al.	Applicant
US5121443(A)	1992-06-01	Tomlinson	Applicant
US5276629(A)	1994-01-01	Reynolds	Applicant
US5278843(A)	1994-01-01	Ako	Applicant
US5295547(A)	1994-03-01	Coelho et al.	Applicant
US5347540(A)	1994-09-01	Karrick	Applicant
US5407172(A)	1995-04-01	Young et al.	Applicant
US5414838(A)	1995-05-01	Kolton et al.	Applicant
US5553235(A)	1996-09-01	Chen	Examiner
US5579368(A)	1996-11-01	Van Berkum	Applicant
US5613113(A)	1997-03-01	Goldring	Applicant
US5627886(A)	1997-05-01	Bowman	Applicant
US5677909(A)	1997-10-01	Heide	Applicant
US5734859(A)	1998-03-01	Yorimitsu et al.	Applicant
US5737600(A)	1998-04-01	Geiner et al.	Applicant
US5745693(A)	1998-04-01	Knight et al.	Applicant
US5751965(A)	1998-05-01	Mayo et al.	Applicant
US5761652(A)	1998-06-01	Wu et al.	Applicant
US5838732(A)	1998-11-01	Carney	Applicant
US5847972(A)	1998-12-01	Eick et al.	Applicant
US5875174(A)	1999-02-01	Okazaki	Applicant
US5951541(A)	1999-09-01	Simpson et al.	Applicant
US5953439(A)	1999-09-01	Ishihara et al.	Applicant
US5960434(A)	1999-09-01	Schimmel	Applicant
US6088717(A)	2000-07-01	Reed et al.	Applicant
US6115705(A)	2000-09-01	Larson	Applicant
US6137283(A)	2000-10-01	Williams et al.	Applicant
US6212494(B1)	2001-04-01	Boguraev	Applicant
US6341176(B1)	2002-01-01	Shirasaki et al.	Applicant
US6363131(B1)	2002-03-01	Beidas et al.	Applicant
US6449618(B1)	2002-09-01	Blott et al.	Applicant
US6484806(B2)	2002-11-01	Childers et al.	Applicant
US6490553(B2)	2002-12-01	Van Thong et al.	Applicant
US6496831(B1)	2002-12-01	Baulier et al.	Applicant
US6516189(B1)	2003-02-01	Frangione et al.	Applicant
US6597683(B1)	2003-07-01	Gehring et al.	Applicant
US6598078(B1)	2003-07-01	Ehrlich et al.	Applicant
US6598087(B1)	2003-07-01	Dixon et al.	Applicant
US6604114(B1)	2003-08-01	Toong et al.	Applicant
US6658367(B2)	2003-12-01	Conrad	Applicant
US6658487(B1)	2003-12-01	Smith	Applicant
US6662176(B2)	2003-12-01	Brunet et al.	Applicant
US6678674(B1)	2004-01-01	Saeki	Applicant
US6725235(B1)	2004-04-01	Dyer et al.	Applicant
US6751228(B1)	2004-06-01	Okamura	Applicant
US6755261(B2)	2004-06-01	Koederitz	Applicant
US6760903(B1)	2004-07-01	Morshed et al.	Applicant
US6763347(B1)	2004-07-01	Zhang	Applicant
US6768994(B1)	2004-07-01	Howard et al.	Applicant
US6789046(B1)	2004-09-01	Murstein et al.	Applicant
US6816175(B1)	2004-11-01	Hamp et al.	Applicant
US6907422(B1)	2005-06-01	Predovic	Applicant
US6907545(B2)	2005-06-01	Ramadei et al.	Applicant
US6920468(B1)	2005-07-01	Cousins et al.	Applicant
US6951541(B2)	2005-10-01	Desmarais	Applicant
US6967937(B1)	2005-11-01	Gormley	Applicant
US6980963(B1)	2005-12-01	Hanzek	Applicant
US6993246(B1)	2006-01-01	Pan et al.	Applicant
US7035925(B1)	2006-04-01	Nareddy et al.	Applicant
US7069176(B2)	2006-06-01	Swaine et al.	Applicant
US7076547(B1)	2006-07-01	Black	Applicant
US7084742(B2)	2006-08-01	Haines	Applicant
US7085682(B1)	2006-08-01	Heller et al.	Applicant
US7123172(B1)	2006-10-01	Ordentlich et al.	Applicant
US7127456(B1)	2006-10-01	Brown et al.	Applicant
US7146416(B1)	2006-12-01	Yoo et al.	Applicant
US7155161(B2)	2006-12-01	Regulinski et al.	Applicant
US7184777(B2)	2007-02-01	Diener et al.	Applicant
US7231403(B1)	2007-06-01	Howitt et al.	Applicant
US7248178(B2)	2007-07-01	Layton	Applicant
US7274989(B2)	2007-09-01	Hopper	Applicant
US7301603(B2)	2007-11-01	Chen et al.	Applicant
US7379999(B1)	2008-05-01	Zhou et al.	Applicant
US7406399(B2)	2008-07-01	Furem et al.	Applicant
US7424530(B2)	2008-09-01	Chagoly	Examiner
US7437266(B2)	2008-10-01	Ueno et al.	Applicant
US7447761(B1)	2008-11-01	Ferguson et al.	Applicant
US7454761(B1)	2008-11-01	Roberts et al.	Applicant
US7457872(B2)	2008-11-01	Aton et al.	Applicant
US7493304(B2)	2009-02-01	Day et al.	Applicant
US7510449(B2)	2009-03-01	Ito et al.	Applicant
US7546553(B2)	2009-06-01	Bozak et al.	Applicant
US7565425(B2)	2009-07-01	Van Vleet et al.	Applicant
US7580911(B2)	2009-08-01	Sun et al.	Applicant
US7580938(B1)	2009-08-01	Pai et al.	Applicant
US7580944(B2)	2009-08-01	Zhuge et al.	Applicant
US7590416(B1)	2009-09-01	Burklin et al.	Applicant
US7593953(B1)	2009-09-01	Malalur	Applicant
US7600029(B1)	2009-10-01	Mashinsky	Applicant
US7617314(B1)	2009-11-01	Bansod et al.	Applicant
US7620697(B1)	2009-11-01	Davies	Applicant
US7627544(B2)	2009-12-01	Chkodrov et al.	Applicant
US7673340(B1)	2010-03-01	Cohen et al.	Applicant
US7680916(B2)	2010-03-01	Barnett et al.	Applicant
US7685109(B1)	2010-03-01	Ransil et al.	Applicant
US7689394(B2)	2010-03-01	Furem et al.	Applicant
US7696900(B2)	2010-04-01	Hall et al.	Applicant
US7747641(B2)	2010-06-01	Kim et al.	Applicant
US7775275(B2)	2010-08-01	Patel	Applicant
US7783750(B1)	2010-08-01	Casey et al.	Applicant
US7810155(B1)	2010-10-01	Ravi	Applicant
US7827182(B1)	2010-11-01	Panigrahy	Applicant
US7832706(B2)	2010-11-01	Judge	Applicant
US7856441(B1)	2010-12-01	Kraft et al.	Applicant
US7885954(B2)	2011-02-01	Barsness et al.	Applicant
US7895167(B2)	2011-02-01	Berg et al.	Applicant
US7934003(B2)	2011-04-01	Carusi et al.	Applicant
US7937164(B2)	2011-05-01	Samardzija et al.	Applicant
US7962489(B1)	2011-06-01	Chiang et al.	Applicant
US7970934(B1)	2011-06-01	Patel	Applicant
US7974728(B2)	2011-07-01	Lin et al.	Applicant
US7979439(B1)	2011-07-01	Nordstrom et al.	Applicant
US7991758(B2)	2011-08-01	Beeston et al.	Applicant
US8005992(B1)	2011-08-01	Pichumani et al.	Applicant
US8031634(B1)	2011-10-01	Artzi et al.	Applicant
US8046749(B1)	2011-10-01	Owen et al.	Applicant
US8051382(B1)	2011-11-01	Kingdom et al.	Applicant
US8073806(B2)	2011-12-01	Garg et al.	Applicant
US8074720(B2)	2011-12-01	Radi	Applicant
US8112425(B2)	2012-02-01	Baum et al.	Applicant
US8149133(B2)	2012-04-01	Milne	Applicant
US8200527(B1)	2012-06-01	Thompson et al.	Applicant
US8271615(B2)	2012-09-01	Ellison et al.	Applicant
US8301603(B2)	2012-10-01	Kan et al.	Applicant
US8321448(B2)	2012-11-01	Zeng et al.	Applicant
US8386410(B2)	2013-02-01	Gopisetty et al.	Applicant
US8401710(B2)	2013-03-01	Budhraja et al.	Applicant
US8516008(B1)	2013-08-01	Marquardt et al.	Applicant
US8536731(B2)	2013-09-01	Biester et al.	Applicant
US8589403(B2)	2013-11-01	Marquardt et al.	Applicant
US8601112(B1)	2013-12-01	Nordstrom et al.	Applicant
US8645390(B1)	2014-02-01	Oztekin et al.	Applicant
US8683474(B2)	2014-03-01	Yamamura et al.	Applicant
US8707194(B1)	2014-04-01	Jenkins et al.	Applicant
US8738333(B1)	2014-05-01	Behera et al.	Applicant
US8793118(B2)	2014-07-01	Srinivasa et al.	Applicant
US8813039(B2)	2014-08-01	Maczuba	Applicant
US8825623(B2)	2014-09-01	Samuelson et al.	Applicant
US8904299(B1)	2014-12-01	Owen et al.	Applicant
US8909622(B1)	2014-12-01	Emigh et al.	Applicant
US8924376(B1)	2014-12-01	Lee	Applicant
US8990184(B2)	2015-03-01	Baum et al.	Applicant
US9002854(B2)	2015-04-01	Baum et al.	Applicant
US9037555(B2)	2015-05-01	Genest et al.	Applicant
US9043185(B2)	2015-05-01	Bender et al.	Applicant
US9047352(B1)	2015-06-01	Dong et al.	Applicant
US9128995(B1)	2015-09-01	Fletcher et al.	Applicant
US9130832(B1)	2015-09-01	Boe et al.	Applicant
US9130860(B1)	2015-09-01	Boe et al.	Applicant
US9146854(B2)	2015-09-01	Biswas et al.	Applicant
US9146954(B1)	2015-09-01	Boe et al.	Applicant
US9146962(B1)	2015-09-01	Boe et al.	Applicant
US9152726(B2)	2015-10-01	Lymperopoulos et al.	Applicant
US9158811(B1)	2015-10-01	Choudhary et al.	Applicant
US9164965(B2)	2015-10-01	Molesky et al.	Applicant
US9202175(B2)	2015-12-01	Al-Yami et al.	Applicant
US9208463(B1)	2015-12-01	Bhide et al.	Applicant
US9256501(B1)	2016-02-01	Rahut	Applicant
US9294361(B1)	2016-03-01	Choudhary et al.	Applicant
US9294362(B2)	2016-03-01	De et al.	Applicant
US9420050(B1)	2016-08-01	Sakata et al.	Applicant
US9465713(B2)	2016-10-01	Tonouchi	Applicant
US9474316(B2)	2016-10-01	Berry	Applicant
US9514175(B2)	2016-12-01	Swan et al.	Applicant
US9521047(B2)	2016-12-01	Alekseyev et al.	Applicant
US9590877(B2)	2017-03-01	Choudhary et al.	Applicant
US9594789(B2)	2017-03-01	Baum et al.	Applicant
US9740755(B2)	2017-08-01	Lamas et al.	Applicant
US9747316(B2)	2017-08-01	Baum et al.	Applicant
US9767197(B1)	2017-09-01	Agarwal et al.	Applicant
US9785417(B2)	2017-10-01	Crossley et al.	Applicant
US9785714(B2)	2017-10-01	Gabriel	Applicant
US10114613(B2)	2018-10-01	Bekas et al.	Applicant
US10255136(B2)	2019-04-01	Salapura et al.	Applicant
US2001/0032307(A1)	2001-10-01	Rohlman et al.	Applicant
US2001/0044795(A1)	2001-11-01	Cohen et al.	Applicant
US2001/0052427(A1)	2001-12-01	Eppink et al.	Applicant
US2002/0042821(A1)	2002-04-01	Muret et al.	Applicant
US2002/0069223(A1)	2002-06-01	Goodisman et al.	Applicant
US2002/0129137(A1)	2002-09-01	Mills et al.	Applicant
US2002/0143575(A1)	2002-10-01	Hansen et al.	Applicant
US2002/0154175(A1)	2002-10-01	Abello et al.	Applicant
US2002/0169735(A1)	2002-11-01	Kil et al.	Applicant
US2002/0177910(A1)	2002-11-01	Quarterman	Examiner
US2002/0186238(A1)	2002-12-01	Sylor et al.	Applicant
US2003/0006070(A1)	2003-01-01	Dean	Applicant
US2003/0014399(A1)	2003-01-01	Hansen et al.	Applicant
US2003/0018435(A1)	2003-01-01	Jenner et al.	Applicant
US2003/0037034(A1)	2003-02-01	Daniels et al.	Applicant
US2003/0037117(A1)	2003-02-01	Tabuchi	Applicant
US2003/0074401(A1)	2003-04-01	Connell et al.	Applicant
US2003/0098799(A1)	2003-05-01	Zimmerman	Applicant
US2003/0110186(A1)	2003-06-01	Markowski et al.	Applicant
US2003/0120593(A1)	2003-06-01	Bansal et al.	Applicant
US2003/0141879(A1)	2003-07-01	Wilsher	Applicant
US2003/0154192(A1)	2003-08-01	Laborde et al.	Applicant
US2003/0182310(A1)	2003-09-01	Charnock et al.	Applicant
US2003/0204698(A1)	2003-10-01	Sachedina et al.	Applicant
US2003/0212699(A1)	2003-11-01	Denesuk et al.	Applicant
US2004/0000121(A1)	2004-01-01	Ichikawa et al.	Applicant
US2004/0008719(A1)	2004-01-01	Ying	Applicant
US2004/0024773(A1)	2004-02-01	Stoffel et al.	Applicant
US2004/0034795(A1)	2004-02-01	Anderson et al.	Applicant
US2004/0040707(A1)	2004-03-01	Dusterhoft et al.	Applicant
US2004/0043777(A1)	2004-03-01	Brouwer et al.	Applicant
US2004/0088314(A1)	2004-05-01	Simes	Applicant
US2004/0107369(A1)	2004-06-01	Cooper et al.	Applicant
US2004/0122656(A1)	2004-06-01	Abir	Applicant
US2004/0133395(A1)	2004-07-01	Ding et al.	Applicant
US2004/0143602(A1)	2004-07-01	Ruiz et al.	Applicant
US2004/0169688(A1)	2004-09-01	Burdick et al.	Applicant
US2004/0170392(A1)	2004-09-01	Lu et al.	Applicant
US2004/0194141(A1)	2004-09-01	Sanders	Applicant
US2004/0243618(A1)	2004-12-01	Malaney et al.	Applicant
US2004/0254919(A1)	2004-12-01	Giuseppini	Applicant
US2004/0267691(A1)	2004-12-01	Vasudeva	Applicant
US2005/0010564(A1)	2005-01-01	Metzger et al.	Applicant
US2005/0015624(A1)	2005-01-01	Ginter et al.	Applicant
US2005/0021736(A1)	2005-01-01	Carusi et al.	Applicant
US2005/0022207(A1)	2005-01-01	Grabarnik et al.	Applicant
US2005/0033803(A1)	2005-02-01	Meet et al.	Applicant
US2005/0055357(A1)	2005-03-01	Campbell	Applicant
US2005/0071379(A1)	2005-03-01	Kekre et al.	Applicant
US2005/0076067(A1)	2005-04-01	Bakalash et al.	Applicant
US2005/0080806(A1)	2005-04-01	Doganata et al.	Applicant
US2005/0081157(A1)	2005-04-01	Clark et al.	Applicant
US2005/0114707(A1)	2005-05-01	DeStefano et al.	Applicant
US2005/0138111(A1)	2005-06-01	Aton et al.	Applicant
US2005/0143009(A1)	2005-06-01	Nielsen et al.	Applicant
US2005/0160413(A1)	2005-07-01	Broussard et al.	Applicant
US2005/0177372(A1)	2005-08-01	Wang et al.	Applicant
US2005/0194182(A1)	2005-09-01	Rodney et al.	Applicant
US2005/0203888(A1)	2005-09-01	Woosley et al.	Applicant
US2005/0235356(A1)	2005-10-01	Wang	Applicant
US2005/0273281(A1)	2005-12-01	Wall et al.	Applicant
US2005/0274513(A1)	2005-12-01	Schultz et al.	Applicant
US2005/0289540(A1)	2005-12-01	Nguyen et al.	Applicant
US2006/0004731(A1)	2006-01-01	Seibel et al.	Applicant
US2006/0004909(A1)	2006-01-01	Takuwa et al.	Applicant
US2006/0026164(A1)	2006-02-01	Jung et al.	Applicant
US2006/0048101(A1)	2006-03-01	Krassovsky et al.	Applicant
US2006/0059238(A1)	2006-03-01	Slater et al.	Applicant
US2006/0069717(A1)	2006-03-01	Mamou et al.	Applicant
US2006/0077945(A1)	2006-04-01	Kethireddy et al.	Applicant
US2006/0082592(A1)	2006-04-01	Black-Ziegelbein	Examiner
US2006/0085163(A1)	2006-04-01	Nader	Applicant
US2006/0143175(A1)	2006-06-01	Ukrainczyk et al.	Applicant
US2006/0153097(A1)	2006-07-01	Schultz	Applicant
US2006/0161816(A1)	2006-07-01	Gula et al.	Applicant
US2006/0168272(A1)	2006-07-01	Rustad et al.	Applicant
US2006/0184529(A1)	2006-08-01	Berg et al.	Applicant
US2006/0184615(A1)	2006-08-01	Park et al.	Applicant
US2006/0197766(A1)	2006-09-01	Raz	Applicant
US2006/0197768(A1)	2006-09-01	Van Hook et al.	Applicant
US2006/0198359(A1)	2006-09-01	Fok et al.	Applicant
US2006/0218278(A1)	2006-09-01	Uyama et al.	Applicant
US2006/0224254(A1)	2006-10-01	Rumi et al.	Applicant
US2006/0224583(A1)	2006-10-01	Fikes et al.	Applicant
US2006/0229931(A1)	2006-10-01	Fligler et al.	Applicant
US2006/0265406(A1)	2006-11-01	Chkodrov et al.	Applicant
US2006/0293806(A1)	2006-12-01	Basilico	Applicant
US2007/0027612(A1)	2007-02-01	Barfoot et al.	Applicant
US2007/0033632(A1)	2007-02-01	Baynger et al.	Applicant
US2007/0038603(A1)	2007-02-01	Guha	Applicant
US2007/0038889(A1)	2007-02-01	Wiggins et al.	Applicant
US2007/0043562(A1)	2007-02-01	Holsinger et al.	Applicant
US2007/0043704(A1)	2007-02-01	Raub et al.	Applicant
US2007/0067575(A1)	2007-03-01	Morris et al.	Applicant
US2007/0073519(A1)	2007-03-01	Long	Applicant
US2007/0073743(A1)	2007-03-01	Bammi et al.	Applicant
US2007/0077884(A1)	2007-04-01	Regulinski et al.	Applicant
US2007/0100873(A1)	2007-05-01	Yako et al.	Applicant
US2007/0107907(A1)	2007-05-01	Smedstad et al.	Applicant
US2007/0113031(A1)	2007-05-01	Brown et al.	Applicant
US2007/0124437(A1)	2007-05-01	Chervets	Applicant
US2007/0130357(A1)	2007-06-01	Matsumoto et al.	Applicant
US2007/0156786(A1)	2007-07-01	May et al.	Applicant
US2007/0156789(A1)	2007-07-01	Semerdzhiev et al.	Applicant
US2007/0168086(A1)	2007-07-01	Schultz	Applicant
US2007/0192300(A1)	2007-08-01	Reuther et al.	Applicant
US2007/0255529(A1)	2007-11-01	Biazetti et al.	Applicant
US2007/0268908(A1)	2007-11-01	Linkola et al.	Applicant
US2007/0283194(A1)	2007-12-01	Villella et al.	Applicant
US2008/0021994(A1)	2008-01-01	Grelewicz et al.	Applicant
US2008/0049641(A1)	2008-02-01	Edwards et al.	Applicant
US2008/0077558(A1)	2008-03-01	Lawrence et al.	Applicant
US2008/0083314(A1)	2008-04-01	Hayashi et al.	Applicant
US2008/0092121(A1)	2008-04-01	Derose et al.	Applicant
US2008/0099197(A1)	2008-05-01	Payne	Applicant
US2008/0134209(A1)	2008-06-01	Bansal et al.	Applicant
US2008/0184110(A1)	2008-07-01	Barsness et al.	Applicant
US2008/0279113(A1)	2008-11-01	Kalliola et al.	Applicant
US2008/0288916(A1)	2008-11-01	Tazoe et al.	Applicant
US2008/0307088(A1)	2008-12-01	Chen	Examiner
US2008/0319975(A1)	2008-12-01	Morris et al.	Applicant
US2009/0003219(A1)	2009-01-01	Beacham et al.	Applicant
US2009/0013281(A1)	2009-01-01	Helfman et al.	Applicant
US2009/0049372(A1)	2009-02-01	Goldberg	Applicant
US2009/0049641(A1)	2009-02-01	Pullins et al.	Applicant
US2009/0083314(A1)	2009-03-01	Maim	Applicant
US2009/0112932(A1)	2009-04-01	Skierkowski	Examiner
US2009/0119257(A1)	2009-05-01	Waters	Applicant
US2009/0125530(A1)	2009-05-01	Martinsson et al.	Applicant
US2009/0171704(A1)	2009-07-01	Bobak	Examiner
US2009/0172014(A1)	2009-07-01	Huetter	Applicant
US2009/0172666(A1)	2009-07-01	Yahalom et al.	Applicant
US2009/0177692(A1)	2009-07-01	Chagoly et al.	Applicant
US2009/0182866(A1)	2009-07-01	Watanabe et al.	Applicant
US2009/0192982(A1)	2009-07-01	Samuelson et al.	Applicant
US2009/0194290(A1)	2009-08-01	Parks et al.	Applicant
US2009/0204380(A1)	2009-08-01	Kato et al.	Applicant
US2009/0212969(A1)	2009-08-01	Voss	Applicant
US2009/0237404(A1)	2009-09-01	Cannon	Applicant
US2009/0259628(A1)	2009-10-01	Farrell et al.	Applicant
US2009/0265395(A1)	2009-10-01	Milne	Applicant
US2009/0271511(A1)	2009-10-01	Peracha	Applicant
US2009/0287414(A1)	2009-11-01	Vickery	Applicant
US2009/0288835(A1)	2009-11-01	Sbordone	Applicant
US2010/0019930(A1)	2010-01-01	Biester et al.	Applicant
US2010/0133004(A1)	2010-06-01	Burleson et al.	Applicant
US2010/0145479(A1)	2010-06-01	Griffiths	Applicant
US2010/0162251(A1)	2010-06-01	Richards et al.	Applicant
US2010/0169253(A1)	2010-07-01	Tan	Applicant
US2010/0205212(A1)	2010-08-01	Quadracci et al.	Applicant
US2010/0223619(A1)	2010-09-01	Jaquet et al.	Applicant
US2010/0227551(A1)	2010-09-01	Volanthen et al.	Applicant
US2010/0250712(A1)	2010-09-01	Ellison et al.	Applicant
US2010/0268797(A1)	2010-10-01	Pyrik et al.	Applicant
US2010/0274777(A1)	2010-10-01	Ho et al.	Applicant
US2010/0332661(A1)	2010-12-01	Tameshige	Applicant
US2011/0007075(A1)	2011-01-01	Lee	Applicant
US2011/0025526(A1)	2011-02-01	Simpson et al.	Applicant
US2011/0055256(A1)	2011-03-01	Phillips et al.	Applicant
US2011/0055817(A1)	2011-03-01	Noble et al.	Applicant
US2011/0161185(A1)	2011-06-01	Antoo et al.	Applicant
US2011/0161851(A1)	2011-06-01	Barber et al.	Applicant
US2011/0179160(A1)	2011-07-01	Liu et al.	Applicant
US2011/0225277(A1)	2011-09-01	Freimuth et al.	Applicant
US2011/0226475(A1)	2011-09-01	Springett et al.	Applicant
US2011/0238687(A1)	2011-09-01	Karpuram et al.	Applicant
US2011/0261055(A1)	2011-10-01	Wong et al.	Applicant
US2011/0261065(A1)	2011-10-01	Pei Xing	Applicant
US2011/0283278(A1)	2011-11-01	Murrell et al.	Applicant
US2011/0285201(A1)	2011-11-01	Peuser	Applicant
US2011/0298804(A1)	2011-12-01	Hao et al.	Applicant
US2011/0307716(A1)	2011-12-01	Diab	Applicant
US2011/0307905(A1)	2011-12-01	Essey et al.	Applicant
US2012/0000646(A1)	2012-01-01	Liotta et al.	Applicant
US2012/0023429(A1)	2012-01-01	Medhi	Applicant
US2012/0032523(A1)	2012-02-01	Overton et al.	Applicant
US2012/0036484(A1)	2012-02-01	Zhang et al.	Applicant
US2012/0037375(A1)	2012-02-01	Reynolds et al.	Applicant
US2012/0046999(A1)	2012-02-01	Jayaraman	Examiner
US2012/0054129(A1)	2012-03-01	Aggarwal	Applicant
US2012/0096458(A1)	2012-04-01	Huang et al.	Applicant
US2012/0097383(A1)	2012-04-01	Fenton	Applicant
US2012/0112924(A1)	2012-05-01	Mackay et al.	Applicant
US2012/0120078(A1)	2012-05-01	Hubbard	Applicant
US2012/0124503(A1)	2012-05-01	Coimbatore et al.	Applicant
US2012/0130774(A1)	2012-05-01	Ziv et al.	Applicant
US2012/0152554(A1)	2012-06-01	Milne	Applicant
US2012/0167083(A1)	2012-06-01	Suit	Applicant
US2012/0173708(A1)	2012-07-01	Bartfai-Walcott et al.	Applicant
US2012/0174001(A1)	2012-07-01	Friedman et al.	Applicant
US2012/0174097(A1)	2012-07-01	Levin	Applicant
US2012/0175969(A1)	2012-07-01	Maughan et al.	Applicant
US2012/0197911(A1)	2012-08-01	Banka et al.	Applicant
US2012/0197928(A1)	2012-08-01	Zhang et al.	Applicant
US2012/0211234(A1)	2012-08-01	Wilie et al.	Applicant
US2012/0216135(A1)	2012-08-01	Wong et al.	Applicant
US2012/0217017(A1)	2012-08-01	Zediker	Applicant
US2012/0221308(A1)	2012-08-01	Chen	Applicant
US2012/0221314(A1)	2012-08-01	Bourlatchkov et al.	Applicant
US2012/0239492(A1)	2012-09-01	Guo et al.	Applicant
US2012/0256634(A1)	2012-10-01	Morys	Applicant
US2012/0260135(A1)	2012-10-01	Beck et al.	Applicant
US2012/0278292(A1)	2012-11-01	Zahavi et al.	Applicant
US2012/0284713(A1)	2012-11-01	Ostermeyer et al.	Applicant
US2012/0292107(A1)	2012-11-01	Orbell et al.	Applicant
US2012/0304191(A1)	2012-11-01	Morgan	Applicant
US2012/0311153(A1)	2012-12-01	Morgan	Applicant
US2012/0311475(A1)	2012-12-01	Wong	Applicant
US2012/0317266(A1)	2012-12-01	Abbott	Applicant
US2012/0323941(A1)	2012-12-01	Chkodrov et al.	Applicant
US2012/0324360(A1)	2012-12-01	Young et al.	Applicant
US2013/0007261(A1)	2013-01-01	Dutta et al.	Applicant
US2013/0030764(A1)	2013-01-01	Chatterjee et al.	Applicant
US2013/0055092(A1)	2013-02-01	Cannon et al.	Applicant
US2013/0055166(A1)	2013-02-01	Stinger et al.	Applicant
US2013/0088362(A1)	2013-04-01	Yates et al.	Applicant
US2013/0097157(A1)	2013-04-01	Ng et al.	Applicant
US2013/0097183(A1)	2013-04-01	McCracken	Applicant
US2013/0104144(A1)	2013-04-01	Arcese et al.	Applicant
US2013/0118755(A1)	2013-05-01	Kotrla et al.	Applicant
US2013/0124714(A1)	2013-05-01	Bednar	Applicant
US2013/0139160(A1)	2013-05-01	Yahalom et al.	Applicant
US2013/0151505(A1)	2013-06-01	Yoon et al.	Applicant
US2013/0151692(A1)	2013-06-01	White	Applicant
US2013/0153241(A1)	2013-06-01	Mallinson et al.	Applicant
US2013/0158950(A1)	2013-06-01	Cohen et al.	Applicant
US2013/0163407(A1)	2013-06-01	Sinha	Examiner
US2013/0173073(A1)	2013-07-01	Breeze et al.	Applicant
US2013/0174129(A1)	2013-07-01	Grammel et al.	Applicant
US2013/0204948(A1)	2013-08-01	Zeyliger et al.	Applicant
US2013/0223840(A1)	2013-08-01	Chang	Applicant
US2013/0247133(A1)	2013-09-01	Price et al.	Applicant
US2013/0262347(A1)	2013-10-01	Dodson	Applicant
US2013/0262656(A1)	2013-10-01	Cao et al.	Applicant
US2013/0269945(A1)	2013-10-01	Mulholland et al.	Applicant
US2013/0275970(A1)	2013-10-01	Heim et al.	Applicant
US2013/0297976(A1)	2013-11-01	McMillen	Applicant
US2013/0300747(A1)	2013-11-01	Wong et al.	Applicant
US2013/0304903(A1)	2013-11-01	Mick et al.	Applicant
US2013/0332594(A1)	2013-12-01	Dvir et al.	Applicant
US2013/0346615(A1)	2013-12-01	Gondi	Applicant
US2013/0346619(A1)	2013-12-01	Panuganty et al.	Applicant
US2014/0040306(A1)	2014-02-01	Peregrine et al.	Applicant
US2014/0047342(A1)	2014-02-01	Breternitz et al.	Applicant
US2014/0059488(A1)	2014-02-01	El-Jayousi et al.	Applicant
US2014/0064029(A1)	2014-03-01	Jaffrey	Applicant
US2014/0067783(A1)	2014-03-01	Awadallah et al.	Applicant
US2014/0075029(A1)	2014-03-01	Lipchuk et al.	Applicant
US2014/0114704(A1)	2014-04-01	Molinsky et al.	Applicant
US2014/0114707(A1)	2014-04-01	Rope et al.	Applicant
US2014/0124265(A1)	2014-05-01	Al-Yami et al.	Applicant
US2014/0195667(A1)	2014-07-01	Ketchum et al.	Applicant
US2014/0201642(A1)	2014-07-01	Pascale	Applicant
US2014/0214888(A1)	2014-07-01	Marquardt et al.	Applicant
US2014/0231075(A1)	2014-08-01	Springett et al.	Applicant
US2014/0280894(A1)	2014-09-01	Reynolds et al.	Applicant
US2014/0283083(A1)	2014-09-01	Gula et al.	Applicant
US2014/0317286(A1)	2014-10-01	Masuda et al.	Applicant
US2014/0351217(A1)	2014-11-01	Bostock	Applicant
US2014/0368202(A1)	2014-12-01	San et al.	Applicant
US2015/0007115(A1)	2015-01-01	Kleser et al.	Applicant
US2015/0026167(A1)	2015-01-01	Neels et al.	Applicant
US2015/0113118(A1)	2015-04-01	Jain et al.	Applicant
US2015/0143180(A1)	2015-05-01	Dawson et al.	Applicant
US2015/0149879(A1)	2015-05-01	Miller et al.	Applicant
US2015/0154269(A1)	2015-06-01	Miller et al.	Applicant
US2015/0178342(A1)	2015-06-01	Seering et al.	Applicant
US2015/0293954(A1)	2015-10-01	Hsiao et al.	Applicant
US2015/0295778(A1)	2015-10-01	Hsiao et al.	Applicant
US2015/0295780(A1)	2015-10-01	Hsiao et al.	Applicant
US2015/0295796(A1)	2015-10-01	Hsiao et al.	Applicant
US2015/0339351(A1)	2015-11-01	Swan et al.	Applicant
US2016/0019215(A1)	2016-01-01	Murphey et al.	Applicant
US2016/0034555(A1)	2016-02-01	Rahut et al.	Applicant
US2016/0034566(A1)	2016-02-01	Rahut	Applicant
US2016/0055225(A1)	2016-02-01	Xu et al.	Applicant
US2016/0070736(A1)	2016-03-01	Swan et al.	Applicant
US2016/0125314(A1)	2016-05-01	Mulukutla et al.	Applicant
US2016/0140128(A1)	2016-05-01	Swan et al.	Applicant
US2016/0140238(A1)	2016-05-01	Swan et al.	Applicant
US2016/0154836(A1)	2016-06-01	Swan et al.	Applicant
US2016/0360382(A1)	2016-12-01	Gross et al.	Applicant
US2017/0046402(A1)	2017-02-01	Swan et al.	Applicant
US2017/0046403(A1)	2017-02-01	Swan et al.	Applicant
US2017/0114810(A1)	2017-04-01	Angerhausen et al.	Applicant
US2017/0139961(A1)	2017-05-01	Baum et al.	Applicant
US2017/0139962(A1)	2017-05-01	Baum et al.	Applicant
US2017/0139963(A1)	2017-05-01	Baum et al.	Applicant
US2017/0139968(A1)	2017-05-01	Baum et al.	Applicant
US2017/0169137(A1)	2017-06-01	Shen et al.	Applicant
US2017/0337230(A1)	2017-11-01	Baum et al.	Applicant
US2017/0337231(A1)	2017-11-01	Baum et al.	Applicant
US2017/0344591(A1)	2017-11-01	Baum et al.	Applicant
CN101015108(A)	2007-08-01		Applicant
CN101446191(A)	2009-06-01		Applicant
CN102168547(A)	2011-08-01		Applicant
CN102561979(A)	2012-07-01		Applicant
EP1480100(A1)	2004-11-01		Applicant
EP2194227(A2)	2010-06-01		Applicant
GB2458944(A)	2009-10-01		Applicant
JP64-046844(A)	1989-02-01		Applicant
JP1-136587(A)	1989-05-01		Applicant
JP4-195639(A)	1992-07-01		Applicant
JP7-110788(A)	1995-04-01		Applicant
JP10-111768(A)	1998-04-01		Applicant
JP2002-531000(A)	2002-09-01		Applicant
JP2005-020113(A)	2005-01-01		Applicant
JP2005-513958(A)	2005-05-01		Applicant
JP2005-517278(A)	2005-06-01		Applicant
JP2007-034415(A)	2007-02-01		Applicant
JP2008-547024(A)	2008-12-01		Applicant
JP2009-215944(A)	2009-09-01		Applicant
KR100745483(B1)	2007-08-01		Applicant
WO97/038376(A1)	1997-10-01		Applicant
WO3/67934(A2)	2003-08-01		Applicant
WO3/096220(A1)	2003-11-01		Applicant
WO2005/111484(A2)	2005-11-01		Applicant
WO2007/027080(A2)	2007-03-01		Applicant
WO2008043082(A2)	2008-04-01		Applicant
WO2012/018322(A1)	2012-02-01		Applicant
WO2012/020405(A1)	2012-02-01		Applicant
WO2012/037173(A2)	2012-03-01		Applicant
WO2012/077088(A2)	2012-06-01		Applicant
WO2012/113757(A1)	2012-08-01		Applicant
WO2014/062858(A1)	2014-04-01		Applicant
WO2015/048592(A1)	2015-04-01		Applicant

Non-Patent Literature (53)

7.10 Managing Virtual Machines, retrieved online from url: https://docs.oracle.com/cd/E35328_01/E35332/html/vmusg-vm-manage.html, Jan. 15, 2013, 9 pages.Applicant
Bitincka, L., et al., “Optimizing Data Analysis with a Semi-structured Time Series Database,” Proceedings of the 2010 Workshop on Managing Systems Via Log Analysis and Machine Learning Techniques, pp. 1-9 (Oct. 3, 2010).Applicant
Butler, Brandon, “16 of the most useful cloud management tools,” www.networkworld.com/article/2162241/cloud-computing/16-of-the-most-useful-cloud-management-tools.html, Dec. 17, 2012, 4 pages.Applicant
Byron, Lee et al., “Stacked Graphs—Geometry & Aesthetics,” IEEE Transactions on Visualization and Computer Graphics, vol. 14, No. 6, pp. 1245-1252, Nov./Dec. 2008.Applicant
Carasso, D., “Exploring Splunk”, Search Processing Language (SPL) Primer and Cookbook, First Edition Published Apr. 2012, CITO Research, New York, New York, pp. 156.Applicant
Che et al., “TDMA frame design for a prototype undenvater RF communication network,” Ad Hoc Networks, 10:317-327, (2012).Applicant
Chitre et al., “Underwater acoustic Communications and Networking: Recent Advances and Future Challenqes,” Marine Technology Society Journal, 42(1):103-116, (2008).Applicant
Colbert, “VMware vCenter Operations—Video Tutorial”, youtu.be/yvrL4mAjdEl, Apr. 5, 2011. (Year: 2011).Applicant
Dell Inc., “Foglight For Virtualization, Free Edition,” Retrieved from the Internet on Oct. 21, 2016: <<http://www.quest.com/foglight-for-virtualization-free-edition/>>, 1 page, 2013.Applicant
Elmqvist et al. (“Hierarchical aggregation for information visualization: Overview, Techniques, and Design Guidelines”, IEEE Transactions on Visualization and Computer Graphics, Institute of Electrical and Electronics Engineers, 2010 (Year: 2010).Applicant
Eric Sloof, “vCOPS 5.6 Integration in the VMware Webclient”, minutes 0:00 to 4:30, youtu.be/qEINzWYyIXA, Dec. 13, 2012 (Year: 2012).Applicant
Russell, S.J. et al., “Artificial Intelligence: A Modern Approach”, 2nd Edition, Pearson Education, Inc., 2003, pp. 733-739.Applicant
Unknown Author, “Migrating Virtual Machines in the vSphere Web Client”, pubs.vmware.com/vsphere-51/index.jsp?topic=%2Fcom.vmware.vsphere.vcenterhost.doc%2FGUID-FE2B516E-7366-4978-B75C-64BF0AC676EB.html, Sep. 11, 2012 (Year: 2012).Applicant
VCenter Operations Manager 5. 7 .2 retrieved from http://www.vmware.com/support/pubs/vcops-pubs.html on Sep. 30, 2013, 2 pages.Applicant
VMware vCenter Operations Manager Documentation retrieved from vmware.com/support/pubs/vcops-pubs.html on Sep. 30, 2013, 2 pages.Applicant
VSphere Monitoring and Performance, Update 1, vSphere 5.5, EN-001357-00, accessed at https://web.archive.org/web/20140913043828/http://pubs.vmware.com/vsphere-55/topic/com.vmware.ICbase/PDF/vsphere-esxi-vcenter-server-551-monitoring-performance-guide.pdf, accessed on Sep. 9, 2019, pp. 174.Applicant
Witten, I.H. et al., “Data Mining: Practicial Machine Learning Tools and Techniques withJava Implementations”, Morgan Kaufmann Publishers, 2000, pp. 80-82, 114-118, 210-218,220-227, 329-335.Applicant
Wood, Julian , “VMware vCenter Operations Management Suite Released”, Jan. 2012.Applicant
Bounsaythip, C., and Runsala, E., R., “Overview of Data Mining for Customer Behaviour Modelling”, VTT Information Technology, Research Report TTE1-2001-18, pp. 1-59 (Jun. 29, 2001).Applicant
Cooley, R., et al., “Data Preparation for Mining World Wide Web Browsing Patterns”, Knowledge and Information Systems 1, Springer-Verlab, pp. 1-27 (1999).Applicant
“Foglight for Virtualization”, Retrieved from the Internet URL : http://www.quest.com/foglight-forvirtualization-free-edition, accessed on Sep. 30, 2013, p. 01 (Oct. 21, 2016).Applicant
Forlizzi, L. et al., “A data model and data structures for moving objects databases”, SIGMOD '00: Proceedings of the 2000 ACM SIGMOD international conference on Management of data, vol. 29, No. 2, pp. 319-330 (2000).Applicant
Goldin, D., et al., “In search of meaning for time series subsequence clustering: matching algorithms based on a new distance measure”, Proceedings of the 15th ACM international conference on Information and knowledge management, pp. 1-10 (Nov. 2006).Applicant
Gleed, K., “Viewing ESXi Logs From the DCUI”, Retrieved from the Internet URL: https://blogs.vmware.com/vsphere/2012/06/viewing-esxi-logs-from-the-dcui.html, posted on Jun. 28, 2012, pp. 1-9 (Jun. 2012).Applicant
Han, E. H., et al., “Text Categorization Using Weight Adjusted k-Nearest Neighbor Classification”, PAKDD 2001, LNAI 2035, Retrieved from the Internet URL: http://springlerlink.com/index25gnd0jb6nklffhh.pdf, pp. 23-65 (Sep. 23, 2010).Applicant
Hoke, E., et al., “InteMon: Continuous mining of sensor data in large-scale self-* infrastructures”, ACM SIGOPS Operating Systems Review, vol. 40, Issue 3, pp. 1-7 (Jul. 2006).Applicant
Kolovson, C., and Stonebraker, M., “Indexing Techniques for Historical Databases”, Proceedings. Fifth International Conference on Data Engineering, IEEE, pp. 127-137 (1989).Applicant
Leung. T.Y.C., and Muntz, R .R., “Query processing for temporal databases”, Proceedings. Sixth International Conference on Data Engineering, IEEE, pp. 200-208 (1990).Applicant
Matsuo, Y., and Ishizuka, M., “Keyword Extraction from a Single Document using Word Co-occurrence Statistical Information”, Proceedings of the Sixteenth International Florida Artificial Intelligence Research Society Conference, Retrieved from the Internet: http://www.aaai.org/Papers/FLAIRS/2003/Flairs03-076.pdf, pp. 392-396 (2003).Applicant
Russell, S. J., et al., “Artificial Intelligence: A Modern Approach Second Edition”, Pearson Education, Inc., pp. 733-739 (2003).Applicant
Srivastava, J. et al., “Web Usage Mining: Discovery and Application of Usage Patterns from Web Data,” ACM SIGKDD Explorations Newsletter, vol. 1, Issue 2, pp. 1-12 (Jan. 2000).Applicant
Stamatatos, E., et al., “Text Genre Detection Using Common Word Frequencies”, Proceedings of the 18th conference on Computational linguistics, vol. 2, pp. 1-7 (2000).Applicant
VMware, Inc., “VMware vCenter Operations Manager Documentation”, vCenter Operations Manager 5.7, Retrieved from the Internet URL : https://web.archive.org/web/20130427082607/http://www.vmware.com/, on Apr. 4, 2013, p. 1.Applicant
Witten, I. H., and Frank, E., “Data Mining Practical Machine Learning Tools and Techniques with Java Implementations”, Morgan Kaufmann Publishers, pp. 78-118, 210-227, 329-337 (2000).Applicant
U.S. Appl. No. 13/874,423, filed Apr. 30, 2013, Status: Patented Case.Applicant
U.S. Appl. No. 14/167,316, filed Jan. 29, 2014, Status: Abandoned.Applicant
U.S. Appl. No. 15/421,382, filed Jan. 31, 2017, Status: Patented Case.Applicant
U.S. Appl. No. 15/421,412, filed Jan. 31, 2017, Status: Patented Case.Applicant
U.S. Appl. No. 15/421,398, filed Jan. 31, 2017, Status: Patented Case.Applicant
U.S. Appl. No. 15/421,353, filed Jan. 31, 2017, Status: Patented Case.Applicant
U.S. Appl. No. 15/421,370, filed Jan. 31, 2017, Status: Patented Case.Applicant
U.S. Appl. No. 15/421,395, filed Jan. 31, 2017, Status: Patented Case.Applicant
U.S. Appl. No. 15/421,348, filed Jan. 31, 2017, Status: Patented Case.Applicant
U.S. Appl. No. 16/000,745, filed Jun. 5, 2018, Status: Patented Case.Applicant
U.S. Appl. No. 16/262,824, filed Jan. 30, 2019, Status: Patented Case.Applicant
U.S. Appl. No. 16/397,466, filed Apr. 29, 2019, Status: Patented Case.Applicant
U.S. Appl. No. 16/460,395, filed Jul. 2, 2019, Status: Patented Case.Applicant
U.S. Appl. No. 16/460,423, filed Jul. 2, 2019, Status: Patented Case.Applicant
U.S. Appl. No. 13/874,441, filed Apr. 30, 2013, Status: Patented Case.Applicant
U.S. Appl. No. 13/874,434, filed Apr. 30, 2013, Status: Patented Case.Applicant
U.S. Appl. No. 13/874,448, filed Apr. 30, 2013, Status: Patented Case.Applicant
U.S. Appl. No. 17/670,773, filed Feb. 14, 2022, Status: Patented Case.Applicant
U.S. Appl. No. 17/806,374, filed Jun. 10, 2022, Status: Pending.Applicant