Aggregate analysis and remediation of data failures

Abstract

The present disclosure relates to processing operations that evaluate the impact of data failures and manage remediation of data failures based on the evaluation results of the impact of data failures on the operation of applications / services. The identified data failures can be aggregated and analyzed. In a non-limiting example, data failure types are aggregated over time counts to identify recent data failures. Analysis of the aggregated types of data failures includes evaluating the intensity of the data failure types identified within the time count. The identified data failures can be ranked based on the intensity analysis of the impact on the presentation of content through the application / service during the time count. Remediation of data failures can be managed based on the ranking process. For example, one or more data failures can be prioritized for remediation processing to correct the underlying data structure associated with the error.

Description

Technical Field

[0001] The present application relates generally to data management, and more particularly to methods, systems, and computer-readable storage media for aggregate analysis and remediation of data failures. Background Art

[0002] Typically, data is accessed and modified in a distributed networking example where one or more users can update content through an application or service. A piece of data stored in a distributed storage device (e.g., a cloud storage device) can be updated by multiple users, from multiple devices, and can also be updated by various services that act on the data. It is possible for the data being updated to become corrupted during the update process. This may be due to problems on either the client or the service accessing the data, among other reasons.

[0003] Previously, in the case of content corruption, the cause of the problem was identified in an ad-hoc manner, where an attempt was made to track the problem to a specific client or service that may have accessed the distributed storage device. Any errors found were fixed. However, this process makes it difficult to consistently identify the cause of the problem, the production data that may have entered a corrupted state, and the impact of the existing problem. In addition, from the perspective of processing efficiency, this type of processing is resource intensive, for example, occupying resources on the client and server sides, and further requiring additional processing operations to retrieve data from the data storage device. The damage remediation service can be configured to solve the damage problem one by one, making it difficult to link multiple data damage problems with the underlying data structure (for file content) that may be invalid. As more and more endpoints are added for system access, it becomes increasingly difficult to ensure that everyone in different systems complies with the pattern rules.

[0004] Furthermore, when data edits are made to the content of an electronic document / electronic file, applications / services often report partial data edits (i.e., deltas) to indicate changes made to a previously existing version of the content that may have been stored. However, partial data edits may not be sufficient to determine the validity of the entire data schema, which may be the root cause of data invalidation. This may require further data retrieval and analysis to resolve the data invalidation issue.

[0005] Further problems exist where an application or service cannot easily identify and associate the issues that have the greatest impact (and / or most recently troubled) on the operation of the application or service. For example, a particular instance of a data error may be corrected in a specific user scenario, but other similar errors may occur in a similar time period. Applications / services may not typically be trained to aggregate data failure types and correct the sources of errors so that the errors do not become repeatable, especially over short time periods. In cases where error correction occurs in real time, real-time error correction can have severe performance impacts because a large number of data validation rules may need to be run to identify and remediate the errors. This can take up valuable resources associated with the operation of the application / service and create latency issues during the operation of the application / service. Summary of the invention

[0006] In view of the above technical challenges, the present disclosure relates to the following processing operations: evaluating the impact of data failures; and managing the remediation of data failures based on the evaluation results of the impact of data failures on the operation of application / services. Data failures may occur in the update of content presented through the application / service. The identified data failures can be aggregated and analyzed. In a non-limiting example, data failure types are aggregated within a time count to identify recent data failures. The analysis of the aggregated types of data failures includes evaluating the intensity of the data failure types identified within the time count. The identified data failures can be ranked based on the intensity analysis of the impact of identifying the content presentation performed by the application / service during the time count. The remediation of data failures can be managed based on the ranking process. For example, one or more data failures can be prioritized for remediation processing to correct the underlying data structure associated with the error.

[0007] The present summary is provided to introduce a selection of concepts that are further described in the detailed description below in a simplified form. This summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter. Additional aspects, features, and / or advantages of the examples will be set forth in part in the subsequent description and in part will become apparent from the description, or may be learned by practice of the present disclosure. BRIEF DESCRIPTION OF THE DRAWINGS

[0008] Non-limiting and non-exhaustive examples are described with reference to the following figures.

[0009] Figure 1 An exemplary process flow providing exemplary components for content validation processing, which may be utilized to practice aspects of the present disclosure, is illustrated.

[0010] Figure 2 Illustrated are exemplary methodologies related to data failure aggregation, analysis, and remediation, which may be utilized to practice aspects of the present disclosure.

[0011] Figure 3 A computing system suitable for implementing the content validation process as described herein is illustrated and may be utilized to practice aspects of the present disclosure. DETAILED DESCRIPTION

[0012] The present disclosure relates to the following processing operations: evaluating the impact of data failures and managing the remediation of data failures based on the evaluation results of the impact of data failures on the operation of applications / services. Updates to content presented through applications / services may cause data failures. The identified data failures can be aggregated and analyzed. In a non-limiting example, the types of data failures are aggregated within a time count to identify recent data failures. The analysis of the aggregated types of data failures includes evaluating the intensity of the data failure types identified within the time count. The identified data failures can be ranked based on the intensity analysis of the impact of identifying the content presentation performed by the application / service during the time count. The remediation of data failures can be managed based on the ranking process. For example, one or more data failures can be prioritized for remediation processing to correct the underlying data structure associated with the error.

[0013] As described above, data failures can be aggregated and analyzed within time counts. This provides many technical improvements over traditional ad hoc data remediation systems. Aggregation of failure events determines which failures have the greatest impact on the operation of applications / services due to excessive counts / volumes. On top of aggregate analysis, intensity analysis helps identify the main errors returned by aggregate analysis based on actual customer impact (e.g., immediate data loss, future data loss, no data loss, data hang, data crash, content loss). In addition, data validation for identifying data failures occurs during real-time editing, which is related to identifying highly used entities through systems / services. This enables components associated with data validation processing to identify data validation patterns within a specific time period (e.g., minutes, hours, days, months, years) and modify their processing to remedy data failures within that time period to improve real-time processing of applications / services. In traditional systems that address data failures, data remediation may occur for each individual identification of data failures, which is inefficient from a processing perspective and also indicates a lack of intelligence for identifying correlations between data failures. The processing operations described herein improve conventional systems by aggregating data failure types and analyzing the aggregated types of data failures to identify how a particular type of data failure affects the operation of an application / service. For example, an update to a particular type of electronic file may result in an error in the data structure of the electronic document, which affects a large number of users over a specific period of time. This may result in data loss when a user attempts to access the updated content of the electronic document at a certain point in the future, which may immediately affect the operation of the application / service. In other cases, a user's update of an electronic file may result in errors in the data structure that may not be immediately apparent. However, these errors may be triggered by other conditions or events at a later point in time. In further examples, some data failures may not result in data loss at all.

[0014] Aggregation and analysis processing improves validation processing by identifying and prioritizing data failure remediation based on potential impact on application / service operation. For example, data failures can be analyzed based on aggregate count types (e.g., numbers and / or time), intensity of impact on application / service operation, business requirements associated with one or more applications / services, user feedback, and / or combinations thereof. Non-limiting examples of parameters for evaluating data failure intensity include, but are not limited to: the number of data failures in an aggregate type (e.g., counts of data failures of a particular type); document types associated with content in which data failures are identified; the amount of data loss associated with individual data failures, domain-specific business requirements associated with an application or service; and user feedback signal data collected from the use of an application or service, among other examples. Intensity levels of data failures (e.g., aggregated types of data failures) can be generated and used to sort data failures for data remediation processing. For example, one or more data failures with the highest intensity level identified within a time count can be prioritized for data remediation processing (e.g., checking for invalidity between data structures associated with content) relative to other queued data validation processing requests.

[0015] In addition, the present disclosure relates to processing operations that implement the use of cache memory for content validation and error remediation of content. Caches are generally used to optimize performance by providing temporary stations for data between users and permanent data storage devices. In the examples described herein, the functionality of the cache is extended to implement engagement between a cache memory, a validation component configured to validate data read directly from the cache memory, and an aggregation component that aggregates and analyzes data failures for priority processing. If content is found to be corrupted, the content can be updated in the cache memory and propagated to permanent data storage devices associated with applications / services, systems, etc. The use of caches may be optimal for content that is recently and / or frequently accessed, and it may be a means for unloading data processing operations from permanent data storage devices (e.g., distributed data storage devices). The examples described herein extend to those examples where data associated with electronic files has been stored in cache memories and those examples where updates directly to permanent data storage devices occur. Data failure can be remedied asynchronously from real-time access to content through applications / services. As a non-limiting example, data failure may occur when read and write access to content is not actively requested through applications / services. For example, content that is not being edited directly by the real-time processing system of the exemplary application / service may be updated (e.g., by the system, another application, or service). In this case, a notification may be provided to add the content to a validation queue. The validation queue provides an asynchronous layer that listens to the transaction stream and validates the queued data.

[0016] In one non-limiting example, a data structure of an electronic file is read from a cache memory associated with an application or service. The content of the electronic file is validated based on an evaluation of the data structure read from the cache memory. For example, the validation process may include the application of example validation rules, which may be used to evaluate any data associated with the data structure, including but not limited to: example data nodes of the data structure; and attributes associated with these data nodes. The exemplary validation rules may programmatically evaluate a hierarchy of any type of data structure (e.g., a data graph, a data tree, a hash), including an evaluation of data nodes (e.g., parent nodes, child nodes), their corresponding child nodes, and attributes corresponding to the corresponding data nodes. Thus, in one example, the complete data structure of the electronic file may be evaluated, as compared to a case where only the correctness of the revision of the electronic file is evaluated. This may improve the accuracy of content invalidity detection and enable repairs to prevent more extensive content corruption and future content corruption.

[0017] Continuing with the above example, one or more invalidities in the content can be detected based on the results of the validation processing. When a corruption instance is detected, processing operations can be automatically performed to perform in-memory repairs of the data structure. In a further example, based on recent usage by the application / service, processing by the aggregation component is utilized to further analyze the data failures to identify trends, patterns, impact of errors, etc. The aggregation component is configured to engage with the validation component and other system components to aggregate and analyze data failures for optimal remedial processing and provision of telemetry feedback regarding the identified data failures (including temporal context).

[0018] An exemplary data structure of an electronic file may be updated to correct one or more invalidities in the content of the electronic file. This may include direct repairs to specific portions of the exemplary data structure (and corresponding data / metadata) as well as corrections to the entirety of a damaged data structure. In one instance, the update may occur through a validation component, where the updated data structure may be propagated to a persistent data storage device associated with an exemplary application / service. An aggregation component may analyze data invalidations and provide an identified subset of data validations to a validation component for remediation based on the analysis of aggregated data invalidations.

[0019] The validation process described herein enables updated versions of electronic files to be accessed directly from a cache memory and retrieved from a permanent data storage device. Updates to the permanent data storage device are important in cases where the file data of the electronic file is cached and the permanent data storage device is a shared data storage device that can be accessed by other systems, applications / services, etc. In any example, the exemplary cache is configured to serve as a repository for detecting content that has reached a corrupted state. The technology can be used in any system (including distributed systems / services) that has access to a shared data storage device, including instances where data is not provided directly to a cache memory. In-memory repair is performed to correct the invalidity of content in the electronic file. In some cases, invalidity detection may result in a determination that the entire data structure (for the electronic file) is corrupted. In this case, the entire data structure (e.g., the complete data structure) can be re-rendered, for example, to prevent ongoing instances of corruption and mitigate future (potentially unforeseen) problems.

[0020] Exemplary technical advantages provided by the processing described in the present disclosure include, but are not limited to: aggregation of data failures for temporal analysis; domain-specific analysis of the impact of data failures on application / service operations, including intensity metrics for contextual analysis of data failures; the ability to prioritize types of data failures for data remediation processing; extending the functionality of cache memories beyond traditional means of use to enable engagement for content validation; improving processing efficiency for content validation and error remediation (when identified); reducing latency in distributed system / service examples that perform data validation processing and error remediation; extending the functionality and availability of shared data storage systems; improving processing efficiency of computing devices (e.g., reducing processing cycles, saving resources / bandwidth) during content validation processing, data failure analysis, and error remediation; programmatic application of custom validation rules to improve validation processing and data failure remediation; an improved graphical user interface (GUI) configured to provide graphical display and telemetry analysis for identified data failures (i.e., aggregated data failures) compared to traditional GUIs; the ability to correct invalidities in large amounts of data; the ability to prioritize corrections based on customer impact; and scalability to any type of data structure, as well as other technical advantages.

[0021] Figure 1 An exemplary process flow 100 is illustrated that provides exemplary components for content validation, which can be utilized to practice aspects of the present disclosure. As an example, the components of the process flow 100 can be implemented by Figure 3The exemplary computing system (or multiple computing systems) described in the description of the process flow 100 is executed. The exemplary components described in the process flow 100 can be hardware and / or software components that are programmed to perform the processing operations described herein. In one example, the components of the process flow 100 can all be one or more computing devices associated with the execution of a specific service. The exemplary service can be managed by an application platform, which also provides the component with access to other components associated with the application / service and knowledge of these other components. In one case, the processing operations described in the process flow 100 can be implemented by one or more components connected on a distributed network. The operations performed in the process flow 100 can correspond to operations performed by a system and / or service that executes a computer program, an application programming interface (API), a neural network or machine learning process, a language understanding process, a search and filtering process, and generates content presented through a user interface of an application / service, as well as other examples.

[0022] In the description of process flow 100, there is provided to illustrate Figure 1 For example, steps 1-10 illustrate an example process flow for performing data validation processing and error remediation as described herein. It should be appreciated that the numbered process flow steps are intended to illustrate the interactions between the components shown in FIG. Figure 1 The process flow between components can be changed without departing from the spirit of the present disclosure.

[0023] Process flow 100 includes a user computing device 102 (eg, a client computing device). An example of a user computing device 102 is Figure 3 A computing system (or multiple computing systems) described in the description of . A user can interact with an exemplary application / service (described later in component 116) via a user computing device 102. For example, a user can connect to an application / service via any number of different device modalities. In some examples, a user can connect to an application / service (e.g., a distributed data storage service; a productivity service) via different user computing devices 102, where non-limiting examples of such are: smartphones, laptops, tablet computers, desktop computers, etc. In other cases, a user can communicate with an application / service multimodally via multiple user computing devices. For example, a user may be accessing a first electronic file via a laptop or tablet computer, and further connected to a collaboratively shared electronic file via a mobile computing device such as a cellular phone or smartphone.

[0024] As described above, the exemplary applications / services may be coupled with other components of the process flow 100 to enhance processing efficiency and functionality as described herein. For example, specific components of the process flow 100 may each be associated with one or more applications / services to implement the functionality of each component. The process flow 100 includes a hosting component 116 that includes services, systems, and applications. The applications and / or services may be any type of programming software. The exemplary applications / services are productivity applications / services that are configured to execute to enable a user to complete tasks on a computing device, wherein the exemplary productivity service may be configured to access content, including content that is available via a network connection (e.g., the Internet, Infrared). Examples of productivity services include, but are not limited to, word processing applications / services, spreadsheet applications / services, note / note-taking applications / services, authoring applications / services, digital presentation applications / services, search engine applications / services, email applications / services, messaging applications / services, web browsing applications / services, collaborative team applications / services, digital assistant applications / services, directory applications / services, mapping services, calendar services, electronic payment services, digital data storage or distributed data storage applications / services, web conferencing applications / services, call communication applications / services, language understanding applications / services, robot framework applications / services, networking applications / services, and social networking applications / services, as well as other examples. In some examples, an exemplary productivity application / service may be a component of a productivity application / service suite, which may be configured to interface with other applications / services associated with an application platform. For example, a word processing service may be included in a bundled service (e.g., In addition, the exemplary productivity service can be configured to interface with other Internet sources / services, including third-party applications / services, for example, to enhance the functionality of the productivity service during the performance of operations such as retrieving file content, accessing file content, updating file content, validating content and storing content, as well as other examples.

[0025] An exemplary electronic file (or digital document) is a representation of content in an electronic media / electronic format such as a digital file. Examples of electronic files may vary, wherein files may be created to be applicable to any type of application / service. The types of electronic files are known to those skilled in the art. For example, an electronic file may be created for a word processing service or a note-taking service, wherein the electronic file may include authored content. The electronic file may be accessed locally by an application stored on a user's computing device. In an alternative example, the electronic file may be accessed over a network connection, such as where the electronic file is a web page accessed through a web browser or a distributed copy of a document being accessed but stored remotely on a data storage device other than the data storage device. Consider an instance in which a user accesses a note-taking service for free-form information collection and multi-user collaboration. The user may be utilizing a note-taking service to access and edit a shared electronic file that is collaboratively accessed by a group of users. In the back end, the note-taking service itself may include a distributed data storage device (or shared data storage device) for users to store electronic files, and / or the note-taking service may be coupled with a data storage application / service to provide a data storage device for the electronic file.

[0026] The exemplary real-time processing system 104 is one or more components configured to provide access to content to users of an application / service through the application / service. The real-time processing system 104 facilitates near-instantaneous output of data between the user computing device 102, the hosting component 116 (e.g., application, service, system), and the backend processing components (e.g., cache 106, queue 108, queue listener 110, validation component 112, persistent data storage 114, pattern validation engine 118, and aggregation component 120). The real-time processing system 104 can be directly interfaced with the user computing device 102 and other components of the process flow 100. As an example, the real-time processing system 104 is configured to provide data to the client from the cache 106. The real-time processing system 104 can be associated to track data from the cache 106 related to content that is being accessed or has been recently accessed (within a predetermined time period specified by the developer and / or data retention policy). Data from the cache 106 is populated from a persistent data store 114, which maintains data (e.g., electronic files, log data, version data) used to execute the exemplary hosting component 116. In execution, the real-time processing system 104 is configured to obtain input of rapidly changing data and then provide output nearly instantaneously, so that changes over time are efficiently updated to the persistent data store 114 and easily visible to the user. For example, the real-time processing system 104 can detect user requests and / or accesses to electronic files and interface with the user computing device 102 to provide a surface of representation of the electronic file through a user interface of an application or service. The cache 106 can store data for actively accessed (or recently accessed) electronic files, where updates to the electronic files can be tracked and implemented on behalf of the user. Updates made to the electronic file (e.g., via the user computing device 102) can be further propagated to the persistent data store 114. The real-time processing system 104 can interface with other processing components of the process flow 100 through an API or the like. In some examples, the real-time processing system 104 can track the use of electronic files within a particular application service. In other examples, the real-time processing system 104 may include multiple components configured to track the use of electronic files across multiple applications / services that may share access to the persistent data storage 114 .

[0027] exist Figure 1 In one example, the method steps for content validation processing may be initiated by the real-time processing system 104, wherein the real-time processing system 104 detects the content to be validated. In one example, the detection of the content to be validated ( Figure 1Step 1) of the validation process may include detecting that the content of the electronic file has been edited or modified. In one non-limiting example, step 1 detects the content to be validated as a partial data edit (i.e., an incremental file) to represent an update to the electronic file, the partial data edit reflecting only the changes made to the electronic file, and the content beyond that is stored in a previously existing version of the electronic file. In an alternative example, the detection of the content to be validated may include detecting that a user has accessed the electronic file, regardless of whether the content of the electronic file has been modified. In this case, the data structure of the file may be queued for validation processing to identify potential data errors when the system has available resources (before the potential data errors rise to a level where the operation of the application / service is affected). This may occur in a technical scenario where many different systems / services are accessing and / or updating the content of the application / service.

[0028] The real-time processing system 104 may also be configured to interface with an exemplary queue component 108 (hereinafter referred to as a “queue” or “validation queue”), wherein the real-time processing system 104 may send / submit an identification (ID) of the content (e.g., an electronic file) to the queue 108 for further validation processing. Figure 1 Step 2 is to transmit the ID of the content from the real-time processing system 104 to the queue 108 for content validation. The exemplary (ID) of the content can be any type of data indicating a specific electronic file, a delta file associated with an update to the content, and / or a reference to the data location of the electronic file within the cache 106, so that the data structure of the electronic file can be analyzed. The exemplary validation component 112 can be configured to retrieve the data of the electronic file from the cache 106 using the ID to perform validation processing.

[0029] As described above, the cache memory 106 (or cache) can be coupled with the real-time processing system 104 and other components. The exemplary cache memory 106 is a hardware or software component that stores data so that future requests for data can be served more quickly. As an example, the cache memory 106 is a high-speed static random access memory (SRAM) that can be accessed faster (and more efficiently) by a processing component (e.g., a processor or microprocessor) than a conventional random access memory (RAM), which can be used for a permanent data storage device 114. Caches are generally used to optimize performance by providing a temporary station for data between a user and a permanent data repository. In the example described herein, the functionality of the cache memory 106 is extended to enable a coupling between the cache memory 106 and a validation component that is configured to validate data read directly from the cache memory. In doing so, the cache memory 106 is configured as a data repository for running validation on content. The content of the electronic file is validated based on an evaluation of the data structure of the electronic file read from the cache memory 106.

[0030] The cache 106 may also be directly engaged with the validation component 112. In doing so, the cache 106 may provide access to data associated with the electronic file so that the validation component 112 may perform validation processing as described herein. The cache 106 may be used to store any data (or metadata) associated with the electronic file, including the underlying data structure of the electronic file. Non-limiting examples of data structures include, but are not limited to: graphs; data trees; and hashes, among other examples. Real-time updates are typically incremental edits to per-user data structures (e.g., graph structures). As previously described, data updates may not always occur directly through the real-time processing system 104. Other validation examples are subsequently described, such as when direct edits to the permanent data storage device 114 are made by other systems (applications / services) without using the cache 106.

[0031] As previously mentioned, it is not always easy to find the data for an electronic file in cache 106. A cache hit occurs when the requested data can be found in cache 106, while a cache miss occurs when the data is not found in cache 106. A cache hit is serviced by reading the data from the cache, which is faster than recalculating the result or reading from a slower data repository. Without departing from the spirit of the present disclosure, a developer may configure settings for storing data in cache 106 for any length of time, including retention of data stored in the cache. The parameters for storing data in cache 106 may be consistent with data retention policies / regulations and any user privacy laws or practices.

[0032] Persistent data storage 114 is a hardware data storage device or software component (e.g., a virtual data repository) configured to store data. Examples of data storage devices and software components are known to those skilled in the art. Exemplary persistent data storage 114 is used as a dedicated storage device for electronic files or other content that may be associated with a user account (or group user account), a system, and / or one or more applications / services. For example, persistent data storage 114 may store content associated with a particular application / service. In another example, persistent data storage 114 may store content across multiple hosting components 116, which may include applications, services, and systems. In such an example, persistent data storage 114 is a shared data storage device for various hosting components 116. In a further example, persistent data storage 114 may be configured to store data associated with a user account, wherein any type of electronic file may be stored across a dedicated storage device associated with a user account.

[0033] As an example, the permanent data storage device 114 can be one or more distributed data storage devices accessible on a network connection. An example of a distributed data storage device is a cloud-based data storage device. A piece of data stored in the cloud can be updated by multiple users, from multiple devices, and can also be updated by various services acting on the data. Due to problems on any client or service accessing it, the updated data is likely to be damaged during the update process. However, once the data is updated in this damaged state in the cloud due to any client or user or service, all users, devices and services accessing the data will obtain the damaged content thereafter, and in some cases the data cannot be displayed back to the user. This can be regarded as data loss or content damage, which is manifested as the inability to synchronize data across devices. In addition, once the data enters this state, there is no recovery mechanism to restore it to the corrected state. Therefore, the cache memory 106 and the processing components for content validation (e.g., validation components 112) are used to get the damaged data out of its invalid state and be restored for user use.

[0034] For example, in situations where the data is being actively accessed (or has recently been accessed), the persistent data storage 114 exchanges data with the cache 106. Furthermore, in one case, the data structure of the electronic file may be validated before an updated version of the electronic file is saved on the persistent data storage 114. In some alternative examples, the persistent data storage 114 may store any version of the electronic file, where updates to the electronic file content (or underlying data structure) may result in overwriting a previous version of the electronic file.

[0035] The real-time processing system 104 may also interface with an exemplary queue 108 for validation processing (or validation queue). The queue 108 is configured to provide a queuing mechanism to systematically feed the content to be validated to the validation component 112. As known to those skilled in the art, any type of queuing mechanism may be implemented. In addition, the queue 108 may be further customized to manage the exemplary validation processing in order to reduce latency during system operation. The exemplary validation processing is designed to improve the processing efficiency of system operation and not interfere with the user's ability to access data. As a corollary, the content to be validated may be detected by the real-time processing system 104 and propagated to the queue 108 to validate it at a later point in time. The execution time of the validation processing may be associated with a point in time when the electronic file is no longer accessed so as not to affect service operations while the content is being accessed.

[0036] The exemplary queue 108 may be configured with processing rules that are capable of prioritizing (or de-prioritizing) data validation processing for specific content. For example, the processing rules may be set based on parameters including, but not limited to: electronic file type; type of modification to the content; volume of access; frequency of access; specific users who edit the content; and processing workload for validation, among other examples. In some examples, the queue 108 may also apply criteria for evaluating whether to validate content modifications. The queue 108 may provide a decision point configured to determine whether to validate specific content or bypass validation processing. Some of these decisions may also occur as part of the real-time processing system 104 before the content is queued for validation. Examples of criteria for determining whether to validate content may include, but are not limited to: type of electronic file; type of modification to the content; frequency of validation processing of the content (e.g., previous validation processing of the electronic file); type of application / service associated with the content; identification: differences between versions of electronic files, and whether there is priority processing for remedial actions for data failures identified by one or more of the pattern validation engine 118 and the aggregation component 120, and the like. In some examples, the discrepancy may be identified after validating the content. In examples where the update satisfies the criteria for selecting content to be validated, the content is queued for validation (with the identity of the content stored in cache 106). In examples where the ID is associated with access to the content detected based on an update to the content, priority rules may be set to govern whether processing for remediating the identified data invalidation is prioritized relative to processing for detecting invalidities in content associated with the queued ID.

[0037] An exemplary queue listener 110 may establish an interface between the queue 108 and the validation component 112. The queue listener 110 is a data object (or multiple data objects) that acts as an asynchronous event handler for propagating the content to be validated to the validation component 112. The queue listener 110 may implement a message passing interface that initiates communication between the queue 108 and the validation component 112 to feed the identification of the content to the validation component 112 (when the validation component 112 has the bandwidth). In some cases, the queue listener 110 may propagate the identification of the content one by one. In other cases, the identification of the content to be validated may be transmitted in batches. The queue listener 110 may perform method step 3, such as Figure 1 As shown, the validation component 112 is called to execute validation processing for specific content (e.g., electronic files). Based on method step 3, the validation component 112 can execute validation processing for content (e.g., updated content) by calling the mode validation engine 118.

[0038] When the validation component 112 receives a message with the identity of the content to be validated from the queue listener 110, the validation component 112 uses the identity (ID) to obtain the latest content for the identity from the cache 106. Figure 1 As shown, method step 4 illustrates the interaction between the cache memory 106 and the validation component 112, wherein the validation component 112 may: 1) directly access the data structure (and associated data) of the electronic file in the cache memory 106; or 2) the cache memory 106 may propagate the data structure (and associated data) of the electronic file to the validation component 112 for further processing.

[0039] As described above, validation component 112 is configured to implement a schema validation engine component (hereinafter referred to as "schema validation engine") 118 to perform validation processing of content, wherein the content may be checked for invalidity. Schema validation engine 118 applies validation rules to identify invalidity in the data structure of the electronic document. Validation component 112 interfaces with schema validation engine 118 to transmit content for schema validation, for example, wherein the data structure may be propagated to schema validation engine 118 (or accessed by schema validation engine 118). Figure 1 Step 5 of ) includes sending the content to the schema validation engine 118 to perform validation processing on the data structure of the content.

[0040] The exemplary pattern validation engine component 118 is configured to perform validation processing to identify data invalidation in the data structure of the electronic file. When performing the validation processing, the pattern validation engine 118 can be configured to perform any of the following: a computer program, a software agent, an application programming interface (API), a neural network and / or a machine learning process, among other examples. For example, an exemplary machine learning model can be generated and trained to: evaluate the data structure of the electronic file by applying validation rules that identify invalidity in the data structure (and specific attributes within the data structure), and determine and apply applicable in-memory repairs to update the data structure to eliminate any invalidity. A set of validation rules can include rules for identifying invalidity and rules for remedying the identified invalidity. In another example, the validation component 112 is configured to manage a separate set of rules for performing in-memory repairs of identified data invalidations. The creation, training, and updating of machine learning models are known to those skilled in the art. In this example, the machine learning model can be further customized for validation processing using training data and applying in-memory repairs to update the data structure of the electronic file, which training data adapts the machine learning model to detect invalidity in the file content. The pattern validation engine 118 is built with a set of validation checks, and they check the consistency of each part of the data structure and detect whether the data is invalid. As an example, consider a graph as the underlying data structure of the content, which has multiple different types of nodes with multiple attributes, which are also cross-referenced in other nodes. In this example, the validation rule may be to check: whether the node has the correct range of attribute values. Another may be to check: whether the graph does not have any missing child nodes or duplicate nodes. In another example, specific file attributes such as file extensions, formats, access permissions, etc. can be validated. The type of content validation may vary depending on the data structure considered.

[0041] The exemplary validation process may include an evaluation of the entire contents of the electronic file, wherein the entire data structure of the electronic file may be evaluated. Thus, in some examples, the validation process may periodically check the data structure of the electronic file to proactively identify and prevent potential problems that may arise during execution of the exemplary application / service. In some alternative instances, the detection of content to be validated may include identifying specific content that is edited within the electronic file (e.g., a portion of the electronic file). It should be understood that the validation process described herein is applicable to situations where the entire data structure is evaluated as well as situations where only a portion of the data structure (e.g., related to specific content within the file) is evaluated.

[0042] Once the schema validation engine 118 has detected invalidities in the content using validation rules, the schema validation engine 118 generates a list of identified data invalidations for the validation component 112 . Figure 1Step 6 of includes processing operations in which the pattern validation engine 118 sends a list of one or more identified data failures to the validation component 112 and the validation component 112 receives the list of data failures. In some examples, the validation component 112 is configured to immediately perform in-memory repairs of the content (e.g., data structures of the content) based on the application of validation rules for remediating the identified failures. In other examples, the validation component 112 is configured to perform subsequent processing to analyze the identified data failures to further improve the operation of the application / service.

[0043] In an example of performing subsequent analysis on the identified data failures, the validation component 112 sends a list of one or more identified data failures to the aggregation component 120 ( Figure 1 The aggregation component 120 is configured to perform processing operations to aggregate and analyze the identified data failures. The specific processing operations performed by the exemplary aggregation component 120 are subsequently described in method 200 ( Figure 2 ) and other parts of this disclosure. The processing performed by the aggregation component 120 is used to assess the impact of data failure and manage the remediation of data failure based on the assessment results of the impact of data failure on the operation of the application / service.

[0044] Aggregation component 120 performs operations to aggregate identified data failures into one or more levels. Rules for data aggregation when applicable to domain-specific content (including rules for classifying data failures into specific types / groups) can be programmed by developers to automate the aggregation process. The classification of data failure types can be specific to an application / service or multiple applications / services (e.g., a suite of productivity applications / services). For example, the types of identified data failures can be aggregated according to one or more time counts to identify the recency of data failures. The time counts used for aggregation can be set by the developer and indicate a specific time period in which the developer wishes to analyze the operation of the application / service. For example, time counts can be set to aggregate data failures within a specific minute, hour, day, month, year, or any other time period. This can help identify the issues that are most relevant to the operation of the application / service in the specified time period. Other levels of aggregation can also be applied (alone or in combination with time count analysis) to enhance the analysis of the identified data failures. Such aggregation levels include, but are not limited to: data failure types based on user classification / user grouping; data failure types specific to one application / service and / or multiple applications / services; and groups of data failures that lead to data loss or application / service interruption, etc.

[0045] Once data failures have been aggregated, the aggregation component 120 is configured to analyze the aggregated types of data failures to determine contextual insights into issues associated with the application / service over a specific time period. The aggregation and analysis process improves validation processing by identifying and prioritizing remediation of data failures based on potential impact on the operation of the application / service. For example, data failures can be analyzed based on aggregate count types (e.g., numbers and / or times), intensity indicating the impact on the operation of the application / service, and / or a combination thereof. As previously described, the intensity associated with data failures refers to the impact of data failures on the operation of the application / service. Non-limiting examples of parameters for evaluating the intensity of data failures include, but are not limited to: the number of data failures in an aggregate type (e.g., a count of a particular type of data failure); document types associated with content in which data failures are identified; the amount of data loss associated with individual data failures, domain-specific business requirements associated with an application or service; and user feedback signal data collected from the use of an application or service, as well as other examples. Developers can pre-set multiple different intensity classifications (e.g., low, medium, high) to classify the aggregated types of data failures. Any number of strength classifications may be generated without departing from the spirit of the present disclosure. The strength classifications may be used to prioritize data failures for remediation by the validation component 112 .

[0046] Aggregation component 120 is configured to implement machine learning modeling to apply parameters associated with intensity to evaluate specific types of data failure. Intensity classification can be generated based on the results of machine learning modeling, which is trained to evaluate data failure in domain-specific contexts. Machine learning modeling can be adjusted, trained, and updated to continuously classify data failure. Developers can apply weighting to different parameters based on contextual scenarios in which data failure is detected. According to the intensity based on the predetermined weight set by the developer, machine learning modeling can be trained to classify aggregated data failure. For example, one type of data failure may occur in an electronic document type that is not frequently accessed by a user, wherein the data failure of this type also does not result in significant data loss during operation (e.g., presentation) within the GUI of the application / service. In this particular scenario, data failure can be classified as having low intensity. In contrast, frequently accessed electronic document types (wherein data failure during the operation of the application / service results in significant data loss) may result in data failure being classified as having high intensity. In another example, data failure may be related to frequently accessed electronic documents, but does not result in significant data loss. This may result in intermediate intensity classifications (e.g., medium, medium-low). In a further example, a particular application / service may have domain-specific requirements for classifying data failures, where the type of electronic document or a threshold for data loss results in a particular intensity classification of data failures. In an additional example, user feedback received through the application / service can be used to classify the intensity of data failures. For example, a user can provide a classification of errors they encountered through the GUI, or user comments / feedback can be considered when classifying the intensity of data failures. Further reiterated, the intensity classification can further consider the number (count) of data failures in the aggregated type of data failures. For example, a classification for a data failure type that has multiple data failure instances of that type can have a higher intensity rating than a classification type that has a small number of data failures in that grouping.

[0047] The aggregation component 120 is configured to generate and utilize intensity levels of data failures (e.g., aggregated types of data failures). For example, one or more data failures with the highest intensity levels identified within a time count may be prioritized for data remediation processing (e.g., checking for invalidity in data structures associated with content) relative to other queued data validation processing requests. The validation component 112 may utilize the levels to identify the order in which to perform error remediation of data failures. The ranking (or scoring process) associated with machine learning modeling is known to those skilled in the art. In one example, a classifier is trained to rank the aggregated types of data failures according to the intensity of domain-specific training based on consideration of training data and parameters (features) defining the intensity. In some examples, the intensity ranking may be plotted as a graphical representation and / or other types of telemetry analysis, which may be provided to developers to illustrate trends in data validation within a specific time count. The aggregation component 120 may be configured to plot the intensity of data failure types and present a graphical representation of the intensity of data failures through a GUI. Other types of telemetry analysis generated from performing machine learning modeling may also be provided to developers, such as in the form of a report presented through a GUI or sent through other types of modalities (e.g., email, message). This can be useful for adjusting subsequent validation processing and error recovery.

[0048] exist Figure 1In step 8, the aggregation component 120 sends / transmits the aggregation of data failures that are prioritized for remediation to the validation component 112. This may include a permutation list of aggregated data failures, which the validation component 112 may utilize to sort how to apply validation processing operations. The permutation list may include identification of one or more aggregated data failure groups. The validation component 112 may be configured to prioritize operations to remedy the identified data failures according to the permutation provided by the aggregation component. In one example, error remediation operations may be prioritized relative to other types of validation processing operations (e.g., identification of new invalidities). In another example, the validation component 112 may utilize the permutation list to reorder processing operations for data validation that will be executed subsequently. For example, data failures with the highest level of intensity may be remedied first, and data failures with lower levels of intensity may be scheduled for remediation at a later point in time. In an alternative example, the aggregation component 120 may be configured to notify the validation component 112 of the analysis of data failures in batches. For example, the identified data failure groups or subsets may be propagated to the validation component 112 based on the analyzed intensity levels associated with the aggregated types of data failures (e.g., the highest intensity data validations sent in one batch and lower intensity data failures in another batch). This may help the validation component 112 to efficiently perform validation processing without being overwhelmed. In some alternative examples (not shown in the process flow 100), the aggregation component 120 may interact directly with the queue 108 to prioritize / reorder validation processing transactions for execution by the validation component 112. This may enable the validation component 112 to focus directly on validation processing and error remediation.

[0049] During error remediation, validation component 112 attempts in-memory repair of the content based on programmed validation rules (step 9 of process flow 100). Along with this type of invalid content detection, validation rules may also have information about how to modify the data structure in order to correct the content therein so that the content enters a consistent state. An example of a repair for a "missing child node problem" may be to search the graph to find if the data expected in the missing child node exists elsewhere, and then reconstruct the child node with that data and replace the missing child node. Another repair for an "incorrect attribute value problem" may be to change the attribute value so that it is consistent with the valid attribute value of the node while maintaining consistency. In another example, validation rules may be set to evaluate file extensions associated with specific content portions. In the case where a file extension is identified as having a problem with corrupted content, an in-memory repair of the data structure of the electronic file may include such a processing operation that updates the file extension to, for example, an identified file extension for content processing (e.g., display).

[0050] When the version of the data structure is updated, the validation component 112 is programmed to write the updated content to the persistent data storage 114 of the real-time system. Figure 1 Method step 10 illustrates the interaction between validation component 112 and / or cache memory 106 and permanent data storage device 114, wherein the data structure of the content (including data invalidation) is updated. In one example, validation component 112 writes the updated data structure to cache memory 106 and instructs cache memory 106 to forward the updated data structure to permanent data storage device 114. In another example, validation component 112 directly requests to update the electronic file with permanent data storage device 114. In that case, validation component 112 propagates the updated data structure of the electronic file to permanent data storage device 114. For example, validation component 112 can obtain the updated data structure from cache memory 106 and forward it to permanent data storage device 114.

[0051] As described above, the process flow 100 may also include a hosting component 116. The hosting component 116 may include an application, service, and / or system, etc., which may store data / content on the persistent data storage device 114 for execution. For example, the persistent data storage device 114 may provide services for multiple applications / services, wherein an application / service may be configured to work with the cache memory 106, while other applications / services may edit content without using the cache memory 106. Examples of applications and services have been provided in the previous description. The exemplary system may include hardware components, software components, or a combination thereof configured to process any type of data including content.

[0052] Figure 2 An exemplary method 200 related to data failure aggregation, analysis, and remediation is illustrated, which can be used to practice aspects of the present disclosure. The processing operations described in the method 200 can be performed by the process flow 100 ( Figure 1 ), wherein the detailed description in process flow 100 supports and supplements the processing operations recorded in method 200. The coupling and communication between exemplary components (e.g., those described in process flow 100) are known to those skilled in the art. For example, data requests and responses can be transmitted between applications / services to enable a particular application / service to process data retrieved from other applications / services. The formatting of such communications can vary depending on the programming protocol implemented by the developer without departing from the spirit of the present disclosure.

[0053] As an example, the method 200 may be performed across Figure 3The exemplary computing system (or multiple computing systems) described in the description of is performed. The exemplary components described in method 200 can be hardware and / or software components that are programmed to perform the processing operations described herein. The operations performed in method 200 can correspond to operations performed by systems and / or services that execute computer programs, software agents, intelligent robots, application programming interfaces (APIs), neural networks, and / or machine learning processes, as well as other examples. In some examples, the processing operations described in method 200 can be performed by one or more applications / services associated with a web service that can access multiple applications / services, devices, knowledge resources, etc. In one case, the processing operations described in method 200 can be implemented by one or more components connected on a distributed network.

[0054] Method 200 begins at processing operation 202, where a plurality of data failures are identified for subsequent error remediation analysis. Figure 1 ) is described in the foregoing description of the description of the application / service. In one example, data invalidation is identified based on the application of a validation rule that detects invalidity in a data structure of content (e.g., updated content) accessed through the application / service. However, data validation processing can be performed on any type of electronic file associated with the application / service without requiring the user to update the content (or add a new electronic file) before performing the validation processing.

[0055] The process flow of method 200 may proceed to process operation 204, wherein the identified data failures are aggregated into one or more levels. Figure 1 The aggregation process of data failures has been described in the previous description of the description of ). The aggregation component can be configured to perform the aggregation process. For example, the identified data failures are aggregated based on type within a specific time count. In one case, various types of data failures are aggregated on a daily basis (i.e., in increments of one day) for subsequent analysis.

[0056] At process operation 206, the aggregated data failure types within a particular time count are analyzed to determine the strength of the aggregated types of data failures. Figure 1) is described in the foregoing description of the description of the aggregation component. The aggregation component can be configured to perform an analysis of the intensity of the aggregated types of data failures. As referenced in the foregoing description, the intensity can be associated with the impact of the data failure on the presentation of content through the application / service. Non-limiting examples of parameters for evaluating the intensity of data failures include, but are not limited to: the number of data failures in the aggregated type (e.g., a count of a particular type of data failure); the document type associated with the content in which the data failure was identified; the amount of data loss associated with individual data failures, domain-specific business requirements associated with the application or service; and user feedback signal data collected from the use of the application or service, as well as other examples.

[0057] The analysis of the intensity of the aggregated types of data failures can result in the generation of a telemetry analysis that can identify trends and patterns of data failures over a specific time period. In processing operation 208, the intensity of the aggregated types of data failures can be mapped. Mapping the various intensities (processing operation 208) can include plotting the intensity of the aggregated types of identified data failures based on the analysis against a time count; and outputting a graphical representation of the plotted intensity of the aggregated types of identified data failures during the time count. As referenced in the previous description, an exemplary mapping of the intensity of aggregated data failures can be presented to a developer via a GUI or other modality.

[0058] The flow of method 200 may proceed to processing operation 210, where the aggregated types of identified data failures during a count (e.g., a time count) are ranked based on the analysis results of the strength of the aggregated types of identified data failures. Figure 1 )'s description above describes the arrangement process.

[0059] The identified permutations of data failures may be propagated (processing operation 212) to a data validation component that performs remediation of the one or more data failures. As identified in the foregoing description, including the description of process flow 100, the data validation component may prioritize remediation processing of the one or more data failures relative to other queued data validation processing requests based on the permutation processing. Examples of such processing operations for prioritizing error remediation transactions and / or reordering data validation transactions for processing based on the permutation have been described in the foregoing description.

[0060] At process operation 214, one or more data failures are remedied based on the arrangement. Figure 1) has been described in the foregoing description of the description of . In some examples, remediation of data failure occurs asynchronously with real-time access to content by applications / services. For example, the data validation component can be configured to detect that content is no longer accessed by the user or is accessed offline by the application / service. This can be a trigger for performing remedial processing on the data failure. In another example, processing operations occur after detecting that read and write access to the content is not requested by the application or service. That is, based on detecting that read and write access to the content is not being actively requested, data remediation occurs asynchronously with real-time access to the content by the application or service.

[0061] Error remediation (processing operation 214) may include processing operations including, but not limited to: reading a complete data structure of the electronic file from a cache memory associated with the application or service for content associated with the data failure; updating the complete data structure to correct one or more data failures, and propagating the updated complete data structure to a permanent data storage device for subsequent access of the electronic file by the application or service. When the electronic file is subsequently called for access at a later point in time, the updated data structure is read into the cache memory associated with the application / service.

[0062] Flow of method 200 may proceed to decision operation 216. At decision operation 216, a determination is made as to whether the data failure was successfully remedied. In the event that the data remediation was unsuccessful, flow of decision operation 216 branches to "no" and processing of method 200 returns to processing operation 214. At processing operation 214, data repair may be retried to resolve the data failure. In the event that the data failure was successfully remedied, flow of decision operation 216 branches to "yes" and processing of method 200 remains idle until a new data failure is to be resolved.

[0063] Figure 3 A computing system 301 suitable for implementing the content validation process described herein is illustrated, and various aspects of the present disclosure can be practiced using the computing system. Computing system 301 represents any system or collection of systems in which the various applications, services, scenarios, and processes disclosed herein can be implemented. Examples of computing system 301 include, but are not limited to, server computers, rack servers, web servers, cloud computing platforms, and data center equipment, as well as any other type of physical or virtual server machines, containers, and any variants or combinations thereof. Other examples may include smartphones, laptops, tablet computers, desktop computers, hybrid computers, game consoles, virtual reality devices, smart TVs, smart watches, and other wearable devices, and any variants or combinations thereof. Computing system 301 can be used to implement process flow 100 ( Figure 1), which implements the exemplary components described in the foregoing description. The computing system 301 can also be used to perform the exemplary method 200 ( Figure 2 ), wherein processing operations related to data failure aggregation, analysis, and remediation as described in the preceding description may be specifically performed.

[0064] The computing system 301 may be implemented as a single device, system or equipment, or may be implemented as multiple devices, systems or equipment in a distributed manner. For example, the computing system 301 may include one or more computing devices that perform processing of applications and / or services through a distributed network to implement the processing operations described herein on one or more services. The computing system 301 may include a set of devices that perform processing of front-end applications / services, back-end applications / services, or a combination thereof. The computing system 301 includes, but is not limited to, a processing system 302, a storage system 303, software 305, a communication interface system 307, and a user interface system 309. The processing system 302 is operably coupled to the storage system 303, the communication interface system 307, and the user interface system 309. The processing system 302 loads and executes the software 305 from the storage system 303. The software 305 includes one or more software components that are configured for cache data validation processing 306a, aggregation component processing 306b, and / or other applications / services of the application platform as described above. Exemplary cache data validation processing includes operations for accessing data in cache memory, reading the data, validating the data, and updating the data, and / or interfacing with permanent data storage. Aggregation component processing performs processing operations described herein related to data failure aggregation, data failure analysis (including strength mapping), and failed data remediation. When executed by processing system 302, software 305 directs processing system 302 to operate as described herein for at least the various processes, operating scenarios, and sequences discussed in the foregoing embodiments. Computing system 301 may optionally include additional devices, features, or functions that are not discussed for the sake of brevity.

[0065] Still reference Figure 3 , processing system 302 may include processors, microprocessors, and other circuits that retrieve and execute software 305 from storage system 303. Processing system 302 may be implemented within a single processing device, but may also be distributed across multiple processing devices or subsystems that collaborate to execute program instructions. Examples of processing system 302 include general-purpose central processing units, graphics processing units, special-purpose processors and logic devices, and any other type of processing device, combination, or variation thereof.

[0066] Storage system 303 may include any computer-readable storage medium that can be read by processing system 302 and that can store software 305. Storage system 303 may include volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer-readable instructions, data structures, program modules, cache memory, or other data. Examples of storage media include random access memory, read-only memory, magnetic disks, optical disks, flash memory, virtual and non-virtual memory, cassettes, magnetic tape, disk storage or other magnetic storage devices, or other suitable storage media, except for propagated signals. In any case, a computer-readable storage medium is not a propagated signal.

[0067] In addition to computer-readable storage media, in some embodiments, storage system 303 may also include computer-readable communication media through which at least some of software 305 may be transmitted internally or externally. Storage system 303 may be implemented as a single storage device, but may also be implemented across multiple storage devices or subsystems that are co-located or distributed relative to each other. Storage system 303 may include additional elements, such as a controller, that can communicate with processing system 302 or possibly other systems.

[0068] The software 305 may be implemented in program instructions and, among other functions, when executed by the processing system 302, may direct the processing system 302 to operate as described with respect to the various operational scenarios, sequences, and processes illustrated herein. For example, the software 305 may include program instructions for implementing the exemplary cache data validation process 306a, the aggregate component process 306b, and / or other applications / services of the application platform, as described in the foregoing description.

[0069] In particular, program instructions may include various components or modules that cooperate or otherwise interact to perform various processes and operation scenarios described herein. Various components or modules may be embodied in compiled or interpreted instructions, or in some other variant or combination of instructions. Various components or modules may be performed in a synchronous or asynchronous manner, serially or in parallel, in a single-threaded environment or in multithreading, or according to any other suitable execution paradigm, variant or combination thereof. Software 305 may include additional processes, programs or components, such as operating system software, virtual machine software or other application software. Software 305 may also include firmware or some other form of machine-readable processing instructions that may be executed by processing system 302.

[0070] In general, when software 305 is loaded into processing system 302 and executed, the entirety of a suitable device, system, or apparatus (represented by computing system 301) is transformed from a general-purpose computing system into a specialized computing system customized to process data and respond to queries. In practice, the encoded software 305 on storage system 303 can transform the physical structure of storage system 303. In various embodiments of the present specification, the specific transformation of the physical structure can depend on various factors. Examples of such factors can include, but are not limited to, the technology of the storage medium used to implement storage system 303, and whether the computer storage medium is characterized as a primary storage device or an auxiliary storage device, as well as other factors.

[0071] For example, if the computer-readable storage medium is implemented as a semiconductor-based memory, the software 305 can transform the physical state of the semiconductor memory (when program instructions are encoded therein), such as by transforming the state of transistors, capacitors, or other discrete circuit elements that make up the semiconductor memory. Similar transformations may occur for magnetic or optical media. Other transformations of the physical media are possible without departing from the scope of the present description, wherein the foregoing examples are provided only for the convenience of this discussion.

[0072] The communication interface system 307 may include communication connections and devices that allow communication with other computing systems (not shown) over a communication network (not shown). The communication interface system 307 may also be used to cover the engagement between the processing components described herein. Examples of connections and devices that together allow inter-system communication may include: network interface cards or devices, antennas, power amplifiers, RF circuits, transceivers, and other communication circuits. The connections and devices may communicate over a communication medium such as metal, glass, air, or any other suitable communication medium to exchange communications with other computing systems or systems networks. The above-mentioned media, connections, and devices are well known and need not be discussed in detail herein.

[0073] The user interface system 309 is optional and may include: a keyboard, a mouse, a voice input device, a touch input device for receiving touch gestures from a user, a motion input device for detecting non-touch gestures and other movements of the user, and other similar input devices and associated processing elements capable of receiving user input from the user. Output devices such as displays, speakers, tactile devices, and other types of output devices may also be included in the user interface system 309. In some cases, input and output devices may be combined in a single device, such as a display capable of displaying images and receiving touch gestures. The aforementioned user input and output devices are well known in the art and do not need to be discussed in detail here.

[0074] The user interface system 309 may also include associated user interface software that can be executed by the processing system 302 to support the various user input and output devices described above. The user interface software and user interface devices can support a graphical user interface, a natural user interface, or any other type of user interface (e.g., a front-end processing that implements the exemplary applications / services described herein (including productivity applications / services)) alone or in combination with each other and other hardware and software elements. In some examples, the user interface system 309 can be configured to output and display the results of data failure aggregation and analysis. For example, a mapping showing the intensity of aggregated data failures within a time count can be output to display the grouping and intensity of data failures within a specific time period for developers, programmers, etc. through a graphical user interface display.

[0075] The communication between computing system 301 and other computing systems (not shown) can occur on one or more communication networks and according to various communication protocols, combinations of protocols or variants thereof. Examples include intranets, the Internet, the Internet, local area networks, wide area networks, wireless networks, wired networks, virtual networks, software-defined networks, data center buses, computing backplanes or any other type of networks, network combinations or variants thereof. The aforementioned communication networks and protocols are well known and do not need to be discussed in detail here. However, some communication protocols that can be used include, but are not limited to, Internet Protocol (IP, IPv4, IPv6, etc.), Transmission Control Protocol (TCP) and User Datagram Protocol (UDP), and any other suitable communication protocols, variants or combinations thereof.

[0076] In any of the foregoing examples in which data, content, or any other type of information is exchanged, the exchange of information can occur according to any of a variety of protocols, including FTP (File Transfer Protocol), HTTP (Hypertext Transfer Protocol), REST (Representational State Transfer), Web Socket, DOM (Document Object Model), HTML (Hypertext Markup Language), CSS (Cascading Style Sheets), HTML5, XML (Extensible Markup Language), JavaScript, JSON (JavaScript Object Notation), and AJAX (Asynchronous JavaScript and XML), as well as any other suitable protocols, variants, or combinations thereof.

[0077] The functional block diagrams, operation scenarios and sequences, and flow charts provided in the figures represent exemplary systems, environments, and methods for performing novel aspects of the present disclosure. Although for simplicity of explanation, the methods included herein may be in the form of functional diagrams, operation scenarios, or sequences or flow charts, and may be described as a series of actions, it should be understood and appreciated that the methods are not limited by the order of actions, because some actions may occur in an order different from that shown and described herein and / or simultaneously with other actions. For example, those skilled in the art will understand and appreciate that the methods may alternatively be represented as a series of interrelated states or events, such as in a state diagram. In addition, for novel embodiments, not all actions described in the methods are required.

[0078] The description and drawings included herein depict specific embodiments to teach those skilled in the art how to make and use the best options. In order to teach the principles of the invention, some conventional aspects have been simplified or omitted. Those skilled in the art will appreciate variations of these embodiments that fall within the scope of the invention. Those skilled in the art will also appreciate that the above features can be combined in a variety of ways to form a variety of embodiments. Therefore, the present invention is not limited to the above specific embodiments, but is only limited by the claims and their equivalents.

[0079] References throughout this specification to "one example" or "an example" mean that a particular described feature, structure, or characteristic is included in at least one example. Thus, use of such phrases may refer to more than one example. Furthermore, the described features, structures, or characteristics may be combined in any suitable manner in one or more examples.

[0080] However, one skilled in the relevant art may recognize that the examples may be practiced without one or more of the specific details, or with other methods, resources, materials, etc. In other cases, well-known structures, resources, or operations are not shown or described in detail, simply to avoid obscuring aspects of the examples.

[0081] Although example embodiments and applications have been illustrated and described, it should be understood that the embodiments are not limited to the precise configuration and resources described above. Various modifications, changes and variations that are obvious to those skilled in the art may be made to the arrangement, operation and details of the methods and systems disclosed herein without departing from the scope of the claimed examples.

Claims

1. A method for aggregate analysis and remediation of data failure, comprising: identifying a plurality of data invalidations associated with content of an application or service; aggregating the types of identified data failures during a time count, the time count specifying a particular time period of operation of the application or service; For each of the identified aggregation types of data invalidation, analyzing a strength corresponding to an impact on presentation of the content by the application or service, wherein the strength is a classification generated based on an evaluation of parameters including: the number of data failures during the time count in the corresponding aggregation type of the identified data failures, and an amount of data loss associated with an individual data failure in the corresponding aggregate type of the identified data failure; ranking the aggregate types of identified data failures during the time count based on the results of the analyzing of the strengths of the aggregate types of identified data failures; and One or more data failures are remedied based on the arrangement.

2. The method of claim 1, wherein: The parameters also include a document type associated with the content.

3. The method of claim 2, wherein: The parameters also include: domain-specific business requirements associated with the application or service, and user feedback signal data collected from the use of the application or service.

4. The method of claim 1, wherein: The arranging further includes: plotting, for the time count, intensity of the aggregated type of identified data failures based on the analysis; and outputting a graphical representation of the plotted intensity of the aggregated type of identified data failures during the time count.

5. The method of claim 1, further comprising: The arrangement of the aggregate type of identified data failures is propagated to a data validation component that performs the remediation of the one or more data failures, and wherein the data validation component prioritizes remediation processing of the one or more data failures relative to other queued data validation processing requests.

6. The method of claim 1, wherein: The remediation further includes detecting that read and write access to the content is not requested by the application or service, and wherein the remediation is performed asynchronously with real-time access to the content by the application or service based on detecting that read and write access to the content is not requested.

7. The method of claim 1, wherein: The remediation also includes: for content associated with data failures in the one or more data failures, reading a complete data structure of the electronic file from a cache memory associated with the application or service; updating the complete data structure to correct the one or more data failures, and propagating the updated complete data structure to a permanent data storage device for subsequent access to the electronic file through the application or service.

8. A system for aggregate analysis and remediation of data failure, comprising: at least one processor; as well as A memory operatively connected to the at least one processor, storing computer executable instructions, which, when executed by the at least one processor, cause the at least one processor to perform a method comprising: identifying a plurality of data invalidations associated with content of an application or service; aggregating the types of identified data failures during a time count, the time count specifying a particular time period of operation of the application or service; For each of the identified aggregation types of data invalidation, analyzing a strength corresponding to an impact on presentation of the content by the application or service, wherein the strength is a classification generated based on an evaluation of parameters including: the number of data failures during the time count in the corresponding aggregation type of the identified data failures, and an amount of data loss associated with an individual data failure in the corresponding aggregate type of the identified data failure; ranking the aggregate types of identified data failures during the time count based on the results of the analyzing of the strengths of the aggregate types of identified data failures; and One or more data failures are remedied based on the arrangement.

9. The system of claim 8, wherein: The parameters also include a document type associated with the content.

10. The system of claim 9, wherein: The parameters also include: domain specific business requirements associated with the application or service, and user feedback signal data collected from the use of the application or service.

11. The system of claim 8, wherein: The arranging further includes: plotting, for the time count, intensity of the aggregated type of identified data failures based on the analyzing; and outputting a graphical representation of the plotted intensity of the aggregated type of identified data failures during the time count.

12. The system of claim 8, wherein: The method performed by the at least one processor also includes: propagating the arrangement of the aggregate type of identified data failures to a data validation component that performs the remediation of the one or more data failures, and wherein the data validation component prioritizes remediation processing of the one or more data failures relative to other queued data validation processing requests.

13. The system of claim 8, wherein: The remediation further includes detecting that read and write access to the content is not requested by the application or service, and wherein, based on detecting that the read and write access to the content is not requested, the remediation is performed asynchronously with real-time access to the content by the application or service.

14. The system of claim 8, wherein: The remediation also includes: for content associated with data failures in the one or more data failures, reading a complete data structure of the electronic file from a cache memory associated with the application or service; updating the complete data structure to correct the one or more data failures, and propagating the updated complete data structure to a permanent data storage device for subsequent access to the electronic file through the application or service.

15. A computer-readable storage medium storing computer-executable instructions, which when executed by at least one processor causes the at least one processor to perform a method comprising: identifying a plurality of data invalidations associated with content of an application or service; aggregating the types of identified data failures during a time count, the time count specifying a particular time period of operation of the application or service; For each of the identified aggregation types of data invalidation, analyzing a strength corresponding to an impact on presentation of the content by the application or service, wherein the strength is a classification generated based on an evaluation of parameters including: the number of data failures during the time count in the corresponding aggregation type of the identified data failures, and an amount of data loss associated with an individual data failure in the corresponding aggregate type of the identified data failure; ranking the aggregate types of identified data failures during the time count based on the results of the analyzing of the strengths of the aggregate types of identified data failures; and One or more data failures are remedied based on the arrangement.

Images