Advance RFC 0049 (entity store) to stage 2 (#2537)

Advance RFC 0049 (entity store) to stage 2

Author: mjwolf

CHANGELOG.next.md

@@ -17,6 +17,7 @@ Thanks, you're awesome :-) -->
 #### Added
 
 * Add `device` value to `event.type` #2524
+* Added `entity` fieldset as beta #2537
 
 #### Improvements
 

docs/reference/ecs-allowed-values-entity-type.md

@@ -0,0 +1,80 @@
+---
+mapped_pages:
+  - https://www.elastic.co/guide/en/ecs/current/ecs-allowed-values-entity-type.html
+applies_to:
+  stack: all
+  serverless: all
+navigation_title: entity.type
+---
+
+# ECS categorization field: entity.type [ecs-allowed-values-entity-type]
+
+A standardized high-level classification of the entity. This provides a normalized way to group similar entities across different providers or systems.
+
+`entity.type` represents a categorization that enables filtering and grouping of entities regardless of their specific implementation or provider. For example, filtering on `entity.type:host` yields all host-related entities whether they are physical machines, virtual machines, or cloud instances.
+
+This field is an array. This allows proper categorization of entities that may fall into multiple types.
+
+**Allowed values**
+
+* [application](#ecs-entity-type-application)
+* [bucket](#ecs-entity-type-bucket)
+* [container](#ecs-entity-type-container)
+* [database](#ecs-entity-type-database)
+* [function](#ecs-entity-type-function)
+* [host](#ecs-entity-type-host)
+* [queue](#ecs-entity-type-queue)
+* [service](#ecs-entity-type-service)
+* [session](#ecs-entity-type-session)
+* [user](#ecs-entity-type-user)
+
+
+## application [ecs-entity-type-application]
+
+Represents a software application or service. This includes web applications, mobile applications, desktop applications, and other software components that provide functionality to users or other systems. Applications may run on various infrastructure components and can span multiple hosts or containers.
+
+
+## bucket [ecs-entity-type-bucket]
+
+Represents a storage container or bucket, typically used for object storage. Common examples include AWS S3 buckets, Google Cloud Storage buckets, Azure Blob containers, and other cloud storage services. Buckets are used to organize and store files, objects, or data in cloud environments.
+
+
+## container [ecs-entity-type-container]
+
+Represents a containerized application or process. This includes Docker containers, Kubernetes pods, and other containerization technologies. Containers encapsulate applications and their dependencies, providing isolation and portability across different environments.
+
+
+## database [ecs-entity-type-database]
+
+Represents a database system or database instance. This includes relational databases (MySQL, PostgreSQL, Oracle), NoSQL databases (MongoDB, Cassandra, DynamoDB), time-series databases, and other data storage systems. The entity may represent the entire database system or a specific database instance.
+
+
+## function [ecs-entity-type-function]
+
+Represents a serverless function or Function-as-a-Service (FaaS) component. This includes AWS Lambda functions, Azure Functions, Google Cloud Functions, and other serverless computing resources. Functions are typically event-driven and execute code without managing the underlying infrastructure.
+
+
+## host [ecs-entity-type-host]
+
+Represents a computing host or machine. This includes physical servers, virtual machines, cloud instances, and other computing resources that can run applications or services. Hosts provide the fundamental computing infrastructure for other entity types.
+
+
+## queue [ecs-entity-type-queue]
+
+Represents a message queue or messaging system. This includes message brokers, event queues, and other messaging infrastructure components such as Amazon SQS, RabbitMQ, Apache Kafka, and Azure Service Bus. Queues facilitate asynchronous communication between applications and services.
+
+
+## service [ecs-entity-type-service]
+
+Represents a service or microservice component. This includes web services, APIs, background services, and other service-oriented architecture components. Services provide specific functionality and may communicate with other services to fulfill business requirements.
+
+
+## session [ecs-entity-type-session]
+
+Represents a user session or connection session. This includes user login sessions, database connections, network sessions, and other temporary interactive or persistent connections between users, applications, or systems.
+
+
+## user [ecs-entity-type-user]
+
+Represents a user account or identity. This includes human users, service accounts, system accounts, and other identity entities that can interact with systems, applications, or services. Users may have various roles, permissions, and attributes associated with their identity.
+

docs/reference/ecs-cloud.md

@@ -43,6 +43,7 @@ Note also that the `cloud` fields may be used directly at the root of the events
 | --- | --- | --- |
 | `cloud.origin.*` | [cloud](/reference/ecs-cloud.md) | Provides the cloud information of the origin entity in case of an incoming request or event. |
 | `cloud.target.*` | [cloud](/reference/ecs-cloud.md) | Provides the cloud information of the target entity in case of an outgoing request or event. |
+| `cloud.target.entity.*` | [entity](/reference/ecs-entity.md) | Entity information for the target cloud entity. |
 
 ### Cloud field usage [_cloud_field_usage]
 

docs/reference/ecs-entity.md

@@ -0,0 +1,40 @@
+---
+mapped_pages:
+  - https://www.elastic.co/guide/en/ecs/current/ecs-entity.html
+applies_to:
+  stack: all
+  serverless: all
+---
+% This file is automatically generated. Don't edit it manually!
+
+# Entity fields [ecs-entity]
+
+The entity fields provide a standardized way to represent and categorize different types of components within an IT environment, including those that don't have dedicated field sets in ECS. An entity represents a discrete, identifiable component that can be described by a set of attributes and maintains its identity over time.
+
+## Entity field details [_entity_field_details]
+
+| Field | Description | Level |
+| --- | --- | --- |
+| $$$field-entity-attributes$$$ [entity.attributes](#field-entity-attributes) | _This field is beta and subject to change._ A set of static or semi-static attributes of the entity. Usually boolean or keyword field data types. Use this field set when you need to track static or semi-static characteristics of an entity for advanced searching and correlation of normalized values across different providers/sources and entity types.<br><br>type: object | extended |
+| $$$field-entity-behavior$$$ [entity.behavior](#field-entity-behavior) | _This field is beta and subject to change._ A set of ephemeral characteristics of the entity, derived from observed behaviors during a specific time period. Usually boolean field data type. Use this field set when you need to capture and track ephemeral characteristics of an entity for advanced searching, correlation of normalized values across different providers/sources and entity types.<br><br>type: object | extended |
+| $$$field-entity-display_name$$$ [entity.display_name](#field-entity-display_name) | _This field is beta and subject to change._ An optional field used when a pretty name is desired for entity-centric operations. This field should not be used for correlation with `*.name` fields for entities with dedicated field sets (e.g., `host`).<br><br>type: keyword<br><br>Multi-fields:<br><br>* entity.display_name.text (type: text) | extended |
+| $$$field-entity-id$$$ [entity.id](#field-entity-id) | A unique identifier for the entity. When multiple identifiers exist, this should be the most stable and commonly used identifier that: 1) persists across the entity's lifecycle, 2) ensures uniqueness within its scope, 3) is commonly used for queries and correlation, and 4) is readily available in most observations (logs/events). For entities with dedicated field sets (e.g., host, user), this value should match the corresponding *.id field. Alternative identifiers (e.g., ARNs values in AWS, URLs) can be preserved in the raw field.<br><br>type: keyword | core |
+| $$$field-entity-last_seen_timestamp$$$ [entity.last_seen_timestamp](#field-entity-last_seen_timestamp) | _This field is beta and subject to change._ Indicates the date/time when this entity was last "seen," usually based upon the last event/log that is initiated by this entity.<br><br>type: date | extended |
+| $$$field-entity-lifecycle$$$ [entity.lifecycle](#field-entity-lifecycle) | _This field is beta and subject to change._ A set of temporal characteristics of the entity. Usually date field data type. Use this field set when you need to track temporal characteristics of an entity for advanced searching and correlation of normalized values across different providers/sources and entity types.<br><br>type: object | extended |
+| $$$field-entity-metrics$$$ [entity.metrics](#field-entity-metrics) | _This field is beta and subject to change._ Field set for any fields containing numeric entity metrics. These use dynamic field data type mapping.<br><br>type: object | extended |
+| $$$field-entity-name$$$ [entity.name](#field-entity-name) | _This field is beta and subject to change._ The name of the entity. The keyword field enables exact matches for filtering and aggregations, while the text field enables full-text search. For entities with dedicated field sets (e.g., `host`), this field should mirrors the corresponding *.name value.<br><br>type: keyword<br><br>Multi-fields:<br><br>* entity.name.text (type: text) | core |
+| $$$field-entity-raw$$$ [entity.raw](#field-entity-raw) | _This field is beta and subject to change._ Original, unmodified fields from the source system. Usually flattened field data type. While the attributes field should be used for normalized fields requiring advanced queries, this field preserves all source metadata with basic search capabilities.<br><br>type: object | extended |
+| $$$field-entity-reference$$$ [entity.reference](#field-entity-reference) | _This field is beta and subject to change._ A URI, URL, or other direct reference to access or locate the entity in its source system. This could be an API endpoint, web console URL, or other addressable location. Format may vary by entity type and source system.<br><br>type: keyword | extended |
+| $$$field-entity-source$$$ [entity.source](#field-entity-source) | _This field is beta and subject to change._ The module or integration that provided this entity data (similar to event.module).<br><br>type: keyword | core |
+| $$$field-entity-type$$$ [entity.type](#field-entity-type) | _This field is beta and subject to change._ A standardized high-level classification of the entity. This provides a normalized way to group similar entities across different providers or systems. Example values: `bucket`, `database`, `container`, `function`, `queue`, `host`, `user`, `application`, `session`, etc.<br><br>type: keyword<br><br>example: `host` | core |
+
+## Field reuse [_field_reuse]
+
+The `entity` fields are expected to be nested at:
+
+* `cloud.target.entity`
+* `host.entity`
+* `service.target.entity`
+* `user.target.entity`
+
+Note also that the `entity` fields are not expected to be used directly at the root of the events.

docs/reference/ecs-host.md

@@ -41,6 +41,7 @@ ECS host.* fields should be populated with details about the host on which the e
 
 | Location | Field Set | Description |
 | --- | --- | --- |
+| `host.entity.*` | [entity](/reference/ecs-entity.md) | Fields to describe various types of entities across IT environments. |
 | `host.geo.*` | [geo](/reference/ecs-geo.md) | Fields describing a location. |
 | `host.os.*` | [os](/reference/ecs-os.md) | OS fields contain information about the operating system. |
 | `host.risk.*` | [risk](/reference/ecs-risk.md) | Fields for describing risk score and level. |

docs/reference/ecs-service.md

@@ -45,6 +45,7 @@ Note also that the `service` fields may be used directly at the root of the even
 | --- | --- | --- |
 | `service.origin.*` | [service](/reference/ecs-service.md) | _Reusing the `service` fields in this location is currently considered beta._ Describes the origin service in case of an incoming request or event. |
 | `service.target.*` | [service](/reference/ecs-service.md) | _Reusing the `service` fields in this location is currently considered beta._ Describes the target service in case of an outgoing request or event. |
+| `service.target.entity.*` | [entity](/reference/ecs-entity.md) | Entity information for the target service. |
 
 ### Service field usage [_service_field_usage]
 

docs/reference/ecs-user.md

@@ -53,6 +53,7 @@ Note also that the `user` fields may be used directly at the root of the events.
 | `user.group.*` | [group](/reference/ecs-group.md) | User's group relevant to the event. |
 | `user.risk.*` | [risk](/reference/ecs-risk.md) | Fields for describing risk score and level. |
 | `user.target.*` | [user](/reference/ecs-user.md) | Targeted user of action taken. |
+| `user.target.entity.*` | [entity](/reference/ecs-entity.md) | Entity information for the targeted user. |
 
 ### User field usage [_user_field_usage]
 

docs/reference/toc.yml

@@ -29,6 +29,9 @@ toc:
       - file: ecs-ecs.md
       - file: ecs-elf.md
       - file: ecs-email.md
+      - file: ecs-entity.md
+        children:
+          - file: ecs-allowed-values-entity-type.md
       - file: ecs-error.md
       - file: ecs-event.md
       - file: ecs-faas.md