203, a Data Domain (deduplication backup) appliance microservices layer 206, an object storage (e.g., Dell ObjectScale) microservices layer 208, a Kubernetes layer 210, a processor layer 212, and a storage layer 214 including different types of storage media, such as HDD, Flash memory, SSD memory, and so on. Each of these component products consists of multiple microservices, and as more nodes are added, Santorini scales CPU, storage, RAM, and networking accordingly. Other layers can also be included, and a cluster 202 may comprise any practical number of nodes 203. The PPDM represents a cloud-native data protection manager system, and ObjectScale represents a scalable object storage manager.

As shown in FIG. 2, embodiments of the cluster network 200 through DD microservices 206 utilize Data Domain backup appliances to provide streaming deduplication, and which use the Data Domain File System (DDFS) as an inline data deduplication filesystem. As data gets written to the filesystem, DDFS creates variable sized segments and writes the unique segments to a compression region. A number of compression regions are grouped together and written as a container to disk. DDFS calculates fingerprint signatures for each segment using SHA1 algorithm. DDFS has an on-disk fingerprint index table, which maps the fingerprint to the container-ID, that has the corresponding segment data. The container has a metadata section followed by several data sections. The data sections store the compression regions; and the container metadata section stores the meta information of the container, i.e., it stores the total number of compression regions, the total number of segments, the fingerprint of each segment, and so on.

In a deduplicated filesystem that forms segments from data, these segments are uniquely identified by their key/label called a ‘fingerprint.’ Given a file offset and length, the corresponding data segment fingerprints need to be looked up. To provide faster offset to fingerprint lookup the mapping is stored in a Merkle tree format where the leaf nodes represent data segments and their fingerprints are stored in the parent nodes which are metadata segments. In a Merkle tree, every non-leaf node is labeled with the hash of the labels of its children nodes to allow efficient and secure verification of the contents of large data structures.

With respect to the directory tree structure of the data processed in system 100, various different data structures can be supported by the file system (e.g., DDFS or Santorini filesystem). A B+ Tree is self-balancing tree structure and is a variant of a standard B Tree, and Each file inode is stored in the B+ Tree as a data blob using the parent directory inode number and the child file inode number as the key. A B+ Tree key structure composed of the parent directory inode as the primary key and child file inode as the secondary key to construct the full key. An Mtree is a tree data structure similar to a B+ Tree (or R-tree), which is constructed using a metric and relies on triangle inequality for efficient range and k-nearest neighbor queries. As with other tree-based data structures, the Mtree is composed of nodes and leaves. In each node there is a data object that identifies it uniquely and a pointer to a sub-tree where its children reside. Every leaf has several data objects

A file in DDFS is represented by a Merkle tree with user data as variable sized segments at the bottom level of the tree, referred to as L0 segments. The SHA1 fingerprints of those segments are grouped together at the next higher level of the tree to form new segments, referred to as L1 segments. SHA1 fingerprints of L1 segments are grouped together as L2 segments, and this continues up to L6 which represents the entire file. The top segment of the tree is always an L6 segment, even though it may refer to any lower numbered segments. Segments above L0 are referred to as Lp chunks. The L6 segment of every file is stored in a namespace which is represented as a B+ Tree. The L0 and Lp segments are written to separate containers, known as L0 and Lp containers.

A Data Domain or similar system can efficiently copy an existing file using the same underlying Merkle tree. It creates the new file with a new name, and therefore a new L6 root of the tree, but that tree then references the identical LP chunks. As this operation involves only the root of the tree, it is trivially fast and does not increase physical space in use beyond the one chunk containing the L6.

In an embodiment, the PPDM (PowerProtect Data Manager) microservices layer 204 builds on the Data Domain system 206 to provide data protection capabilities for VM image backups and Kubernetes workloads.

Upon creation of an Mtree, it can identify the domain on which the Mtree is created. All namespace metadata as well as the file data and metadata associated with a Mtree is allocated from resources owned by that domain. The Mtree names as well as Mtree IDs are unique across the cluster. Santorini exposes a global namespace that is a union of all namespaces in all domains.

FIG. 3 illustrates details of the services related to the data path running in Santorini cluster network, under some embodiments. As shown in diagram 300, a product services layer 302 provides the necessary REST APIs and user interface utilities. The API server implements a RESTful interface, allowing many different tools and libraries can readily communicate with it. A client called kubecfg is packaged along with the server-side tools and can be used from a local computer to interact with the Kubernetes cluster.

Below layer 302, the protection software services layer 304 includes a data manager (e.g., Power Protect Data Manager, PPDM) component 305 that provides backup software functionality. Within the scale-out protection storage services layer 306, the File System Redirection Proxy (FSRP) service 307 redirects file operations in a consistent manner based on the hash of a file handle, path, or other properties to instance of the access object service 309. The access object service 309 handles protocols and a content store manager. This means that files are segmented and the Lp tree is constructed by an access object 309. The FSRP 307 redirects file system accesses in a consistent way to the access objects 309 so that any in-memory state can be reused if a file is accessed repeatedly in a short time, and it avoids taking global locks.

Also included in this layer 306 are any number of nodes (e.g., Nodes 1 to 3, as shown), each containing a dedup/compression packer and a key-value (KV) store.

As an L1 is formed, a similarity group is calculated for the L1 based on the SHA1 fingerprints of the L0 segments (or other properties). The similarity group is checked against a mapping table, which leads to consistently routing the L1 based on its similarity group to an instance of a node's dedup/compress service. If similarity groups are in a range of 0-1023, then if there are four instances of the dedup/compress service, then the instances may uniquely be responsible for the ranges 0-255, 256-511, 512-767, 768-1023, though other mappings are possible. The dedup/compress instance will deduplicate the L0 segments relative to other fingerprints within the same similarity group. Other functionality exists in the dedup/compress service such as packing segments into compression regions, containers, and blobs that will be written to an underlying object storage such as provided by the object scale service layer 301, or an object store provided by the public cloud.

Distributed key value stores are also a component of Santorini and are used to hold much of the metadata such as the namespace Btree, the Lp tree, fingerprint index, and container fingerprints. These run as containers within the Santorini cluster and are stored to low latency media such as NVMe. There is also a distributed and durable log that replaces NVRAM for Santorini.

Support Bundle Collector Service

Because of system complexity and variety of features and products, Santorini and other similar cluster systems are typically provided to users by different system providers, or ‘vendors’. Such vendors usually provide the necessary hardware and software infrastructure necessary for users to install and deploy cluster networks in their own environment. As part of this service, vendors may also provide ongoing support in the way of bug fixes, system optimization, software upgrades/updates, configuration recommendations, and so on.

As products are developed for release and deployment, bug fixes, version iterations, and configuration support are important activities of the vendor. Such activities rely on timely and efficient interchange of information between the user and vendor to satisfactorily solve any issues that the user may encounter during and after system deployment. In an embodiment, this information is encapsulated in the form of ‘support bundles’ that comprise the relevant information and data used by the vendor to identify and solve user issues. As stated above, support bundle collection is a critical feature for Santorini, and similar systems, during both customer deployment and during product development. Support bundles are collected, transferred back to the vendor, and analyzed during debugging. Similarly, during development, engineers collect and analyze support bundles to understand problems in their code. As shown in FIG. 1B, support bundle processing 158 is an aspect of the cluster system serviceability components 150.

FIG. 4 illustrates the generation and transmission of support bundles between a user and vendor, under some embodiments. As shown in FIG. 4, system 400 comprises a user system 402 having a deployed cluster network including a number of individual nodes 403 coupled to one another through network links 401. User system 402 can represent any appropriate cluster network, but the description will refer to a Santorini system, although embodiments are not so limited. Such a system may be used to implement any appropriate application 420 and file system 421, though the description may specifically mention a Data Domain-based deduplication backup application and the DDFS filesystem.

During installation, deployment, and use, system 402 may encounter various issues related to software/hardware operation, configuration, application compatibility, data corruption, and so on. Any number of issues may arise, and some may be directly addressable by the system vendor. For the embodiment of system 400, the vendor operates a backend system 410 that provides development and service/support functions to both produce the components for the user and debug, support, and improve these components as they are used. For this ongoing process, the user deployment 402 produces, usually on a periodic or on-demand basis, a support bundle 404 comprising any necessary information and data necessary for the vendor backend 410 to provide appropriate fixes, updates, patches, and so on, back to the user system. In an embodiment, the support bundle includes relevant configuration for each individual node 403 and network 401, and the overall system 402. It also includes any specific problem or bug issues, and log information for relevant events and transactions.

In general, a support bundle may include all of the logs written by the various services running within the cluster, as well as topology information listing which services are running on particular nodes and their version numbers. Hardware configuration information may also be included such as drive model numbers, MAC addresses for network cards, etc. Overall system information that may be included comprise total storage capacity, capacity currently utilized, and remaining capacity. Performance statistics may include read/write latencies, read/write throughputs, replication throughput, garbage collection performance, etc. Support bundle information can also include any identified failures such as offline nodes, hardware components, or services. An overall cluster identifier will be included in the support bundle such as a product identifier number. While this information could be gathered across the entire cluster in a single support bundle, filter criteria may also be applied to limit the information gathered to particular nodes and services.

The support bundle information 404 is provided to the vendor backend 410 through a user interface or application program interface (API) component 412 that can send and receive data and commands to and from the user system 402. The vendor system may also include debug tools 414 to correct any specific issues encountered in the user system. Other vendor components include any necessary customer service (personnel) support and/or development tools to address the issues encapsulated in the support bundle 404.

In an embodiment, the support bundle 404 is collected and provided to the vendor by a support bundle processor component 406 that includes a collector service 407 that collects support bundles from the Santorini network across all of the components and nodes in the cluster. The collector service component can be configured to specifically gather the information necessary for a Data Domain (or other application) support bundle.

The collector service 407 collects system configuration and operation information from each component (node, network, application, etc.) and collects logs from persistent volumes (PVs) on each node while applying filter criteria for one or more filters 408. The filters are configured to remove unnecessary data from the user to vendor transmission in a way that does not bottleneck the data flow. The collection is scalable by collecting from each node in parallel with a coordinator-worker design.

FIG. 5 illustrates components of a support bundle collector service, under some embodiments. System 500 illustrates component 406 of FIG. 4 in greater detail, and for an example embodiment of a Kubernetes-based implementation. As shown in FIG. 5, a support bundle request 502, as issued by a user or the system, triggers a Kubernetes API 504 call to trigger support bundle collection from operator 506. This call may include filter criteria to be applied to logs, such as time ranges, component types, and so on. This starts a scheduler 516 that creates a set of BundleJobs 518 for a node 510, where each job is based on a container image stored in an image repository 508. The BundleJob process 518 has the responsibility to create a support bundle for its area of responsibility and upload 520 the bundle to an interface or software component that will then transfer it to the vendor.

Different conditions can trigger or initiate a support bundle request. A typical use case is that the cluster has experienced some sort of problem that generates an alert that goes to the user and/or to the vendor. The user contacts vendor support (or support sometimes contacts the user first), and a support situation is initiated. The vendor directs the customer to generate a support bundle, which the user can do through a GUI or calling a REST API directly. The GUI has configuration options to set filter criteria and possibly set up a schedule for automatically generating a support bundle if that is deemed useful. Support bundles are usually initiated only when a problem is encountered and are typically not generated for normal cluster operation. The request may be configured to be automatically generated upon detection of a defined problem, error, or exception condition, or it can be manually triggered by the user upon such a condition or as needed/desired during cluster operation. An error condition automatically generating a support bundle request may be defined by any appropriate measurable situation, such as if capacity usage exceeds a threshold, processing bandwidth exceeds a maximum allowable percentage, and so on.

In an embodiment, the log files and various other information is gathered from individual nodes into a single support bundle by the DDOS bundler job 518. The support bundle 404 thus comprises individual sets of log and config/statistic information from each node, and which may comprise multiple files, that are then combined together into a single dataset (i.e., the support bundle), which can then be conveniently transferred to the vendor.

FIG. 6 is a flowchart that illustrates a method of gathering a support bundle for Data Domain in Santorini, under some embodiments. As shown in FIG. 6, process 600 involves the three main steps of gathering component statistics, 602; gathering system logs, 604; and transferring the support bundle to in interface for transfer to the vendor, 606.

In an embodiment, the component statistics gathered in step 602 comprise component statistics. Each service may be queried by the support bundle collection service, and each service will provide information to include in a support bundle. As described above, this information may include statistics about the service such as counters, performance measurements, latencies, and other details that will allow support and engineers to understand its internal workings. Any error situations identified by the service can also be included in this information.

Core Files

As shown in FIG. 1B, the cluster system serviceability components comprise or use core files 156. For this embodiment, core files are used for the data elements of the support bundle, such as the component statistics 602 and system logs 604. In an embodiment, ‘core’ files are files that include a captured memory state of the independent pods, rather than the cluster as a whole. A core file encapsulates the memory state of the pod (the constituent container or containers) at the time that a program crashes. Core files allow viewing and analysis of variables of the system by capturing memory states during normal operation and extraordinary events, such as system/program crashes, attacks, and so on. Such core files can then be processed by certain debugging tools. For example, a debugger tool may be attached to the memory core and the program binary to view the threads, variables, and system states around the event. Core files may be generated automatically upon detection of a crash by the operating system of the node and uses an auto-capture utility that captures the state at the time of the crash.

Core files can be formatted, stored, and processed in any appropriate manner, but should generally be stored consistently in memory. In an embodiment, core files are stored in each node at: /var/lib/systemd/coredump/. Core partitions stores both kernel and process core files. Core files can be compressed with zstd (or similar) compression, and may typically be on the order of 2 GB in size after compression. Core files are named and formatted to facilitate use in a multi-node, Santorini cluster, and so include more than simply name and timestamp information, such as may be common in single node systems.

An example core file format may be:

- core.<podname>.<proc_name>.<uid>.<boot_id>.<pid>.<timestamp>.zst
- core.ddfsaob-1-0.ddfs.0.9a955b6ae94841c487d548874cacb863.13907.1679230726000000.zst

A core dump helper service may be used to rename a core file name once a process core file is generated. A service can also be used to delete old core files (e.g., set to run every 30 minutes) since core files may tend to be large in size. Old crash core files can be deleted to make sure crash core file used space is smaller than 30 GB (or similar space). Similarly, it can delete old application core files, to make sure application core file used space is smaller than 220 GB (or similar). It can also rename application core files if there is a core file not renamed. Nodes may be configured to store core files for defined time periods, and generally core files are retained indefinitely until more space is needed, however, periodic memory saving operations may also be performed, for example the system may be configured to ensure that there is always 30 GB (for example) free on each node.

For security reasons, access to core files may be restricted or prevented. In an embodiment, a PV mounter pod is used access to core file directory. Such a PV mounter pod has heightened permissions depending on system configuration. This can be used to transfer core files through an interface to the vendor or system administrator, where debugging can then be performed.

In an embodiment, certain support bundle automation features may also be provided in conjunction with the core files, such as using existing scripts to process cores in a utility that is used to analyze core files, such as GNU Project debugger (GDB). Such a utility typically shows the state of a running node and the value of variables within the code at the time the core was generated. This can be used to return thread back traces and other details, and avoid transferring core files. Other features include automatically creating and transferring support bundles, providing user opt-in, avoiding delays when filing support tickets, and providing targeted support bundles with the option to gather more information later.

In an embodiment, certain end-to-end system observability tools may also be provided and used to track operations (e.g., backup/restore/replication, GC, etc.) across components and nodes. One such tool is a trace ID, which allows operations running in the system to be tracked across all of the various log files. Trace IDs provide a unique job ID that is associated with each operation (e.g., backup job). This ID flows through to all services handling the job and any print message also includes this ID allowing tracking through all of the log files for the job. Sub-operations can spawn a span ID that is used in conjunction with the main trace ID. These IDs comprise simple alphanumeric labels attached as metadata for the job. As the job is processed by different services and progresses through the system, the ID stays the same and is incorporated into the logs at each relevant stage. To ensure the integrity of the trace ID, span IDs can be used for any sub operations of the job, without touching the trace ID. Trace and span IDs can be used by one or more of the debugging tools provided in the system.

Logging

In a cluster network, each component/product has many services, and often many different instances of each service. Services may be started, stopped, and re-started, even on different nodes. Logging the execution and issue of processes across all of the components is necessary to diagnose any issues in the system, and logs should be available across container failures. Logging 152 is thus a key function of the cluster system serviceability components 150 of FIG. 1B. This component provides comprehensive creation, formatting, management and aggregation of logs to provide consistent and useful information to the scalable support bundle process. The logging function is configured to provide certain minimum logging requirements for the system. These include minimizing the risk of losing log lines, providing a consistent logging format for use by multiple nodes and resources in the system, imposing low resource overhead, and supporting the creation of support bundles from logs, among other requirements.

With respect to FIG. 2, generally the microservices layers 204, 206, and 208 perform the logging functions.

A significant component of support bundles are logs that record operations performed by the system components (e.g., nodes, pods, services, interfaces, etc.) in log files. In large scale cluster executing several applications or services, the type and number of log files can be significantly large. Logs are used as a primary source of information when trying to debug a problem in the system. Managing and processing log files is thus an important factor in providing serviceability of cluster networks.

Certain organizations, such as government agencies, public companies, and so on may be required to retain audit logs to comply with applicable requirements imposed under corporate and governmental guidelines. Such rules impose event logging requirements that allow agencies to collect the same type of data consistently making it easier to analyze and share information across agencies. Audit logs are used to capture relevant information, such as event names, descriptions, timestamps, entities that create/edit/delete the event, and entities that are impacted by the event, and so on. The information comprising the support bundles for a cluster network include log files that can be very useful in generating such audit logs. Present systems, however, are generally not capable of processing and utilizing this information without the extensive per-node processing provided by the architecture of FIG. 1B. Audit logs are provided by the audit log generation component 154 of the cluster network serviceability components 150.

A primary logging requirement is to verify that a log was properly created and stored, and still has integrity when retrieved for use in debugging. Because of the great volume of logged data that potentially may be generated, it is necessary to provide resource (CPU, memory) saving mechanisms, and to properly aggregate logs from all of the different components/services in the system. In an embodiment, these and other goals are achieved by using a distributed persistent volume (PV) architecture that stores logs for critical applications in dedicated PV storage through a mounter pod, in addition to a standard central PV location, as described in further detail below.

As shown in FIG. 6, step 604 comprises gathering system logs for the support bundle. In general, the following events are logged for all systems. FIG. 7 lists the events and items 702 that are logged for all systems. As shown in FIG. 7, the logged items 702 include system changes 704, which can comprise component availability state changes, such as nodes or processes shutting down; component failures and errors, such as device failures and recoverable memory errors; configuration changes, such as adding a device, installing an application or enabling a service; or changes to source code in production or configuration changes in a production system; and other similar system changes.

Logged items also include authentication and authorization events 706, such as authentication failures (e.g., login failures and account lockouts); failed accesses, such as insufficient permissions to access a database or transaction; or identity and access provisioning activities (e.g., creating new accounts, granting new permissions or changing existing permissions); and other similar activities. Privileged access events 708 can include access to privileged functions (e.g., using a super user level access (e.g., Linux sudo), running the administrative console or logging in as a normal user account; or all actions taken by any individual with root or administrative privileges. The audit-related activities 710 can include changing the event logging configuration or deleting event logs, or audit log failure, among others. FIG. 7 is provided for purposes of illustration and other items may also be logged as needed.

The system can implement log management using any one of a number of possible processes. A first process is to write log files directly to a persistent location. For this method, each pod must manage log rotation to maintain space within the persistent location. The technique involves limiting a log file (“log”) to a specific upper size. When that size is reached, the log file is renamed such as to ‘log.1’ and a new, empty log file is available for new log lines, where a log line is generally a single line of printed text for a log. If log. 1 exists, it is renamed to ‘log.2’, and this applies to other logs with conflicting names. The number of log files is limited based on a calculation of the space allowed for logging. By rotating the log names and deleting the highest numbered log, space is managed. This may only be supported for pods with node affinity, otherwise it would be complicated to manage logs across nodes if a service restarted on different nodes. This direct writing process generally involves only simple file writes, and avoids double-write overhead; it does, however, require that each pod must manage its own internal logs, and does add some complexity to support bundle collection.

A second method of writing log files is to write the log files to local files and use a sidecar. Many pods in a Data Domain system already write logs to local files, so a sidecar can be used to track directories and file extensions for updates. The sidecar will copy the log lines to the persistent location. For this method, legacy log file usage is supported, and log management is handled by rsyslogd (or similar) pod. This method, however, imposes a double-write overhead, and the need for each pod to manage its internal logs. There is also a small risk of possible loss of log lines when log lines are transferred from the sidecar to rsyslogd. As used in this description, a ‘sidecar’ is Kubernetes container that tracks log files in a pod and can be used to transfer these files to other services, storage, etc.

A third method of writing log files is to write to STDOUT and use Fluentbit, for example, which are standard Kubernetes service to copy log files from a pod to persistent volume. Kubernetes typically redirects STDOUT to a directory such as ‘/var/log/containers {POD},’ which is generally a well-established log management process handled by rsyslogd pod. This may, however, impose a double-write overhead and possible loss of log lines. Fluentbit is a fast log processor and forwarder for popular operating systems, and tracks updates to the established directory and then copies those updates across the internal network to rsyslog, which will write the lines to the corresponding log file within its persistent volume.

In an embodiment, the logging process is implemented in a way that provides a consistent logging framework with low risk of losing log lines, and maintaining low resource overheads with no major code changes between on-premises and cloud deployments. One or more defined policies may dictate log storage and removal schedules. For example, logs within pods and dedicated PVs are rotated and removed per a defined policy, and certain log quotas and retention rules at the node level may be defined, where quotas can be specified per node, application, service, and so on.

Logs are generally available outside of containers, but are not available if a node fails, however, the system can handle drive failures within a node. The system is configured to generate a support bundle from the logs. In system 100, a service or component crash generates a core file, which encapsulates the memory state stored in a file as a crash dump and which is used for debugging purposes. Core files and logs need to be stored persistently outside of pods, since pod memory is ephemeral, i.e., it is erased upon shutdown. Present systems typically store this information by writing directly to a single persistent volume (PV) or writing to local files through a sidecar container. Embodiments improve this method by providing additional PVs for selected services so that support bundle information is maintained in multiple locations for multi-node and multi-service environments to prevent failure of a single PV to result in log loss. Certain aggregations techniques are then used to generate a single support bundle for use by the vendor.

FIG. 8 is a flowchart that illustrates a method of collecting logs to generate a support bundle, under some embodiments. Process 800 of FIG. 8 generally illustrates a log aggregation process for a manageability process shown in FIG. 9A. As shown in FIG. 9A, a node 901 has storage components 902 (access object, AOB) and 904 (key-value store, KVS). For the embodiment of FIG. 9A, components 902 and 904 represent special or critical components/services that require certain needs such as node affinity (services restart on the same node only in the event of failure recovery), and that need to have their logs persevere, i.e., failure of a central PV or any other event that causes losing log lines is not acceptable. For this embodiment, a dedicated PV 906 is associated with each special service, along with the central PV 916. Other non-critical components (e.g., manageability or filesystem pods) can continue to use STDOUT or the sidecar with the single PV.

For the example embodiment of FIG. 9A, AOB component 902 is a type of content store that may store Lp trees, name spaces, and so on, and KVS 904 may be a key-value store for metadata. Other types of special storage may include DOB that is a segment store for a deduplication layer, and other similar resources. A respective persistent volume (PV) 906 is associated with each storage, where the PV is mounted using a PV mounter pod 908. In an embodiment the PV mounter pod 908 accesses the persistent volumes 906 used in a first logging case. The system needs a service to mount those persistent volumes so that it can access the logs to include in a support bundle. In some cases, the services that are writing to those persistent volumes may go offline due to software failures, so it cannot count on access logs through those services. The PV mounter pod represents a simple service that is unlikely to become unavailable so as to alleviate this possibility. Although specific example storage types (e.g., AOB and KVS) have been shown, it should be noted that any appropriate storage for objects and data elements may be used.

One or more services 910 using a sidecar or FluentBit 912 use the Rsyslogd function 914, which has its own PV 916 mounted. The support bundle collection job will then include logs from both rsyslog PV (916) and logging PV (906).

As shown in FIG. 8, to collect logs, the system tools copy from a node 901 mounting a PV 906 with the logs, step 802. For this process, Rsyslogd pod 914 is likely to be running, and regular pods may be down. The process adds a PV mounter pod 908 mounts all PVs with the appropriate label, 804. The process may restart if the PVs switch devices due to failures, 806 and will likely also mount or crash-dump to core files. To create a support bundle, the system will log into to each PV mounter POD running on each node and access the logging PVs and copy the log files.

The logs information may be provided in any appropriate format and contents. For example, logs may be timestamped in ISO 8601 format and with the UTC timezone (e.g., 2020-03-18T22:00:55.040Z). This may then be converted to local time zone when displaying to users. The logs may be defined to encapsulate relevant information, such as [timestamp, severity, source, body].

In an embodiment, logs can be selected based on various different parameters or characteristics, such as keywords, component, data ranges, nodes, and so on. The configuration information that is gathered can be provided in a standard system or industry configuration, or it may be defined by individual or specifically tailored criteria, as needed.

Support bundles can be managed through any appropriate management program or process. A user interface or management program can be configured to list bundles according to a system or user defined format, and bundles can be generated, defined, deleted, or modified, as needed. The system includes mechanisms to automatically delete old or corrupted bundles to provide space awareness and management.

In an embodiment, different log levels may be used to differentiate among different error/exception conditions and assign logging verbosity. Logs are thus provided in levels are of different verbosity of logging for activities such as debug, error, info, warning, and so on. Any practical number of log levels may be used depending on the number and type of different errors that may occur, and higher log levels imply greater logging activity, and the verbosity can be increased to collect extra logs to debug the problem. For example, the info level may have the least amount of logging and consists of function call history. In contrast, the debug level may be the most verbose and include all of the content from the info level as well as more detailed logging information about operations within functions.

A UI or API function may be used to configure these log levels, for example by a UI/API call to set log level for one or multiple components. The implementation will be specific to each component. Some components may use a registry, while others may use an API. FIG. 9B illustrates a logging processing component implementing log levels in a multi-node cluster system, under some embodiments. System 920 of FIG. 9B illustrates an API implementation for configuring log levels. Any number of nodes may be present in the system, such as nodes 921 and 923. Each node has services or components, such as AOB storage 922 and KVS 924, for example. Log levels are set by a user or system admin (vendor) through API calls 929, and a special API handler 926 for setting the log levels configures the log levels in all of the components of the node, such as storage 922 and 924, along with manageability 928 and filesystem 930 services, for example.

FIG. 9B illustrates the use of API calls to set log levels, but other mechanisms are also possible, such as registries, command line interface (CLI) commands, metadata definitions, and so on.

The logs can be configured at different levels of granularity, such as per component-product, component, and node. The system is configured to set different log levels for different components within Santorini. For example, it can set the Data Domain services to log at a detailed level, while all other services on all nodes remain at a default level that has minimal logging. As another example, it may set the PPDM indexing service on node 1 to debug logging, while all other services on all nodes remain at a default level that has minimal logging.

Audit Log Processing

As shown in FIG. 1B, the cluster system serviceability components 150 include an audit log generation or processing component 154. This functional component is used to produce and manage audit logs that may be needed for certain corporate and/or government requirements. As stated above, some organizations may be required to keep and manage system logs for audit purposes by corporate or government auditors. The audit log service 124 generates audit logs that capture relevant information, such as event names, descriptions, timestamps, entities that create/edit/delete the event, and entities that are impacted by the event, etc., and conform the logs to any required format and management processes.

FIG. 10 is a table illustrating logged events in a cluster network, under some embodiments. To conform with common requirements table 950 lists four main areas of events and activities that must be logged. These include system changes 952, authentication/authorization activities 954, privileged access activity 956, and audit-related activities 958.

The system changes 952 typically comprise system availability state changes, such as shut downs; component failures and errors, such as device failures and recoverable memory errors; configuration changes, such as adding a device or installing an application or enabling a service; and changes to source code in production or configuration changes in a production system.

Authentication and authorization 954 activities typically comprise authentication failures and warnings, such as login failures and account lockouts; and failed accesses, such as insufficient permissions to access a database or transaction; and identity and access provisioning activities that can include creating new accounts, granting new permissions or changing existing permissions.

Privileged access 956 typically comprise attempted access to privileged functions, such as using sudo, running the administrative console or logging in as a normal user account; and all actions taken by any individual with root or administrative privileges.

Audit-related activities 958 typically comprise actions such as changing the event logging configuration or deleting event logs; and audit log failures.

FIG. 10 is provided for purposes of example only, and other or different system events and interactions can also be included, depending on requirements, applications and system configuration and constraints.

In an embodiment, the system consolidates all of the local logs (log files) from all of the system components (nodes and pods), and which can also be displayed through a GUI. The audit logs information is stored persistently in one or more persistent volumes (PVs) outside of the pods. A specialized audit log management system with high availability is made available to all components. With respect to storage, hashes of the log files are stored separately from the log files themselves so that the files are tamper proof. Audit logs can be exported to external, secure syslog server. Audit logs can be made subject to defined retention policies, as needed.

Audit logs are formatted such that they conform with a common audit logging format (e.g., EL1). Such a format may include sender, receiver, and other specified details. All specified user operations are logged, and each log entry includes details of who, when, and what action was performed on a particular component for audit review purposes. Old and new values are captured and stored. A consistent format for audit logs is used so that users can analyze when logs are exported, and the consolidated logs can be displayed through the GUI.

In an embodiment, local copies of audit logs are retained for viewing for a specified number of days if needed, and even in the event the external syslog server is available. Audit logs are not changeable, but utilities may be provided to allow user annotation.

The GUI can be configured to allow a user, vendor, or auditor to view the entire cluster system (Santorini's) audit logs. Alerts can be raised when the audit logging service is offline. In order to maintain integrity of the logging process, the system may reject operations if they cannot be logged.

In an embodiment, the audit logging service 124 can be configured to conform to any of the Event Logging (EL) levels defined by the US government, or similar requirements by other governments or agencies. Presently these guidelines specify four levels from EL0 (Not Effective) to EL3 (Advanced). For example, to meet the EL1 level (Basic), the audit logging feature must meet certain requirements, such as basic logging categories (administrator actions, faults, and system events), minimum logging data, and a set time standard (ISO 86801 UTC, same as debug logs). In addition, log forwarding must be allowed, and log information must be protected and validated, and the system must use passive DNS. Other requirements may include Cybersecurity Infrastructure Security Agency (CISA) and Federal Bureau of Investigations (FBI) access requirements, and implementation of Logging Orchestration, Automation, and Response (SOAR), and user behavior monitoring.

In an embodiment, the logs generated by all of the system components are aggregated by process 124 using a log aggregator, such as Fluentbit. This process may use a regular expression filter (regex) or similar function to copy audit lines to an audit log management system. Components with an audit file can also configure a sidecar just for the audit file to redirect those logs.

FIG. 11 illustrates a log aggregation process in a node for audit log generation, under some embodiments. As shown system 1100 of FIG. 11, a node 1101 has storage components 1102 (AOB) and 1104 (KVS). A respective persistent volume (PV) 1106 is associated with each storage, where the PV is mounted using a PV mounter pod 1108. In an embodiment the PV mounter pod 1108 accesses the persistent volumes 1106 used for logging.

One or more services 1110 using a sidecar or FluentBit 1112 use the Rsyslogd function 1114 in PV 1116. The log management system will then receive logs from both rsyslog PV (1116) and logging PVs (1106).

For the embodiment of FIG. 11, the process writes to STDOUT (standard output) and uses Fluentbit, which is standard for new microservices. The Kubernetes system typically redirects STDOUT to/var/log/containers {POD}, as shown in 1114.

As shown for a first service (1110), the process can write to local files and use a sidecar. Many application pods (e.g. DD pods) already write logs to local files, so a sidecar can be used to track certain directories and file extensions for updates. The sidecar will copy the log lines to the persistent location, PV 1116.

As shown for a second service (1112), the process can also write log files directly to the persistent location 1116. This may be supported only in limited cases, depending on system configuration.

Once generated, the audit logs are transferred to an audit log management system. FIG. 12 illustrates a process of transferring audit logs from a node, under some embodiments. As shown in FIG. 12, system 1200 comprises a node 1201 coupled to an audit log management system 1220. The node 1201 comprises a number of pods 1202 that have their own PVs 1204 using a mounter pod, as described above with respect to FIG. 11. The node also includes other pods 1206 that use PV 1216 through a sidecar or directly, again as described above with respect to FIG. 11. In an embodiment the pods of node 1201 write to the audit log management system through remote procedure calls (gRPC) 1218 or direct links 1219.

In an embodiment, gRPC 1218 adjusts DD code paths that write to a database to use gRPC to write to the audit log management system 1220. This allows the process to confirm transfer, handle errors, and reject operations that cannot be recorded. For non-DD components, there is an option to configure Fluentbit or the sidecar to perform a direct transfer 1219 of audit logs to the audit log management system 1220. A single sidecar can transfer debug logs and audit logs to different endpoints, depending on system configuration.

FIG. 13 is a flowchart that illustrates an overall method of providing audit log management for a cluster network, under some embodiments. The process of FIG. 13 starts with aggregating logs from the different components and services in the system, 1302, such as described above with respect to FIG. 9A. Log files for critical components/services are written to dedicated PV locations, 1304, while log files for all other components/services are written to a central PV location. If an audit is initiated, the log files are then transferred to an audit log management system, 1308, such as described above with reference to claim 12.

Transferring Support Bundles

In an embodiment support bundles processed by function 158 of FIG. 1B are collected using a support bundle collector service, such as shown in FIG. 5. Once the system logs have been gathered 602 in process 600, they can be transferred to the vendor through a relevant interface, step 606.

FIG. 14 illustrates a system and process of transferring support bundles for a Data Domain application, under an example embodiment. System 1450 of FIG. 10 illustrates two different example nodes 1456 and 1458 in a Santorini cluster. As shown in 1450, a support bundle collection is triggered by a UI 1452 or API 1454 call. Lines 1453 (illustrated in white) represent communication with each data protection component to request statistics to be included in a support bundle. These include calls from the support bundle collector in node 1456 to the PPDM in node 1458 and the access object and deduplication/compression processes in 1456 and 1458. For the example of FIG. 10, there is one instance of the support bundle collector, and this can reside on any node of the network. As illustrated, there is SSH, UI, and API access to the support bundle collector and support bundles can be transferred out of the cluster to a vendor through either a remote connection (ESE) process or manual download.

Lines 1455 (illustrated in black) show logs being gathered from persistent volumes (PVs) and the rsyslogd pod that has its own persistent volume. The support bundle is then transferred out to the vendor or made available for download when users have not enabled external communication. Support bundles can be transferred with a remote connectivity process (e.g., Embedded Support Assist Solution, ESE), manual transfer, or any other appropriate method.

FIG. 15 illustrates log collection and transfers in a multi-node system, under an example embodiment. As shown in FIG. 15, cluster system 1500 contains two nodes 1502 and 1504. Each node has multiple components running such as the AOB 1506 and KVS 1508 and other manageability 1510 and filesystem 1512 components. The manageability and filesystem components run as pods that are use a sidecar mechanism to transfer logs to a persistent volume 1514 managed by rsyslogd. Those components write files to a local directory (e.g., “/var/log/containers”) and manage the log rotation and space quotas within their directory space. A sidecar is added to those pods that tails the local log files and sends the log lines to rsyslogd to be written to its persistent volume 1514. For these components, log collection happens by contacting rsyslog and copying from its attached persistent volume.

Other components in Santorini use a different mechanism for log persistence. A persistent volume is created specifically for those components and attached to those components when they start up. In one embodiment, the AOB, KVS, and several other components may have their own persistent volumes 1516 for logging. For these components, writing logs is very similar to the process described above. The components write logs to a local directory and need to manage log rotation and space quotas. The difference is that the local directory is actually on a persistent volume. For these components, the system gathers logs from their respective persistent volumes.

Some Kubernetes implementations may have limitations that prevent the system from providing persistent volumes to all components or having all components share the same persistent volume. In such a case, a combination of individual and shared persistent volumes may be used.

For the components with directly attached persistent volumes (e.g., 1516), there is a possibility that the component will be offline due to problems such as software bugs. In this case, the system can be configured to start a PV mounter pod 1518 that mounts the detached persistent volumes and copies the logs through that pod.

Besides gathering logs, the system also needs to gather system status information not currently printed to logs. In an embodiment, this is performed in a manner similar to what may be done for auto support generation. In this case, the system queries each software module to print out auto support information. In a Santorini system, a process will similarly query each component to print out its auto support information to include in the overall support bundle. The call mechanism “kubectl_exec” is used to reach each pod and trigger it to print its information. This call is performed using the black connection lines 1455 shown in FIG. 10 to the PVs and debug logs from the support bundle connector from the support bundle collector.

For the embodiment of FIG. 15, any number of nodes 1502 or 1504 may be configured to collect respective support bundles, and each operates as illustrated and described for node 1502. FIG. 51 illustrates collecting a support bundle independently for different nodes in a Santorini (or similar) cluster network. In an embodiment, the support bundle collection and transfer system is scalable to provide a support bundle across an entire Santorini cluster to support scalability and space management. This is important for some networks and applications, such as deduplication backup (Data Domain) systems that raise certain challenges for scalability and space management. In such systems, collecting a support bundle can take significant time considering the number of components to collect information from across multiple nodes.

When collecting the support bundle, process 112 provides an option to collect from each node independently and transfer its portion of the support bundle separately. Compression can be applied to the support bundle to reduce space requirements. The overall support bundle then needs to be merged at the receiving side. Due to size limitations of the cluster interface, the support bundle may be divided into more manageable pieces to transfer, as needed.

In an embodiment, support bundle collection may be across the nodes in parallel. One method to send a support bundle for multiple nodes is to configure a controller module that runs from a single location and issues collection commands to all of the nodes and receives back the support bundle content to transfer out to the vendor. This would require a large space to be reserved on that node to handle the full support bundle content.

A second method is to use dedicated worker modules on each node to temporarily store content to alleviate the need for a single node to bear the entire storage requirement. This embodiment is illustrated in FIG. 16, which shows a system for collecting a support bundle from multiple nodes as a group. As shown in FIG. 16, cluster system 1600 contains three example nodes 1602, 1604, and 1606. Each node has the components and functionality illustrated and described with respect to node 1102 in FIG. 11. For this embodiment, each node includes a support bundle worker component 1603. The support bundle worker module will run on each node to collect logs from logging PV on each node and the system can then either copy these bundle to a master node, or copy it separately to the vendor backend.

A support bundle controller module 1605 in a controller node 1604 issues collection commands to all of the nodes and direct respective worker modules 1603 on those nodes to temporarily store the content on each node. In this way, the space requirement scales effectively with the number of nodes in the system. The controller module 1605 then coordinates the transfer of support bundle content from each node through the appropriate interface 1610. From this interface, the partial support bundle can be transferred to the vendor 1612, and the controller will track the progress. The controller 1605, and possibly the workers 1603 if used, would manage space usage related to support bundles. Sufficient space must exist to collect a support bundle, and older bundles should be deleted over time to maintain space for new bundles. A pre-phase process that estimates the amount of space needed for a support bundle by analyzing the existing log files may also be used to further optimize space usage.

Although FIG. 16 illustrates an embodiment for three nodes in a cluster, embodiments are not so limited. Any number of nodes, such as 16 or more may be supported depending on application and system requirements and constraints.

Another embodiment to control the size of support bundles is to create a targeted support bundle based on filter criteria. When collecting a support bundle, the API may use an optional filter criteria that can be passed from the GUI or from direct API calls. The criteria includes start/end times, component-products, components, job IDs, and so on. These criteria pass through the API call to the support bundle collector service 1605 and to each of the bundle collection jobs in workers 1603. The DD bundle job will use that filter criteria to determine which components to collect from, the time ranges from logs to collect, etc. This can dramatically shrink the collection size, and filter options can be used to build knowledge over time, and can also be configured to collect more data rather than less to avoid asking users to collect data repeatedly. One option for setting the filter criteria is that the support team member will provide the filter values when a support request is opened. Depending on the nature of the problem, it may be appropriate to gather logs for a certain period of time leading up to an error message.

In an embodiment, support bundles may be transferred manually rather than transferring directly from the cluster across the Internet. This may be for cases in which the cluster is in a dark site without Internet connectivity, or because the user wishes to perform their own security scan on the support bundle before transfer. In this situation, there is an option for the customer to download the support bundle and then send it to the vendor separately.

FIG. 17 is a flowchart illustrating an overall method of providing support bundle processing for cluster file system serviceability and debugging, under some embodiments. As shown in FIG. 17, process 1700 begins by creating a support bundle to report system states and issues to a vendor, 1702. This step entails gathering system statistics and log information, as illustrated in FIG. 6. For a multi-node cluster system, support bundle information is gathered for all of the nodes by a controller module, such as shown in FIG. 16, step 1704. A single support module for all of the nodes can then be created for transfer to the vendor, step 1706.

Debugging Tools

Log and operation/configuration information in the form of service bundles ultimately help the user or vendor debug detected problems encountered in the cluster network. The task of analyzing the support bundle information and debugging program code, operating parameters, or characteristics is an important task in providing network serviceability. As shown in FIG. 4, certain debugging tools 414 are provided to or for use by a vendor to provide fixes for issues in the user deployment 402. These tools thus comprise part of the cluster system serviceability components 150 as tools 152.

For this embodiment, debugging tools are provided in a comprehensive package that presents the cluster network as a single product to a user. A single support team can thus be utilized without excessive user effort and interaction. This solution minimizes the number of UI commands and interactions required by the user, and facilitates the installation of debugging and corrective tools at one time, rather than on an individual basis. It allows the user or vendor to debug the entire system from one location, and importantly it greatly reduces the number of ports required to be opened during a debug session in a multi-node system. To ease the task of debugging, embodiments provide a single place where users and support staff can access the cluster and run debugging, analysis tools across the entire cluster.

As shown in step 1708 of FIG. 17, once support bundles are provided to a vendor, the vendor can perform certain debugging tasks using debugging tools 414, shown in FIG. 4. As shown in FIG. 1A, cluster network 101 includes debugging tools that represent a cluster network debugging suite that provides a single product suite that provides information through a single interface, and that considers a full set of logs and system information for debugging purposes. In an embodiment, the debugging tools may be provided in a special node, such as a service node 126, or other dedicated node.

In general, the service node contains individual containers for each application executed on in the cluster. In a single-node system, transmission and receipt of core files and vendor communication does not generally impose too much vulnerability for a system. However, in a multi-node system, any practical number (e.g., 16) nodes may be executing the various applications provided by the service node. In this case, multiple ports will need to be open concurrently for systems that are performing service events on various nodes concurrently, thus exposing a significant security threat to the system. To minimize the number of open ports, embodiments of system 100 implements a single multi-container service pod that presents single interface to collect service bundles and provide debugging tools for the vendor.

The service node can include or comprise a service pod having one or more containers. From the service pod, the system can debug problems that impact services on the same or different node. It can be used to trigger tools on other services on the same or different nodes. From a service pod, a user can view logs, status information, or statistics from other services on the same or different nodes. It can also run tools to pause, stop, or restart other services, and also run tools to adjust configuration parameters for other services.

FIG. 18 illustrates a system and process of providing debugging through a multi-container service pod for a cluster network, under an example embodiment. System 1800 of FIG. 18 illustrates two different example nodes 1806 and 1808 in a Santorini cluster, though the actual number may be on the order of 16 or more. As shown in 1800, a service pod 1805 is provided in one node (e.g., 1806) and includes a bundle collector that can be triggered by a UI 1802 or API 1804 call. The service pod 1805 communicates with each data protection component present in itself and the other nodes, such as PPDM, access object, and DD functions, such as deduplication/compression, and so on. As illustrated, there is SSH, UI, and API access to the support bundle collector and support bundles can be transferred out of the cluster to a vendor through either a remote connection (ESE) process or manual download.

The service pod 1805 also includes a comprehensive set of debugging tools that access and process system logs and debug logs in each node. As the debugging programs or tools are run, they communicate out to pods on the same or other nodes and access Kubernetes-level information and can access logs, restart pods, and so on. The service pod is made aware of the different pods to connect with and the appropriate debugging tools to run.

Embodiments have been described for a data backup system that comprises a Data Domain (DD) system where the Santorini network 101 supports various related filesystem and data managers, such as PPDM, as well as services such as ObjectScale and other services. For this example embodiment, service pod contains individual containers for each application or tool specific to Santorini. This is in significant contrast to previous systems where a pod had only one container with a tool specific to a particular application. Since Santorini has many internal products, the service pod now has multiple containers inside of the pod.

FIG. 19 illustrates the service pod of system 1800 in greater detail for an example embodiment. For an example Data Domain embodiment, service pod 1900 has containers for each of the main component products, such as DD 1902, PPDM 1904, and ObjectScale 1906, among any other possible products. Each application container represents essentially a separate product, and the container are brought together in a Santorini network, such that application processes are able to switch among these products from this one location, as needed. Service pod 1900 also includes a set of debugging tools that facilitate debugging of the multiple individual nodes (e.g., 1806, 1808, etc.) from the one service pod 1908 location. These tools include a SFS dump tool 1910 that debugs problems in Access Object (for example). A script makes the debugging tools aware of the cluster environment and call each of the other nodes to collect log information from those nodes. Similar dump tools can be provided for the DD and PPDM product components.

Although FIG. 19 illustrates containers 1902, 1904, and 1906 as separate containers, these containers could be merged into a single container, or a fewer number of containers. In this case, the debugging tools 1908 may contain a single tool or a smaller number of tools that are used to debug the applications/services in this merged container. The single container embodiment may streamline manageability, while the multiple container embodiment allows for containers to be upgraded independently and the addition of more containers if more component products are added to the overall system.

In an embodiment, the debugging tools are made aware of the cluster environment through the use of certain Kubernetes utilities that allows the system to identify a pod name and execute a program in that location, or any other different place. The service pod 1900 is aware of all of the debugging tools 1908 and can call a Kubernetes function to trigger execution of the tool in the appropriate places in the network. Other tools may also be provided, such as a connectivity check tool 1912, a log search tool 1914 to search across nodes, a listing tool to list all running services and their version numbers, or all hardware, or internal space usage on every node and each PV per node. Yet more tools could include a tool to analyze core files from crashed programs, a tool to display and update configuration settings, and so on.

As shown in FIG. 19, the single multi-container service pod provides a single location from which to call any number of debugging tools in a way that is cluster-aware and triggers execution of the tool in various locations of the cluster, all while minimizing the number of open ports during service event and debug processing and communication with the vendor.

FIG. 20 is a flowchart that illustrates a process of using a service pod for debugging a cluster network system, under some embodiments. As shown in FIG. 20, process 2000 starts (2002) by deploying a service pod having multiple application containers and centralized debugging tools in a multi-node system, such as shown in FIG. 14. The support process by the vendor or other personnel then obtains permission to access the service pod for support bundle collection, such as through SSH or other similar means, step 2004. This requires opening a port into the cluster network system, but the centralized or single service pod 1900 minimizes the number of open ports through the SSH interface.

The service pod runs a Kubernetes tool to then get the relevant logs from the various components and nodes in the system that need to report bugs or issues, step 2006. Each pod has an installed analysis tool, and the service pod runs a script to trigger this analysis tool in each pod, 2008. In response to the service support bundle request, the vendor will have provided appropriate fixes for transmission back to the service node, and the service pod will then run scripts that trigger corrective action that runs within the pods, 2010.

In an embodiment, the debugging tools are used by the vendor to analyze downloaded core files in or with support bundles. Such debugging can be considered static as the tools are used on static datasets where state and variable information are basically frozen in time. In an alternative embodiment, a debugging tool can be used to debug the system live by accessing the core files dynamically as the system is running. For this embodiment, permissions must be temporarily changes, such as to allow root access to run a debugger on the system. Such access is granted only temporarily to prevent long-term vulnerability exposure.

As stated above, the debugging process in a distributed system produces a great many log files over a potentially large number of nodes, each running deduplication, compression, and other processes. In such a case, user files being backed up will be processed through an access object (for example), and many deduplication pods, compression pods, and so on. Tracking such a file will thus generate many log files, just for this one instance.

System 100 includes mechanisms to more easily collect the logs beyond simply opening all of the log files and searching through them when trying to debug a problem. Embodiments include a new script process that takes a support bundle that has upwards of hundreds to thousands or more logs, extracts them from any compressed file format, transforms and normalizes them as needed (e.g., renaming log files, normalizing time stamps, etc.) and then loads them into an appropriate search engine, such as elastic search or open search. Such a search engine may be an existing tool that opens log files and facilitates searches. The system further provides a GUI or dashboard to allow users to efficiently analyze the log files.

A multi-node microservice environment may have many times the number of log files as single node system that may have a relatively small number of log files. An engineer or user trying to diagnose an issue thus needs to search through a multitude of log files to trace a problem and understand how operations flow through the services and nodes. Instead of simply opening all of the individual log files separately, the log files are loaded into a search engine with a GUI interface so that the user can search through all of the logs from one screen by specifying search terms, such as IDs, time ranges, services to include/exclude, and so on.

In an embodiment, the overall debugging process provides a UI-based system that takes all of the logs, collates them to produce an index as a unified file index tool, facilitates search engine operation, and then displays search results through a GUI. The user can then focus on specific log files responsive to the search rather than going through all of the log files.

FIG. 21 illustrates a system for debugging with logs in a cluster network, under some embodiments. FIG. 21 illustrates a system 2100 comprising a user site 2102 being a cluster network, such as network 101 shown in FIG. 1A, which is coupled to a vendor site 2104. The user site 2102 is a multi-node system that generates a support bundle 2106 upon request and using core files, system and configuration information, and logs 2108, as described above. The support bundle is transferred to the vendor site by a loader component 2112 on either the user or vendor site that executes a script to load appropriate information from the support bundle 2106. The support bundle may comprise a large number of logs depending on the scale of the user site, and the loader extracts relevant data from compressed files and normalizes this data such as by renaming log files, conforming timestamps, and so on.

The loaded log files 2108 can then be searched 2116 by an engineer or support staff using appropriate search terms to locate specific log files related to the problem encountered by the user. Once the specific log files are found and returned to the vendor, they can be analyzed to identify the error conditions that caused the problem. In an embodiment, the search engine 2120 used for this search can include a visual dashboard to provide comprehensive information about the corresponding search results.

Using certain debugging tools 2118, such as described above, the vendor debugs 2109 the relevant program code using the support bundle information. A successful debugging operation will yield one or more fixes that eliminate or ameliorate the problem, and these can then be transmitted to the user. At the user site, the user can implement the prescribed or recommended fix by performing a software or hardware upgrade, change configuration or system settings, or any other action or instructions provided by the vendor. An interface on the vendor site sends any responsive search result information back to the user for display through GUI 2110, and any relevant fixes/updates 2112 are also sent from the debugger to the user site.

In an embodiment, search engine 2120 may be any appropriate search engine program typically provided over the Internet, such as OpenSearch, which is a combination search engine and data visualization dashboard to display search results. In an embodiment, the search results 2122 can be displayed through GUI in any appropriate format and content, such as overall system statistics, descriptions and visualizations of specific issues, nodes, resources, etc., and may use appropriate GUI tools, such as colors, shapes, display windows, and so on. This comprehensive information and presentation can aid the vendor personnel analyze the problem in relation to the overall system based on different search parameters.

SSD Failure Recovery

As shown and described above, embodiments utilize various instances of persistent volumes for logging and implementing the support bundle manageability service. For performance purposes, the PVs are stored using solid-state disk (SSD) devices, which are generally faster in terms of read and write times than other types of storage, such as hard disks, and so on. SSD's are thus used in systems such as shown in FIG. 11 to store the PVs 1116 in order to meet the IOPS and latency requirements for logging.

In a Kubernetes environment, persistent volumes are stored in a single storage device and do not span devices, disks, or RAID arrays, etc. Within each node