Application of data services based on services policies

Techniques described herein relate to a method for performing data services. The method may include receiving, from a monitor agent, a global name and metadata corresponding to data written to a data structure of storage of a data host; performing a services assessment using the global name, the metadata, and a data service policy rule to obtain at least one data service to perform on the data; and performing the at least one data service based on the services assessment.

BACKGROUND

Computing devices often exist in complex ecosystems of devices in which data exists and/or is generated. Such data may be used and/or operated on to produce any number of results. Additionally, such data may be produced and stored by any device within the ecosystem, and the amount of data items produced and stored locally by such devices may be vast. Therefore, techniques are required for understanding such data.

SUMMARY

In general, certain embodiments described herein relate to a method for performing data services. The method may include receiving, from a monitor agent, a global name and metadata corresponding to data written to a data structure of storage of a data host; performing a services assessment using the global name, the metadata, and a data service policy rule to obtain at least one data service to perform on the data; and performing the at least one data service based on the services assessment.

In general, certain embodiments described herein relate to a non-transitory computer readable medium that includes computer readable program code, which when executed by a computer processor enables the computer processor to perform a method for performing data services. The method may include receiving, from a monitor agent, a global name and metadata corresponding to data written to a data structure of storage of a data host; performing a services assessment using the global name, the metadata, and a data service policy rule to obtain at least one data service to perform on the data; and performing the at least one data service based on the services assessment.

In general, certain embodiments described herein relate to a system for using pipeline data for performing data services. The system may include a services management application, executing on a processor comprising circuitry, operatively connected to a monitor agent and to storage of a data host, and configured to receive, from the monitor agent, a global name and metadata corresponding to data written to a data structure of storage of a data host; perform a services assessment using the global name, the metadata, and a data service policy rule to obtain at least one data service to perform on the data; and perform the at least one data service based on the services assessment.

Other aspects of the embodiments disclosed herein will be apparent from the following description and the appended claims.

DETAILED DESCRIPTION

Specific embodiments will now be described with reference to the accompanying figures.

In the below description, numerous details are set forth as examples of embodiments described herein. It will be understood by those skilled in the art, who have the benefit of this Detailed Description, that one or more embodiments of the embodiments described herein may be practiced without these specific details and that numerous variations or modifications may be possible without departing from the scope of the embodiments described herein. Certain details known to those of ordinary skill in the art may be omitted to avoid obscuring the description.

As used herein, the phrase operatively connected, or operative connection, means that there exists between elements/components/devices a direct or indirect connection that allows the elements to interact with one another in some way. For example, the phrase ‘operatively connected’ may refer to any direct connection (e.g., wired directly between two devices or components) or indirect connection (e.g., wired and/or wireless connections between any number of devices or components connecting the operatively connected devices). Thus, any path through which information may travel may be considered an operative connection.

In general, embodiments described herein relate to methods, systems, and non-transitory computer readable mediums storing instructions for generating global names and associated metadata for data when it is written locally by a device within a device ecosystem. In one or more embodiments, the global name and metadata are stored with the data, published to a global name repository, and used to determine what data services to apply to the data.

Data is often produced remotely by any number of ecosystems. As an example, multimedia sensor systems provide a very high volume of data to be processed in cognitive and analytics systems remote from data centers. Some estimates indicate that 175 Zettabytes of data will be produced by 2025 and that over 80% will be produced outside of cloud/core data centers. Data that is produced remotely is often difficult to insert into a data catalog and name space at the scale of edge systems. Additionally, many data catalogs are industry specific (e.g., healthcare genomics, autonomous driving, etc.) and few contemplate distributed ingest and processing of the data. This may lead to heuristic systems and distribution of cloud stacks to attempt to create distributed data frameworks. However, many cloud services may not properly operate in the edge of a device ecosystem. Remote data awareness, ingest, catalog and processing are often managed in a fragmented and organizationally specific manner.

Data that is produced at the edge of device ecosystems under existing frameworks often must be conditioned through a process to determine validity and applicability. The data may be moved from a collector capability and placed into file, object, steaming service, or database. The data may have to be sized appropriately and/or organized based on a sequential metric (e.g., time) or other metric, and placed into a file store directory structure, database, object store, etc. Many frameworks require different data types to be combined into a single data structure and associated with the sequential metric. Such processes are complex and often cumbersome with custom automation tools. As the data production moves to be predominantly on the edge of device ecosystems, the process may become unmanageable due to scale and complexity. Such unmanageability may be due to the changes in environment and/or limited process visibility which result in numerous process exceptions. One issue is a lack of visibility at a granular level to understand what data is produced, when, and by what entity.

Data is produced for a variety of purposes, but it is not always clear what process, service, application, etc. produced the data. Additionally, file/object name and owner may not make clear the purpose of the data. As an example, data from a manufacturing facility could be produced for a variety of reasons (e.g., anomaly detection, random training data, etc.), but from a content perspective be very similar In one or more embodiments, intent and expectation of use is context sensitive and should be determined at time of production of the data. This may be difficult in distributed edge systems as the system may be computationally limited and/or not be connected to a network. Additionally, data production is often ephemeral.

In order to address, at least in part, the above-described problems with managing data generated in a device ecosystem, in one or more embodiments, monitor agents are distributed on computing devices where data is locally produced and/or stored. In one or more embodiments, such agents are in communication with a global policy manager. In one or more embodiments, the global policy manager distributes heuristic rules and machine learning (ML) classifiers to the monitor agent, each of which may be used to classify the intent (e.g., intended use) of data written where the agent is located.

In one or more embodiments, the monitor agent monitors the relevant storage of the host on which the agent is deployed to determine when data is written on the host (e.g., to a file system, object store, data streams, key-value databases, etc.). In one or more embodiments, when data is written, the monitor agent classifies the intent of the data, assigns a global name to the data, and generates metadata associated with the data. The intent of the data may be obtained through use of an application programming interface (API) used by the application writing the data to provide intent and other information about the data to the monitor agent.

Additionally or alternatively, when the monitor agent determines that data has written, the monitor agent may use various techniques to gather information about the data, and to perform a classification of the data to obtain the intent of the data. In one or more embodiments, the classification is performed using a set of rules provided to the monitor agent by the global policy manager, with which the monitor agent attempts to classify the intent of the data. In one or more embodiments, the results of the intent classification and the information about the data are then provided to an ML classifier. In one or more embodiments, if the classification performed by the monitor agent using rules produced a result with a probability of 100%, then the ML classifier does not perform additional classification, as the intent of the data is already classified. In one or more embodiments, if the classification result produced by the monitor agent using the rules is less than 100% certain of the intent of the data, then the ML classifier uses the information provided by the monitor agent to produce a classification result indicating the primary intent of the data.

In one or more embodiments, once the information associated with the data has been obtained, and the intent has been obtained, the monitor agent generates a global name to associate with the data, as well as a set of metadata. In one or more embodiments, the global name associated with the data by the monitor agent is a name that is different from the public name given to the data by the application that wrote the data, and has semantic meaning, and is globally unique. In one or more embodiments, portions of the global name that convey semantic meaning may include, but are not limited to, a sequence number uniquely identifying the particular instance of the data, an identifier of the entity that produced the data, an identifier of the location of the data in the storage (e.g., a geotag), an identifier of the physical location of the host, a timestamp, and/or any other semantic information.

In one or more embodiments, the global name and metadata are stored locally with the data, and published to a global name repository. In one or more embodiments, the global name repository may be searched by other entities (e.g., computing devices) in the device ecosystem for any purpose. For example, data items having certain characteristics may be searched for and produced as a result of the search (e.g., all data produced from an autonomous vehicle in a specific geographic region during a given time window). As another example, the data having certain characteristics may be identified so that it may be obtained for analysis by a device outside the planned workflow using the data.

In one or more embodiments, the global name and metadata are additionally provided to a services management application, which determines what services to perform on the data based at least in part on the global name and metadata, including the intent of the data. Such services may include, but are not limited to, data compression, data encryption, data priority, urgency of data processing, whether data can be transformed while in transit between devices, data content obfuscation, data transformation, data annotation, data security services, data copy protection, secure data deletion services, etc.

FIG. 1shows a diagram of a system in accordance with one or more embodiments described herein. The system may include a global policy manager (100), any number of data hosts (e.g., data host A (102), data host N (104)), and a global name repository (106). Each of these components is described below.

In one or more embodiments, all of the devices shown inFIG. 1are part of and/or operatively connected to a device ecosystem. In one or more embodiments, a device ecosystem may be a hierarchy of ecosystem portions. As an example, a device ecosystem may include a client portion, an edge portion, a core portion, and a cloud portion. A device ecosystem is not limited such an example arrangement shown inFIG. 1. A device ecosystem may have any number of client portions, each operatively connected to any number of edge portions, which may, in turn, be operatively connected to any number of core portions, which may, in turn, be connected to one or more cloud portions. One of ordinary skill in the art will recognize that there are many possible arrangements of a device ecosystem other than the example hierarchy shown inFIG. 1. In one or more embodiments, each of the devices shown inFIG. 1may exist anywhere in a device ecosystem. As an example, the data hosts (102,104) may exist in the client and/or edge portions of the device ecosystem, and the global policy manager (100) and global name repository (106) may exist in a core and/or cloud portion (e.g., in a data center).

In one or more embodiments, global policy manager (100) is all or any portion of a computing device. In one or more embodiments, a computing device is any device, portion of a device, or any set of devices capable of electronically processing instructions and may include any number of components, which include, but are not limited to, any of the following: one or more processors (e.g. components that include integrated circuitry) (not shown), memory (e.g., random access memory (RAM)) (not shown), input and output device(s) (not shown), non-volatile storage hardware (e.g., solid-state drives (SSDs), hard disk drives (HDDs) (not shown)), one or more physical interfaces (e.g., network ports, storage ports) (not shown), any number of other hardware components (not shown), accelerators (e.g., GPUs) (not shown), sensors for obtaining data, and/or any combination thereof

Examples of computing devices include, but are not limited to, a server (e.g., a blade-server in a blade-server chassis, a rack server in a rack, etc.), a desktop computer, a mobile device (e.g., laptop computer, smart phone, personal digital assistant, tablet computer, automobile computing system, and/or any other mobile computing device), a storage device (e.g., a disk drive array, a fibre/fiber channel storage device, an Internet Small Computer Systems Interface (iSCSI) storage device, a tape storage device, a flash storage array, a network attached storage device, etc.), a network device (e.g., switch, router, multi-layer switch, etc.), a hyperconverged infrastructure, a cluster, a virtual machine, a logical container (e.g., for one or more applications), a controller, a sensor, and/or any other type of device with the aforementioned requirements.

In one or more embodiments, any or all of the aforementioned examples may be combined to create a system of such devices. Other types of computing devices may be used without departing from the scope of the embodiments described herein.

In one or more embodiments, the non-volatile storage (not shown) and/or memory (not shown) of a computing device or system of computing devices may be one or more data repositories for storing any number of data structures storing any amount of data (i.e., information). In one or more embodiments, a data repository is any type of storage unit and/or device (e.g., a file system, database, collection of tables, RAM, and/or any other storage mechanism or medium) for storing data. Further, the data repository may include multiple different storage units and/or devices. The multiple different storage units and/or devices may or may not be of the same type or located at the same physical location.

In one or more embodiments, any non-volatile storage (not shown) and/or memory (not shown) of a computing device or system of computing devices may be considered, in whole or in part, as non-transitory computer readable mediums, which may store software and/or firmware.

Such software and/or firmware may include instructions which, when executed by the one or more processors (not shown) or other hardware (e.g., circuitry) of a computing device and/or system of computing devices, cause the one or more processors and/or other hardware components to perform operations in accordance with one or more embodiments described herein.

The software instructions may be in the form of computer readable program code to perform, when executed, methods of embodiments as described herein, and may, as an example, be stored, in whole or in part, temporarily or permanently, on a non-transitory computer readable medium such as a compact disc (CD), digital versatile disc (DVD), storage device, diskette, tape storage, flash storage, physical memory, or any other non-transitory computer readable medium.

In one or more embodiments, such computing devices in a device ecosystem may be operatively connected to other computing devices in any way, thereby creating any topology of computing devices. Such operative connections may be all or part of a network (not shown). A network may refer to an entire network or any portion thereof (e.g., a logical portion of the devices within a topology of devices). A network may include a data center network, a wide area network, a local area network, a wireless network, a cellular phone network, and/or any other suitable network that facilitates the exchange of information from one part of the network to another. A network may be located at a single physical location, or be distributed at any number of physical sites. In one or more embodiments, a network may be coupled with or overlap, at least in part, with the Internet.

In one or more embodiments, a network may include any number of devices, at least a portion of such devices are network devices (not shown). In one or more embodiments, a network device is a device that includes and/or is operatively connected to persistent storage (not shown), memory (e.g., random access memory (RAM)) (not shown), one or more processor(s) (e.g., integrated circuits) (not shown), and at least two physical network interfaces, which may provide connections (i.e., links) to other devices (e.g., computing devices, other network devices, etc.). In one or more embodiments, a network device also includes any number of additional components (not shown), such as, for example, network chips, field programmable gate arrays (FPGAs), application specific integrated circuits (ASICs), indicator lights (not shown), fans (not shown), etc. A network device may include any other components without departing from the scope of embodiments described herein. Examples of a network device include, but are not limited to, a network switch, a router, a multilayer switch, a fibre channel device, an InfiniBand® device, etc. A network device is not limited to the aforementioned specific examples.

In one or more embodiments, a network device includes functionality to receive network traffic data units (e.g., frames, packets, tunneling protocol frames, etc.) at any of the network interfaces (i.e., ports) of a network device and to process the network traffic data units. In one or more embodiments, processing a network traffic data unit includes, but is not limited to, a series of one or more lookups (e.g., longest prefix match (LPM) lookups, forwarding equivalence class (FEC) lookups, etc.) and corresponding actions (e.g., forward from a certain egress port, add a labeling protocol header, rewrite a destination address, encapsulate, etc.). Examples of network traffic data unit processing include, but are not limited to, performing a lookup to determine: (i) whether to take a security action (e.g., drop the network traffic data unit); (ii) whether to mirror the network traffic data unit; and/or (iii) how to route/forward the network traffic data unit in order to transmit the network traffic data unit from an interface of the network device.

In one or more embodiments, a computing device may form one or more virtualization environments (not shown). In one or more embodiments, a virtualization environment is any environment in which any number of computing devices are subject, at least in part, to a shared scheme pooling compute resources for use in deploying virtualized computing device instances (e.g., VMs, containers, emulators, etc.), which may be used in any arrangement to perform all or any portion of any work requested.

In one or more embodiments, a global policy manager (100) includes functionality to provide rules, classifiers, and information related to data services to distributed monitor agents (not shown) executing on data hosts (102,104). In one or more embodiments, rules may be any information item that a monitor agent may use when attempting to identify the intent (e.g., purpose) of data written on a data host (102,104). Such rules may correlate various intent possibilities with information items that include, but are not limited to, the application that writes the data, the type of data, the environment in which the data was produced, etc. In one or more embodiments, a classifier is an ML classifier that is trained prior to distribution to the data hosts (102,104) to classify the primary intent of a given data item. There may be any number of ML classifiers, each trained for a different context such as, for example, a factory or manufacturing facility, an autonomous vehicle, a specific type of location (e.g., an airport), etc. In one or more embodiments, the global policy manager (100) distributes one or more ML classifiers to data hosts that are relevant to the context in which the data host exists. As an example, an ML classifier may be a multiclass support vector machine (SVM). Other ML classifiers may be used without departing from the scope of embodiments described herein. In one or more embodiments, information related to data services may include additional rules that, when evaluated by a services management application executing on the data host, determine what data services should be applied to data, based at least in part on the global name and metadata associated with the data and generated by the monitor agent.

In one or more embodiments, the global policy manager (100) is operatively connected to any number of data hosts (102,104). In one or more embodiments, a data host (102,104) is a computing device (described above). In one or more embodiments, a data host (102,104) is any computing device where data is written to storage of any type. Data hosts are discussed further in the description ofFIG. 2, below.

In one or more embodiments, the global policy manager (100) and the data hosts (102,104) are operatively connected (e.g., via a network) to a global name repository (106). In one or more embodiments, a global name repository (106) is a data structure of any type that may store global names and metadata associated with data written on data hosts (102,104). AlthoughFIG. 1shows the global name repository as a single device, the global name repository may be a data structure distributed among any number of devices without departing from the scope of embodiments described herein. In one or more embodiments, the global data repository is accessible to entities interested in data produced and stored on data hosts (102,104) within a device ecosystem, such as, for example, other devices within the device ecosystem, administrators, etc. In one or more embodiments, the global name repository is implemented using any number of computing devices.

WhileFIG. 1shows a configuration of components, other configurations may be used without departing from the scope of embodiments described herein. Accordingly, embodiments disclosed herein should not be limited to the configuration of components shown inFIG. 1.

FIG. 2shows a diagram of an example data host in accordance with one or more embodiments described herein. The data host (150) may include applications (160), storage (162), a monitor agent (164), any number of ML classifier(s) (166), and a services management application (168). Each of these components is described below.

In one or more embodiments, there are any number of applications (160) executing on a data host (150). In one or more embodiments, an application is any hardware (e.g., circuitry), software, firmware, or any combination thereof that includes functionality to write data to storage (162) of a data host (150). As used herein, application may refer to any process, thread, software, firmware, writer, etc. that writes data to storage (162) of a data host (150). As an example, an application may execute and have an associated process identifier, and, when the application is writing data, the process identifier may be obtained as associated with the data as it is being written. An application may execute to achieve any purpose without departing from the scope of embodiments herein. Examples include, but are not limited to, an application that controls one or more sensors and writes to storage the data obtained therefrom; an application that gathers and writes data for use in machine learning training, validation, or execution; an application that monitors physical processes to perform anomaly detection, an application that analyzes images, an application that monitors equipment for signs of possible failure, etc. In one or more embodiments, applications (160) of data host (150) are operatively connected to storage (162) in which the applications (160) store data.

In one or more embodiments, data host (150) includes and/or is operatively connected to storage (162). In one or more embodiments, storage (162) is any type of physical medium for storing data in which one or more data structures of any type are implemented to organize the stored data. Examples of such data structures include, but are not limited to, a file system, object store, data streams, key-value databases, etc. In one or more embodiments, the storage (162) may be one or more data repositories for storing any number of data structures storing any amount of data (i.e., information). In one or more embodiments, a data repository is any type of storage unit and/or device (e.g., a file system, database, collection of tables, RAM, and/or any other storage mechanism or medium) for storing data. Further, the data repository may include multiple different storage units and/or devices. The multiple different storage units and/or devices may or may not be of the same type or located at the same physical location.

In one or more embodiments, the storage (162) of data host (150) is operatively connected to a monitor agent (164). In one or more embodiments, a monitor agent is an instance of a distributed agent. In one or more embodiments, data host (150) includes any number of agents (e.g., monitor agent (164)). In one or more embodiments, an agent is any hardware (e.g., circuitry), software, firmware, or any combination thereof that includes functionality to perform any tasks or actions for which it was designed. Examples of agent functionality include, but are not limited to: monitoring hardware; monitoring other software; monitoring log files; receiving information; parsing information; writing information (e.g., to hardware tables); performing repetitive tasks (e.g., data backup, memory management, etc.); providing an environment for a user to interact, locally or remotely, with hardware and/or software components of a computing device; automatically adding data to certain types of fields; performing management functions; simulating other software and/or hardware; sending an/or receiving signals (e.g., beacon signals) to determine if a device is still has an operative connection with another device; any other task or action; or any combination thereof An agent may be a process, or a part of a process, may include one or more threads within one or more processes, and/or may be capable of creating additional threads. In one or more embodiments, an agent executes within an operating system (not shown) using one or more processors (not shown) of data host (150).

In one or more embodiments, a monitor agent (164) includes functionality to monitor whatever one or more data structures are implemented in storage (162) to ascertain when data is written thereto. As an example, the monitor agent (164) may monitor a file system in the storage (162) to determine when new files are written. In one or more embodiments, when a monitor agent (164) determines that data is written to a data structure in the storage (162), the determination serves as a trigger for the monitor agent to perform a variety of actions relating to obtaining information about the data, and classifying the intent of the data. The various actions performed by monitor agent (164) are discussed further in the description ofFIG. 3, below.

In one or more embodiments, the monitor agent (164) is operatively connected to a global policy manager (e.g., global policy manager (100) of FIG.1). In one or more embodiments, the global policy manager distributes to each distributed monitor agent instance in a device ecosystem (including monitor agent (164)) policy rules and one or more ML classifiers (166).

In one or more embodiments, the policy rules are a set of rules for the monitor agent (164) to evaluate when trying to determine information about data that is written to storage (162), including the intent of the data. As an example, a rule may indicate that data written by a particular application always has a particular intent, has two or more possible intents, etc. As another example, a rule may include that when a particular application writes data of a particular type, the data has a certain intent. Any other rule may be provided to the monitor agent (164) by a global policy manager without departing from the scope of embodiments described herein.

In one or more embodiments, the one or more ML classifiers (166) distributed to the monitor agent (164) from a global policy manager may be any type of ML classifier capable of taking as input information related to data that the monitor agent (164) determined was written to storage (162), and producing as output a primary intent (i.e., intended use) of the data. In one or more embodiments, the ML classifier(s) (166) are software to be executed using one or more processors, including circuitry, of data host (150). In one or more embodiments, the ML classifier(s) (166) distributed to a monitor agent (164) on a given data host (e.g., data host (150)) are a set of ML classifiers that have been trained (e.g., using other devices in a device ecosystem) using data relevant to the context in which the data host exists. Examples of such contexts include, but are not limited to, retail establishments, manufacturing facilities, transportation hubs, telecommunications companies, autonomous vehicles, etc. In one or more embodiments, ML classifiers trained using data relevant to a particular context in which a data host exists helps facilitate classification of the intent of data written on said data host. In one or more embodiments, the ML classifier(s) (166) are operatively connected to the monitor agent (164), which invokes the appropriate ML classifier when attempting to determine the intent of data that is written to storage (162) of data host (150). In one or more embodiments, as discussed above, the ML classifier(s) may be multiclass SVMs. In one or more embodiments, a SVM is a supervised learning model that analyzes input data to produce a classification result. In one or more embodiments, multiclass SVMs are SVMs that produce classification results when there are more than two possible classes.

In one or more embodiments, the monitor agent (164) includes functionality to, after determining that data is written to a data structure in storage (162) of data host (150), (i) obtain and/or generate metadata corresponding to the data; (ii) classify the intent of the data, with intent becoming part of the metadata; (iii) generate a global name for the metadata, the global name having any amount of semantic meaning; (iv) store the global name and metadata locally associated with the data from which the global name and metadata were derived; (v) publish the global name and metadata to a global name repository (e.g., global name repository (106) ofFIG. 1); and (vi) provide the global name, metadata, and any other relevant information to a services management application (168).

In one or more embodiments, the global name generated for a given data item by monitor agent (164) includes information for conveying semantic meaning that is to be understood in the context of the device ecosystem in which the data is generated. Examples of such semantic meanings include, but are not limited to: an identifier of the producer of the data (e.g., the Vehicle Identification Number (VIN) of an autonomous vehicle), where the information was produced (e.g., a geotag), a sequence number to uniquely identify the particular instance of the data, the name of the application that wrote the data, a timestamp, and/or any other semantic information. In one or more embodiments, the global name for a given data item generated by the monitor agent (164) may be generated pursuant to policy rules that are distributed to the monitor agent (164) from a global policy manager.

In one or more embodiments, metadata that the monitor agent (164) may generate or otherwise obtain for data written to storage (162) of a data host (150) may include any type of metadata related to the data, from any source. The following are examples of metadata generated or obtained by the monitor agent (164) for a given data item written to storage (162) of data host (150):

A public name, which may be the name given to the data by the application that writes the data, which may have meaning to the application and to other entities within a workflow that may consume or otherwise use the data. In one or more embodiments, the public name is obtained from the application that writes the data.

A global name, described above, which is generated by the monitor agent (164) based on policy rules and includes semantic information related to the data.

A source lineage, which may be the public name of the predecessor/lineage of data/parent data global name. In one or more embodiments, the source lineage is derived from the application that writes the data.

A signature, which may be a hash value to track changes or data corruption, and may be obtained based on policy rules.

A signature type, which may be the scheme used to create the aforementioned signature, and may be obtained using policy rules.

An application name, which may be the name of the application that produced and/or wrote the data.

A time value, which may be, for example, the coordinated universal time (UTC) of when the write of the data completed.

A data source classification, which may be the actual source of the data (e.g., machine generated, camera, RADAR, LIDAR, ultrasonic sensors, audio sensors, application generated (e.g., file, object, stream, segment, time series, etc.), etc.). In one or more embodiments, the data source classification is obtained by the monitor agent's application of policy rules and/or as a result of an ML classifier.

A version or sequence number associated with the data, which may be assigned based on policy rules.

A data type, which may be unstructured data (e.g., video, image, audio, point cloud, etc.) or structured data (e.g., structured binary, asci, executable, etc.). In one or more embodiments, the data type may be obtained from the application that wrote the data and/or as a result of the application of policy rules or the result of an ML classifier.

A data size, which may be the size of the data in a relevant unit, such as, for example, bytes. In one or more embodiments, the data size is obtained by inspecting the data, and the unit is determined by policy rules provided to the monitor agent (164).

Segment information, which may include file segment size, number of segments in the data, etc.

Intent, which may be the intended use of the data. Examples of such uses include, but are not limited to, training, mapping, process control, compliance, diagnostics, lawful intercept, entertainment, manifest, etc. Intent may be obtained from the application that wrote the data (e.g., via an API), determined from the application of policy rules by the monitor agent (164), and/or determined as a result of an ML classifier.

Data reduction information, which may include whether the data is lossy, lossless, has copy protection, is compressed, etc.;

Data reduction type information, which may include the actual compression applied to the data;

Encryption information, which may include whether or not the data is encrypted and, if so, what type of encryption was used to encrypt the data;

Sensitivity information, which may include the level of sensitivity of the data which defines level of security (e.g., sign only, sign/encrypt, anonymize, etc.);

Retention period information, which may include a value representing a time period (e.g., number of days) for which the data is to be retained;

Location information, which may include the geographic information of where the data was written;

Priority information, which may include a priority level associated with the data, which may impact the urgency with which the data should be processed;

A time to live (TLV) value associated with the data;

A value level, which may indicate an economic value assessment of the data, and may be provided by the application that wrote the data or derived as a result of an ML classifier; and/or

Content information, which may include, for example, annotations related to the data, structured content, etc.

Other types of information may be generated or obtained as metadata by the monitor agent (164) without departing from the scope of embodiments described herein. Additionally, all or any portion of such metadata may be generated or obtained for a given data item.

In one or more embodiments, the monitor agent (164) is operatively connected to a services management application (168). In one or more embodiments, a services management application is any hardware (e.g., circuitry), software, firmware, or any combination thereof, that includes functionality to determine what services to apply to data written on a data host (150) based at least in part on the global name and metadata associated with the data and provided to the services management application (168) by the monitor agent (164). Such services may include, but are not limited to, data compression, data encryption, data priority, urgency of data processing, whether data can be transformed while in transit between devices, data content obfuscation, data transformation, data annotation, data security services, data copy protection, secure data deletion services, etc. In one or more embodiments, the determination of what services should be applied for data is determined, at least in part, by evaluation of one or more data service policy rules provided by a global policy manager in a device ecosystem. Such rules may correlate any action that may be performed on data with any one or more items of metadata and/or semantic information included in the global name associated with the data.

As an example, a data service policy rule may specify that if the data is intended for ML training (i.e., its intent metadata indicates ML training), it may not be compressed (because that may affect the ML training). As another example, a data service policy rule may specify that if the metadata associated with data indicates an urgent priority (e.g., data from an autonomous car after a car crash), the data may be captured, moved, analyzed. As another example, a data service policy rule may indicate that data having a certain set of metadata items associated with it should be encrypted. As another example, a data service policy rule may indicate that data having a certain combination of metadata and semantic information in the global name should not be uploaded over a mobile internet connection, but instead should be held until a wireless network connection becomes available.

As another example, a data service policy rule may indicate that data should be transformed when transmitted from a data host to a target computing device (i.e., a data destination). Examples of such transformations include, but are not limited to, transforming data from an object format to a columnar format, transforming data into a format required or desired for efficient processing by one or more GPUs, etc.

Any other action or set of actions associated with all or any portion of a global name and/or metadata associated with data may be used as a data service policy rule without departing from the scope of embodiments described herein.

In one or more embodiments, determining which services to apply to data is expectation based. In one or more embodiments, the application produces data with certain expectation of use. In one or more embodiments, the services management application (168) will receive expectation-related information from the monitor agent (164). Said another way, in one or more embodiments, semantic understanding of the data is established by the monitor agent (164) and passed to the services management application (168). In one or more embodiments, understanding intent (i.e., expectation), the services management application (168) may select an appropriate policy that would apply, which provides a list of prioritized data services that are appropriate for the intent associated with the data. In one or more embodiments, obtaining such a list of services takes into the account the semantic information, and may also be derived based on context. In one or more embodiments, once an optimal policy has been determined, services are selected based on acceptable resource budget and service level objective (SLO), and then applied. In one or more embodiments, after applying services for the data, the metadata corresponding to the data may be updated. As an example, if the service performed encrypts the data, the metadata may be updated to reflect that the data is encrypted and what type of encryption was used.

WhileFIG. 2shows a configuration of components, other configurations may be used without departing from the scope of embodiments described herein. Accordingly, embodiments disclosed herein should not be limited to the configuration of components shown inFIG. 2.

FIG. 3shows a flowchart describing a method for applying data management techniques using a distributed monitor agent, and using the results to determine what services to apply to data in accordance with one or more embodiments disclosed herein.

While the various steps in the flowchart shown inFIG. 3are presented and described sequentially, one of ordinary skill in the relevant art, having the benefit of this Detailed Description, will appreciate that some or all of the steps may be executed in different orders, that some or all of the steps may be combined or omitted, and/or that some or all of the steps may be executed in parallel.

In Step300, a determination is made that data is written to a data structure in storage of a data host. In one or more embodiments, the determination is made by a monitor agent executing on the data host. In one or more embodiments, the monitor agent monitors one or more data structures on the data host. As an example, the data structure may be a file system. In such an example, the monitor agent may capture that the file system is accessed, the file is opened, the data is being written, the process identifier of the application that writes the data, the application associated with the process identifier, whether the data is encrypted, whether the data is compressed, what type of data it is, and/or any other relevant information related to the data.

In Step302, a determination is made as to whether an API is configured. In one or more embodiments, an application may register to use an API to interact with the monitor agent. In such scenarios, in one or more embodiments, the application when writing the data, may use the API to provide information to the monitor agent about the data, including the intent of the data. In one or more embodiments, if such an API is configured, the method proceeds to Step304. In one or more embodiments, if such an API is not configured, the method proceeds to Step306.

In Step304, data information (i.e., information related to the data being written) is obtained by the monitor agent via the API from the application that writes the data. In one or more embodiments, after Step304, the method proceeds to Step316.

In Step306, the monitor agent assesses the data to obtain data information, such as the application that wrote the data, the process identifier of the application, the data type, the environment in which the data was produced, etc.

In Step308, the monitor agent evaluates any number of rules, provided by a global policy manager, to attempt to classify the intent of the data. In one or more embodiments, the monitor agent is able to produce a result of the intent with a probability of 100%. In other cases, the monitor agent may produce a probability ranking of several possible intents. In still other cases, the monitor agent may not be able to classify the data intent using the rules (i.e., possible intents based on the rules may be 0%).

In Step310, information related to the data obtained in Step306, and the results of the intent analysis of Step308are provided to an ML classifier. Such information may be provided to the ML classifier using any means of conveying information within a computing device (e.g., inter-process communication).

In Step312, a determination is made as to whether the results of the rules-based intent analysis of Step308produced a certain result (i.e., a result with a probability of 100%). In one or more embodiments, if the intent result is certain, the method proceeds to Step316. In one or more embodiments, if the rules-based intent result is not certain, the method proceeds to Step314.

In Step314, the ML classifier uses the information and/or the rules-based intent analysis as input to produce a result of the primary intent classification for the data.

In Step316, the monitor agent generates a global name and metadata for the data. In one or more embodiments, the global name is generated based on information obtained about the data, the results of the intent analysis, and policy rules related to global naming received from a global policy manager. In one or more embodiments, the metadata is either obtained or generated, as discussed above in the description ofFIG. 2.

In Step318, the global name and metadata created in Step316are stored locally on the data host associated with the data from which it was derived.

In Step320, the global name and metadata are published by the monitor agent to a global name repository. In one or more embodiments, the global name and metadata are published to the global name repository using any technique for transmitting data (e.g., over a network).

In Step322, the global name and metadata are provided by the monitor agent to a services management application. In one or more embodiments, the global name and metadata are provided to the services management application using any scheme for sharing information between applications executing on a data host (e.g., providing a location in storage where the information may be found).

In Step324, the services management application uses the global name and the metadata associated with the data, along with any number of data service policy rules, to determine what data services to apply to the data. In one or more embodiments, such a determination is referred to as a services assessment.

The following are examples of selecting services to perform on data. The examples are meant to be simple examples that illustrate concepts described herein. However, such examples may not illustrate all possible aspects of embodiments described herein. Accordingly, embodiments described herein should not be limited by the following examples.

One example of selecting services to apply to data relates to intelligent connected vehicles. In one or more embodiments, autonomous and connected vehicles produce vast amounts of data from highly specialized sensor systems, and require life safety functions to operate per safety guidelines. In one or more embodiments, data services and prioritized execution are tightly linked, as certain data produced must be moved with urgency over communications link with potentially limited bandwidth. In one or more embodiments, context understanding coupled with expectation based methodology is key for solving this challenge. In one or more embodiments, environmental understanding (e.g., limited bandwidth) with expectation (e.g., ten second data round trip is needed) is important for selecting appropriate data services to compress the data to meet available bandwidth resources, to generate metadata modifications, and to queue the data for transport.

Another example of selecting services to apply to data relates to remote healthcare. In one or more embodiments, clinical healthcare produces highly sensitive data on patients, as well as financial and insurance information and other sensitive information. In one or more embodiments, this information needs to be shared with a high degree of security and data governance based on patient consent regulatory frameworks. Additionally, a high degree of anonymization may be used so that overall patient confidentiality is protected. However, statistical healthcare studies can be pursued to benefit many individuals (e.g., other than the patient). In one or more embodiments, selection and communication of data services for encryption and compression are essential. Communication of data services applied are also required.

As discussed above, embodiments of the invention may be implemented using computing devices.FIG. 4shows a diagram of a computing device in accordance with one or more embodiments of the invention. The computing device (400) may include one or more computer processors (402), non-persistent storage (404) (e.g., volatile memory, such as random access memory (RAM), cache memory), persistent storage (406) (e.g., a hard disk, an optical drive such as a compact disc (CD) drive or digital versatile disc (DVD) drive, a flash memory, etc.), a communication interface (412) (e.g., Bluetooth® interface, infrared interface, network interface, optical interface, etc.), input devices (410), output devices (408), and numerous other elements (not shown) and functionalities. Each of these components is described below.

In one embodiment of the invention, the computing device (400) may include one or more output devices (408), such as a screen (e.g., a liquid crystal display (LCD), a plasma display, touchscreen, cathode ray tube (CRT) monitor, projector, or other display device), a printer, external storage, or any other output device. One or more of the output devices may be the same or different from the input device(s). The input and output device(s) may be locally or remotely connected to the computer processor(s) (402), non-persistent storage (404), and persistent storage (406). Many different types of computing devices exist, and the aforementioned input and output device(s) may take other forms.

The problems discussed above should be understood as being examples of problems solved by embodiments of the invention and the invention should not be limited to solving the same/similar problems. The disclosed invention is broadly applicable to address a range of problems beyond those discussed herein.