{"id":1911,"date":"2026-02-15T10:17:49","date_gmt":"2026-02-15T10:17:49","guid":{"rendered":"https:\/\/sreschool.com\/blog\/semantic-conventions\/"},"modified":"2026-02-15T10:17:49","modified_gmt":"2026-02-15T10:17:49","slug":"semantic-conventions","status":"publish","type":"post","link":"https:\/\/sreschool.com\/blog\/semantic-conventions\/","title":{"rendered":"What is Semantic conventions? Meaning, Architecture, Examples, Use Cases, and How to Measure It (2026 Guide)"},"content":{"rendered":"\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">Quick Definition (30\u201360 words)<\/h2>\n\n\n\n<p>Semantic conventions are standardized naming and attribute rules for telemetry data that enable interoperability and consistent interpretation across tools and teams. Analogy: like a shared dictionary for observability signals. Formal line: a specification defining attribute keys, value types, and expected semantics for traces, metrics, and logs.<\/p>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">What is Semantic conventions?<\/h2>\n\n\n\n<p>Semantic conventions are explicit rules and best practices that prescribe how to name, tag, and structure telemetry (traces, metrics, logs, events, and resources) so systems and people can reason about observability data consistently. They are not a specific tool, nor a runtime component; they are a contract between producers and consumers of telemetry.<\/p>\n\n\n\n<p>What it is \/ what it is NOT<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>It is a contract: naming, types, cardinality guidance.<\/li>\n<li>It is NOT implementation code or a vendor API.<\/li>\n<li>It is NOT a replacement for domain-specific labels or business context; it augments them.<\/li>\n<\/ul>\n\n\n\n<p>Key properties and constraints<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Predictable attribute keys and value types.<\/li>\n<li>Guidance on cardinality to avoid cardinality explosion.<\/li>\n<li>Compatibility focus across languages and runtimes.<\/li>\n<li>Versioning and evolution constraints to avoid breaking consumers.<\/li>\n<li>Security-aware: avoid secrets and PII in attributes.<\/li>\n<\/ul>\n\n\n\n<p>Where it fits in modern cloud\/SRE workflows<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Instrumentation libraries embed conventions so telemetry is consistent.<\/li>\n<li>CI pipelines check that new telemetry follows conventions (linting).<\/li>\n<li>Observability backends map conventions to dashboards, SLIs, and alerts.<\/li>\n<li>Incident postmortems reference conventions when adding context or changing instrumentation.<\/li>\n<\/ul>\n\n\n\n<p>Text-only diagram description (visualize)<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Service A emits trace span with standardized attributes -&gt; Telemetry collector normalizes attributes using semantic conventions -&gt; Observability backend indexes normalized data -&gt; Alerting rules and dashboards use known attribute keys to compute SLIs and SLOs -&gt; Engineers debug using consistent filters and fields.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Semantic conventions in one sentence<\/h3>\n\n\n\n<p>A set of standardized attribute names, types, and usage rules that make telemetry data consistent, searchable, and interoperable across tools and teams.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Semantic conventions vs related terms (TABLE REQUIRED)<\/h3>\n\n\n\n<figure class=\"wp-block-table\"><table>\n<thead>\n<tr>\n<th>ID<\/th>\n<th>Term<\/th>\n<th>How it differs from Semantic conventions<\/th>\n<th>Common confusion<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>T1<\/td>\n<td>Schema<\/td>\n<td>Schema defines data shape; conventions define naming and semantics<\/td>\n<td>Often used interchangeably<\/td>\n<\/tr>\n<tr>\n<td>T2<\/td>\n<td>API<\/td>\n<td>API is an interface; conventions are naming rules for data sent via APIs<\/td>\n<td>People expect vendor APIs to enforce conventions<\/td>\n<\/tr>\n<tr>\n<td>T3<\/td>\n<td>Telemetry<\/td>\n<td>Telemetry is raw data; conventions are rules applied to that data<\/td>\n<td>Telemetry producers skip naming standards<\/td>\n<\/tr>\n<tr>\n<td>T4<\/td>\n<td>Ontology<\/td>\n<td>Ontology models relationships; conventions focus on attributes<\/td>\n<td>Ontology sounds academic<\/td>\n<\/tr>\n<tr>\n<td>T5<\/td>\n<td>Tagging<\/td>\n<td>Tagging is ad-hoc labels; conventions are prescriptive tags<\/td>\n<td>Teams use inconsistent tags<\/td>\n<\/tr>\n<tr>\n<td>T6<\/td>\n<td>Data model<\/td>\n<td>Data model is storage format; conventions are semantic layer<\/td>\n<td>Model may change without updating conventions<\/td>\n<\/tr>\n<tr>\n<td>T7<\/td>\n<td>Observability spec<\/td>\n<td>Observability spec is broader; conventions are part of it<\/td>\n<td>Overlapping scope causes confusion<\/td>\n<\/tr>\n<\/tbody>\n<\/table><\/figure>\n\n\n\n<h4 class=\"wp-block-heading\">Row Details (only if any cell says \u201cSee details below\u201d)<\/h4>\n\n\n\n<ul class=\"wp-block-list\">\n<li>None<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">Why does Semantic conventions matter?<\/h2>\n\n\n\n<p>Business impact (revenue, trust, risk)<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Faster incident resolution reduces downtime, protecting revenue.<\/li>\n<li>Consistent telemetry builds customer trust through reliable SLA reporting.<\/li>\n<li>Poor conventions lead to missed regulatory signals and data leakage risk.<\/li>\n<\/ul>\n\n\n\n<p>Engineering impact (incident reduction, velocity)<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Engineers spend less time interpreting fields; they search and filter faster.<\/li>\n<li>Reusable dashboards and alerts across services accelerate new deployments.<\/li>\n<li>Reduced debugging toil increases developer velocity.<\/li>\n<\/ul>\n\n\n\n<p>SRE framing (SLIs\/SLOs\/error budgets\/toil\/on-call)<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>SLIs rely on known attribute keys to compute correctness and latency.<\/li>\n<li>SLOs are meaningful only if instrumentation is consistent across services.<\/li>\n<li>Error budgets and automated burn-rate policies depend on reliable telemetry semantics.<\/li>\n<li>Well-specified conventions reduce on-call cognitive load and toil of noisy alerts.<\/li>\n<\/ul>\n\n\n\n<p>3\u20135 realistic \u201cwhat breaks in production\u201d examples<\/p>\n\n\n\n<ol class=\"wp-block-list\">\n<li>Broken dependency mapping: A service emits inconsistent dependency attributes; topology views miss edges and the team misrouted incident ownership.<\/li>\n<li>Alert flapping: High-cardinality user_id fields cause cardinality explosion; alerts generate massive noise and paging.<\/li>\n<li>SLA reporting mismatch: Two teams use different keys for \u201crequest.duration\u201d; monthly SLA reports disagree with billing.<\/li>\n<li>Security leak: Unstructured log fields contain PII due to lack of convention forbidding secrets.<\/li>\n<li>Cost spike: Uncontrolled high-cardinality telemetry increases storage and query costs.<\/li>\n<\/ol>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">Where is Semantic conventions used? (TABLE REQUIRED)<\/h2>\n\n\n\n<figure class=\"wp-block-table\"><table>\n<thead>\n<tr>\n<th>ID<\/th>\n<th>Layer\/Area<\/th>\n<th>How Semantic conventions appears<\/th>\n<th>Typical telemetry<\/th>\n<th>Common tools<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>L1<\/td>\n<td>Edge \/ CDN<\/td>\n<td>Standardized request attributes for client info<\/td>\n<td>Traces, access logs<\/td>\n<td>CDN logs and telemetry<\/td>\n<\/tr>\n<tr>\n<td>L2<\/td>\n<td>Network<\/td>\n<td>Labels for network hops and protocols<\/td>\n<td>Network metrics and traces<\/td>\n<td>Net observability tools<\/td>\n<\/tr>\n<tr>\n<td>L3<\/td>\n<td>Service \/ API<\/td>\n<td>Span attributes for endpoints and methods<\/td>\n<td>Traces, metrics, logs<\/td>\n<td>Tracing SDKs and APMs<\/td>\n<\/tr>\n<tr>\n<td>L4<\/td>\n<td>Application<\/td>\n<td>Standard field names for business ops<\/td>\n<td>Application logs and custom metrics<\/td>\n<td>Logging libs and metrics SDKs<\/td>\n<\/tr>\n<tr>\n<td>L5<\/td>\n<td>Data layer<\/td>\n<td>Conventions for DB calls and cache keys<\/td>\n<td>DB spans and latency metrics<\/td>\n<td>SQL tracing, DB APM<\/td>\n<\/tr>\n<tr>\n<td>L6<\/td>\n<td>Kubernetes<\/td>\n<td>Pod, container, and k8s resource attributes<\/td>\n<td>Pod metrics and traces<\/td>\n<td>K8s metadata collectors<\/td>\n<\/tr>\n<tr>\n<td>L7<\/td>\n<td>Serverless \/ Functions<\/td>\n<td>Cold-start, invocation attributes standardized<\/td>\n<td>Traces, metrics, logs<\/td>\n<td>Function runtimes<\/td>\n<\/tr>\n<tr>\n<td>L8<\/td>\n<td>CI\/CD<\/td>\n<td>Build and deploy attributes standardized<\/td>\n<td>Event logs and traces<\/td>\n<td>CI systems and pipelines<\/td>\n<\/tr>\n<tr>\n<td>L9<\/td>\n<td>Observability<\/td>\n<td>Ingestion mapping and normalization rules<\/td>\n<td>All telemetry types<\/td>\n<td>Collectors and backends<\/td>\n<\/tr>\n<tr>\n<td>L10<\/td>\n<td>Security \/ Audit<\/td>\n<td>Standard fields for auth and identity events<\/td>\n<td>Audit logs and security traces<\/td>\n<td>SIEM and security tooling<\/td>\n<\/tr>\n<\/tbody>\n<\/table><\/figure>\n\n\n\n<h4 class=\"wp-block-heading\">Row Details (only if needed)<\/h4>\n\n\n\n<ul class=\"wp-block-list\">\n<li>None<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">When should you use Semantic conventions?<\/h2>\n\n\n\n<p>When it\u2019s necessary<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Cross-team metrics, SLIs, and SLOs depend on consistent attribute names.<\/li>\n<li>Multi-tenant systems where tenant and customer identifiers must be uniform.<\/li>\n<li>Regulatory or compliance reporting where fields must be auditable.<\/li>\n<\/ul>\n\n\n\n<p>When it\u2019s optional<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Single small project with few services and a single owner.<\/li>\n<li>Very early prototypes where speed matters over observability consistency.<\/li>\n<\/ul>\n\n\n\n<p>When NOT to use \/ overuse it<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Avoid adding high-cardinality identifiers as convention defaults.<\/li>\n<li>Do not store secrets, raw PII, or full payloads as standard attributes.<\/li>\n<li>Don\u2019t force conventions that conflict with essential domain-specific labels.<\/li>\n<\/ul>\n\n\n\n<p>Decision checklist<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>If multiple teams and shared dashboards -&gt; adopt conventions.<\/li>\n<li>If you require automated SLOs across services -&gt; adopt conventions.<\/li>\n<li>If single-owner experimental microservice -&gt; lightweight convention optional.<\/li>\n<li>If telemetry cardinality unknown -&gt; iterate and add cardinality guards.<\/li>\n<\/ul>\n\n\n\n<p>Maturity ladder: Beginner -&gt; Intermediate -&gt; Advanced<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Beginner: Adopt a minimal set of attributes for HTTP and DB calls.<\/li>\n<li>Intermediate: Enforce via CI checks, central registry, and collectors.<\/li>\n<li>Advanced: Automated schema enforcement, telemetry transformations, cross-service contract testing, and versioned conventions with migration tooling.<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">How does Semantic conventions work?<\/h2>\n\n\n\n<p>Explain step-by-step<\/p>\n\n\n\n<p>Components and workflow<\/p>\n\n\n\n<ol class=\"wp-block-list\">\n<li>Specification: A human-readable and machine-parseable document that lists keys, types, cardinality, and examples.<\/li>\n<li>Instrumentation libraries: SDKs and auto-instrumentation implement conventions by emitting attributes.<\/li>\n<li>Collector\/ingestion: Agents normalize incoming telemetry and map non-conforming keys.<\/li>\n<li>Backend mapping: Observability backends index and expose fields as standardized filters.<\/li>\n<li>CI\/CD validation: Linting and tests check new instrumentation against the spec.<\/li>\n<li>Monitoring &amp; alerts: Alerts and dashboards reference the standardized keys.<\/li>\n<li>Governance: Change control and versioning for convention updates.<\/li>\n<\/ol>\n\n\n\n<p>Data flow and lifecycle<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Instrumentation emits telemetry -&gt; Local SDK attaches resource attributes -&gt; Collector receives and normalizes -&gt; Backend stores events and indexes attributes -&gt; Consumers (dashboards, alerts, automation) query using convention keys -&gt; Feedback leads to spec updates and CI checks.<\/li>\n<\/ul>\n\n\n\n<p>Edge cases and failure modes<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Unknown attribute keys: Collector can tag and store them but may be unmapped.<\/li>\n<li>Cardinality spikes: High-cardinality keys cause indexing costs and query slowdowns.<\/li>\n<li>Version drift: Older SDKs use deprecated keys leading to fragmented queries.<\/li>\n<li>Security leakage: Sensitive data accidentally emitted due to developer error.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Typical architecture patterns for Semantic conventions<\/h3>\n\n\n\n<ol class=\"wp-block-list\">\n<li>Agent + Collector normalization\n   &#8211; Use when many language runtimes and responsibility for normalization centralized.<\/li>\n<li>SDK-first enforcement with CI linting\n   &#8211; Use when teams control code and want early validation.<\/li>\n<li>API Gateway normalization\n   &#8211; Use at the edge to ensure upstream services see uniform request attributes.<\/li>\n<li>Sidecar telemetry adapter\n   &#8211; Use in Kubernetes when you prefer no-code changes in application pods.<\/li>\n<li>Event-stream normalization\n   &#8211; Use for asynchronous pipelines where events need standardized metadata.<\/li>\n<\/ol>\n\n\n\n<h3 class=\"wp-block-heading\">Failure modes &amp; mitigation (TABLE REQUIRED)<\/h3>\n\n\n\n<figure class=\"wp-block-table\"><table>\n<thead>\n<tr>\n<th>ID<\/th>\n<th>Failure mode<\/th>\n<th>Symptom<\/th>\n<th>Likely cause<\/th>\n<th>Mitigation<\/th>\n<th>Observability signal<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>F1<\/td>\n<td>High cardinality<\/td>\n<td>Slow queries and cost spike<\/td>\n<td>Per-request IDs in attributes<\/td>\n<td>Strip or hash identifiers<\/td>\n<td>Query latency and storage increase<\/td>\n<\/tr>\n<tr>\n<td>F2<\/td>\n<td>Inconsistent keys<\/td>\n<td>Dashboards show gaps<\/td>\n<td>Multiple naming patterns<\/td>\n<td>Centralize and map keys<\/td>\n<td>Missing spans in topology<\/td>\n<\/tr>\n<tr>\n<td>F3<\/td>\n<td>PII leakage<\/td>\n<td>Compliance alert<\/td>\n<td>Developers logging secrets<\/td>\n<td>Block and redaction rules<\/td>\n<td>Security log alerts<\/td>\n<\/tr>\n<tr>\n<td>F4<\/td>\n<td>Version drift<\/td>\n<td>New attributes not found<\/td>\n<td>Old SDK versions<\/td>\n<td>Enforce CI checks<\/td>\n<td>Diverging attribute counts<\/td>\n<\/tr>\n<tr>\n<td>F5<\/td>\n<td>Collector overload<\/td>\n<td>Dropped telemetry<\/td>\n<td>Unbounded ingestion<\/td>\n<td>Rate limit and sampling<\/td>\n<td>Ingestion error metrics<\/td>\n<\/tr>\n<tr>\n<td>F6<\/td>\n<td>Alert noise<\/td>\n<td>Frequent paging<\/td>\n<td>Incorrect SLIs or keys<\/td>\n<td>Tune SLOs and dedupe<\/td>\n<td>High pager frequency<\/td>\n<\/tr>\n<\/tbody>\n<\/table><\/figure>\n\n\n\n<h4 class=\"wp-block-heading\">Row Details (only if needed)<\/h4>\n\n\n\n<ul class=\"wp-block-list\">\n<li>None<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">Key Concepts, Keywords &amp; Terminology for Semantic conventions<\/h2>\n\n\n\n<p>Below is an extensive glossary of terms relevant to semantic conventions. Each entry lists a short definition, why it matters, and a common pitfall.<\/p>\n\n\n\n<ol class=\"wp-block-list\">\n<li>Attribute \u2014 A key-value pair on telemetry \u2014 Enables filtering and grouping \u2014 Pitfall: high cardinality.<\/li>\n<li>Tag \u2014 Synonym for attribute in some systems \u2014 Simple metadata on spans\/metrics \u2014 Pitfall: inconsistent naming.<\/li>\n<li>Label \u2014 Another synonym used by metrics systems \u2014 Important for aggregation \u2014 Pitfall: labels differing by case.<\/li>\n<li>Resource \u2014 Identity of the emitting entity \u2014 Critical for ownership and context \u2014 Pitfall: missing service name.<\/li>\n<li>Span \u2014 Unit of work in tracing \u2014 Core for distributed traces \u2014 Pitfall: incomplete parent-child relations.<\/li>\n<li>Trace \u2014 Collection of spans for a request flow \u2014 Shows end-to-end latency \u2014 Pitfall: broken context propagation.<\/li>\n<li>Metric \u2014 Numeric time-series data \u2014 Useful for SLOs and trends \u2014 Pitfall: misinterpreted units.<\/li>\n<li>Log \u2014 Time-stamped event record \u2014 Good for debug context \u2014 Pitfall: unstructured logs with secrets.<\/li>\n<li>Semantic layer \u2014 The logical mapping of keys to meaning \u2014 Makes data interpretable \u2014 Pitfall: no formal spec.<\/li>\n<li>Cardinality \u2014 Number of unique values for a key \u2014 Drives cost and query performance \u2014 Pitfall: unguarded user_id tags.<\/li>\n<li>Sampling \u2014 Reducing telemetry by selecting subset \u2014 Manages volume \u2014 Pitfall: biased sampling.<\/li>\n<li>Normalization \u2014 Converting variations into standard form \u2014 Enables unified queries \u2014 Pitfall: lossy transformations.<\/li>\n<li>Auto-instrumentation \u2014 Runtime libraries that add telemetry automatically \u2014 Speeds adoption \u2014 Pitfall: lacks domain context.<\/li>\n<li>Manual instrumentation \u2014 Developer-added telemetry points \u2014 Precise but laborious \u2014 Pitfall: inconsistent naming.<\/li>\n<li>Ingestion pipeline \u2014 Collector and processors handling telemetry \u2014 Central control point \u2014 Pitfall: single point of failure.<\/li>\n<li>Indexing \u2014 Storing attributes for fast search \u2014 Improves queries \u2014 Pitfall: cost of indexing high-cardinality fields.<\/li>\n<li>Schema evolution \u2014 Changing spec over time \u2014 Needed for improvements \u2014 Pitfall: poor versioning plan.<\/li>\n<li>Contract testing \u2014 Tests ensuring producers match the spec \u2014 Catches regressions \u2014 Pitfall: missing tests in CI.<\/li>\n<li>Linting \u2014 Automated checks on code for conformance \u2014 Early feedback \u2014 Pitfall: false positives.<\/li>\n<li>Redaction \u2014 Removing sensitive fields from telemetry \u2014 Required for privacy \u2014 Pitfall: over-redaction losing context.<\/li>\n<li>Hashing \u2014 Pseudonymize identifiers \u2014 Balances traceability and privacy \u2014 Pitfall: weak hashing causing collisions.<\/li>\n<li>Sampling rate \u2014 The percentage of telemetry collected \u2014 Balances cost and fidelity \u2014 Pitfall: setting too low for error detection.<\/li>\n<li>SLI \u2014 Service Level Indicator \u2014 Measures user-facing behavior \u2014 Pitfall: poorly defined SLI means misleading SLOs.<\/li>\n<li>SLO \u2014 Service Level Objective \u2014 Target for SLI performance \u2014 Pitfall: unrealistic targets causing alert fatigue.<\/li>\n<li>Error budget \u2014 Allowance for SLO violations \u2014 Drives release decisions \u2014 Pitfall: miscalculated budget.<\/li>\n<li>Burn rate \u2014 Speed of error budget consumption \u2014 Used for escalation \u2014 Pitfall: improper thresholds.<\/li>\n<li>Observability lineage \u2014 Mapping from instrumentation to dashboards \u2014 Helps governance \u2014 Pitfall: stale lineage docs.<\/li>\n<li>Field mapping \u2014 Translating vendor fields to conventions \u2014 Ensures compatibility \u2014 Pitfall: mapping ambiguity.<\/li>\n<li>Telemetry contract \u2014 A machine-readable spec of emitted fields \u2014 Enables automated checks \u2014 Pitfall: missing ownership.<\/li>\n<li>Collector processor \u2014 Component that transforms telemetry \u2014 Enforces conventions at ingest \u2014 Pitfall: misconfiguration.<\/li>\n<li>Topology \u2014 Graph of service dependencies \u2014 Key for incident routing \u2014 Pitfall: incomplete or noisy edges.<\/li>\n<li>Context propagation \u2014 Passing trace IDs across boundaries \u2014 Required for distributed tracing \u2014 Pitfall: dropped headers.<\/li>\n<li>Sampling bias \u2014 When sampling skews representativeness \u2014 Misleads SLI calculations \u2014 Pitfall: sampling per-route inconsistently.<\/li>\n<li>Observability pipeline cost \u2014 Total cost of storing and querying telemetry \u2014 Needs governance \u2014 Pitfall: uncontrolled retention.<\/li>\n<li>Metric aggregation keys \u2014 Labels used to aggregate metrics \u2014 Defines SLI granularity \u2014 Pitfall: too-fine aggregation.<\/li>\n<li>Event enrichment \u2014 Adding metadata to events in pipeline \u2014 Adds value \u2014 Pitfall: late enrichment losing raw context.<\/li>\n<li>Telemetry contract registry \u2014 Central store of specs \u2014 Source of truth \u2014 Pitfall: not synced with code.<\/li>\n<li>Auto-remediation \u2014 Automation driven by telemetry semantics \u2014 Reduces toil \u2014 Pitfall: unsafe automations.<\/li>\n<li>Privacy-safe telemetry \u2014 Conventions to avoid PII \u2014 Compliance support \u2014 Pitfall: accidental language in messages.<\/li>\n<li>Observability maturity \u2014 Level of tooling\/process sophistication \u2014 Guides roadmap \u2014 Pitfall: skipping foundational steps.<\/li>\n<li>Vendor-neutral conventions \u2014 Standards that work across backends \u2014 Prevents lock-in \u2014 Pitfall: tooling specific extensions.<\/li>\n<li>Attribute typing \u2014 Declaring value types for attributes \u2014 Prevents misinterpretation \u2014 Pitfall: inconsistent types across services.<\/li>\n<li>Metric units \u2014 Standard units like ms, bytes \u2014 Critical for correct aggregation \u2014 Pitfall: unit mismatch in dashboards.<\/li>\n<li>Sampling decision \u2014 Determined by SDK or collector \u2014 Affects trace completeness \u2014 Pitfall: inconsistent sampling across services.<\/li>\n<\/ol>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">How to Measure Semantic conventions (Metrics, SLIs, SLOs) (TABLE REQUIRED)<\/h2>\n\n\n\n<figure class=\"wp-block-table\"><table>\n<thead>\n<tr>\n<th>ID<\/th>\n<th>Metric\/SLI<\/th>\n<th>What it tells you<\/th>\n<th>How to measure<\/th>\n<th>Starting target<\/th>\n<th>Gotchas<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>M1<\/td>\n<td>Attribute coverage<\/td>\n<td>Percent services using key X<\/td>\n<td>Count services emitting key \/ total<\/td>\n<td>90% initially<\/td>\n<td>Some services offline<\/td>\n<\/tr>\n<tr>\n<td>M2<\/td>\n<td>Attribute consistency<\/td>\n<td>Ratio of services using same type<\/td>\n<td>Check type against spec<\/td>\n<td>95%<\/td>\n<td>Type coercion in SDKs<\/td>\n<\/tr>\n<tr>\n<td>M3<\/td>\n<td>Cardinality per attribute<\/td>\n<td>Unique values per time window<\/td>\n<td>Count unique values<\/td>\n<td>Keep low per attribute<\/td>\n<td>Burst during jobs<\/td>\n<\/tr>\n<tr>\n<td>M4<\/td>\n<td>Missing fields rate<\/td>\n<td>Fraction of telemetry missing required keys<\/td>\n<td>Missing \/ total events<\/td>\n<td>&lt;1%<\/td>\n<td>Instrumentation deploys lag<\/td>\n<\/tr>\n<tr>\n<td>M5<\/td>\n<td>Telemetry ingestion error rate<\/td>\n<td>Failures during ingestion<\/td>\n<td>Error count \/ total<\/td>\n<td>&lt;0.1%<\/td>\n<td>Collector misconfig<\/td>\n<\/tr>\n<tr>\n<td>M6<\/td>\n<td>SLI validity coverage<\/td>\n<td>Percent SLIs backed by convention keys<\/td>\n<td>SLIs with standard keys \/ total<\/td>\n<td>100%<\/td>\n<td>Legacy SLIs<\/td>\n<\/tr>\n<tr>\n<td>M7<\/td>\n<td>Alert noise rate<\/td>\n<td>Pager events per incident<\/td>\n<td>Pager count \/ time<\/td>\n<td>Target depends<\/td>\n<td>Bad SLO definitions<\/td>\n<\/tr>\n<tr>\n<td>M8<\/td>\n<td>Storage cost per metric<\/td>\n<td>Billing per attribute group<\/td>\n<td>Cost allocation metrics<\/td>\n<td>Reduce over time<\/td>\n<td>Hidden backend costs<\/td>\n<\/tr>\n<\/tbody>\n<\/table><\/figure>\n\n\n\n<h4 class=\"wp-block-heading\">Row Details (only if needed)<\/h4>\n\n\n\n<ul class=\"wp-block-list\">\n<li>None<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Best tools to measure Semantic conventions<\/h3>\n\n\n\n<h4 class=\"wp-block-heading\">Tool \u2014 OpenTelemetry<\/h4>\n\n\n\n<ul class=\"wp-block-list\">\n<li>What it measures for Semantic conventions: instrumentation coverage and standardized attributes.<\/li>\n<li>Best-fit environment: heterogeneous language environments and cloud-native stacks.<\/li>\n<li>Setup outline:<\/li>\n<li>Add SDK and auto-instrumentation to services.<\/li>\n<li>Configure resource attributes per service.<\/li>\n<li>Enable attribute and span processors.<\/li>\n<li>Connect to a collector for normalization.<\/li>\n<li>Run CI contract checks.<\/li>\n<li>Strengths:<\/li>\n<li>Vendor-neutral and wide language support.<\/li>\n<li>Extensible processors for normalization.<\/li>\n<li>Limitations:<\/li>\n<li>Does not provide backend storage; requires collector\/backend.<\/li>\n<li>Spec evolution needs governance.<\/li>\n<\/ul>\n\n\n\n<h4 class=\"wp-block-heading\">Tool \u2014 Prometheus<\/h4>\n\n\n\n<ul class=\"wp-block-list\">\n<li>What it measures for Semantic conventions: metric label consistency and cardinality.<\/li>\n<li>Best-fit environment: metrics-heavy, Kubernetes-native systems.<\/li>\n<li>Setup outline:<\/li>\n<li>Export metrics with consistent label names.<\/li>\n<li>Use recording rules for SLOs.<\/li>\n<li>Run metric linting in CI.<\/li>\n<li>Monitor label cardinalities.<\/li>\n<li>Strengths:<\/li>\n<li>Efficient time-series store for metrics.<\/li>\n<li>Strong ecosystem for alerts.<\/li>\n<li>Limitations:<\/li>\n<li>Not for traces; labels can cause high cardinality costs.<\/li>\n<li>Single-node metrics scraping patterns can miss ephemeral workloads.<\/li>\n<\/ul>\n\n\n\n<h4 class=\"wp-block-heading\">Tool \u2014 Grafana<\/h4>\n\n\n\n<ul class=\"wp-block-list\">\n<li>What it measures for Semantic conventions: dashboard panels consuming convention keys.<\/li>\n<li>Best-fit environment: multi-data-source dashboards for ops and executives.<\/li>\n<li>Setup outline:<\/li>\n<li>Create templated panels using standard keys.<\/li>\n<li>Share dashboards and version them.<\/li>\n<li>Use provisioning to enforce dashboard standards.<\/li>\n<li>Strengths:<\/li>\n<li>Flexible visualization and templating.<\/li>\n<li>Good for cross-team dashboards.<\/li>\n<li>Limitations:<\/li>\n<li>Dashboards can diverge without governance.<\/li>\n<li>Query languages vary across backends.<\/li>\n<\/ul>\n\n\n\n<h4 class=\"wp-block-heading\">Tool \u2014 Jaeger \/ Tempo<\/h4>\n\n\n\n<ul class=\"wp-block-list\">\n<li>What it measures for Semantic conventions: trace completeness and span attribute consistency.<\/li>\n<li>Best-fit environment: distributed tracing across microservices.<\/li>\n<li>Setup outline:<\/li>\n<li>Collect traces via OpenTelemetry.<\/li>\n<li>Ensure context propagation across services.<\/li>\n<li>Instrument key spans with convention attributes.<\/li>\n<li>Strengths:<\/li>\n<li>Good trace visualizations and dependency graphs.<\/li>\n<li>Low overhead tracing options.<\/li>\n<li>Limitations:<\/li>\n<li>Storage costs and sampling configuration needed.<\/li>\n<li>Deep analysis needs complementary logs\/metrics.<\/li>\n<\/ul>\n\n\n\n<h4 class=\"wp-block-heading\">Tool \u2014 SIEM \/ Security tools<\/h4>\n\n\n\n<ul class=\"wp-block-list\">\n<li>What it measures for Semantic conventions: audit and security attribute compliance.<\/li>\n<li>Best-fit environment: teams requiring security and compliance evidence.<\/li>\n<li>Setup outline:<\/li>\n<li>Map audit fields to convention keys.<\/li>\n<li>Perform ingestion-time redaction.<\/li>\n<li>Create alerts for PII leakage.<\/li>\n<li>Strengths:<\/li>\n<li>Centralized security investigations.<\/li>\n<li>Correlation of telemetry with security events.<\/li>\n<li>Limitations:<\/li>\n<li>High volume can be costly.<\/li>\n<li>Requires careful privacy controls.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Recommended dashboards &amp; alerts for Semantic conventions<\/h3>\n\n\n\n<p>Executive dashboard<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Panels: Top-level telemetry coverage %, SLO compliance summary, Cost trend of telemetry, High-impact missing keys.<\/li>\n<li>Why: High-level health, cost, and compliance visibility.<\/li>\n<\/ul>\n\n\n\n<p>On-call dashboard<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Panels: Current SLO burn rate, Top missing or inconsistent attributes, Recent topology changes, Active alerts grouped by service.<\/li>\n<li>Why: Fast triage and ownership.<\/li>\n<\/ul>\n\n\n\n<p>Debug dashboard<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Panels: Recent traces without required keys, Attribute cardinality heatmaps, Raw logs with context, Per-service attribute coverage.<\/li>\n<li>Why: Deep debugging and instrumentation verification.<\/li>\n<\/ul>\n\n\n\n<p>Alerting guidance<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>What should page vs ticket:<\/li>\n<li>Page: SLO burn-rate escalation, collector down, ingestion failures causing data loss.<\/li>\n<li>Ticket: Missing non-critical attributes, minor drops in attribute coverage.<\/li>\n<li>Burn-rate guidance:<\/li>\n<li>Page at sustained burn rate &gt;4x for critical SLOs.<\/li>\n<li>Use progressive thresholds for paging vs ticketing.<\/li>\n<li>Noise reduction tactics:<\/li>\n<li>Dedupe by fingerprinting root causes.<\/li>\n<li>Group alerts by service and top-level cause.<\/li>\n<li>Suppress during deploy windows if expected.<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">Implementation Guide (Step-by-step)<\/h2>\n\n\n\n<p>1) Prerequisites\n&#8211; Inventory services and languages.\n&#8211; Define minimal required attributes and cardinality limits.\n&#8211; Choose telemetry transport and backend.\n&#8211; Assign convention owners and reviewers.<\/p>\n\n\n\n<p>2) Instrumentation plan\n&#8211; Identify critical paths and business transactions.\n&#8211; Choose auto vs manual instrumentation per component.\n&#8211; Define attribute naming for each service and domain.<\/p>\n\n\n\n<p>3) Data collection\n&#8211; Deploy OpenTelemetry SDKs and collectors.\n&#8211; Configure processors for normalization, redaction, and sampling.\n&#8211; Validate ingestion and indexing.<\/p>\n\n\n\n<p>4) SLO design\n&#8211; Map SLIs to standardized attributes.\n&#8211; Define SLO windows and error budgets.\n&#8211; Use aggregate keys compatible with conventions.<\/p>\n\n\n\n<p>5) Dashboards\n&#8211; Build templates referencing convention keys.\n&#8211; Use templated variables for service selection.\n&#8211; Create baseline panels for coverage and cardinality.<\/p>\n\n\n\n<p>6) Alerts &amp; routing\n&#8211; Create alert rules referencing convention-backed SLIs.\n&#8211; Route by ownership using resource attributes.\n&#8211; Implement dedupe and grouping.<\/p>\n\n\n\n<p>7) Runbooks &amp; automation\n&#8211; Provide runbooks that reference specific attribute keys.\n&#8211; Script common remediations based on telemetry semantics.\n&#8211; Automate rollbacks and canaries tied to SLO breaches.<\/p>\n\n\n\n<p>8) Validation (load\/chaos\/game days)\n&#8211; Run load tests to validate metric aggregation and cardinality.\n&#8211; Execute chaos experiments to verify topology and tracing.\n&#8211; Do game days simulating missing keys and collector failures.<\/p>\n\n\n\n<p>9) Continuous improvement\n&#8211; Collect feedback and measure attribute coverage trends.\n&#8211; Iterate spec and enforce via CI.\n&#8211; Rotate sensitive fields and refine cardinality rules.<\/p>\n\n\n\n<p>Checklists<\/p>\n\n\n\n<p>Pre-production checklist<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Inventory done and owners assigned.<\/li>\n<li>SDKs and auto-instrumentation working locally.<\/li>\n<li>Minimal spec approved and published.<\/li>\n<li>CI linting added for new instrumentation.<\/li>\n<\/ul>\n\n\n\n<p>Production readiness checklist<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Collector scaling tested.<\/li>\n<li>Dashboards and alerts validated end-to-end.<\/li>\n<li>On-call runbooks include attribute-driven play.<\/li>\n<li>Redaction rules in place for PII.<\/li>\n<\/ul>\n\n\n\n<p>Incident checklist specific to Semantic conventions<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Verify collector health and queue depths.<\/li>\n<li>Check recent deploys for instrumentation changes.<\/li>\n<li>Inspect SLI sources and attribute keys.<\/li>\n<li>Roll back instrumentation changes if causing noise.<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">Use Cases of Semantic conventions<\/h2>\n\n\n\n<p>Provide common real-world use cases.<\/p>\n\n\n\n<ol class=\"wp-block-list\">\n<li>\n<p>Cross-service SLOs\n&#8211; Context: Multi-service transaction spanning services.\n&#8211; Problem: Aggregating latency across services requires common keys.\n&#8211; Why helps: Standardized request id and endpoint keys enable full-chain SLIs.\n&#8211; What to measure: End-to-end latency, per-service latency, error rates.\n&#8211; Typical tools: Tracing SDKs, collector, metrics store.<\/p>\n<\/li>\n<li>\n<p>Multi-tenant billing reconciliation\n&#8211; Context: Usage attribution per tenant.\n&#8211; Problem: Inconsistent tenant_id naming breaks billing reports.\n&#8211; Why helps: Single tenant attribute ensures correct cost allocation.\n&#8211; What to measure: Requests per tenant, compute usage, errors.\n&#8211; Typical tools: Metrics store, event pipelines.<\/p>\n<\/li>\n<li>\n<p>Security auditing\n&#8211; Context: Authentication and access logs for compliance.\n&#8211; Problem: Missing standardized user and auth fields hamper audits.\n&#8211; Why helps: Standard audit attributes make queries automated and auditable.\n&#8211; What to measure: Auth success\/failure counts, privilege changes.\n&#8211; Typical tools: SIEM, audit log pipeline.<\/p>\n<\/li>\n<li>\n<p>Dependency mapping\n&#8211; Context: Visualize service-to-service calls.\n&#8211; Problem: Inconsistent peer.service or db.instance attributes hide edges.\n&#8211; Why helps: Conventions for peer attributes produce accurate topology.\n&#8211; What to measure: Call counts, latencies, error rates per dependency.\n&#8211; Typical tools: Tracing backend, topology visualizer.<\/p>\n<\/li>\n<li>\n<p>Cost control\n&#8211; Context: Observability cost management.\n&#8211; Problem: High-cardinality metrics balloon storage costs.\n&#8211; Why helps: Conventions prescribe cardinality limits and hashing strategies.\n&#8211; What to measure: Cardinality per label, storage per dataset.\n&#8211; Typical tools: Cost allocation tools, metrics store.<\/p>\n<\/li>\n<li>\n<p>Automated runbook triggers\n&#8211; Context: Automatic remediation based on telemetry.\n&#8211; Problem: Alerts lack structured fields to automate recovery.\n&#8211; Why helps: Standardized fields allow reliable automation inputs.\n&#8211; What to measure: Success rate of automated remediations.\n&#8211; Typical tools: Automation platform, alerting system.<\/p>\n<\/li>\n<li>\n<p>On-call handoffs\n&#8211; Context: Clear ownership during incidents.\n&#8211; Problem: No standard service or team attributes; routing delayed.\n&#8211; Why helps: Resource attributes include team\/contact for quick routing.\n&#8211; What to measure: Mean time to owner identification.\n&#8211; Typical tools: Incident management tools.<\/p>\n<\/li>\n<li>\n<p>Feature rollout monitoring\n&#8211; Context: Canary releases and experiments.\n&#8211; Problem: Can&#8217;t filter by feature flag consistently.\n&#8211; Why helps: Standard feature flag attribute allows targeted SLOs.\n&#8211; What to measure: Error rates by feature flag, performance deltas.\n&#8211; Typical tools: Tracing, metrics, experimentation platform.<\/p>\n<\/li>\n<\/ol>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">Scenario Examples (Realistic, End-to-End)<\/h2>\n\n\n\n<h3 class=\"wp-block-heading\">Scenario #1 \u2014 Kubernetes microservice debugging<\/h3>\n\n\n\n<p><strong>Context:<\/strong> A Kubernetes cluster with multiple microservices written in different languages.\n<strong>Goal:<\/strong> Consistent tracing and metric labels across pods for faster root cause.\n<strong>Why Semantic conventions matters here:<\/strong> Service, pod, and container attributes allow portable dashboards and ownership tagging.\n<strong>Architecture \/ workflow:<\/strong> Apps instrumented with OpenTelemetry SDKs -&gt; Collector sidecar normalizes attributes -&gt; Backend shows topology and SLOs.\n<strong>Step-by-step implementation:<\/strong><\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Agree on service and deployment attribute keys.<\/li>\n<li>Add OpenTelemetry SDK or sidecar to pods.<\/li>\n<li>Configure collector to add k8s.resource attributes.<\/li>\n<li>Add CI linting to ensure resource attributes present.<\/li>\n<li>Build a debug dashboard for missing attributes.\n<strong>What to measure:<\/strong> Span coverage, attribute coverage per pod, cardinality of pod labels.\n<strong>Tools to use and why:<\/strong> OpenTelemetry, Kubernetes metadata collectors, Grafana.\n<strong>Common pitfalls:<\/strong> Using pod name as a high-cardinality label.\n<strong>Validation:<\/strong> Run a job that emits traces and validate dashboards show the pod and service attributes.\n<strong>Outcome:<\/strong> Faster MTTD due to consistent metadata.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Scenario #2 \u2014 Serverless function SLOs (managed PaaS)<\/h3>\n\n\n\n<p><strong>Context:<\/strong> Serverless functions across accounts and regions with managed logging\/metrics.\n<strong>Goal:<\/strong> Compute SLOs across functions with consistent cold-start and request attributes.\n<strong>Why Semantic conventions matters here:<\/strong> Functions must emit the same invocation and error attributes to align SLOs.\n<strong>Architecture \/ workflow:<\/strong> Function runtime emits metrics with convention keys -&gt; Central collector normalizes -&gt; SLOs computed in metrics backend.\n<strong>Step-by-step implementation:<\/strong><\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Define function invocation attributes: function.name, cold_start, memory_alloc.<\/li>\n<li>Add wrapper layer or middleware to inject standard attributes.<\/li>\n<li>Ensure redaction for input payloads.<\/li>\n<li>Aggregate metrics by function.name for SLOs.\n<strong>What to measure:<\/strong> Invocation latency, cold start rate, errors.\n<strong>Tools to use and why:<\/strong> Function monitoring, metrics store, collector.\n<strong>Common pitfalls:<\/strong> Provider-managed logs adding non-standard keys.\n<strong>Validation:<\/strong> Simulate bursts to observe cold-start rates and SLOs.\n<strong>Outcome:<\/strong> Unified SLO reporting across serverless fleet.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Scenario #3 \u2014 Incident response and postmortem<\/h3>\n\n\n\n<p><strong>Context:<\/strong> Production outage where dependency mapping failed.\n<strong>Goal:<\/strong> Improve instrumentation so future incidents are trackable and owned.\n<strong>Why Semantic conventions matters here:<\/strong> Postmortem identifies missing peer.service attributes as root cause.\n<strong>Architecture \/ workflow:<\/strong> During incident, on-call uses traces but topology is missing. Postmortem updates conventions and CI checks.\n<strong>Step-by-step implementation:<\/strong><\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Reconstruct incident using available telemetry.<\/li>\n<li>Identify missing attributes and add to spec.<\/li>\n<li>Implement SDK changes and CI contract tests.<\/li>\n<li>Run a game day to validate.\n<strong>What to measure:<\/strong> Time to map service dependency before vs after.\n<strong>Tools to use and why:<\/strong> Tracing backend, CI test suites.\n<strong>Common pitfalls:<\/strong> Not enforcing changes in CI, leading to drift.\n<strong>Validation:<\/strong> Conduct postmortem follow-up verification.\n<strong>Outcome:<\/strong> Reduced time-to-owner and clearer topology in next incident.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Scenario #4 \u2014 Cost vs performance trade-off<\/h3>\n\n\n\n<p><strong>Context:<\/strong> Storage costs rising due to high-cardinality logs and metrics.\n<strong>Goal:<\/strong> Reduce observability cost while retaining actionable detail.\n<strong>Why Semantic conventions matters here:<\/strong> Conventions define which keys are high-cardinality and how to hash or sample them.\n<strong>Architecture \/ workflow:<\/strong> Inventory attributes -&gt; Classify cardinality -&gt; Apply hashing and sampling rules in collector -&gt; Recompute SLOs to ensure fidelity.\n<strong>Step-by-step implementation:<\/strong><\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Measure cardinality per attribute.<\/li>\n<li>Decide hashing strategy for identifiers.<\/li>\n<li>Implement sampling on verbose logs and traces.<\/li>\n<li>Validate SLI accuracy under sampling.\n<strong>What to measure:<\/strong> Storage cost, SLI degradation, cardinality metrics.\n<strong>Tools to use and why:<\/strong> Metrics store, cost allocation, collector processors.\n<strong>Common pitfalls:<\/strong> Over-aggressive sampling hiding rare errors.\n<strong>Validation:<\/strong> Run price-performance scenarios and rollback if SLOs fail.\n<strong>Outcome:<\/strong> Reduced costs with acceptable SLI fidelity.<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">Common Mistakes, Anti-patterns, and Troubleshooting<\/h2>\n\n\n\n<p>List of mistakes with symptom -&gt; root cause -&gt; fix.<\/p>\n\n\n\n<ol class=\"wp-block-list\">\n<li>Symptom: Missing traces in topology -&gt; Root cause: Context propagation broken -&gt; Fix: Ensure trace headers pass through proxies.<\/li>\n<li>Symptom: Dashboards show empty metrics -&gt; Root cause: Wrong attribute name in query -&gt; Fix: Align queries to conventions.<\/li>\n<li>Symptom: Alert storms -&gt; Root cause: High-cardinality label on SLI -&gt; Fix: Remove label from SLI or aggregate.<\/li>\n<li>Symptom: Storage spike -&gt; Root cause: Unbounded logging of request bodies -&gt; Fix: Redact payloads and limit retention.<\/li>\n<li>Symptom: Compliance flag -&gt; Root cause: PII emitted in attributes -&gt; Fix: Enforce redaction and privacy checks.<\/li>\n<li>Symptom: CI lint failures -&gt; Root cause: New instrumentation not following the spec -&gt; Fix: Update code or spec and review.<\/li>\n<li>Symptom: False negatives in SLO -&gt; Root cause: Sampling removed error traces -&gt; Fix: Adjust sampling for error paths.<\/li>\n<li>Symptom: Multiple dashboards with different names -&gt; Root cause: No dashboard templating -&gt; Fix: Create shared templates.<\/li>\n<li>Symptom: High query latency -&gt; Root cause: Too many indexed high-cardinality fields -&gt; Fix: Reduce indexed attributes.<\/li>\n<li>Symptom: People use ad-hoc tags -&gt; Root cause: No registry or governance -&gt; Fix: Publish registry and require approvals.<\/li>\n<li>Symptom: Broken ownership routing -&gt; Root cause: Missing team attribute -&gt; Fix: Add standardized team\/resource attributes.<\/li>\n<li>Symptom: Inconsistent units -&gt; Root cause: Metrics emitted in ms and s -&gt; Fix: Standardize units in spec.<\/li>\n<li>Symptom: Unreproducible tests -&gt; Root cause: Instrumentation varies between environments -&gt; Fix: Use test fixtures enforcing conventions.<\/li>\n<li>Symptom: Collector crashes -&gt; Root cause: Unbounded attribute sizes -&gt; Fix: Enforce max attribute size and sampling.<\/li>\n<li>Symptom: Alerts during deploys -&gt; Root cause: Deployment-induced metric changes -&gt; Fix: Use suppression windows and canary SLOs.<\/li>\n<li>Symptom: Missing dependency edges -&gt; Root cause: Auto-instrumentation filtered certain frameworks -&gt; Fix: Add explicit span instrumentation.<\/li>\n<li>Symptom: Long on-call escalations -&gt; Root cause: Lack of standardized runbooks referencing attributes -&gt; Fix: Build runbooks tied to keys.<\/li>\n<li>Symptom: Incorrect billing -&gt; Root cause: Tenant_id inconsistently named -&gt; Fix: Centralize tenant attribute and migrate data.<\/li>\n<li>Symptom: Queries failing in dashboards -&gt; Root cause: Attribute type changed -&gt; Fix: Migrate or cast types and update spec.<\/li>\n<li>Symptom: Slow search responses -&gt; Root cause: Non-indexed but frequently queried fields -&gt; Fix: Index required fields or change queries.<\/li>\n<li>Symptom: Observability blind spots -&gt; Root cause: Sampling policy excludes important flows -&gt; Fix: Create guarantees for critical paths.<\/li>\n<li>Symptom: Conflicting conventions between vendors -&gt; Root cause: Vendor-specific extensions not mapped -&gt; Fix: Map vendor fields to vendor-neutral keys.<\/li>\n<li>Symptom: Runaway cost from trace retention -&gt; Root cause: No retention policy per data class -&gt; Fix: Implement tiered retention and aggregation.<\/li>\n<li>Symptom: Alerts lack context -&gt; Root cause: Missing correlation IDs in logs -&gt; Fix: Add request IDs to logs and spans.<\/li>\n<li>Symptom: Debugging slow due to lack of context -&gt; Root cause: Incomplete enrichment pipeline -&gt; Fix: Enrich events earlier in pipeline.<\/li>\n<\/ol>\n\n\n\n<p>Observability-specific pitfalls included above: cardinality, sampling bias, missing context propagation, inconsistent units, and redaction mistakes.<\/p>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">Best Practices &amp; Operating Model<\/h2>\n\n\n\n<p>Ownership and on-call<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Assign a conventions owner and a data steward per team.<\/li>\n<li>Include observability on-call rotation for collector and indexer health.<\/li>\n<li>Define escalation paths tied to resource attributes.<\/li>\n<\/ul>\n\n\n\n<p>Runbooks vs playbooks<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Runbooks: step-by-step remediation referencing convention keys.<\/li>\n<li>Playbooks: higher-level decision flows and owner mappings.<\/li>\n<\/ul>\n\n\n\n<p>Safe deployments (canary\/rollback)<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Use canaries to validate new instrumentation.<\/li>\n<li>Automate rollback triggers based on SLO burn rates.<\/li>\n<\/ul>\n\n\n\n<p>Toil reduction and automation<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Automate telemetry contract checks in CI.<\/li>\n<li>Auto-remediate common collector issues with safe guards.<\/li>\n<\/ul>\n\n\n\n<p>Security basics<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Prohibit secrets in attributes; enforce redaction.<\/li>\n<li>Use hashing and tokenization for identifiers.<\/li>\n<li>Audit telemetry for PII regularly.<\/li>\n<\/ul>\n\n\n\n<p>Weekly\/monthly routines<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Weekly: Review attribute cardinality and top new keys.<\/li>\n<li>Monthly: Audit coverage for critical SLOs and enforcement in CI.<\/li>\n<li>Quarterly: Review spec and deprecate old keys.<\/li>\n<\/ul>\n\n\n\n<p>What to review in postmortems related to Semantic conventions<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Was required telemetry present during incident?<\/li>\n<li>Any convention changes required?<\/li>\n<li>Did any attribute cause noise or cost spikes?<\/li>\n<li>Follow-up tasks for CI checks and runbook updates.<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">Tooling &amp; Integration Map for Semantic conventions (TABLE REQUIRED)<\/h2>\n\n\n\n<figure class=\"wp-block-table\"><table>\n<thead>\n<tr>\n<th>ID<\/th>\n<th>Category<\/th>\n<th>What it does<\/th>\n<th>Key integrations<\/th>\n<th>Notes<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>I1<\/td>\n<td>Instrumentation SDK<\/td>\n<td>Emits telemetry with conventions<\/td>\n<td>Languages, frameworks<\/td>\n<td>Core for producer-side enforcement<\/td>\n<\/tr>\n<tr>\n<td>I2<\/td>\n<td>Collector<\/td>\n<td>Normalizes and processes telemetry<\/td>\n<td>Backends and processors<\/td>\n<td>Can enforce redaction and hashing<\/td>\n<\/tr>\n<tr>\n<td>I3<\/td>\n<td>Tracing backend<\/td>\n<td>Stores and visualizes traces<\/td>\n<td>Collector and SDKs<\/td>\n<td>Useful for dependency graphs<\/td>\n<\/tr>\n<tr>\n<td>I4<\/td>\n<td>Metrics store<\/td>\n<td>Time-series storage for SLIs<\/td>\n<td>Scrapers and exporters<\/td>\n<td>Good for SLOs and alerts<\/td>\n<\/tr>\n<tr>\n<td>I5<\/td>\n<td>Logging platform<\/td>\n<td>Stores structured logs<\/td>\n<td>Log shippers and processors<\/td>\n<td>Indexing decisions critical<\/td>\n<\/tr>\n<tr>\n<td>I6<\/td>\n<td>CI linters<\/td>\n<td>Validates telemetry contracts<\/td>\n<td>VCS and build pipelines<\/td>\n<td>Early feedback loop<\/td>\n<\/tr>\n<tr>\n<td>I7<\/td>\n<td>Dashboarding<\/td>\n<td>Visualizes convention-backed panels<\/td>\n<td>Backends and templates<\/td>\n<td>Collaboration surface<\/td>\n<\/tr>\n<tr>\n<td>I8<\/td>\n<td>Alerting system<\/td>\n<td>Routes alerts per attributes<\/td>\n<td>Incident management<\/td>\n<td>Needs integration with resource tags<\/td>\n<\/tr>\n<tr>\n<td>I9<\/td>\n<td>Security SIEM<\/td>\n<td>Audit and compliance analysis<\/td>\n<td>Log and event sources<\/td>\n<td>Enforce PII policies<\/td>\n<\/tr>\n<tr>\n<td>I10<\/td>\n<td>Cost allocation<\/td>\n<td>Allocates telemetry cost to owners<\/td>\n<td>Billing and telemetry data<\/td>\n<td>Guides cardinality trade-offs<\/td>\n<\/tr>\n<\/tbody>\n<\/table><\/figure>\n\n\n\n<h4 class=\"wp-block-heading\">Row Details (only if needed)<\/h4>\n\n\n\n<ul class=\"wp-block-list\">\n<li>None<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">Frequently Asked Questions (FAQs)<\/h2>\n\n\n\n<h3 class=\"wp-block-heading\">What are semantic conventions in observability?<\/h3>\n\n\n\n<p>Semantic conventions are standardized rules for naming and typing telemetry attributes to ensure consistent meaning across systems and teams.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Are semantic conventions mandatory?<\/h3>\n\n\n\n<p>Varies \/ depends. They are essential in multi-team and production environments but optional for small prototypes.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Do conventions increase telemetry cost?<\/h3>\n\n\n\n<p>They can reduce cost if they enforce low cardinality; misused, they can increase cost.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">How do I handle PII in telemetry?<\/h3>\n\n\n\n<p>Redact or hash identifiers and enforce telemetry privacy rules in the collector.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">How to enforce conventions automatically?<\/h3>\n\n\n\n<p>Use CI linting, SDKs that follow the spec, and collector processors that normalize or reject non-conforming attributes.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Can conventions be vendor-specific?<\/h3>\n\n\n\n<p>Yes, but vendor-neutral conventions prevent lock-in. Mapping layers can translate vendor fields.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">How often should conventions change?<\/h3>\n\n\n\n<p>Spec updates should be infrequent and versioned; follow quarterly or as-needed changes with migration plans.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">How do conventions affect SLOs?<\/h3>\n\n\n\n<p>SLIs rely on consistent keys; conventions make SLO computation correct and repeatable.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">What is the role of OpenTelemetry?<\/h3>\n\n\n\n<p>OpenTelemetry provides SDKs and an ecosystem that commonly implements conventions; it is vendor-neutral.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">How to prevent cardinality explosion?<\/h3>\n\n\n\n<p>Limit allowed high-cardinality keys, hash identifiers, and monitor cardinality metrics.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Who owns the semantic conventions?<\/h3>\n\n\n\n<p>A central observability owner and per-team stewards share responsibility.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Can conventions be tested in CI?<\/h3>\n\n\n\n<p>Yes; contract tests and linters can validate instrumentation changes before merge.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">How to map legacy telemetry to new conventions?<\/h3>\n\n\n\n<p>Use collector processors to transform keys and run parallel reporting during migration.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">What to do if a convention causes paging?<\/h3>\n\n\n\n<p>Tune SLOs, adjust alert thresholds, or change the attribute aggregation to reduce noise.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">How to measure attribute coverage?<\/h3>\n\n\n\n<p>Compute the percentage of services emitting required keys over a time window.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Are conventions useful for security monitoring?<\/h3>\n\n\n\n<p>Yes; standardized audit fields make security queries and correlations reliable.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">What prevents secrets from being emitted?<\/h3>\n\n\n\n<p>Static code reviews, linters, runtime redaction in collectors, and training prevent secret leakage.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">How do conventions interact with feature flags?<\/h3>\n\n\n\n<p>Feature flag attributes should be standardized to measure performance and errors by variant.<\/p>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">Conclusion<\/h2>\n\n\n\n<p>Semantic conventions are an operational contract that unlocks repeatable, scalable observability. They reduce incident time-to-resolution, avoid costly data growth, and enable meaningful SLIs and SLOs across diverse systems. A pragmatic, incremental approach\u2014backed by SDKs, CI checks, and collector normalization\u2014delivers the most value.<\/p>\n\n\n\n<p>Next 7 days plan<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Day 1: Inventory critical services and assign owners.<\/li>\n<li>Day 2: Define a minimal convention set for HTTP, DB, and auth.<\/li>\n<li>Day 3: Add OpenTelemetry SDKs or sidecars to two pilot services.<\/li>\n<li>Day 4: Implement CI linting for attribute presence and types.<\/li>\n<li>Day 5: Build one executive and one on-call dashboard using the new keys.<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator\" \/>\n\n\n\n<h2 class=\"wp-block-heading\">Appendix \u2014 Semantic conventions Keyword Cluster (SEO)<\/h2>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Primary keywords<\/li>\n<li>semantic conventions<\/li>\n<li>observability conventions<\/li>\n<li>telemetry conventions<\/li>\n<li>OpenTelemetry semantic conventions<\/li>\n<li>\n<p>semantic naming for telemetry<\/p>\n<\/li>\n<li>\n<p>Secondary keywords<\/p>\n<\/li>\n<li>attribute naming standard<\/li>\n<li>telemetry schema<\/li>\n<li>observability schema<\/li>\n<li>telemetry normalization<\/li>\n<li>\n<p>resource attributes<\/p>\n<\/li>\n<li>\n<p>Long-tail questions<\/p>\n<\/li>\n<li>what are semantic conventions in observability<\/li>\n<li>how to create semantic conventions for microservices<\/li>\n<li>semantic conventions for serverless functions<\/li>\n<li>impact of semantic conventions on SLOs<\/li>\n<li>how to measure semantic conventions coverage<\/li>\n<li>best practices for semantic conventions in kubernetes<\/li>\n<li>how to prevent PII in telemetry<\/li>\n<li>how to reduce cardinality with semantic conventions<\/li>\n<li>how to enforce semantic conventions in CI<\/li>\n<li>strategies for migrating legacy telemetry to new conventions<\/li>\n<li>semantic conventions vs telemetry schema differences<\/li>\n<li>how semantic conventions affect incident response<\/li>\n<li>how to build dashboards using semantic conventions<\/li>\n<li>semantic conventions for multi-tenant systems<\/li>\n<li>\n<p>how to test semantic conventions automatically<\/p>\n<\/li>\n<li>\n<p>Related terminology<\/p>\n<\/li>\n<li>attribute coverage<\/li>\n<li>tag cardinality<\/li>\n<li>resource metadata<\/li>\n<li>trace context propagation<\/li>\n<li>SLI definition<\/li>\n<li>SLO design<\/li>\n<li>error budget policy<\/li>\n<li>telemetry sampling<\/li>\n<li>ingestion normalization<\/li>\n<li>collector processors<\/li>\n<li>telemetry contract registry<\/li>\n<li>contract linting<\/li>\n<li>telemetry redaction<\/li>\n<li>hashing identifiers<\/li>\n<li>audit logging attributes<\/li>\n<li>topology mapping<\/li>\n<li>dependency graph keys<\/li>\n<li>observability pipeline<\/li>\n<li>metric units standardization<\/li>\n<li>metric label guidelines<\/li>\n<li>event enrichment<\/li>\n<li>runbooks tied to telemetry<\/li>\n<li>CI telemetry checks<\/li>\n<li>telemetry cost allocation<\/li>\n<li>canary instrumentation<\/li>\n<li>auto-instrumentation best practices<\/li>\n<li>manual instrumentation checklist<\/li>\n<li>telemetry schema evolution<\/li>\n<li>vendor-neutral telemetry<\/li>\n<li>observability maturity model<\/li>\n<li>telemetry privacy rules<\/li>\n<li>collector normalization rules<\/li>\n<li>ingestion error metrics<\/li>\n<li>dashboard templating<\/li>\n<li>alert deduplication<\/li>\n<li>burn-rate escalation<\/li>\n<li>telemetry retention tiers<\/li>\n<li>structured logging conventions<\/li>\n<li>feature flag telemetry<\/li>\n<li>serverless telemetry attributes<\/li>\n<li>kubernetes resource attributes<\/li>\n<li>security SIEM mapping<\/li>\n<li>telemetry contract testing<\/li>\n<li>attribute typing standards<\/li>\n<li>index vs raw telemetry trade-offs<\/li>\n<li>telemetry governance checklist<\/li>\n<li>telemetry owner assignment<\/li>\n<li>telemetry transformation rules<\/li>\n<li>telemetry observability health metrics<\/li>\n<li>telemetry cardinality heatmap<\/li>\n<\/ul>\n","protected":false},"excerpt":{"rendered":"<p>&#8212;<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[149],"tags":[],"class_list":["post-1911","post","type-post","status-publish","format-standard","hentry","category-terminology"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v26.5 - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>What is Semantic conventions? Meaning, Architecture, Examples, Use Cases, and How to Measure It (2026 Guide) - SRE School<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/sreschool.com\/blog\/semantic-conventions\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"What is Semantic conventions? Meaning, Architecture, Examples, Use Cases, and How to Measure It (2026 Guide) - SRE School\" \/>\n<meta property=\"og:description\" content=\"---\" \/>\n<meta property=\"og:url\" content=\"https:\/\/sreschool.com\/blog\/semantic-conventions\/\" \/>\n<meta property=\"og:site_name\" content=\"SRE School\" \/>\n<meta property=\"article:published_time\" content=\"2026-02-15T10:17:49+00:00\" \/>\n<meta name=\"author\" content=\"Rajesh Kumar\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Rajesh Kumar\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"27 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/sreschool.com\/blog\/semantic-conventions\/\",\"url\":\"https:\/\/sreschool.com\/blog\/semantic-conventions\/\",\"name\":\"What is Semantic conventions? Meaning, Architecture, Examples, Use Cases, and How to Measure It (2026 Guide) - SRE School\",\"isPartOf\":{\"@id\":\"https:\/\/sreschool.com\/blog\/#website\"},\"datePublished\":\"2026-02-15T10:17:49+00:00\",\"author\":{\"@id\":\"https:\/\/sreschool.com\/blog\/#\/schema\/person\/0ffe446f77bb2589992dbe3a7f417201\"},\"breadcrumb\":{\"@id\":\"https:\/\/sreschool.com\/blog\/semantic-conventions\/#breadcrumb\"},\"inLanguage\":\"en\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/sreschool.com\/blog\/semantic-conventions\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/sreschool.com\/blog\/semantic-conventions\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/sreschool.com\/blog\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"What is Semantic conventions? Meaning, Architecture, Examples, Use Cases, and How to Measure It (2026 Guide)\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/sreschool.com\/blog\/#website\",\"url\":\"https:\/\/sreschool.com\/blog\/\",\"name\":\"SRESchool\",\"description\":\"Master SRE. Build Resilient Systems. Lead the Future of Reliability\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/sreschool.com\/blog\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/sreschool.com\/blog\/#\/schema\/person\/0ffe446f77bb2589992dbe3a7f417201\",\"name\":\"Rajesh Kumar\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en\",\"@id\":\"https:\/\/sreschool.com\/blog\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/f901a4f2929fa034a291a8363d589791d5a3c1f6a051c22e744acb8bfc8e022a?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/f901a4f2929fa034a291a8363d589791d5a3c1f6a051c22e744acb8bfc8e022a?s=96&d=mm&r=g\",\"caption\":\"Rajesh Kumar\"},\"sameAs\":[\"http:\/\/sreschool.com\/blog\"],\"url\":\"https:\/\/sreschool.com\/blog\/author\/admin\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"What is Semantic conventions? Meaning, Architecture, Examples, Use Cases, and How to Measure It (2026 Guide) - SRE School","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/sreschool.com\/blog\/semantic-conventions\/","og_locale":"en_US","og_type":"article","og_title":"What is Semantic conventions? Meaning, Architecture, Examples, Use Cases, and How to Measure It (2026 Guide) - SRE School","og_description":"---","og_url":"https:\/\/sreschool.com\/blog\/semantic-conventions\/","og_site_name":"SRE School","article_published_time":"2026-02-15T10:17:49+00:00","author":"Rajesh Kumar","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Rajesh Kumar","Est. reading time":"27 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/sreschool.com\/blog\/semantic-conventions\/","url":"https:\/\/sreschool.com\/blog\/semantic-conventions\/","name":"What is Semantic conventions? Meaning, Architecture, Examples, Use Cases, and How to Measure It (2026 Guide) - SRE School","isPartOf":{"@id":"https:\/\/sreschool.com\/blog\/#website"},"datePublished":"2026-02-15T10:17:49+00:00","author":{"@id":"https:\/\/sreschool.com\/blog\/#\/schema\/person\/0ffe446f77bb2589992dbe3a7f417201"},"breadcrumb":{"@id":"https:\/\/sreschool.com\/blog\/semantic-conventions\/#breadcrumb"},"inLanguage":"en","potentialAction":[{"@type":"ReadAction","target":["https:\/\/sreschool.com\/blog\/semantic-conventions\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/sreschool.com\/blog\/semantic-conventions\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/sreschool.com\/blog\/"},{"@type":"ListItem","position":2,"name":"What is Semantic conventions? Meaning, Architecture, Examples, Use Cases, and How to Measure It (2026 Guide)"}]},{"@type":"WebSite","@id":"https:\/\/sreschool.com\/blog\/#website","url":"https:\/\/sreschool.com\/blog\/","name":"SRESchool","description":"Master SRE. Build Resilient Systems. Lead the Future of Reliability","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/sreschool.com\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en"},{"@type":"Person","@id":"https:\/\/sreschool.com\/blog\/#\/schema\/person\/0ffe446f77bb2589992dbe3a7f417201","name":"Rajesh Kumar","image":{"@type":"ImageObject","inLanguage":"en","@id":"https:\/\/sreschool.com\/blog\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/f901a4f2929fa034a291a8363d589791d5a3c1f6a051c22e744acb8bfc8e022a?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/f901a4f2929fa034a291a8363d589791d5a3c1f6a051c22e744acb8bfc8e022a?s=96&d=mm&r=g","caption":"Rajesh Kumar"},"sameAs":["http:\/\/sreschool.com\/blog"],"url":"https:\/\/sreschool.com\/blog\/author\/admin\/"}]}},"_links":{"self":[{"href":"https:\/\/sreschool.com\/blog\/wp-json\/wp\/v2\/posts\/1911","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/sreschool.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/sreschool.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/sreschool.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/sreschool.com\/blog\/wp-json\/wp\/v2\/comments?post=1911"}],"version-history":[{"count":0,"href":"https:\/\/sreschool.com\/blog\/wp-json\/wp\/v2\/posts\/1911\/revisions"}],"wp:attachment":[{"href":"https:\/\/sreschool.com\/blog\/wp-json\/wp\/v2\/media?parent=1911"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/sreschool.com\/blog\/wp-json\/wp\/v2\/categories?post=1911"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/sreschool.com\/blog\/wp-json\/wp\/v2\/tags?post=1911"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}