Mechanisms for graph manipulation of transactional performance data are provided in order to identify and emphasize root causes of electronic business system transaction processing performance problems. A system transaction monitoring system, such as IBM Tivoli Monitoring for Transaction Performance™ (ITMTP) system, is utilized to obtain transaction performance data for a system. This transaction performance data is stored in a database and is utilized to present a graph of a given transaction or transactions. Having generated a graph of the transaction, and having identified problem conditions in the processing of the transaction(s), the present invention provides mechanisms for performing graph manipulation operations to best depict the root cause of the problems.
1. A method, in a data processing system, for identifying problem components of an enterprise computing system, comprising:
obtaining transaction processing performance data for the enterprise computing system;
generating a first graph data structure of a transaction processing topology of the enterprise computing system based on the transaction processing performance data;
applying one or more graph manipulation mechanisms to the first graph data structure to generate a second graph data structure of the transaction processing topology; and
generating a graphical representation of the transaction processing topology based on the second graph data structure, wherein the second graph data structure is a modified form of the first graph data structure.
2. The method of
3. The method of
4. The method of
5. The method of
6. The method of
7. The method of
8. The method of
9. The method of
10. The method of
11. The method of
12. The method of
13. A computer program product in a computer readable medium for identifying problem components of an enterprise computing system, comprising:
first instructions for obtaining transaction processing performance data for the enterprise computing system;
second instructions for generating a first graph data structure of a transaction processing topology of the enterprise computing system based on the transaction processing performance data;
third instructions for applying one or more graph manipulation mechanisms to the first graph data structure to generate a second graph data structure of the transaction processing topology; and
fourth instructions for generating a graphical representation of the transaction processing topology based on the second graph data structure, wherein the second graph data structure is a modified form of the first graph data structure.
14. The computer program product of
15. The computer program product of
16. The computer program product of
17. The computer program product of
18. The computer program product of
19. The computer program product of
20. The computer program product of
21. The computer program product of
22. The computer program product of
23. The computer program product of
24. The computer program product of
25. An apparatus for identifying problem components of an enterprise computing system, comprising:
means for obtaining transaction processing performance data for the enterprise computing system;
means for generating a first graph data structure of a transaction processing topology of the enterprise computing system based on the transaction processing performance data;
means for applying one or more graph manipulation mechanisms to the first graph data structure to generate a second graph data structure of the transaction processing topology; and
means for generating a graphical representation of the transaction processing topology based on the second graph data structure, wherein the second graph data structure is a modified form of the first graph data structure.
1. Technical Field
The present invention is generally directed to a method and apparatus for visualizing results of root cause analysis on transaction performance data. More specifically, the present invention provides a plurality of graph manipulation mechanisms for providing alternative views of a transactional system architecture in order to emphasize and identify root causes of detected problems.
2. Description of Related Art
IBM Tivoli Monitoring for Transaction Performance™ (hereafter ITMTP) is a centrally managed suite of software components that monitor the availability and performance of Web-based services and operating system applications. ITMTP captures detailed transaction and application performance data for all electronic business transactions. With ITMTP, every step of a customer transaction as it passes through an array of hosts, systems, application, Web and proxy servers, Web application servers, middleware, database management software, and legacy back-office software, may be monitored and performance characteristic data compiled and stored in a data repository for historical analysis and long-term planning. One way in which this data may be compiled in order to test the performance of a system is to simulate customer transactions and collect “what-if” performance data to help assess the health of electronic business components and configurations. ITMTP provides prompt and automated notification of performance problems when they are detected.
ITMTP permits, for a particular transaction, a user to generate a graph (topology) of the transaction. The graph is a tree that visually describes a transaction through the enterprise software being monitored. While this graph provides an indication of the manner by which a transaction is processed by the various elements of the electronic business, the graph does not provide a mechanism for isolating and detecting the root causes of problems. That is, while ITMTP permits users to be alerted when there are problems, and a graph of the transaction may be provided, there is no mechanism in ITMTP for isolating the root cause of the detected problem within the graph of the transaction. Thus, it would be beneficial to have a mechanism for performing graph manipulations for easily and quickly identifying and emphasizing root causes of problems in transaction processing of an electronic business system.
The present invention provides a mechanism for graph manipulation of transactional performance data in order to identify and emphasize root causes of electronic business system transaction performance problems. With the present invention, a system transaction monitoring system, such as IBM Tivoli Monitoring for Transaction Performance (ITMTP) system, is utilized to obtain transaction performance data for a system, such as an electronic business system. This transaction performance data may be utilized to determine when and where problem conditions occur.
This transaction performance data is stored in a database and is utilized to present a graph, or topology, of a given transaction or transactions. The graph or topology represents the software components that perform some processing of the transaction as it is handled by the system.
Having generated a graph of the transaction, and having identified problem conditions in the processing of the transaction(s), the present invention provides mechanisms for performing graph manipulation operations to best depict the root cause of the problems. The determination of which graph manipulation mechanisms to utilize may be performed automatically based on an analysis of the graph, may be performed manually by a user making use of a graphical user interface, or a combination of automatic and manual selection of the graph manipulation mechanisms.
The graph manipulation mechanism may include, for example, exclusion of certain nodes from the graph structure or inclusion of certain nodes from the graph structure in other nodes of the graph structure, based on a monitoring policy. Another mechanism may include a graph tree reversal mechanism for reversing or inverting a graph tree such that child nodes appear at the top of the graph tree. Child hiding is another useful graph manipulation mechanism of the present invention in which child nodes of graph nodes may be hidden to reduce the size of the depicted graph tree. Another mechanism may be a unique parent view or common child view in which two unique parents who have a common child may be viewed as separate unique branches of a graph tree or may be viewed as a graph tree in which branches intersect.
Yet another graph manipulation mechanism of the present invention includes a host, transaction, application, user (HTAU) manipulation in which a user may expand a leaf node by virtual nodes corresponding to hosts, transactions, applications, or users. Other metrics or parameters associated with the transaction could also be used in addition to, or in replacement of, the host, transaction, application and user parameters to perform graph manipulations without departing from the spirit and scope of the present invention. In addition, other mechanisms for expanding the leaf nodes may include selecting unique values of fields in tables associated with nodes so that only descendants that correspond to the selected field values are depicted.
In addition, the order of child nodes in the graph may be ordered based on the identity of the child nodes. Also, the number of the child nodes may be limited to a finite number in order to reduce the number of depicted child nodes such that the graph is more readable. Other graph manipulation mechanism may be defined with the present invention in addition to, or in replacement of, the above graph manipulation mechanisms without departing from the spirit and scope of the present invention.
With reference now to the figures,
In the depicted example, server 104 is connected to network 102 along with storage unit 106. In addition, clients 108, 110, and 112 are connected to network 102. These clients 108, 110, and 112 may be, for example, personal computers or network computers. In the depicted example, server 104 provides data, such as boot files, operating system images, and applications to clients 108-112. Clients 108, 110, and 112 are clients to server 104. Network data processing system 100 may include additional servers, clients, and other devices not shown. In the depicted example, network data processing system 100 is the Internet with network 102 representing a worldwide collection of networks and gateways that use the Transmission Control Protocol/Internet Protocol (TCP/IP) suite of protocols to communicate with one another. At the heart of the Internet is a backbone of high-speed data communication lines between major nodes or host computers, consisting of thousands of commercial, government, educational and other computer systems that route data and messages. Of course, network data processing system 100 also may be implemented as a number of different types of networks, such as for example, an intranet, a local area network (LAN), or a wide area network (WAN).
Peripheral component interconnect (PCI) bus bridge 214 connected to I/O bus 212 provides an interface to PCI local bus 216. A number of modems may be connected to PCI local bus 216. Typical PCI bus implementations will support four PCI expansion slots or add-in connectors. Communications links to clients 108-112 in
Additional PCI bus bridges 222 and 224 provide interfaces for additional PCI local buses 226 and 228, from which additional modems or network adapters may be supported. In this manner, data processing system 200 allows connections to multiple network computers. A memory-mapped graphics adapter 230 and hard disk 232 may also be connected to I/O bus 212 as depicted, either directly or indirectly.
Those of ordinary skill in the art will appreciate that the hardware depicted in
The data processing system depicted in
With reference now to
An operating system runs on processor 302 and is used to coordinate and provide control of various components within data processing system 300 in
Those of ordinary skill in the art will appreciate that the hardware in
As another example, data processing system 300 may be a stand-alone system configured to be bootable without relying on some type of network communication interfaces. As a further example, data processing system 300 may be a personal digital assistant (PDA) device, which is configured with ROM and/or flash ROM in order to provide non-volatile memory for storing operating system files and/or user-generated data.
The depicted example in
One or more servers, such as server 104, may provide web services of an electronic business for access by client devices, such as clients 108, 110 and 112. With the present invention, a transaction performance monitoring system is provided for monitoring performance of components of the web server and its enterprise back end systems in order to provide data representative of the enterprise business' performance in handling transactions. In one exemplary embodiment of the present invention, this transaction performance monitoring system is IBM Tivoli Monitoring for Transaction Performance™ (ITMTP) which measures and compiles transaction performance data including transaction processing times for various components within the enterprise system, error messages generated, and the like.
From the compiled transaction performance data, a graph, or topology, of the transaction identifying the components of the enterprise system that performed some processing on the transaction is generated and a corresponding graph data structure is created. The graph may include a plurality of iconic depictions of nodes of the graph corresponding to the type of component the node represents. In addition, performance data may be superimposed or made available through this graph. For example, timing data for each component indicating how long each component took to perform its processing on the transaction may be provided with each iconic depiction of nodes in the graph. In addition, problem identifiers may be provided with iconic depictions of nodes in which problems are detected.
In the known systems, this graph or topology depiction is a fixed topology with a graphical user interface that permits the user to traverse the graph and drill down from a collapsed system overview level to an expanded system overview level, to a drill down view of the transaction, and finally to a method call trace for a particular component of the transaction. The present invention builds upon this known system and provides graph manipulation mechanisms for modifying the depiction of the graph or topology structure of the transaction such that the root cause of a problem in the processing of the transaction may be clearly depicted in an emphasized manner in order to bring a system administrator's attention to the root cause in order to aid in resolving problems in the enterprise system.
The web server 410, enterprise computing system resources 460 and ITMTP system 470 are part of an enterprise system. Client devices 420-450 may submit requests to the enterprise system via the web server 410 which causes transactions to be created. The transactions are processed by the web server 410 and enterprise computing system resources 460 with the ITMTP system 470 monitoring the performance of the web server 410 and enterprise computing system resources 460 as they process the transactions. This performance monitoring involves collecting and storing data regarding performance parameters of the various components of the web server 410 and enterprise computing system resources 460. For example, monitoring of performance may involve collecting and storing information regarding the amount of time a particular component spends processing the transaction, the bit rate of the component, an SQL query, component information including class name and instance id in the JAVA Virtual Machine (JVM), memory usage statistics, any properties of the state of the JVM, properties of the components of the JVM, and/or properties of the system in general.
The components of the web server 410 and enterprise computing system resources 460 may include both hardware and software components. For example, the components may include host systems, JAVA Server Pages, servlets, entity beans, Enterprise Java Beans, data connections, and the like. Each component may have its own set of performance characteristics which may be collected and stored by the ITMTP system 470 in order to obtain an indication as to how the enterprise system is handling transactions. More information regarding the manner by which the ITMTP system 470 collects performance data, stores it, and uses it to generate reports and transaction graph data structures may be obtained from the Application Response Measurement (ARM) Specification, version 3.0, which is available from the Open Group at www.opengroup.org/tech/ management/arm/uploads/40/2459/ARM3Final.pdf, which is hereby incorporated by reference.
As mentioned above, the transaction data that is collected and stored by the ITMTP system 470 is used to generate a graph data structure for depicting the interaction of the components involved in processing transactions. The graphical representation of the graph data structure, in a preferred embodiment, resembles a tree graph data structure in which nodes may be parent and/or child nodes in the tree graph data structure. Parent nodes have pointers to their child nodes and child nodes have pointers to their parent nodes. A child node may be a parent to its own child nodes. In addition, each node has its own set of component attributes and may include method trace information for identifying the methods executed by the component represented by the node.
Various indicators may be provided associated with each iconic representation of the enterprise system components. These indicators may be used to identify the components where additional attention of the system administrator(s) is warranted. For example, these indicators may identify components where collected performance data indicates an error, less than acceptable performance, potential bottlenecks, and the like.
Nodes 510 in the graph data structure representation 500 are selectable in order to obtain more detailed information about the nodes 510. For example, a node may be selected in order to view the node's component attributes, a method trace associated with the node, and the like.
The expanded system overview representation 620 may then be drilled down to a transaction representation 630 in which the components involved in the transaction are represented in the depicted graph data structure. From there, individual nodes of the transaction representation 630 may be selected to obtain a component attribute representation 640 and/or a method call trace 650.
As discussed previously, the graph data structure representations described above, and illustrated in
The present invention builds upon the graph mechanism described above by providing graph manipulation mechanisms for modifying the presentation of the transaction representation 630 such that the root cause of problems being experienced with the enterprise system are emphasized and are easily identifiable by users of the present invention, e.g., system administrators. The graph manipulation mechanisms of the present invention operate to modify an actual topology of the transaction, i.e. the topology through which the transaction is processed, into a modified topology that is a change in the organization of component nodes which makes it easier for a human user to view the root cause of errors or problems in the processing of the transaction. These graph manipulation mechanisms may be performed automatically by the graphical user interface of a transaction processing performance monitor, may be selected by a human user of the graphical user interface, and/or a combination of automatic and user initiated graphical manipulation mechanisms may be utilized.
The actual topology or original transaction processing topology is represented as a first graph that is comprised of first nodes that represent system entities involved in processing of a sub-transaction of the transaction, e.g., the systems and the network interconnections. The first nodes may be child nodes, parent nodes, or both.
The present invention takes the actual topology represented by the first graph and generates a virtual topology, represented by a second graph, based on the actual topology. The second graph is a graph of nodes which may or may not correlate to nodes in the first graph. The second graph represents a higher level of abstraction, i.e. where the nodes are selective or a combination of nodes when compared to the first graph of nodes. A second graph node may also be a child node, a parent node, or both.
The elimination of a node in the first graph when generating the second graph of the transaction processing topology involves identifying any parent of the node to be eliminated in the first graph, and children nodes of the node to be eliminated in the first graph, and then generating nodes in the second graph to graphically representing the children from the first graph as children of a parent node in the second graph corresponding to the parent node of the node that is to be eliminated in the first graph. This is illustrated in
Assume that the monitoring policy established by the user states that the user is not interested in viewing nodes associated with EJBs. This may be the fact for many different reasons. For example, the user may be aware that there are a proportionally greater number of EJBs in the enterprise system than any other component and the user wishes to minimize the size of the graph so that possible error sources are more easily identifiable. Similarly, if the user has determined that, based on historical information, root causes of errors typically do not arise in components of a certain type, these components may be eliminated from the transaction processing topology in order to simplify the topology for quicker identification of root causes of errors or problems with transaction processing.
The essence of this graph manipulation is to use process of elimination to find root cause. The user session during graph manipulation represents this process of elimination. Each successive graph represents a different model of the transaction. Each node represents a probable root cause. By decreasing the number of nodes, the user is eliminating possible root causes. By increasing the number of nodes, the user is determining a more precise set of possibilities for a root cause.
When the monitoring policy is applied to the transaction processing topology or first graph, the resulting second graph representation includes only the servlet node 740, as a parent node, and the JDBC node 750, as a child node of the parent node 740. With regard to the data structure representing the first graph, the entries in the first graph data structure are copied over to a second graph data structure and then the second graph data structure is used to generate the second graph representation. During the copying over process, if an entry has an attribute identifying the component or node corresponding to the entry as being a component or node for which the monitoring policy indicates monitoring to be disabled, the entry is not copied over to the second graph data structure. Any parent entry and child entries of this entry are modified to point to each other. As a result, the parent entry of the removed entry is now the parent of the child entries of the removed entry, and the graphical representation is as shown in
The idea here is that two nodes may be different because of only the application associated to the node. By removing the application distinction, the two nodes become the same, and so the view of the graph shows one node instead of two. This reduces the graph size, simplifying the view. In essence, the user is saying that the root cause is not the application, and to unbind it from the nodes.
It should be noted that the graphical user interface through which the graphical depictions of the transaction processing topologies are presented may include user selectable virtual buttons, menus, etc., via which the application of the monitoring policy may be removed from the modified graphical representation of the topology. In this way, the first graph representation of the transaction processing topology may be obtained from the second transaction processing topology.
In order to perform this reversal of the first graph to generate a reversed second graph, a column of the first graph data structure representing the child nodes and the column of the first graph data structure representing the parent nodes are switched and stored in a second graph data structure. As a result, the child nodes in the first graph are now parent nodes in the second graph and the parent nodes in the first graph are now child nodes in the second graph. The graphical representation of the second graph is then generated using this second graph data structure.
An example of the graph reversal mechanism of the present invention is shown in
Since, in many cases, the leaf nodes, or nodes nearest the leaf nodes, of the transaction processing topology tend to be the root cause of processing problems or errors, by performing the reversal modification of the present invention, the root cause node is brought to a more prominent position in the second graph representation. While the depicted examples are kept simple for clarification purposes, it can be appreciated that with complex topologies, such a reversal mechanism will greatly speed up the locating of the root cause of problems being experienced with transaction processing.
From the standpoint of the first graph data structure, child nodes of a designated parent node are not copied over to the second graph data structure when generating the graphical representation of the transaction processing topology. As a result, these child nodes are not included in the graphical representation that the user perceives.
An example of this child hiding mechanism is provided in
When switched to a common child representation, rather than having a copy of the common child node 1030 in each tree, the trees merge at the common child node 1030. That is, the child node 1020 and the child node 1040 both point to the same single node representation of the common child node 1030. In this way, redundant nodes in the graphical representation of the transaction processing topology are removed and thus, the graphical representation is simplified making it less difficult to identify root causes of errors or problems in transaction processing.
In limiting the child nodes included in the second graphical representation, node entries from the first graph data structure are copied to a second graph data structure. If a parent node has a selected attribute, e.g., host, transaction, application, or user attribute, then each child node entry in the first graph data structure is checked to determine if they include the same selected attribute or attributes. If the child node has the same selected attribute or attributes, it is copied over to the second graph data structure. If it does not have the same selected attribute or attributes, then the child nodes is not copied over to the second graph data structure. If this child node is the parent node of another child node, then a mechanism such as that described above with regard to
Thus, in the depicted example, since JDBC1 1120 and JDBC2 1130 have attributes matching the selected attributes of the EJB 1110, i.e. host names that are host1.domain1.com or host2.domain1.com, these child nodes are displayed. Since JDBC3 1140 does not have a host name corresponding to either of hostl.domainl.com or host2.domain2.com, the JDBC3 node 1140 is not displayed in the modified graph of the transaction processing topology.
Each node is bound to a set of attributes. During parametric search, each attribute may have more than one value. Nodes are not considered unique based on the value of the attribute, but by their key, until the user binds a value to the key. This binding prunes the graph at the corresponding node to eliminate sub-graphs that could not be derived without this binding. For example, node A may have a child node B with attributes named ‘health’ and ‘host’. The corresponding values for the attribute ‘health’ may be ‘good’ and ‘bad’. The corresponding values for the attribute ‘host’ may be ‘host1.domain.com’ and ‘host2.domain.com’. The actual transaction may have a binding of the health to the host, such that host1.domain.com has bad health and the host2.domain.com has good health. The user does not see this binding until he/she narrows the parametric search by binding either the health attribute or the host attribute. By binding a value on an attribute, e.g. health to the value bad, then attribute host is implicitly bound to hostl.domain.com.
Consider a modification of the example where there was a third host, host3.domain.com, for which the actual transaction data bound the health to bad. By binding the health to bad in the parametric search, the host1.domain.com would be eliminated from the attribute values to which host could be bound.
With this graph manipulation mechanism, the ordering criteria may be set a priori or may be input by a user at the time the graphical representation is to be generated. This ordering criteria is then used along with an ordering algorithm to traverse the first graph data structure and copy entries from the first graph data structure to a second graph data structure in a proper order according to the ordering criteria. The resulting second graph data structure is then used to render the graphical representation of the modified transaction processing topology.
This mechanism permits any ordering of the child nodes that is deemed to be most helpful in identifying the root cause of errors or problems with transaction processing. Using the ordering mechanism, child nodes that have attributes indicative of being sources of problems with regard to transaction processing may be placed at the top of a group of child nodes so that they are more easily noticed by a user. For example, the child nodes may be ordered according to worst response times such that the most probable root cause of an error or problem is placed at the top of the group of child nodes.
In addition, the number of child nodes that are actually displayed may be limited to a designated number. Thus, once ordering of the child nodes is performed in accordance with the embodiments described above, only the designated number of child nodes from the top of the reordered group will actually be displayed. For example, if the limit is set to 10, only the top 10 child nodes in the reordered group of child nodes will be displayed. Child nodes appearing in the group after the 10 child node will not be present in the modified graphical representation of the transaction processing topology.
While various mechanisms for graph manipulation have been described above, these are not exhaustive of the possible graph manipulation mechanisms that may be implemented using the present invention. To the contrary, the present invention is intended to include any graph manipulation mechanism that may be applied to actual graphs of transaction processing performance monitoring data in order to identify and emphasize root causes of errors or problems in transaction processing of an enterprise system. For example, another graph manipulation may be one in which nodes representing root causes of errors may be directly linked to the root of the graph with all other child nodes removed. Other graph manipulation mechanisms, which may become apparent to those of ordinary skill in the art in view of the present disclosure, are intended to be within the spirit and scope of the present invention.
It should also be noted that while the above graph manipulation mechanisms are described separately for clarity, these graph manipulation mechanisms may be used in conjunction with one another. Thus, both the HTAU graph manipulation mechanism and the child ordering graph manipulation may be used together, for example. In such embodiments, a first graph manipulation mechanism may be applied to the actual graph data structure in order to generate a first virtual graph data structure. A second graph manipulation mechanism may then be applied to the first virtual graph data structure in order to generate a second virtual graph data structure. This process may be repeated for each subsequent graph manipulation mechanism.
Also, as noted above, these graph manipulation mechanisms may be performed automatically, manually, or both. With an automated mechanism, based on the identified problem location(s) in a transaction processing topology, as determined by the ITMTP system, an appropriate graph manipulation mechanism may be selected that would best emphasize the problem location(s). Thus, for example, if the problem location is in a child node that is one of one hundred child nodes of a parent node, then the child ordering mechanism may be used along with a limit on how many child nodes are displayed. As a result, the child node in which the problem is detected may be more easily identified.
Accordingly, blocks of the flowchart illustration support combinations of means for performing the specified functions, combinations of steps for performing the specified functions and program instruction means for performing the specified functions. It will also be understood that each block of the flowchart illustration, and combinations of blocks in the flowchart illustration, can be implemented by special purpose hardware-based computer systems which perform the specified functions or steps, or by combinations of special purpose hardware and computer instructions.
As stated above,
A first graph manipulation mechanism is applied to the first graph data structure in order to generate a second graph data structure (step 1440). A determination is then made as to whether there are additional graph manipulation mechanisms to be applied (step 1450). If so, a next graph manipulation mechanism is applied to the second graph data structure to generate a modified second graph data structure (step 1460). The modified second graph data structure is then set as the second graph data structure (step 1470) and the operation returns to step 1450.
If there are no additional graph manipulation mechanisms to be applied, the second graph data structure is used to generate a graphical representation of the transaction processing topology (step 1480). This graphical representation is modified from the graphical representation that would be obtained from the first graph data structure due to the application of the one or more graph manipulation mechanisms.
Thus, the present invention provides a plurality of graph manipulation mechanisms through which a first graph of a transaction processing topology, obtained from transaction processing performance monitoring data, may be modified. These modifications are used to provide a graph of the transaction processing topology through which a user may more easily identify the root cause of transaction processing problems in an enterprise system.
It is important to note that while the present invention has been described in the context of a fully functioning data processing system, those of ordinary skill in the art will appreciate that the processes of the present invention are capable of being distributed in the form of a computer readable medium of instructions and a variety of forms and that the present invention applies equally regardless of the particular type of signal bearing media actually used to carry out the distribution. Examples of computer readable media include recordable-type media, such as a floppy disk, a hard disk drive, a RAM, CD-ROMs, DVD-ROMs, and transmission-type media, such as digital and analog communications links, wired or wireless communications links using transmission forms, such as, for example, radio frequency and light wave transmissions. The computer readable media may take the form of coded formats that are decoded for actual use in a particular data processing system.
The description of the present invention has been presented for purposes of illustration and description, and is not intended to be exhaustive or limited to the invention in the form disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art. The embodiment was chosen and described in order to best explain the principles of the invention, the practical application, and to enable others of ordinary skill in the art to understand the invention for various embodiments with various modifications as are suited to the particular use contemplated.