Overview
EntityStore is the unified storage engine for the UModel system. It stores and manages core metadata in the observability realm, such as UModel metadata, entity data, and entity relationship data. EntityStore provides high-performance data storage and query capabilities for observability analysis.
Core concepts
Before you explore EntityStore, it is important to understand the following core concepts, which are often confused:
Concept | Definition | Analogy | Example |
UModel | A complete knowledge graph system | The entire database schema | A complete modeling system that includes all APM, K8s, and cloud resources |
EntitySet | An entity type definition in the knowledge graph | A table schema definition in a database |
|
Entity | A specific entity instance | A specific record in a database |
|
EntitySetLink | A relationship definition between entities | A relationship type definition in a Graph Database |
|
EntityRelations | A relationship instance between entities | A relationship instance in a Graph Database |
|
Detailed relationships
UModel (knowledge graph)
Function: Defines the modeling standards for the entire observability realm.
Includes: All EntitySet definitions, field specifications, relationship types, and more.
Characteristic: A schema-level definition that describes what types of entities can exist.
EntitySet (entity type)
Function: Defines the structure and property standards for a class of entities.
Includes: Field definitions, primary keys, indexes, validation rules, and more.
Characteristic: Similar to a class definition, it specifies the properties that an instance must have.
Entity (entity instance)
Function: A specific business object instance.
Includes: Specific property values and status information.
Characteristic: Represents real runtime data.
How they work together
UModel (knowledge graph)
├── EntitySet: apm.service (type definition)
│ ├── Entity: user-service (instance 1)
│ ├── Entity: payment-service (instance 2)
│ └── Entity: order-service (instance 3)
├── EntitySet: k8s.pod (type definition)
│ ├── Entity: web-pod-123 (instance 1)
│ └── Entity: api-pod-456 (instance 2)
└── EntitySetLink: service_runs_on_pod (relationship definition)
├── Relation: user-service -> web-pod-123
└── Relation: payment-service -> api-pod-456EntityStore architecture
Core components
EntityStore uses a layered architecture that includes the following core components:
┌─────────────────────────────────────────────────────┐
│ Query Layer │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ USearch │ │ Graph Query │ │ UModel Query│ │
│ │(Entity Retrieval)│ │(Relationship Query)│ │(Metadata Query) │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
└─────────────────────────────────────────────────────┘
│
┌─────────────────────────────────────────────────────┐
│ Storage Engine │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ UModel │ │ Entity │ │ Topo │ │
│ │ (Metastore) │ │(Entity Storage) │ │(Relationship Storage)│ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
└─────────────────────────────────────────────────────┘SLS Logstore assets
EntityStore uses Simple Log Service (SLS) Logstores to write and consume data. When you create an EntityStore, the following Logstore assets are also created:
${workspace}__entity: Used to write entity data.${workspace}__topo: Used to write relationship data.
Features
1. Multi-pattern query support
USearch (entity retrieval)
Full-text index: Supports fuzzy searches across multiple fields.
Term query: Supports exact matches based on ID or properties.
Aggregation analysis: Provides statistics and grouping features.
UModel Query (metadata query)
Schema query: Retrieves EntitySet definitions.
Relationship definition query: Retrieves EntitySetLink configurations.
Graph computing: Performs association analysis based on UModel metadata.
Graph Query (relationship query)
Path query: Analyzes multi-hop relationship paths.
Neighbor query: Analyzes adjacent relationships of an entity.
Custom query: Recognizes custom topology patterns.
2. Dynamic lifecycle for entity topology
Dynamic lifecycle: Entities and relationships have a dynamic lifecycle, which lets you set their expiration and deletion times.
Point-in-time recovery: You can restore the state of entities and relationships to any point in time, which is useful for troubleshooting.
Query performance optimization: A dynamic entity replacement mechanism ensures query performance across different epochs.
3. Write pattern support
Incremental writes: Real-time updates based on events.
Full writes: Periodic and complete data synchronization.
Lifecycle management: Supports Create, Update, Expire, Delete, and Revise operations.