How Entity Explorer Redefines Cloud‑Native Observability with Unified Queries and Model‑Driven UI

Entity Explorer Overview

Entity Explorer is a cloud‑native observability feature that treats any independently identifiable object—such as hosts, containers, services, databases, user sessions, or deployment environments—as an entity . Entities are grouped into four logical categories: infrastructure , application , business , and operations .

Why Entity Exploration Is Needed

Traditional monitoring isolates data by product or metric, creating siloed views. Entity Explorer builds a panoramic asset catalog that enables:

Listing all entity types and instances defined in the unified model (UModel), grouped by domain and type.

Fast, precise searches using the USearch language, supporting full‑text, exact match, and conditional filters.

One‑stop diagnosis by starting from any entity and exploring its status, performance metrics, related logs, trace links, and topology.

Core Technical Challenges

Performance at massive scale : Billions of entity records make naïve pairwise matching infeasible, leading to exponential computation cost and latency.

Heterogeneous and semantically diverse data : Entities originate from multiple systems with inconsistent formats, aliases, misspellings, and missing fields, hindering accurate identification.

Front‑end coupling and maintenance overhead : Each entity type traditionally requires a dedicated UI, causing duplicated effort, fragile hard‑coded links, and complex configuration.

Solution Architecture (Four Pillars)

Unified query entry : A global USearch component abstracts storage details. Users write natural‑language queries that are parsed, dispatched to heterogeneous back‑ends (logs, metrics, CMDB), aggregated, cleaned, and returned as a uniform entity model.

Scenario‑driven business integration : Pre‑defined “apps” map technical entities to business contexts (e.g., database monitoring), automatically enriching entity data by linking across sources.

Visual exploration : Interactive topology graphs display dynamic relationships (service calls, host deployments, network access), supporting focus‑mode, root‑cause tracing, and impact analysis.

Model‑driven UI rendering : A schema‑as‑UI engine reads entity schemas (UModel) and generates detail pages, lists, and forms on the fly, eliminating hand‑coded front‑ends and enabling low‑code extensions.

USearch Query Language

USearch provides a concise DSL for entity retrieval. The basic syntax is:

.entity with(
    domain='domain_pattern',    -- domain filter
    type='type_pattern',        -- type filter
    query='search_query',       -- search condition
    topk=10                     -- max results
)

Key features:

Full‑text search across all fields.

Field‑specific queries (e.g., status:running).

Logical operators AND, OR, NOT.

Relevance scoring based on IDF and column weights.

Automatic handling of special characters.

Typical queries:

.entity with(query='web service')
.entity with(query='status:running')
.entity with(query='environment:prod AND status:error')
.entity with(domain='apm', type='apm.service', query='production')

SPL Data Processing Language

SPL (SLS Processing Language) processes raw log data after an initial USearch filter. It follows a pipeline model:

First stage: index filtering (e.g., USearch query).

Subsequent stages: SPL commands for transformation, aggregation, and analysis.

Final output: filtered and enriched result set.

Common SPL operators: | where status = "error" – condition filtering. | where cpu_usage > 0.8 – numeric filtering. | where __time__ > "2024-01-01 00:00:00" – time range filtering. | extend new_field = field1 + field2 – field extraction. | project-rename new_name = old_name – field renaming. | project field1, field2, field3 – field selection.

Combining USearch and SPL

USearch can serve as the data source for SPL, enabling end‑to‑end workflows such as:

.entity with(domain='apm', type='apm.service', query='production')
| where language = 'java'

Entity Overview UI

The overview page is generated from the entity schema. It automatically selects dashboards and data sources based on entity metadata, displays associated entities, relationship tables (containment, equivalence, upstream/downstream), and provides navigation to related entity pages.

Visual Topology Exploration

Topology graphs render the relationships between entities (service calls, host deployments, network access). Users can:

Zoom, pan, and drag nodes.

Click a node to view detailed metrics, alerts, and logs.

Use focus mode to isolate a node’s upstream and downstream dependencies for root‑cause analysis.

Model‑Driven UI Generation

Instead of hand‑coding a UI for each entity type, a unified rendering engine consumes the UModel schema:

Define‑once‑render‑any : The schema describes fields, data types, and UI directives (e.g., render as chart, link to another entity, format as timestamp).

Low‑code extension : Adding a new entity type only requires updating the schema; the front‑end automatically generates the appropriate pages.

Plugin architecture : The engine can be extended with custom UI components without modifying core code.

Console Interaction

Enter a USearch query directly in the global quick‑search bar to retrieve matching entities.

Select a domain and entity type from the left pane for filtered searches.

Click a result to view detailed metrics and environment information.

Switch to SPL mode for advanced data processing.

Hover over a field to reveal a shortcut that auto‑populates the USearch box with the field value.

Key Benefits

Extreme efficiency : Model‑driven UI reduces weeks of front‑end development to a few hours of schema configuration.

High precision : Provides a trustworthy 360° entity panorama across heterogeneous sources.

Deep insight : Empowers engineers, operators, and analysts to uncover hidden relationships and performance bottlenecks.

Representative Diagrams