Skip to content

ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.

Trace apps through an OpenTelemetry Collector

Juan Denis0c18aa421f8d
diff --git a/backend/app/models/app_attachment.py b/backend/app/models/app_attachment.py
index 8d279b42..ca8a4f87 100644
--- a/backend/app/models/app_attachment.py
+++ b/backend/app/models/app_attachment.py
@@ -21,7 +21,7 @@ class AppAttachment(JsonColumnMixin, db.Model):
db.UniqueConstraint('app_id', 'kind', name='uq_app_attachments_app_kind'),
)
- KINDS = ('storage', 'cache', 'queue', 'metrics', 'logs')
+ KINDS = ('storage', 'cache', 'queue', 'tracing', 'metrics', 'logs', 'traces')
id = db.Column(db.Integer, primary_key=True)
app_id = db.Column(db.Integer, db.ForeignKey('applications.id', ondelete='CASCADE'),
diff --git a/backend/app/services/app_attachment_service.py b/backend/app/services/app_attachment_service.py
index 0fafc50b..0117ac34 100644
--- a/backend/app/services/app_attachment_service.py
+++ b/backend/app/services/app_attachment_service.py
@@ -57,9 +57,10 @@ def _storage_env(service_name: str, bucket: str, access_key_id: str,
}
-# kind -> (offers(template, engine) -> bool, env keys for the service's url).
-# The env keys depend on what was attached: a Redis used as a queue is still
-# only a BROKER_URL, never an AMQP_URL.
+# kind -> [(offers(template, engine) -> bool, {env key: source})]. A source is
+# the service property to reference, or '=literal' for a fixed value. The env
+# depends on what was attached: a Redis used as a queue is still only a
+# BROKER_URL, never an AMQP_URL.
def _is_redis(template, engine):
return engine.get('protocol') == 'redis'
@@ -68,6 +69,14 @@ def _is_amqp(template, engine):
return template.get('id') == 'rabbitmq'
+def _is_otel_collector(template, engine):
+ return template.get('id') == 'otel-collector'
+
+
+def _is_jaeger(template, engine):
+ return template.get('id') == 'jaeger'
+
+
def _is_prometheus(template, engine):
return template.get('id') == 'prometheus'
@@ -82,10 +91,19 @@ GRAFANA_KINDS = {'metrics': _is_prometheus, 'logs': _is_loki}
CONNECTION_KINDS = {
- 'cache': [(_is_redis, ('REDIS_URL',))],
- 'queue': [(_is_amqp, ('AMQP_URL', 'BROKER_URL')), (_is_redis, ('BROKER_URL',))],
+ 'cache': [(_is_redis, {'REDIS_URL': 'url'})],
+ 'queue': [(_is_amqp, {'AMQP_URL': 'url', 'BROKER_URL': 'url'}),
+ (_is_redis, {'BROKER_URL': 'url'})],
+ # The standard OpenTelemetry SDK variables (plan 86 §A4).
+ 'tracing': [(_is_otel_collector, {'OTEL_EXPORTER_OTLP_ENDPOINT': 'otlpEndpoint',
+ 'OTEL_EXPORTER_OTLP_PROTOCOL': '=http/protobuf'})],
+ # Collector -> trace store; read by the collector template's config.
+ 'traces': [(_is_jaeger, {'TRACES_OTLP_ENDPOINT': 'otlpGrpc'})],
}
+# Kinds only one consumer template can take.
+CONSUMER_ONLY = {'traces': 'otel-collector'}
+
# One line per kind, shown where the operator decides (plan 86 §C4).
FAILURE_MODES = {
'storage': 'Objects outlive the app: detaching keeps the bucket and its data.',
@@ -93,6 +111,8 @@ FAILURE_MODES = {
'queue': 'A job can be delivered twice; make jobs safe to run again.',
'metrics': 'Grafana shows what Prometheus kept: past its retention, history is gone.',
'logs': 'Grafana shows what Loki kept: past its retention, logs are gone.',
+ 'tracing': 'Spans are sampled and batched: a trace can be partial, and a crash can lose the last batch.',
+ 'traces': 'Jaeger keeps traces on its own disk; losing that volume loses the history.',
}
@@ -128,16 +148,16 @@ class AppAttachmentService:
if cls._provisioner(a) == 'garage']
@staticmethod
- def _connection_env_keys(service_app, kind):
- """The env keys ``service_app`` fills for ``kind``, or None when it
- does not offer that kind."""
+ def _connection_env(service_app, kind):
+ """``{env key: source}`` ``service_app`` fills for ``kind``, or None
+ when it does not offer that kind."""
from app.services.service_connection_service import _template_for
from app.services.template_service import TemplateService
template = _template_for(service_app) or {}
engine = TemplateService.engine_metadata(template) or {}
- for offers, keys in CONNECTION_KINDS.get(kind, []):
+ for offers, env in CONNECTION_KINDS.get(kind, []):
if offers(template, engine):
- return keys
+ return env
return None
@staticmethod
@@ -151,9 +171,11 @@ class AppAttachmentService:
def kinds_for(cls, app_row):
"""What ``app_row`` can attach: every app takes cache / storage / queue;
a Grafana install also takes metrics and logs data sources."""
- kinds = ['cache', 'storage', 'queue']
- if cls.is_grafana(app_row):
+ kinds = ['cache', 'storage', 'queue', 'tracing']
+ template_id = cls._template_and_engine(app_row)[0].get('id')
+ if template_id == 'grafana':
kinds += list(GRAFANA_KINDS)
+ kinds += [k for k, only in CONSUMER_ONLY.items() if only == template_id]
return kinds
@classmethod
@@ -171,7 +193,7 @@ class AppAttachmentService:
if GRAFANA_KINDS[kind](*cls._template_and_engine(a))]
from app.models.application import Application
return [a for a in Application.query_active().order_by(Application.name).all()
- if cls._connection_env_keys(a, kind)]
+ if cls._connection_env(a, kind)]
@classmethod
def attach(cls, app, service_app, kind, user_id=None):
@@ -191,21 +213,27 @@ class AppAttachmentService:
if service_app.id == app.id:
raise AttachmentError('A service cannot be attached to itself')
- keys = cls._connection_env_keys(service_app, kind)
- if not keys:
+ only = CONSUMER_ONLY.get(kind)
+ if only and cls._template_and_engine(app)[0].get('id') != only:
+ raise AttachmentError(f'Only a {only} install can attach {kind}')
+ env = cls._connection_env(service_app, kind)
+ if not env:
raise AttachmentError(f'{service_app.name} cannot be used as a {kind}')
existing = AppAttachment.query.filter_by(app_id=app.id, kind=kind).first()
if existing is not None:
if existing.service_app_id != service_app.id:
raise AttachmentError(f'This app already has a {kind} attached; detach it first')
return existing, False
- ref = {'kind': 'service', 'service': service_app.name, 'property': 'url'}
- for env_key in keys:
- _v, _c, error = EnvService.set_env_reference(app.id, env_key, ref, user_id=user_id)
+ for env_key, source in env.items():
+ if source.startswith('='):
+ _v, _c, error = EnvService.set_env_var(app.id, env_key, source[1:], user_id=user_id)
+ else:
+ ref = {'kind': 'service', 'service': service_app.name, 'property': source}
+ _v, _c, error = EnvService.set_env_reference(app.id, env_key, ref, user_id=user_id)
if error:
raise AttachmentError(f'Could not set {env_key}: {error}')
row = AppAttachment(app_id=app.id, service_app_id=service_app.id, kind=kind)
- row.details = {'env_keys': list(keys)}
+ row.details = {'env_keys': list(env)}
db.session.add(row)
db.session.commit()
return row, True
diff --git a/backend/templates/index.json b/backend/templates/index.json
index 02644091..d4f4a4cc 100644
--- a/backend/templates/index.json
+++ b/backend/templates/index.json
@@ -2,7 +2,7 @@
"name": "serverkit-official",
"schema_version": "1.0",
"generated_at": "2026-07-25T20:06:08.123735",
- "count": 120,
+ "count": 121,
"templates": [
{
"id": "actualbudget",
@@ -1013,6 +1013,18 @@
"chat"
]
},
+ {
+ "id": "otel-collector",
+ "name": "OpenTelemetry Collector",
+ "version": "0.120",
+ "description": "Receives traces, metrics and logs from apps over OTLP and forwards traces to a trace store such as Jaeger",
+ "icon": "https://serverkit.ai/imgs/template-icons/otel-collector.svg",
+ "categories": [
+ "monitoring",
+ "tracing",
+ "observability"
+ ]
+ },
{
"id": "outline",
"name": "Outline",
diff --git a/backend/templates/otel-collector.yaml b/backend/templates/otel-collector.yaml
new file mode 100644
index 00000000..8ba70386
--- /dev/null
+++ b/backend/templates/otel-collector.yaml
@@ -0,0 +1,104 @@
+id: otel-collector
+name: OpenTelemetry Collector
+version: "0.120"
+description: Receives traces, metrics and logs from apps over OTLP and forwards traces to a trace store such as Jaeger
+icon: https://serverkit.ai/imgs/template-icons/otel-collector.svg
+website: https://opentelemetry.io/docs/collector/
+documentation: https://opentelemetry.io/docs/collector/configuration/
+categories:
+ - monitoring
+ - tracing
+ - observability
+
+variables:
+ - name: GRPC_PORT
+ description: Host port for OTLP over gRPC
+ type: port
+ default: "4317"
+ hidden: true
+ - name: HTTP_PORT
+ description: Host port for OTLP over HTTP
+ type: port
+ default: "4318"
+ hidden: true
+ - name: BIND_ADDRESS
+ type: string
+ default: 127.0.0.1
+ hidden: true
+ description: Address the OTLP ports bind to. Apps reach the collector over the shared service network.
+
+# What an app gets through `fromService` (Attach → Tracing). ServerKit does
+# not instrument apps: an OpenTelemetry SDK in the app reads these.
+connection:
+ port: 4318
+ properties:
+ otlpEndpoint: "http://{host}:4318"
+ otlpGrpcEndpoint: "http://{host}:4317"
+
+files:
+ - path: /etc/otelcol-contrib/config.yaml
+ content: |
+ # Written by ServerKit at install. Traces go to TRACES_OTLP_ENDPOINT
+ # (set by attaching a trace store such as Jaeger to this collector);
+ # until one is attached they are counted by the debug exporter and
+ # dropped.
+ receivers:
+ otlp:
+ protocols:
+ grpc:
+ endpoint: 0.0.0.0:4317
+ http:
+ endpoint: 0.0.0.0:4318
+
+ processors:
+ batch: {}
+
+ exporters:
+ debug:
+ verbosity: basic
+ otlp/traces:
+ endpoint: ${env:TRACES_OTLP_ENDPOINT:-127.0.0.1:1}
+ tls:
+ insecure: true
+ retry_on_failure:
+ enabled: false
+ sending_queue:
+ enabled: false
+
+ service:
+ pipelines:
+ traces:
+ receivers: [otlp]
+ processors: [batch]
+ exporters: [otlp/traces, debug]
+ metrics:
+ receivers: [otlp]
+ processors: [batch]
+ exporters: [debug]
+ logs:
+ receivers: [otlp]
+ processors: [batch]
+ exporters: [debug]
+
+ports:
+ - port: "${GRPC_PORT}"
+ protocol: tcp
+ description: OTLP gRPC
+ - port: "${HTTP_PORT}"
+ protocol: tcp
+ description: OTLP HTTP
+
+requirements:
+ memory: 256MB
+ storage: 1GB
+
+compose:
+ services:
+ collector:
+ image: otel/opentelemetry-collector-contrib:0.120.0
+ container_name: ${APP_NAME}
+ restart: unless-stopped
+ command: ["--config=/etc/otelcol-contrib/config.yaml"]
+ ports:
+ - "${BIND_ADDRESS}:${GRPC_PORT}:4317"
+ - "${BIND_ADDRESS}:${HTTP_PORT}:4318"
diff --git a/backend/tests/test_app_attachments.py b/backend/tests/test_app_attachments.py
index 64ec02c9..1b6d2907 100644
--- a/backend/tests/test_app_attachments.py
+++ b/backend/tests/test_app_attachments.py
@@ -276,8 +276,9 @@ class FakeGrafana:
def test_grafana_gets_metrics_and_logs_kinds_and_others_do_not(installed):
graf, web = installed('graf', 'grafana'), installed('web')
- assert AppAttachmentService.kinds_for(graf) == ['cache', 'storage', 'queue', 'metrics', 'logs']
- assert AppAttachmentService.kinds_for(web) == ['cache', 'storage', 'queue']
+ assert AppAttachmentService.kinds_for(graf) == ['cache', 'storage', 'queue', 'tracing',
+ 'metrics', 'logs']
+ assert AppAttachmentService.kinds_for(web) == ['cache', 'storage', 'queue', 'tracing']
def test_metrics_attach_creates_a_data_source_and_the_dashboard(installed):
@@ -326,3 +327,26 @@ def test_the_bundled_dashboard_charts_the_metrics_the_panel_exports():
with open(DASHBOARD_PATH, encoding='utf-8') as fh:
used = set(re.findall(r'serverkit_[a-z_]+', fh.read()))
assert used and used <= exported, used - exported
+
+
+# ── tracing (plan 86 §A4) ─────────────────────────────────────────────────────
+
+def test_tracing_sets_the_standard_otel_variables(installed):
+ otel, web = installed('otel', 'otel-collector'), installed('web')
+ row, _ = AppAttachmentService.attach(web, otel, 'tracing')
+ env = EnvService.get_effective_env(web.id)
+ assert env['OTEL_EXPORTER_OTLP_ENDPOINT'] == 'http://otel:4318'
+ assert env['OTEL_EXPORTER_OTLP_PROTOCOL'] == 'http/protobuf'
+ AppAttachmentService.detach(row)
+ assert 'OTEL_EXPORTER_OTLP_PROTOCOL' not in EnvService.get_effective_env(web.id)
+
+
+def test_only_a_collector_forwards_traces_to_jaeger(installed):
+ otel, jaeger, web = (installed('otel', 'otel-collector'), installed('jaeger1', 'jaeger'),
+ installed('web'))
+ assert 'traces' in AppAttachmentService.kinds_for(otel)
+ assert 'traces' not in AppAttachmentService.kinds_for(web)
+ with pytest.raises(AttachmentError, match='Only a otel-collector'):
+ AppAttachmentService.attach(web, jaeger, 'traces')
+ AppAttachmentService.attach(otel, jaeger, 'traces')
+ assert EnvService.get_effective_env(otel.id)['TRACES_OTLP_ENDPOINT'] == 'jaeger1:4317'
diff --git a/backend/tests/test_real_tracing_docker.py b/backend/tests/test_real_tracing_docker.py
new file mode 100644
index 00000000..5bbc018f
--- /dev/null
+++ b/backend/tests/test_real_tracing_docker.py
@@ -0,0 +1,141 @@
+"""App → OpenTelemetry Collector → Jaeger, through REAL containers (plan 86 §A4).
+
+The bundled collector and Jaeger templates are rendered with the panel's rules.
+The collector gets Jaeger attached (traces), an app gets the collector attached
+(tracing); the app posts one OTLP/HTTP span to the endpoint it was given, and
+Jaeger's API then knows the app's service name.
+
+ SERVERKIT_DOCKER_BUILDS=1 pytest tests -m docker_builds
+"""
+import json
+import os
+import shutil
+import subprocess
+import time
+import urllib.request
+import uuid
+
+import pytest
+import yaml
+
+from app import db
+from app.services.app_attachment_service import AppAttachmentService
+from app.services.compose_env_service import ComposeEnvService
+from app.services.template_service import TemplateService
+from tests.factories import make_application
+
+
+def _docker_ready() -> bool:
+ if shutil.which('docker') is None:
+ return False
+ try:
+ return subprocess.run(['docker', 'info'], capture_output=True,
+ timeout=20).returncode == 0
+ except (OSError, subprocess.TimeoutExpired):
+ return False
+
+
+pytestmark = [
+ pytest.mark.docker_builds,
+ pytest.mark.skipif(os.environ.get('SERVERKIT_DOCKER_BUILDS') != '1',
+ reason='docker-builds leg; opt in with SERVERKIT_DOCKER_BUILDS=1'),
+ pytest.mark.skipif(not _docker_ready(), reason='docker daemon not reachable'),
+]
+
+SEND = r'''
+import json, os, time, urllib.request
+now = time.time_ns()
+span = {"resourceSpans": [{"resource": {"attributes": [
+ {"key": "service.name", "value": {"stringValue": os.environ["SERVICE"]}}]},
+ "scopeSpans": [{"spans": [{"traceId": "5b8efff798038103d269b633813fc60c",
+ "spanId": "eee19b7ec3c1b174", "name": "probe", "kind": 1,
+ "startTimeUnixNano": str(now - 1000000), "endTimeUnixNano": str(now)}]}]}]}
+req = urllib.request.Request(os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] + "/v1/traces",
+ data=json.dumps(span).encode(),
+ headers={"Content-Type": "application/json"})
+for _ in range(30):
+ try:
+ print("SENT", urllib.request.urlopen(req, timeout=5).status, flush=True)
+ break
+ except OSError:
+ time.sleep(2)
+'''
+
+
+def _install(tmp_path, installed, template_id, name, variables):
+ template = TemplateService.get_template(template_id)['template']
+ variables = dict(variables, APP_NAME=name)
+ for var in template.get('variables', []):
+ variables.setdefault(var['name'], TemplateService.generate_value(var))
+ root = tmp_path / name
+ root.mkdir()
+ rendered = TemplateService._render_compose_and_files(template, variables, str(root))
+ compose = yaml.safe_load(rendered['compose_content'])
+ for svc in compose['services'].values():
+ svc.pop('ports', None) # the shared network is the only path in
+ (root / 'docker-compose.yml').write_text(yaml.safe_dump(compose))
+ for f in rendered['files']:
+ with open(f['path'], 'w', newline='\n') as fh:
+ fh.write(f['content'])
+ (root / '.serverkit-template.json').write_text(json.dumps(
+ {'template_id': template_id, 'variables': variables}))
+ row = make_application(db, name=name, root_path=str(root))
+ installed[str(row.id)] = {'template_id': template_id}
+ return row
+
+
+def _files(row):
+ files = ['-f', os.path.join(row.root_path, 'docker-compose.yml')]
+ override = os.path.join(row.root_path, ComposeEnvService.OVERRIDE_NAME)
+ return files + (['-f', override] if os.path.exists(override) else [])
+
+
+def test_a_span_reaches_jaeger_through_the_collector(app, tmp_path, monkeypatch):
+ suffix = uuid.uuid4().hex[:8]
+ installed = {}
+ monkeypatch.setattr(TemplateService, 'get_config', classmethod(
+ lambda cls: {'repos': [], 'installed': installed}))
+ jaeger = _install(tmp_path, installed, 'jaeger', f'skc-jaeger-{suffix}', {})
+ otel = _install(tmp_path, installed, 'otel-collector', f'skc-otel-{suffix}', {})
+ web_root = tmp_path / f'skc-web-{suffix}'
+ web_root.mkdir()
+ (web_root / 'send.py').write_text(SEND)
+ service = f'probe-{suffix}'
+ (web_root / 'docker-compose.yml').write_text(yaml.safe_dump({'services': {'app': {
+ 'image': 'python:3.12-alpine', 'volumes': ['./send.py:/send.py:ro'],
+ 'environment': {'SERVICE': service}, 'command': ['python', '/send.py']}}}))
+ web = make_application(db, name=f'skc-web-{suffix}', root_path=str(web_root))
+
+ AppAttachmentService.attach(otel, jaeger, 'traces')
+ AppAttachmentService.attach(web, otel, 'tracing')
+ rows = [jaeger, otel, web]
+ try:
+ for row in (jaeger, otel):
+ ComposeEnvService.refresh_for_project(row.root_path)
+ subprocess.run(['docker', 'compose', '-p', row.name, *_files(row), 'up', '-d'],
+ check=True, capture_output=True, timeout=300)
+ ComposeEnvService.refresh_for_project(web.root_path)
+ sent = subprocess.run(['docker', 'compose', '-p', web.name, *_files(web), 'run', '--rm', 'app'],
+ capture_output=True, text=True, timeout=300)
+ assert 'SENT 200' in sent.stdout, sent.stdout + sent.stderr
+
+ # Jaeger's query API, from inside the network (its UI port is not published).
+ probe = ('import json,urllib.request,time\n'
+ 'for _ in range(45):\n'
+ ' try:\n'
+ f' d=json.load(urllib.request.urlopen("http://{jaeger.name}:16686/api/services"))\n'
+ f' if "{service}" in (d.get("data") or []): print("FOUND"); break\n'
+ ' except OSError: pass\n'
+ ' time.sleep(2)\n')
+ found = subprocess.run(['docker', 'run', '--rm', '--network', 'serverkit-services',
+ 'python:3.12-alpine', 'python', '-c', probe],
+ capture_output=True, text=True, timeout=300)
+ if 'FOUND' not in found.stdout:
+ logs = {name: subprocess.run(['docker', 'logs', '--tail', '40', name],
+ capture_output=True, text=True).stderr[-3000:]
+ for name in (otel.name, jaeger.name)}
+ pytest.fail(f'span never reached jaeger\n{found.stdout}{found.stderr}\n{logs}')
+ finally:
+ for row in reversed(rows):
+ subprocess.run(['docker', 'compose', '-p', row.name, *_files(row), 'down', '-v'],
+ capture_output=True, timeout=180)
diff --git a/frontend/src/components/service-detail/AttachmentsCard.jsx b/frontend/src/components/service-detail/AttachmentsCard.jsx
index 77be9bf9..8beda266 100644
--- a/frontend/src/components/service-detail/AttachmentsCard.jsx
+++ b/frontend/src/components/service-detail/AttachmentsCard.jsx
@@ -20,9 +20,11 @@ const DEFAULT_TEMPLATES = {
queue: { id: 'rabbitmq', name: 'RabbitMQ' },
metrics: { id: 'prometheus', name: 'Prometheus' },
logs: { id: 'loki', name: 'Loki' },
+ tracing: { id: 'otel-collector', name: 'OpenTelemetry Collector' },
+ traces: { id: 'jaeger', name: 'Jaeger' },
};
// Until the server says otherwise (a Grafana install also takes metrics/logs).
-const DEFAULT_KINDS = ['cache', 'storage', 'queue'];
+const DEFAULT_KINDS = ['cache', 'storage', 'queue', 'tracing'];
// "Attach → Cache / Storage / Queue" (plan 86 §C4): reuse an installed
// service or install one, write the env references, then offer a redeploy.
@@ -47,6 +49,8 @@ export default function AttachmentsCard({ app }) {
queue: t('app.attachments.failureQueue', 'A job can be delivered twice; make jobs safe to run again.'),
metrics: t('app.attachments.failureMetrics', 'Grafana shows what Prometheus kept: past its retention, history is gone.'),
logs: t('app.attachments.failureLogs', 'Grafana shows what Loki kept: past its retention, logs are gone.'),
+ tracing: t('app.attachments.failureTracing', 'Spans are sampled and batched: a trace can be partial, and a crash can lose the last batch.'),
+ traces: t('app.attachments.failureTraces', 'Jaeger keeps traces on its own disk; losing that volume loses the history.'),
}[k]);
const kindLabel = (k) => ({
@@ -55,6 +59,8 @@ export default function AttachmentsCard({ app }) {
queue: t('app.attachments.kindQueue', 'Queue'),
metrics: t('app.attachments.kindMetrics', 'Metrics'),
logs: t('app.attachments.kindLogs', 'Logs'),
+ tracing: t('app.attachments.kindTracing', 'Tracing'),
+ traces: t('app.attachments.kindTraces', 'Trace store'),
}[k]);
const load = useCallback(() => {
diff --git a/frontend/src/i18n/locales/en.json b/frontend/src/i18n/locales/en.json
index ffa5a6cd..91a93e70 100644
--- a/frontend/src/i18n/locales/en.json
+++ b/frontend/src/i18n/locales/en.json
@@ -520,6 +520,8 @@
"failureMetrics": "Grafana shows what Prometheus kept: past its retention, history is gone.",
"failureQueue": "A job can be delivered twice; make jobs safe to run again.",
"failureStorage": "Objects outlive the app: detaching keeps the bucket and its data.",
+ "failureTraces": "Jaeger keeps traces on its own disk; losing that volume loses the history.",
+ "failureTracing": "Spans are sampled and batched: a trace can be partial, and a crash can lose the last batch.",
"grafanaDataSource": "Grafana data source",
"installAndAttach": "Install {{template}} and attach",
"installFailed": "The install failed.",
@@ -530,6 +532,8 @@
"kindMetrics": "Metrics",
"kindQueue": "Queue",
"kindStorage": "Storage",
+ "kindTraces": "Trace store",
+ "kindTracing": "Tracing",
"noneInstalled": "No {{kind}} service is installed yet. ServerKit can install one now.",
"noneInstalledAskAdmin": "No {{kind}} service is installed yet. Ask an admin to install one.",
"redeployHint": "The app picks up the change on its next deploy.",
diff --git a/frontend/src/i18n/locales/es.json b/frontend/src/i18n/locales/es.json
index 82df9b59..1e109f8f 100644
--- a/frontend/src/i18n/locales/es.json
+++ b/frontend/src/i18n/locales/es.json
@@ -6737,7 +6737,11 @@
"failureMetrics": "Grafana muestra lo que Prometheus conservó: pasado su periodo de retención, el historial desaparece.",
"grafanaDataSource": "Fuente de datos de Grafana",
"kindLogs": "Registros",
- "kindMetrics": "Métricas"
+ "kindMetrics": "Métricas",
+ "failureTraces": "Jaeger guarda las trazas en su propio disco; perder ese volumen es perder el historial.",
+ "failureTracing": "Los spans se muestrean y se agrupan: una traza puede quedar incompleta y un fallo puede perder el último lote.",
+ "kindTraces": "Almacén de trazas",
+ "kindTracing": "Trazas"
},
"dbInsights": {
"cacheHitMysql": "Tasa de aciertos del buffer pool de InnoDB",