RocketCloudX Platform

Overview

Resumen

RocketCloudX unifies the four telemetry signals — logs, traces, metrics and real-user monitoring (RUM) — behind a single query language and a single isolation model. Instead of stitching together separate tools for each signal, you work with all of them in one platform, from one workspace, on one bill.

RocketCloudX unifica las cuatro señales de telemetría — logs, traces, métricas y monitoreo de usuario real (RUM) — detrás de un único lenguaje de consultas y un único modelo de aislamiento. En lugar de combinar herramientas separadas para cada señal, trabajás con todas en una sola plataforma, desde un solo workspace y con una sola factura.

Capabilities

Capacidades

Architecture at a glance

Arquitectura de un vistazo

Telemetry travels a single path from your workloads into isolated, per-tenant storage, where the platform's engines read from it.

La telemetría recorre un único camino desde tus cargas de trabajo hasta un almacenamiento aislado por tenant, desde donde la leen los motores de la plataforma.

Quickstart — send your first telemetry

Inicio rápido — enviá tu primera telemetría

If your application already speaks OpenTelemetry, point it at the RocketCloudX ingestion endpoint and add your token.

Si tu aplicación ya habla OpenTelemetry, apuntala al endpoint de ingesta de RocketCloudX y agregá tu token.

1 · Get your ingestion token

1 · Conseguí tu token de ingesta

Create a token in your workspace under Settings → Ingestion. Every token maps to exactly one tenant.

Creá un token en tu workspace en Settings → Ingestion. Cada token corresponde a exactamente un tenant.

2 · Point your OTLP exporter at RocketCloudX

2 · Apuntá tu exporter OTLP a RocketCloudX

Set the OTLP endpoint and headers on any OpenTelemetry SDK or Collector. Both headers are required.

Configurá el endpoint OTLP y los headers en cualquier SDK o Collector de OpenTelemetry. Ambos headers son obligatorios.

export OTEL_EXPORTER_OTLP_ENDPOINT="https://ingest.rocketx.io"
export OTEL_EXPORTER_OTLP_HEADERS="Api-Token=rcx_live_8f2…,X-Tenant-ID=your-tenant"
export OTEL_SERVICE_NAME="checkout"

3 · Verify data is arriving

3 · Verificá que los datos estén llegando

Open Explore and run a query. Within seconds you should see your service's logs, traces and metrics.

Abrí Explore y ejecutá una consulta. En segundos deberías ver los logs, traces y métricas de tu servicio.

get logs
| filter service.name = "checkout"
| summarize count(), by: {loglevel}

Instrument your application

Instrumentar tu aplicación

Any OpenTelemetry SDK works out of the box. Point the OTLP exporter at RocketCloudX, add your two headers, and telemetry flows in — logs, traces and metrics from the same setup. Pick your language or platform below; the endpoint and token are the same for all of them.

Cualquier SDK de OpenTelemetry funciona sin cambios. Apuntá el exporter OTLP a RocketCloudX, agregá tus dos headers y la telemetría empieza a fluir — logs, traces y métricas desde la misma configuración. Elegí tu lenguaje o plataforma abajo; el endpoint y el token son los mismos para todos.

Common setup

Configuración común

Every SDK reads the same three values. Set them however your runtime prefers (environment variables shown here).

Todos los SDK leen los mismos tres valores. Configuralos como prefiera tu runtime (acá se muestran como variables de entorno).

export OTEL_EXPORTER_OTLP_ENDPOINT="https://ingest.rocketx.io"
export OTEL_EXPORTER_OTLP_HEADERS="Api-Token=rcx_live_8f2…,X-Tenant-ID=your-tenant"
export OTEL_SERVICE_NAME="checkout"

Node.js

Zero-code auto-instrumentation covers HTTP, popular frameworks and database clients. Install the packages, set the environment, and start your app with the OpenTelemetry loader.

La auto-instrumentación sin código cubre HTTP, frameworks populares y clientes de base de datos. Instalá los paquetes, configurá el entorno y arrancá tu app con el loader de OpenTelemetry.

npm install @opentelemetry/api @opentelemetry/auto-instrumentations-node

# with the common environment set, start your app through the loader
node --require @opentelemetry/auto-instrumentations-node/register app.js

Python

The OpenTelemetry distro auto-instruments common libraries. Bootstrap the instrumentations once, then run your app under opentelemetry-instrument.

El distro de OpenTelemetry auto-instrumenta las librerías comunes. Hacé el bootstrap de las instrumentaciones una vez y después ejecutá tu app bajo opentelemetry-instrument.

pip install opentelemetry-distro opentelemetry-exporter-otlp
opentelemetry-bootstrap -a install

opentelemetry-instrument python app.py

Go

Go is instrumented in code: add the OpenTelemetry SDK and the OTLP/HTTP exporter, then initialize a tracer provider at startup. It reads the same endpoint and headers from the environment.

Go se instrumenta en el código: agregá el SDK de OpenTelemetry y el exporter OTLP/HTTP, y después inicializá un tracer provider al arranque. Toma el mismo endpoint y headers del entorno.

go get go.opentelemetry.io/otel \
       go.opentelemetry.io/otel/sdk \
       go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp

See the OpenTelemetry Go guide for the tracer-provider setup snippet.

Consultá la guía de OpenTelemetry Go para el snippet de configuración del tracer provider.

Java

The Java agent instruments your app with no code changes. Attach the agent jar at startup; it reads the endpoint and headers from the environment.

El agente de Java instrumenta tu app sin cambios de código. Adjuntá el jar del agente al arranque; toma el endpoint y los headers del entorno.

# download once
curl -sSLO https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/latest/download/opentelemetry-javaagent.jar

java -javaagent:opentelemetry-javaagent.jar -jar app.jar

Browser & RUM

Navegador y RUM

Real-user monitoring captures front-end sessions, page loads, web vitals and errors. Add the snippet with your app key; sessions replay in Session replay, correlated with the backend traces they triggered.

El monitoreo de usuario real captura sesiones de front-end, cargas de página, web vitals y errores. Agregá el snippet con tu app key; las sesiones se reproducen en Replay de sesiones, correlacionadas con las trazas de backend que dispararon.

<script src="https://rum.rocketx.io/v1/rum.js"></script>
<script>
  RCX.init({ appKey: "rcx_rum_8f2…", service: "web-frontend" });
</script>

Kubernetes

Deploy the RCX agent as a DaemonSet with Helm. It collects node and cluster metrics, pod logs and Kubernetes events, and relays OTLP from your workloads — the node and cluster scopes are enabled for you.

Desplegá el agente RCX como DaemonSet con Helm. Recolecta métricas de nodo y cluster, logs de pods y eventos de Kubernetes, y retransmite OTLP desde tus workloads — los scopes node y cluster ya vienen habilitados.

helm repo add rocketx https://charts.rocketx.io
helm install rcx-agent rocketx/agent \
    --set token=rcx_live_8f2… \
    --set tenant=acme \
    --set group=prod-k8s

Docker & collectors

Docker y collectors

Run the RCX agent as a container next to your services, or keep the collector you already have — existing pipelines forward OTLP to RocketCloudX with no re-instrumentation.

Corré el agente RCX como contenedor junto a tus servicios, o quedate con el collector que ya tenés — tus pipelines existentes reenvían OTLP a RocketCloudX sin reinstrumentar.

docker run -d --name rcx-agent \
    -e RCX_TOKEN=rcx_live_8f2… \
    -e RCX_TENANT=acme -e RCX_GROUP=prod-docker \
    -e RCX_ENDPOINT=https://ingest.rocketx.io \
    ghcr.io/rocketx/agent:latest

How OpenTelemetry works

Cómo funciona OpenTelemetry

OpenTelemetry (OTel) is the open standard RocketCloudX is built on. It defines a vendor-neutral way to generate, collect and export telemetry, so your instrumentation is portable and not tied to any single vendor — including us.

OpenTelemetry (OTel) es el estándar abierto sobre el que se construye RocketCloudX. Define una forma agnóstica de proveedor para generar, recolectar y exportar telemetría, de modo que tu instrumentación es portable y no queda atada a ningún proveedor — incluidos nosotros.

The three signals

Las tres señales

OpenTelemetry models telemetry as three signals. RocketCloudX ingests all of them, and adds RUM on top:

OpenTelemetry modela la telemetría como tres señales. RocketCloudX ingiere las tres y suma RUM por encima:

OTLP — the wire protocol

OTLP — el protocolo de transporte

Signals are exported over OTLP (the OpenTelemetry Protocol) as gRPC or HTTP/protobuf. RocketCloudX accepts OTLP natively.

Las señales se exportan mediante OTLP (el OpenTelemetry Protocol) como gRPC o HTTP/protobuf. RocketCloudX acepta OTLP de forma nativa.

Semantic conventions

Convenciones semánticas

OpenTelemetry's semantic conventions give attributes standard names — service.name, http.request.method, k8s.pod.name. RocketCloudX relies on these for topology discovery, correlation and detectors, so the more your instrumentation follows them, the more the platform does automatically.

Las convenciones semánticas de OpenTelemetry dan nombres estándar a los atributos — service.name, http.request.method, k8s.pod.name. RocketCloudX se apoya en ellas para el descubrimiento de topología, la correlación y los detectores, así que cuanto más las siga tu instrumentación, más hace la plataforma de forma automática.

How ingestion works

Cómo funciona la ingesta

All telemetry enters through RCX Pipelines, the ingestion gateway. Its job is to accept data on open protocols, prove who it belongs to, and route it to the correct tenant.

Toda la telemetría entra a través de RCX Pipelines, la puerta de ingesta. Su tarea es aceptar datos en protocolos abiertos, comprobar a quién pertenecen y enrutarlos al tenant correcto.

Data model & retention

Modelo de datos y retención

Each tenant's telemetry is stored in its own isolated store, built for fast search and aggregation at scale. You control how long data is kept and where it ends up through buckets.

La telemetría de cada tenant se guarda en su propio almacén aislado, pensado para búsqueda y agregación rápidas a gran escala. Controlás cuánto tiempo se conservan los datos y dónde terminan mediante buckets.

The RCX agent

El agente RCX

The RCX agent is a standard OpenTelemetry Collector — not a proprietary agent. It runs next to your workloads, collects telemetry, batches and compresses it, and forwards OTLP to RCX Pipelines. Anything the OpenTelemetry ecosystem supports, the RCX agent supports.

El agente RCX es un OpenTelemetry Collector estándar — no un agente propietario. Corre junto a tus cargas de trabajo, recolecta telemetría, la agrupa y comprime, y reenvía OTLP a RCX Pipelines. Todo lo que soporta el ecosistema OpenTelemetry, lo soporta el agente RCX.

What the agent collects

Qué recolecta el agente

• Host metrics — CPU, memory, disk, network, filesystem, processes.
• Métricas de host — CPU, memoria, disco, red, filesystem, procesos.
• Kubernetes — cluster, namespace, workload, pod and container telemetry and events.
• Kubernetes — telemetría y eventos de cluster, namespace, workload, pod y contenedor.
• Logs — files, journald, Windows Event Log, container stdout/stderr.
• Logs — archivos, journald, Windows Event Log, stdout/stderr de contenedores.
• OTLP relay — receives OTLP from your app SDKs and forwards it upstream.
• Relay OTLP — recibe OTLP de los SDKs de tu app y lo reenvía upstream.

Where it runs

Dónde corre

The agent runs on Linux, Windows, containers and Kubernetes (as a DaemonSet). IoT and edge devices can report over HTTPS or a bridged MQTT path.

El agente corre en Linux, Windows, contenedores y Kubernetes (como DaemonSet). Los dispositivos IoT y edge pueden reportar por HTTPS o por un puente MQTT.

Install the agent

Instalar el agente

Install from the fleet UI's + Install agent wizard, which generates a one-liner scoped to your workspace and group. The agent registers itself over OpAMP the moment it starts.

Instalá desde el wizard + Install agent de la UI de flota, que genera un comando de una línea ajustado a tu workspace y grupo. El agente se registra por OpAMP en cuanto arranca.

# one-liner from the Install wizard — token + group are pre-filled
curl -sSL https://get.rocketx.io/agent | sudo sh -s -- \
    --token "rcx_live_8f2…" \
    --tenant "your-tenant" \
    --group  "prod-linux"

On Kubernetes, the wizard emits a Helm values snippet that deploys the collector as a DaemonSet with the node and cluster scopes enabled.

En Kubernetes, el wizard emite un snippet de values de Helm que despliega el collector como DaemonSet con los scopes node y cluster habilitados.

OpAMP fleet management

Gestión de flota con OpAMP

Agents are managed with OpAMP (Open Agent Management Protocol), the open standard for remotely managing a fleet of collectors. Each agent performs a handshake, sends heartbeats, and can receive configuration pushed from RocketCloudX.

Los agentes se gestionan con OpAMP (Open Agent Management Protocol), el estándar abierto para gestionar una flota de collectors de forma remota. Cada agente hace un handshake, envía heartbeats y puede recibir configuración desde RocketCloudX.

• Status — connected, disconnected and stale-config agents.
• Estado — agentes conectados, desconectados y con configuración desactualizada.
• Distribution — collector versions and group membership across the fleet.
• Distribución — versiones de collector y pertenencia a grupos en toda la flota.
• Per-agent detail — host, platform, version, group, throughput and last-seen.
• Detalle por agente — host, plataforma, versión, grupo, throughput y visto por última vez.
• Remote config — push a new pipeline to a group; agents apply it and confirm the change.
• Config remota — mandá un pipeline nuevo a un grupo; los agentes lo aplican y confirman el cambio.

Pipeline configuration

Configuración de pipelines

A pipeline is the collector's receivers → processors → exporters chain. RocketCloudX lets a tenant admin edit it from the UI, with preview, activate and rollback — no SSH, no hand-edited YAML on boxes.

Un pipeline es la cadena receivers → processors → exporters del collector. RocketCloudX permite que un admin del tenant lo edite desde la UI, con preview, activar y rollback — sin SSH ni YAML editado a mano en las máquinas.

Routing rules (OTTL)

Reglas de ruteo (OTTL)

Routing rules use OTTL (the OpenTelemetry Transformation Language) to match telemetry and send it to a destination bucket — or drop it. Rules are evaluated in order; the first match wins.

Las reglas de ruteo usan OTTL (el OpenTelemetry Transformation Language) para hacer match con la telemetría y enviarla a un bucket destino — o descartarla. Las reglas se evalúan en orden; gana la primera coincidencia.

# 1 · drop anything below INFO
where severity_number < SEVERITY_NUMBER_INFO        → drop
# 2 · keep audit logs for a year
where resource["service.name"] == "audit"       → logs-compliance (365d)
# 3 · prod logs go hot
where attributes["env"] == "prod"              → logs-hot (7d)
# 4 · everything else to archive
*                                                → logs-archive (S3)

Explore & search

Explorar y buscar

Explore is where you search raw telemetry. Type an RCXQL query (or use the builder), pick a timeframe, and get a volume histogram plus a live result table. Facets on the left let you drill in by any field.

Explore es donde buscás telemetría cruda. Escribí una consulta RCXQL (o usá el builder), elegí un rango de tiempo y obtené un histograma de volumen más una tabla de resultados en vivo. Las facetas de la izquierda permiten profundizar por cualquier campo.

• Facets — every field becomes a filter with live counts (service, severity, namespace…).
• Facetas — cada campo se vuelve un filtro con conteos en vivo (service, severity, namespace…).
• Histogram — see volume and error spikes over the window before you read a single line.
• Histograma — mirá los picos de volumen y de errores en la ventana antes de leer una sola línea.
• Pivot — jump from a log line to its trace, its service in the map, or a saved dashboard.
• Pivot — saltá de una línea de log a su trace, a su servicio en el mapa o a un dashboard guardado.

RCXQL — one query language

RCXQL — un solo lenguaje de consultas

RCXQL is RocketCloudX's piped query language. One language covers every signal — logs, traces, metrics, sessions and topology — so you don't learn a different dialect for each. Steps are chained with |, reading left to right, and each step transforms the rows from the one before it.

RCXQL es el lenguaje de consultas piped de RocketCloudX. Un solo lenguaje cubre todas las señales — logs, traces, métricas, sesiones y topología — así no aprendés un dialecto distinto para cada una. Los pasos se encadenan con |, leyendo de izquierda a derecha, y cada paso transforma las filas del anterior.

With RCXQL the same question is one readable line — RocketCloudX resolves the storage, the field names and the safety limits for you:

Con RCXQL la misma pregunta es una sola línea legible — RocketCloudX resuelve el almacenamiento, los nombres de campo y los límites de seguridad por vos:

get logs, from: -1h
| filter service.name = "checkout" and loglevel = "ERROR"
| limit 50

• No query language to learn — the visual builder writes RCXQL for you, or type it with autocomplete.
• Nada que aprender — el builder visual escribe el RCXQL por vos, o escribilo con autocompletado.
• One language, every signal — the same steps work over logs, traces, metrics, sessions and topology.
• Un lenguaje, todas las señales — los mismos pasos funcionan sobre logs, traces, métricas, sesiones y topología.
• Safe by default — scan, row and result limits are applied for you, so a broad query can't run away.
• Seguro por defecto — los límites de escaneo, filas y resultado se aplican solos, para que una consulta amplia no se dispare.
• Runs everywhere — the same queries power the explorer, dashboards and the HTTP API.
• Corre en todos lados — las mismas consultas alimentan el explorador, los dashboards y la API HTTP.

RCXQL reference

Referencia RCXQL

A query starts with an entity and flows through pipeline steps, left to right. Each step takes the rows from the previous one and transforms them.

Una consulta empieza con una entidad y fluye a través de pasos del pipeline, de izquierda a derecha. Cada paso toma las filas del anterior y las transforma.

get <entity> | <step> | <step> | …

Entities

Entidades

Pipeline steps

Pasos del pipeline

Functions

Funciones

Common tasks

Tareas comunes

Want to see something specific? Start from one of these — every query here is validated against the language.

¿Querés ver algo puntual? Empezá por una de estas — cada consulta acá está validada contra el lenguaje.

Metrics & dashboards

Métricas y dashboards

Any RCXQL query can become a panel, and panels compose into dashboards. Metrics carry no per-host cap — you're not penalized for scaling out.

Cualquier consulta RCXQL puede volverse un panel, y los paneles se componen en dashboards. Las métricas no tienen tope por host — no se penaliza escalar horizontalmente.

The golden-signals dashboard shown in §01 pairs request rate, error rate and latency percentiles with saturation, each panel with its own time control and alert-threshold overlays.

El dashboard de golden signals mostrado en §01 combina tasa de requests, tasa de errores y percentiles de latencia con saturación, cada panel con su propio control de tiempo y overlays de umbral de alerta.

Distributed tracing

Trazas distribuidas

Traces show a request's full path across services as a flame-graph, with a span table and per-span attributes. Spans are standard OpenTelemetry — no proprietary tracing SDK — and every trace is queryable via get spans.

Las trazas muestran el camino completo de un request a través de los servicios como un flame-graph, con una tabla de spans y atributos por span. Los spans son OpenTelemetry estándar — sin SDK de tracing propietario — y toda traza es consultable con get spans.

• Flame-graph — nesting and duration make the slow path obvious; errors are outlined.
• Flame-graph — el anidamiento y la duración hacen obvio el camino lento; los errores quedan resaltados.
• Correlation — pivot from a span to its logs, or from a service to the topology map.
• Correlación — pivoteá de un span a sus logs, o de un servicio al mapa de topología.
• Queryable — aggregate spans in RCXQL (p95 by operation, error ratio by service).
• Consultable — hacé agregaciones de spans en RCXQL (p95 por operación, ratio de error por servicio).

Session replay (RUM)

Replay de sesiones (RUM)

Real-user monitoring captures front-end sessions — page loads, clicks, inputs and errors — and lets you replay them with a timeline. Front-end errors correlate with the backend traces they triggered, so a failed checkout links to the span that timed out.

El monitoreo de usuario real captura sesiones de front-end — cargas de página, clics, inputs y errores — y permite reproducirlas con una línea de tiempo. Los errores de front-end se correlacionan con las trazas de backend que dispararon, así un checkout fallido enlaza al span que hizo timeout.

Topology & service map

Topología y mapa de servicios

RocketCloudX continuously discovers your estate from incoming telemetry and draws it as a live map: hosts, containers, Kubernetes objects, processes and services, with edges for physical containment, Kubernetes ownership, logical grouping and service-to-service calls.

RocketCloudX descubre continuamente tu infraestructura a partir de la telemetría entrante y la dibuja como un mapa en vivo: hosts, contenedores, objetos de Kubernetes, procesos y servicios, con aristas de contención física, pertenencia en Kubernetes, agrupación lógica y llamadas servicio-a-servicio.

• Auto-discovery — nothing to draw by hand; the map is built from your telemetry.
• Auto-descubrimiento — nada que dibujar a mano; el mapa se construye desde tu telemetría.
• Health overlay — error rate and latency color the nodes and edges.
• Overlay de salud — la tasa de error y la latencia colorean nodos y aristas.
• Drill-down — select a node for its metrics, dependencies and related incidents.
• Drill-down — seleccioná un nodo para ver sus métricas, dependencias e incidentes relacionados.

Alerts & incidents

Alertas e incidentes

RocketCloudX ships 20+ packaged detectors for the common failure modes across Kubernetes, containers, hosts and services. Detectors learn an adaptive baseline per entity and metric, so they alert on unusual behavior rather than a fixed threshold you have to tune.

RocketCloudX incluye más de 20 detectores empaquetados para los modos de falla comunes en Kubernetes, contenedores, hosts y servicios. Los detectores aprenden una baseline adaptativa por entidad y métrica, así alertan sobre comportamiento inusual en vez de un umbral fijo que hay que ajustar.

From alert to incident

De alerta a incidente

• Grouping — related alerts on the same entity merge into a single incident instead of a storm.
• Agrupación — las alertas relacionadas de la misma entidad se fusionan en un solo incidente en vez de una tormenta.
• Correlation — the timeline pulls in correlated signals (latency, pod restarts) around the breach.
• Correlación — la línea de tiempo suma señales correlacionadas (latencia, reinicios de pods) alrededor de la ruptura.
• Lifecycle — incidents open, merge, reopen and auto-resolve; silences suppress known noise.
• Ciclo de vida — los incidentes se abren, fusionan, reabren y auto-resuelven; los silencios suprimen ruido conocido.

Notifications

Notificaciones

Route incidents to where your team already works. Notification channels are configured from Settings → Notifications and delivered through the automation layer.

Ruteá los incidentes a donde tu equipo ya trabaja. Los canales de notificación se configuran desde Settings → Notifications y se entregan por la capa de automatización.

Workflows (Automatron)

Flujos de trabajo (Automatron)

Automatron is the automation engine. Build a flow of steps with dependencies, branches and parallelism, triggered by an inbound webhook (POST /api/signals) or by an alert. Every run is recorded and queryable in RCXQL.

Automatron es el motor de automatización. Armá un flujo de pasos con dependencias, ramas y paralelismo, disparado por un webhook entrante (POST /api/signals) o por una alerta. Cada ejecución queda registrada y es consultable en RCXQL.

• Verified actions — HTTP request, RCXQL query, and console/log actions.
• Acciones verificadas — request HTTP, consulta RCXQL y acciones de consola/log.
• Isolated execution — each action runs in isolation; secrets are provided at run time.
• Ejecución aislada — cada acción corre de forma aislada; los secretos se proveen en tiempo de ejecución.
• Queryable runs — every run is recorded and can be queried and alerted on.
• Ejecuciones consultables — cada ejecución queda registrada y podés consultarla o alertar sobre ella.

Multi-tenancy & isolation

Multi-tenancy y aislamiento

Isolation in RocketCloudX is enforced at every layer, not just with permission checks. A tenant's data, state, ingestion path and runtime are separated so that one tenant can never read another's telemetry.

En RocketCloudX el aislamiento se aplica en cada capa, no solo con chequeos de permisos. Los datos, el estado, el camino de ingesta y el runtime de un tenant están separados, de modo que un tenant nunca puede leer la telemetría de otro.

Security & SSO

Seguridad y SSO

• SSO — sign in with your identity provider over SAML or OIDC.
• SSO — iniciá sesión con tu proveedor de identidad por SAML u OIDC.
• Layered authorization — ingest token, session, tenant scope, role and per-surface permission are all checked independently.
• Autorización por capas — token de ingesta, sesión, alcance de tenant, rol y permiso por superficie se verifican de forma independiente.
• Your data stays yours — archive to your own object storage; no data gravity tying you to the platform.
• Tus datos siguen siendo tuyos — archivá en tu propio object storage; sin data gravity que te ate a la plataforma.
• Portability — standard OpenTelemetry in, standard export out. Leaving takes your configuration and telemetry with you.
• Portabilidad — OpenTelemetry estándar de entrada, exportación estándar de salida. Si te vas, te llevás tu configuración y tu telemetría.

Roles & permissions

Roles y permisos

Workspaces are isolated per team or customer, with granular roles. An admin in one workspace has no visibility into another.

Los workspaces están aislados por equipo o cliente, con roles granulares. Un admin en un workspace no tiene visibilidad sobre otro.

Per-surface permissions refine this further, so you can grant access to specific tabs and capabilities beyond the base role.

Los permisos por superficie afinan esto aún más, para otorgar acceso a pestañas y capacidades específicas más allá del rol base.