diff --git a/semantic-core/generation/gen_semantic_defs.py b/semantic-core/generation/gen_semantic_defs.py index d6e967e..d6190a8 100755 --- a/semantic-core/generation/gen_semantic_defs.py +++ b/semantic-core/generation/gen_semantic_defs.py @@ -5,6 +5,7 @@ import os import re from typing import NamedTuple +from pydantic.json_schema import GenerateJsonSchema from semantic_model.payloads import AgentPayload from semantic_model.payloads import IntakeResolvedDbSpan @@ -19,8 +20,21 @@ logger = logging.getLogger(__name__) +class JSONSchemaGenerator(GenerateJsonSchema): + def generate(self, schema, mode='validation'): + json_schema = super().generate(schema, mode=mode) + json_schema['$schema'] = self.schema_dialect + + try: + json_schema = schema['cls'].customize_json_schema(json_schema) + except AttributeError: + pass + + return json_schema + + def generate_schema(*args, payload_type, version_info): - json_schema_str = json.dumps(payload_type.model_json_schema(), indent=2) + json_schema_str = json.dumps(payload_type.model_json_schema(schema_generator=JSONSchemaGenerator), indent=2) subdir = "releases" if version_info.is_release else "drafts" # Create the directory if it doesn't exist diff --git a/semantic-core/generation/semantic_model/payloads/agent_payload.py b/semantic-core/generation/semantic_model/payloads/agent_payload.py index 0c968ba..a0ae51c 100644 --- a/semantic-core/generation/semantic_model/payloads/agent_payload.py +++ b/semantic-core/generation/semantic_model/payloads/agent_payload.py @@ -4,7 +4,12 @@ from typing import List, Dict from semantic_model.registry.types import Hostname - +from semantic_model.registry.types.span import Span +from semantic_model.registry.types.span_type import SpanType +from semantic_model.registry.types.tags_base import TagsBase +from semantic_model.registry.types.tags_http import TagsHTTP +from semantic_model.registry.types.tags_sql import TagsSQL +from semantic_model.registry.types.tracer_payload import TracerPayload NonEmptyString = Annotated[str, Field(min_length=1)] PositiveFloat = Annotated[float, Field(gt=0)] @@ -15,6 +20,54 @@ class AgentPayload(BaseModel): Represents the generic semantic_model for the agent payload, structurally defined here: https://github.com/DataDog/datadog-agent/blob/main/pkg/proto/datadog/trace/agent_payload.proto """ + @staticmethod + def customize_json_schema(schema): + if '$defs' not in schema: + schema['$defs'] = {} + + extra_models = [TagsBase, TagsHTTP, TagsSQL] + + # generate the JSON schema for the extra models and add it to the root definitions. + for cls in extra_models: + name = cls.__name__ + schema['$defs'][name] = cls.model_json_schema() + + span_type = 'type' + + # Validate the span.meta property using different schemas conditionally, based on + # the span.type attribute. + # https://json-schema.org/understanding-json-schema/reference/conditionals#ifthenelse + # This feature is not supported by Pydantic: https://github.com/pydantic/pydantic/issues/529 + schema['$defs'][Span.__name__]['allOf'] = [ + # default case when type is not defined or is not a known value + { + 'if': {'not': {'properties': {span_type: {'enum': [SpanType.web, SpanType.http, SpanType.sql]}}}}, + 'then': {'properties': {'meta': {'$ref': f"#/$defs/{TagsBase.__name__}"}}} + }, + { + 'if': { + 'properties': {span_type: {'enum': [SpanType.web, SpanType.http]}}, + 'required': [span_type] + }, + 'then': {'properties': {'meta': {'$ref': f"#/$defs/{TagsHTTP.__name__}"}}}, + }, + { + 'if': { + 'properties': {span_type: {'const': SpanType.sql}}, + 'required': [span_type] + }, + 'then': {'properties': {'meta': {'$ref': f"#/$defs/{TagsSQL.__name__}"}}}, + }, + ] + + # Move the nested $defs to the root model, so the generated references still work. + for cls in extra_models: + name = cls.__name__ + schema['$defs'] = schema['$defs'] | schema['$defs'][name]['$defs'] + del schema['$defs'][name]['$defs'] + + return schema + hostName: Annotated[ Hostname, Field( @@ -75,5 +128,11 @@ class AgentPayload(BaseModel): description="""Holds `RareSamplerEnabled` value in AgentConfig""", ), ] = None - - # TODO: tracerPayloads + tracerPayloads: Annotated[ + List[TracerPayload], + Field( + alias="tracerPayloads", + title="Tracer Payloads", + description="""Specifies the list of the payloads received from tracers""", + ) + ] diff --git a/semantic-core/generation/semantic_model/registry/types/__init__.py b/semantic-core/generation/semantic_model/registry/types/__init__.py index 609e84d..cfca641 100644 --- a/semantic-core/generation/semantic_model/registry/types/__init__.py +++ b/semantic-core/generation/semantic_model/registry/types/__init__.py @@ -22,4 +22,3 @@ from .trace_flags import TraceFlags from .trace_state import TraceState from .tags import Tags - diff --git a/semantic-core/generation/semantic_model/registry/types/language_name.py b/semantic-core/generation/semantic_model/registry/types/language_name.py new file mode 100644 index 0000000..4799800 --- /dev/null +++ b/semantic-core/generation/semantic_model/registry/types/language_name.py @@ -0,0 +1,11 @@ +from enum import Enum + + +class LanguageName(str, Enum): + go = 'go' + python = 'python' + php = 'php' + ruby = 'ruby' + jvm = 'jvm' + dotnet = 'dotnet' + js = 'js' diff --git a/semantic-core/generation/semantic_model/registry/types/span.py b/semantic-core/generation/semantic_model/registry/types/span.py new file mode 100644 index 0000000..6d2b3f3 --- /dev/null +++ b/semantic-core/generation/semantic_model/registry/types/span.py @@ -0,0 +1,111 @@ +from pydantic import BaseModel, Field +from typing_extensions import Annotated + +from semantic_model.registry.types import SpanId +from semantic_model.registry.types.span_type import SpanType + + +class Span(BaseModel): + service: Annotated[ + str, + Field( + alias="service", + title="Service", + description="The name of the service with which this span is associated" + ) + ] + name: Annotated[ + str, + Field( + alias="name", + title="Name", + description="The operation name of this span" + ) + ] + resource: Annotated[ + str, + Field( + alias="resource", + title="Resource", + description="The resource name of this span, also sometimes called the endpoint (for web spans)" + ) + ] + traceID: Annotated[ + str, + Field( + alias="traceID", + title="Trace ID", + description="The ID of the trace to which this span belongs" + ) + ] + spanID: Annotated[ + SpanId, + Field( + alias="spanID", + title="Span ID", + ), + ] = None + parentID: Annotated[ + SpanId, + Field( + alias="parentID", + title="Parent ID", + description="The ID of this span's parent, or zero if this span has no parent" + ) + ] = None + start: Annotated[ + int, + Field( + alias="start", + title="Start", + description="The number of nanoseconds between the Unix epoch and the beginning of this span" + ) + ] + duration: Annotated[ + int, + Field( + alias="duration", + title="Duration", + description="The time length of this span in nanoseconds" + ) + ] + error: Annotated[ + int, + Field( + alias="error", + title="Error", + description="Error is 1 if there is an error associated with this span, or 0 if there is not" + ) + ] = None + meta: Annotated[ + dict[str, str], + Field( + alias="meta", + title="Meta", + description="Meta is a mapping from tag name to tag value for string-valued tags" + ) + ] = None + metrics: Annotated[ + dict[str, float], + Field( + alias="metrics", + title="Metrics", + description="Metrics is a mapping from tag name to tag value for numeric-valued tags" + ) + ] = None + type: Annotated[ + SpanType, + Field( + alias="type", + title="Type", + description="Represents the type of the service with which this span is associated. Example values: `web`, `db`, `lambda`" + ) + ] = None + meta_struct: Annotated[ + dict[str, int], + Field( + alias="meta_struct", + title="Meta Struct", + description="Represents a registry of structured \"other\" data used by, e.g., AppSec" + ) + ] = None diff --git a/semantic-core/generation/semantic_model/registry/types/span_kind.py b/semantic-core/generation/semantic_model/registry/types/span_kind.py new file mode 100644 index 0000000..d2a763a --- /dev/null +++ b/semantic-core/generation/semantic_model/registry/types/span_kind.py @@ -0,0 +1,9 @@ +from enum import Enum + + +class SpanKind(str, Enum): + internal = 'internal' + client = 'client' + server = 'server' + producer = 'producer' + consumer = 'consumer' diff --git a/semantic-core/generation/semantic_model/registry/types/span_type.py b/semantic-core/generation/semantic_model/registry/types/span_type.py new file mode 100644 index 0000000..e6b0e3e --- /dev/null +++ b/semantic-core/generation/semantic_model/registry/types/span_type.py @@ -0,0 +1,22 @@ +from enum import Enum + + +class SpanType(str, Enum): + """Span types have similar behaviour to "app types" and help categorize + traces in the Datadog application. They can also help fine grain agent + level behaviours such as obfuscation and quantization, when these are + enabled in the agent's configuration.""" + + web = 'web' + http = 'http' + sql = 'sql' + cassandra = 'cassandra' + redis = 'redis' + memcached = 'memcached' + mongodb = 'mongodb' + elasticsearch = 'elasticsearch' + leveldb = 'leveldb' + dns = 'dns' + queue = 'queue' + consul = 'consul' + graphql = 'graphql' diff --git a/semantic-core/generation/semantic_model/registry/types/tags_base.py b/semantic-core/generation/semantic_model/registry/types/tags_base.py new file mode 100644 index 0000000..dcaa454 --- /dev/null +++ b/semantic-core/generation/semantic_model/registry/types/tags_base.py @@ -0,0 +1,16 @@ +from pydantic import BaseModel, Field + +from typing_extensions import Annotated + +from semantic_model.registry.types.span_kind import SpanKind + + +class TagsBase(BaseModel): + span_kind: Annotated[ + SpanKind, + Field( + alias="span.kind", + title="span.kind", + description="", + ) + ] diff --git a/semantic-core/generation/semantic_model/registry/types/tags_http.py b/semantic-core/generation/semantic_model/registry/types/tags_http.py new file mode 100644 index 0000000..bc877b4 --- /dev/null +++ b/semantic-core/generation/semantic_model/registry/types/tags_http.py @@ -0,0 +1,146 @@ +from pydantic import Field +import textwrap +from typing_extensions import Annotated + +from semantic_model.registry.types import HttpStatusCode +from semantic_model.registry.types import HttpUrl +from semantic_model.registry.types import HttpMethod +from semantic_model.registry.types import HttpVersion +from semantic_model.registry.types import HttpRoute +from semantic_model.registry.types import IpAddress +from semantic_model.registry.types import HttpUserAgent +from semantic_model.registry.types import HttpContentLength +from semantic_model.registry.types.tags_base import TagsBase + + +class TagsHTTP(TagsBase): + http_status_code: Annotated[ + HttpStatusCode, + Field( + title="HTTP Status Code", + alias="http.status_code", + description=textwrap.dedent( + """ + The HTTP response status code. + When span.kind: client the response status code received. + When span.kind: server the response status code sent. + Note: Although this is an integer, it must be sent as a string.""" + ), + ), + ] = ... + http_url: Annotated[ + HttpUrl, + Field( + alias="http.url", + title="HTTP URL", + description=textwrap.dedent( + """ + The URL of the HTTP request, including the obfuscated query string.""" + ), + ), + ] = ... + http_method: Annotated[ + HttpMethod, + Field( + alias="http.method", + title="HTTP Method", + description=textwrap.dedent( + """ + The HTTP method used for the connection. Required for both client and server spans.""" + ), + ), + ] = ... + http_version: Annotated[ + HttpVersion, + Field( + alias="http.version", + title="HTTP Version", + description=textwrap.dedent( + """ + The version of HTTP used for the request.""" + ), + ), + ] = None + http_route: Annotated[ + HttpRoute, + Field( + alias="http.route", + title="HTTP Route", + description=textwrap.dedent( + """ + The matched route (path template). + Only when span.kind: server.""" + ), + ), + ] = None + http_client_ip: Annotated[ + IpAddress, + Field( + alias="http.client_ip", + title="HTTP Client IP", + description=textwrap.dedent( + """ + The IP address of the original client behind all proxies, if known (discovered from headers such as X-Forwarded-For).""" + ), + ), + ] = None + http_useragent: Annotated[ + HttpUserAgent, + Field( + alias="http.useragent", + title="HTTP User Agent", + description=textwrap.dedent( + """ + The user agent header received with the request. + Only when span.kind: server.""" + ), + ), + ] = None + http_request_content_length: Annotated[ + HttpContentLength, + Field( + alias="http.request.content_length", + title="HTTP Request Content Length", + description=textwrap.dedent( + """ + The size of the request body. + The size of the request payload body in bytes. This is the number of bytes transferred excluding headers and is often, but not always, present as the Content-Length header. + For requests using transport encoding, this should be compressed size.""" + ), + ), + ] = None + http_response_content_length: Annotated[ + HttpContentLength, + Field( + alias="http.response.content_length", + title="HTTP Response Content Length", + description=textwrap.dedent( + """ + The size of the response payload body in bytes. + The size of the response payload body in bytes. This is the number of bytes transferred excluding headers and is often, but not always, present as the Content-Length header. + For requests using transport encoding, this should be compressed size.""" + ), + ), + ] = None + http_request_content_length_uncompressed: Annotated[ + HttpContentLength, + Field( + alias="http.request.content_length_uncompressed", + title="HTTP Request Content Length Uncompressed", + description=textwrap.dedent( + """ + The size of the request payload body after transport decoding. Not set if transport encoding not used.""" + ), + ), + ] = None + http_response_content_length_uncompressed: Annotated[ + HttpContentLength, + Field( + alias="http.response.content_length_uncompressed", + title="HTTP Response Content Length Uncompressed", + description=textwrap.dedent( + """ + The size of the response payload body after transport decoding. Not set if transport encoding not used.""" + ), + ), + ] = None diff --git a/semantic-core/generation/semantic_model/registry/types/tags_sql.py b/semantic-core/generation/semantic_model/registry/types/tags_sql.py new file mode 100644 index 0000000..5f11de8 --- /dev/null +++ b/semantic-core/generation/semantic_model/registry/types/tags_sql.py @@ -0,0 +1,71 @@ +from pydantic import Field +from typing_extensions import Annotated + +from semantic_model.registry.types import DbSystem +from semantic_model.registry.types import DbUser +from semantic_model.registry.types import DbName +from semantic_model.registry.types import DbStatement +from semantic_model.registry.types import DbOperation +from semantic_model.registry.types import DbSqlTable +from semantic_model.registry.types import DbRowCount +from semantic_model.registry.types import DbConnectionString +from semantic_model.registry.types.tags_base import TagsBase + + +class TagsSQL(TagsBase): + db_system: Annotated[ + DbSystem, + Field( + alias="db.system", + title="DB System", + ), + ] = ... + db_connection_string: Annotated[ + DbConnectionString, + Field( + alias="db.connection_string", + title="DB Connection String", + ), + ] = None + db_user: Annotated[ + DbUser, + Field( + alias="db.user", + title="DB User", + ), + ] = None + db_name: Annotated[ + DbName, + Field( + alias="db.name", + title="DB Name", + ), + ] = None + db_statement: Annotated[ + DbStatement, + Field( + alias="db.statement", + title="DB Statement", + ), + ] = None + db_operation: Annotated[ + DbOperation, + Field( + alias="db.operation", + title="DB Operation", + ), + ] = None + db_sql_table: Annotated[ + DbSqlTable, + Field( + alias="db.sql.table", + title="DB SQL Table", + ), + ] = None + db_row_count: Annotated[ + DbRowCount, + Field( + alias="db.row_count", + title="DB Row Count", + ), + ] = None diff --git a/semantic-core/generation/semantic_model/registry/types/trace_chunk.py b/semantic-core/generation/semantic_model/registry/types/trace_chunk.py new file mode 100644 index 0000000..f303e73 --- /dev/null +++ b/semantic-core/generation/semantic_model/registry/types/trace_chunk.py @@ -0,0 +1,48 @@ +from pydantic import BaseModel, Field +from typing_extensions import Annotated +from typing import List + +from semantic_model.registry.types.span import Span + + +class TraceChunk(BaseModel): + priority: Annotated[ + int, + Field( + alias="priority", + title="Priority", + description="Specifies the sampling priority of the trace" + ) + ] + origin: Annotated[ + str, + Field( + alias="origin", + title="Origin", + description="Specifies the origin product (`lambda`, `rum`, etc.) of the trace" + ) + ] = None + spans: Annotated[ + List[Span], + Field( + alias="spans", + title="Spans", + description="Specifies the list of containing spans" + ) + ] + tags: Annotated[ + dict[str, str], + Field( + alias="tags", + title="Tags", + description="Specifies the list of tags common in all Spans", + ) + ] = None + droppedTrace: Annotated[ + bool, + Field( + alias="droppedTrace", + title="Dropped Trace", + description="Specifies whether the trace was dropped by samplers or not", + ) + ] = None diff --git a/semantic-core/generation/semantic_model/registry/types/tracer_payload.py b/semantic-core/generation/semantic_model/registry/types/tracer_payload.py new file mode 100644 index 0000000..abe4f29 --- /dev/null +++ b/semantic-core/generation/semantic_model/registry/types/tracer_payload.py @@ -0,0 +1,92 @@ +from pydantic import BaseModel, Field +from typing_extensions import Annotated +from typing import List + +from semantic_model.registry.types.language_name import LanguageName +from semantic_model.registry.types.trace_chunk import TraceChunk + + +class TracerPayload(BaseModel): + containerID: Annotated[ + str, + Field( + alias="containerID", + title="Container ID", + description="Specifies the ID of the container where the tracer is running on" + ) + ] = None + languageName: Annotated[ + LanguageName, + Field( + alias="languageName", + title="Language Name", + description="Specifies the language of the tracer", + ) + ] + languageVersion: Annotated[ + str, + Field( + alias="languageVersion", + title="Language Version", + description="Specifies the language version of the tracer", + # TODO: add pattern to validate version string + ) + ] + tracerVersion: Annotated[ + str, + Field( + alias="tracerVersion", + title="Tracer Version", + description="Specifies the version of the tracer", + # TODO: add pattern to validate version string + ) + ] + runtimeID: Annotated[ + str, + Field( + alias="runtimeID", + title="Runtime ID", + description="Specifies V4 UUID representation of a tracer session", + # TODO: add pattern to validate UUID + ) + ] = None + chunks: Annotated[ + List[TraceChunk], + Field( + alias="chunks", + title="Trace Chunks", + description="Specifies the list of containing trace chunks", + ) + ] + tags: Annotated[ + dict[str, str], + Field( + alias="tags", + title="Trace Tags", + description="Specifies the list of tags common in all Trace Chunks", + ) + ] = None + env: Annotated[ + str, + Field( + alias="env", + title="Env", + description="Specifies the `env` tag that is set in the tracer configuration", + ) + ] + hostname: Annotated[ + str, + Field( + alias="hostname", + title="Hostname", + description="Specifies the hostname where the tracer is running", + ) + ] = None + appVersion: Annotated[ + str, + Field( + alias="appVersion", + title="App Version", + description="Specifies the `version` tag that set in the tracer configuration", + ) + ] diff --git a/semantic-core/schema/releases/1.1.0/agent_payload.json b/semantic-core/schema/releases/1.1.0/agent_payload.json new file mode 100644 index 0000000..1b4ce73 --- /dev/null +++ b/semantic-core/schema/releases/1.1.0/agent_payload.json @@ -0,0 +1,688 @@ +{ + "$defs": { + "LanguageName": { + "enum": [ + "go", + "python", + "php", + "ruby", + "jvm", + "dotnet", + "js" + ], + "title": "LanguageName", + "type": "string" + }, + "Span": { + "properties": { + "service": { + "description": "The name of the service with which this span is associated", + "title": "Service", + "type": "string" + }, + "name": { + "description": "The operation name of this span", + "title": "Name", + "type": "string" + }, + "resource": { + "description": "The resource name of this span, also sometimes called the endpoint (for web spans)", + "title": "Resource", + "type": "string" + }, + "traceID": { + "description": "The ID of the trace to which this span belongs", + "title": "Trace ID", + "type": "string" + }, + "spanID": { + "default": null, + "description": "\n Span identifier, generated by the tracer library. The value of this field is a 64-bit integer, and uniquely identifies the span within the trace.", + "examples": [ + 0, + 12345, + 543210, + 9999999 + ], + "is_sensitive": false, + "title": "Span ID", + "type": "integer" + }, + "parentID": { + "default": null, + "description": "The ID of this span's parent, or zero if this span has no parent", + "examples": [ + 0, + 12345, + 543210, + 9999999 + ], + "is_sensitive": false, + "title": "Parent ID", + "type": "integer" + }, + "start": { + "description": "The number of nanoseconds between the Unix epoch and the beginning of this span", + "title": "Start", + "type": "integer" + }, + "duration": { + "description": "The time length of this span in nanoseconds", + "title": "Duration", + "type": "integer" + }, + "error": { + "default": null, + "description": "Error is 1 if there is an error associated with this span, or 0 if there is not", + "title": "Error", + "type": "integer" + }, + "meta": { + "additionalProperties": { + "type": "string" + }, + "default": null, + "description": "Meta is a mapping from tag name to tag value for string-valued tags", + "title": "Meta", + "type": "object" + }, + "metrics": { + "additionalProperties": { + "type": "number" + }, + "default": null, + "description": "Metrics is a mapping from tag name to tag value for numeric-valued tags", + "title": "Metrics", + "type": "object" + }, + "type": { + "allOf": [ + { + "$ref": "#/$defs/SpanType" + } + ], + "default": null, + "description": "Represents the type of the service with which this span is associated. Example values: `web`, `db`, `lambda`", + "title": "Type" + }, + "meta_struct": { + "additionalProperties": { + "type": "integer" + }, + "default": null, + "description": "Represents a registry of structured \"other\" data used by, e.g., AppSec", + "title": "Meta Struct", + "type": "object" + } + }, + "required": [ + "service", + "name", + "resource", + "traceID", + "start", + "duration" + ], + "title": "Span", + "type": "object", + "allOf": [ + { + "if": { + "not": { + "properties": { + "type": { + "enum": [ + "web", + "http", + "sql" + ] + } + } + } + }, + "then": { + "properties": { + "meta": { + "$ref": "#/$defs/TagsBase" + } + } + } + }, + { + "if": { + "properties": { + "type": { + "enum": [ + "web", + "http" + ] + } + }, + "required": [ + "type" + ] + }, + "then": { + "properties": { + "meta": { + "$ref": "#/$defs/TagsHTTP" + } + } + } + }, + { + "if": { + "properties": { + "type": { + "const": "sql" + } + }, + "required": [ + "type" + ] + }, + "then": { + "properties": { + "meta": { + "$ref": "#/$defs/TagsSQL" + } + } + } + } + ] + }, + "SpanType": { + "description": "Span types have similar behaviour to \"app types\" and help categorize\ntraces in the Datadog application. They can also help fine grain agent\nlevel behaviours such as obfuscation and quantization, when these are\nenabled in the agent's configuration.", + "enum": [ + "web", + "http", + "sql", + "cassandra", + "redis", + "memcached", + "mongodb", + "elasticsearch", + "leveldb", + "dns", + "queue", + "consul", + "graphql" + ], + "title": "SpanType", + "type": "string" + }, + "TraceChunk": { + "properties": { + "priority": { + "description": "Specifies the sampling priority of the trace", + "title": "Priority", + "type": "integer" + }, + "origin": { + "default": null, + "description": "Specifies the origin product (`lambda`, `rum`, etc.) of the trace", + "title": "Origin", + "type": "string" + }, + "spans": { + "description": "Specifies the list of containing spans", + "items": { + "$ref": "#/$defs/Span" + }, + "title": "Spans", + "type": "array" + }, + "tags": { + "additionalProperties": { + "type": "string" + }, + "default": null, + "description": "Specifies the list of tags common in all Spans", + "title": "Tags", + "type": "object" + }, + "droppedTrace": { + "default": null, + "description": "Specifies whether the trace was dropped by samplers or not", + "title": "Dropped Trace", + "type": "boolean" + } + }, + "required": [ + "priority", + "spans" + ], + "title": "TraceChunk", + "type": "object" + }, + "TracerPayload": { + "properties": { + "containerID": { + "default": null, + "description": "Specifies the ID of the container where the tracer is running on", + "title": "Container ID", + "type": "string" + }, + "languageName": { + "allOf": [ + { + "$ref": "#/$defs/LanguageName" + } + ], + "description": "Specifies the language of the tracer", + "title": "Language Name" + }, + "languageVersion": { + "description": "Specifies the language version of the tracer", + "title": "Language Version", + "type": "string" + }, + "tracerVersion": { + "description": "Specifies the version of the tracer", + "title": "Tracer Version", + "type": "string" + }, + "runtimeID": { + "default": null, + "description": "Specifies V4 UUID representation of a tracer session", + "title": "Runtime ID", + "type": "string" + }, + "chunks": { + "description": "Specifies the list of containing trace chunks", + "items": { + "$ref": "#/$defs/TraceChunk" + }, + "title": "Trace Chunks", + "type": "array" + }, + "tags": { + "additionalProperties": { + "type": "string" + }, + "default": null, + "description": "Specifies the list of tags common in all Trace Chunks", + "title": "Trace Tags", + "type": "object" + }, + "env": { + "description": "Specifies the `env` tag that is set in the tracer configuration", + "title": "Env", + "type": "string" + }, + "hostname": { + "default": null, + "description": "Specifies the hostname where the tracer is running", + "title": "Hostname", + "type": "string" + }, + "appVersion": { + "description": "Specifies the `version` tag that set in the tracer configuration", + "title": "App Version", + "type": "string" + } + }, + "required": [ + "languageName", + "languageVersion", + "tracerVersion", + "chunks", + "env", + "appVersion" + ], + "title": "TracerPayload", + "type": "object" + }, + "TagsBase": { + "properties": { + "span.kind": { + "allOf": [ + { + "$ref": "#/$defs/SpanKind" + } + ], + "description": "", + "title": "span.kind" + } + }, + "required": [ + "span.kind" + ], + "title": "TagsBase", + "type": "object" + }, + "TagsHTTP": { + "properties": { + "span.kind": { + "allOf": [ + { + "$ref": "#/$defs/SpanKind" + } + ], + "description": "", + "title": "span.kind" + }, + "http.status_code": { + "description": "\nThe HTTP response status code.\nWhen span.kind: client the response status code received.\nWhen span.kind: server the response status code sent.\nNote: Although this is an integer, it must be sent as a string.", + "examples": [ + "200", + "404", + "500" + ], + "is_sensitive": false, + "pattern": "^[12345]\\d\\d$", + "title": "HTTP Status Code", + "type": "string" + }, + "http.url": { + "description": "\nThe URL of the HTTP request, including the obfuscated query string.", + "examples": [ + "https://example.com:443/search?q=datadog" + ], + "is_sensitive": true, + "minLength": 1, + "title": "HTTP URL", + "type": "string" + }, + "http.method": { + "description": "\nThe HTTP method used for the connection. Required for both client and server spans.", + "examples": [ + "GET", + "POST", + "PUT", + "DELETE", + "PATCH" + ], + "is_sensitive": false, + "pattern": "^(GET|HEAD|POST|PUT|DELETE|CONNECT|OPTIONS|TRACE|PATCH)$", + "title": "HTTP Method", + "type": "string" + }, + "http.version": { + "default": null, + "description": "\nThe version of HTTP used for the request.", + "examples": [ + "1.0", + "1.1", + "2.0" + ], + "is_sensitive": false, + "pattern": "^1\\.[01]$|^2\\.0$", + "title": "HTTP Version", + "type": "string" + }, + "http.route": { + "default": null, + "description": "\nThe matched route (path template).\nOnly when span.kind: server.", + "examples": [ + "/users/:userID" + ], + "is_sensitive": false, + "minLength": 1, + "title": "HTTP Route", + "type": "string" + }, + "http.client_ip": { + "default": null, + "description": "\nThe IP address of the original client behind all proxies, if known (discovered from headers such as X-Forwarded-For).", + "examples": [ + "192.168.123.132" + ], + "is_sensitive": true, + "pattern": "^(?:[0-9]{1,3}\\.){3}[0-9]{1,3}|(?:[A-F0-9]{1,4}:){7}[A-F0-9]{1,4}$", + "title": "HTTP Client IP", + "type": "string" + }, + "http.useragent": { + "default": null, + "description": "\nThe user agent header received with the request.\nOnly when span.kind: server.", + "examples": [ + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36" + ], + "is_sensitive": true, + "minLength": 1, + "title": "HTTP User Agent", + "type": "string" + }, + "http.request.content_length": { + "default": null, + "description": "\nThe size of the request body.\nThe size of the request payload body in bytes. This is the number of bytes transferred excluding headers and is often, but not always, present as the Content-Length header.\nFor requests using transport encoding, this should be compressed size.", + "examples": [ + 1234 + ], + "exclusiveMinimum": 0, + "is_sensitive": true, + "title": "HTTP Request Content Length", + "type": "integer" + }, + "http.response.content_length": { + "default": null, + "description": "\nThe size of the response payload body in bytes.\nThe size of the response payload body in bytes. This is the number of bytes transferred excluding headers and is often, but not always, present as the Content-Length header.\nFor requests using transport encoding, this should be compressed size.", + "examples": [ + 1234 + ], + "exclusiveMinimum": 0, + "is_sensitive": true, + "title": "HTTP Response Content Length", + "type": "integer" + }, + "http.request.content_length_uncompressed": { + "default": null, + "description": "\nThe size of the request payload body after transport decoding. Not set if transport encoding not used.", + "examples": [ + 1234 + ], + "exclusiveMinimum": 0, + "is_sensitive": true, + "title": "HTTP Request Content Length Uncompressed", + "type": "integer" + }, + "http.response.content_length_uncompressed": { + "default": null, + "description": "\nThe size of the response payload body after transport decoding. Not set if transport encoding not used.", + "examples": [ + 1234 + ], + "exclusiveMinimum": 0, + "is_sensitive": true, + "title": "HTTP Response Content Length Uncompressed", + "type": "integer" + } + }, + "required": [ + "span.kind", + "http.status_code", + "http.url", + "http.method" + ], + "title": "TagsHTTP", + "type": "object" + }, + "TagsSQL": { + "properties": { + "span.kind": { + "allOf": [ + { + "$ref": "#/$defs/SpanKind" + } + ], + "description": "", + "title": "span.kind" + }, + "db.system": { + "description": "An identifier for the database management system (DBMS) product being used.", + "examples": [ + "mysql", + "postgresql" + ], + "is_sensitive": false, + "pattern": "^(adabas|buntdb|cache|cassandra|cloudscape|cockroachdb|coldfusion|consul|cosmosdb|couchbase|couchdb|db2|derby|dynamodb|edb|elasticsearch|eloquent|filemaker|firebird|firstsql|geode|h2|hanadb|hbase|hive|hsqldb|informix|ingres|instantdb|interbase|leveldb|mariadb|maxdb|memcached|mongodb|mssql|mysql|neo4j|netezza|opensearch|oracle|other_sql|pervasive|pointbase|postgresql|presto|progress|redis|redshift|snowflake|sqlite|sybase|teradata|vertica)$", + "title": "DB System", + "type": "string" + }, + "db.connection_string": { + "default": null, + "description": "The connection string used to connect to the database.", + "examples": [ + "Server=(localdb)\u000b11.0;Integrated Security=true;", + "postgresql://localhost:5432" + ], + "is_sensitive": true, + "title": "DB Connection String", + "type": "string" + }, + "db.user": { + "default": null, + "description": "Username for accessing the database.", + "examples": [ + "widget_user" + ], + "is_sensitive": false, + "title": "DB User", + "type": "string" + }, + "db.name": { + "default": null, + "description": "The name of the database being connected to.", + "examples": [ + "customers" + ], + "is_sensitive": false, + "title": "DB Name", + "type": "string" + }, + "db.statement": { + "default": null, + "description": "The database statement being executed.", + "examples": [ + "SELECT * FROM wuser_table', 'SET mykey \"WuValue" + ], + "is_sensitive": true, + "title": "DB Statement", + "type": "string" + }, + "db.operation": { + "default": null, + "description": "The name of the operation being executed, e.g. the MongoDB command name such as findAndModify, or the SQL keyword.", + "examples": [ + "findAndModify", + "HMSET", + "SELECT" + ], + "is_sensitive": false, + "title": "DB Operation", + "type": "string" + }, + "db.sql.table": { + "default": null, + "description": "The name of the primary table that the operation is acting upon, including the database name (if applicable).", + "examples": [ + "customers" + ], + "is_sensitive": false, + "title": "DB SQL Table", + "type": "string" + }, + "db.row_count": { + "default": null, + "description": "\nThe number of rows/results from the query or operation. For caches and other datastores, i.e. Redis, this tag should only set for operations that retrieve stored data,\nsuch as GET operations and queries, excluding SET and other commands not returning data. ", + "examples": [ + "customers" + ], + "is_sensitive": false, + "minimum": 0, + "title": "DB Row Count", + "type": "integer" + } + }, + "required": [ + "span.kind", + "db.system" + ], + "title": "TagsSQL", + "type": "object" + }, + "SpanKind": { + "enum": [ + "internal", + "client", + "server", + "producer", + "consumer" + ], + "title": "SpanKind", + "type": "string" + } + }, + "description": "Represents the generic semantic_model for the agent payload, structurally defined here: https://github.com/DataDog/datadog-agent/blob/main/pkg/proto/datadog/trace/agent_payload.proto", + "properties": { + "hostName": { + "default": null, + "description": "\nHostname of where the agent is running.", + "examples": [ + "my-hostname" + ], + "is_sensitive": false, + "minLength": 0, + "title": "Hostname", + "type": "string" + }, + "env": { + "default": null, + "description": "Specifies the 'env' set in the agent's configuration.", + "minLength": 1, + "title": "Env", + "type": "string" + }, + "tags": { + "additionalProperties": { + "type": "string" + }, + "default": null, + "description": "Tags specifies tags common in all `tracerPayloads`", + "title": "Tags", + "type": "object" + }, + "agentVersion": { + "description": "Specifies version of the agent", + "minLength": 1, + "title": "Agent Version", + "type": "string" + }, + "targetTPS": { + "description": "Holds `TargetTPS` value in AgentConfig", + "exclusiveMinimum": 0.0, + "title": "Target TPS", + "type": "number" + }, + "errorTPS": { + "description": "Holds `ErrorTPS` value in AgentConfig", + "exclusiveMinimum": 0.0, + "title": "Error TPS", + "type": "number" + }, + "rareSamplerEnabled": { + "default": null, + "description": "Holds `RareSamplerEnabled` value in AgentConfig", + "title": "Rare Sampler Flag", + "type": "boolean" + }, + "tracerPayloads": { + "description": "Specifies the list of the payloads received from tracers", + "items": { + "$ref": "#/$defs/TracerPayload" + }, + "title": "Tracer Payloads", + "type": "array" + } + }, + "required": [ + "agentVersion", + "targetTPS", + "errorTPS", + "tracerPayloads" + ], + "title": "AgentPayload", + "type": "object", + "$schema": "https://json-schema.org/draft/2020-12/schema" +} \ No newline at end of file diff --git a/semantic-core/schema/releases/1.1.0/aspects_registry.json b/semantic-core/schema/releases/1.1.0/aspects_registry.json new file mode 100644 index 0000000..76784d3 --- /dev/null +++ b/semantic-core/schema/releases/1.1.0/aspects_registry.json @@ -0,0 +1,18 @@ +{ + "description": "Represents the registry of all Semantic Aspects, i.e. the groups of properties that are related to each other and\nare curated by one owner.", + "properties": { + "infosec": { + "description": "This aspect relates to infosec concerns", + "id": "infosec", + "owner": "trust_and_safety", + "title": "Infosec", + "type": "string" + } + }, + "required": [ + "infosec" + ], + "title": "AspectsRegistry", + "type": "object", + "$schema": "https://json-schema.org/draft/2020-12/schema" +} \ No newline at end of file diff --git a/semantic-core/schema/releases/1.1.0/intake_resolved_db_span.json b/semantic-core/schema/releases/1.1.0/intake_resolved_db_span.json new file mode 100644 index 0000000..5a9e44b --- /dev/null +++ b/semantic-core/schema/releases/1.1.0/intake_resolved_db_span.json @@ -0,0 +1,96 @@ +{ + "description": "Semantic model for the DB information present in a span during intake.", + "properties": { + "db.system": { + "description": "An identifier for the database management system (DBMS) product being used.", + "examples": [ + "mysql", + "postgresql" + ], + "is_sensitive": false, + "pattern": "^(adabas|buntdb|cache|cassandra|cloudscape|cockroachdb|coldfusion|consul|cosmosdb|couchbase|couchdb|db2|derby|dynamodb|edb|elasticsearch|eloquent|filemaker|firebird|firstsql|geode|h2|hanadb|hbase|hive|hsqldb|informix|ingres|instantdb|interbase|leveldb|mariadb|maxdb|memcached|mongodb|mssql|mysql|neo4j|netezza|opensearch|oracle|other_sql|pervasive|pointbase|postgresql|presto|progress|redis|redshift|snowflake|sqlite|sybase|teradata|vertica)$", + "title": "DB System", + "type": "string" + }, + "db.connection_string": { + "default": null, + "description": "The connection string used to connect to the database.", + "examples": [ + "Server=(localdb)\u000b11.0;Integrated Security=true;", + "postgresql://localhost:5432" + ], + "is_sensitive": true, + "title": "DB Connection String", + "type": "string" + }, + "db.user": { + "default": null, + "description": "Username for accessing the database.", + "examples": [ + "widget_user" + ], + "is_sensitive": false, + "title": "DB User", + "type": "string" + }, + "db.name": { + "default": null, + "description": "The name of the database being connected to.", + "examples": [ + "customers" + ], + "is_sensitive": false, + "title": "DB Name", + "type": "string" + }, + "db.statement": { + "default": null, + "description": "The database statement being executed.", + "examples": [ + "SELECT * FROM wuser_table', 'SET mykey \"WuValue" + ], + "is_sensitive": true, + "title": "DB Statement", + "type": "string" + }, + "db.operation": { + "default": null, + "description": "The name of the operation being executed, e.g. the MongoDB command name such as findAndModify, or the SQL keyword.", + "examples": [ + "findAndModify", + "HMSET", + "SELECT" + ], + "is_sensitive": false, + "title": "DB Operation", + "type": "string" + }, + "db.sql.table": { + "default": null, + "description": "The name of the primary table that the operation is acting upon, including the database name (if applicable).", + "examples": [ + "customers" + ], + "is_sensitive": false, + "title": "DB SQL Table", + "type": "string" + }, + "db.row_count": { + "default": null, + "description": "\nThe number of rows/results from the query or operation. For caches and other datastores, i.e. Redis, this tag should only set for operations that retrieve stored data,\nsuch as GET operations and queries, excluding SET and other commands not returning data. ", + "examples": [ + "customers" + ], + "is_sensitive": false, + "minimum": 0, + "title": "DB Row Count", + "type": "integer" + } + }, + "required": [ + "db.system" + ], + "title": "IntakeResolvedDbSpan", + "type": "object", + "$schema": "https://json-schema.org/draft/2020-12/schema" +} \ No newline at end of file diff --git a/semantic-core/schema/releases/1.1.0/intake_resolved_http_span.json b/semantic-core/schema/releases/1.1.0/intake_resolved_http_span.json new file mode 100644 index 0000000..116e18d --- /dev/null +++ b/semantic-core/schema/releases/1.1.0/intake_resolved_http_span.json @@ -0,0 +1,139 @@ +{ + "description": "Semantic model for the HTTP information present in a span during intake.", + "properties": { + "http.status_code": { + "description": "\nThe HTTP response status code.\nWhen span.kind: client the response status code received.\nWhen span.kind: server the response status code sent.\nNote: Although this is an integer, it must be sent as a string.", + "examples": [ + "200", + "404", + "500" + ], + "is_sensitive": false, + "pattern": "^[12345]\\d\\d$", + "title": "HTTP Status Code", + "type": "string" + }, + "http.url": { + "description": "\nThe URL of the HTTP request, including the obfuscated query string.", + "examples": [ + "https://example.com:443/search?q=datadog" + ], + "is_sensitive": true, + "minLength": 1, + "title": "HTTP URL", + "type": "string" + }, + "http.method": { + "description": "\nThe HTTP method used for the connection. Required for both client and server spans.", + "examples": [ + "GET", + "POST", + "PUT", + "DELETE", + "PATCH" + ], + "is_sensitive": false, + "pattern": "^(GET|HEAD|POST|PUT|DELETE|CONNECT|OPTIONS|TRACE|PATCH)$", + "title": "HTTP Method", + "type": "string" + }, + "http.version": { + "description": "\nThe version of HTTP used for the request.", + "examples": [ + "1.0", + "1.1", + "2.0" + ], + "is_sensitive": false, + "pattern": "^1\\.[01]$|^2\\.0$", + "title": "HTTP Version", + "type": "string" + }, + "http.route": { + "default": null, + "description": "\nThe matched route (path template).\nOnly when span.kind: server.", + "examples": [ + "/users/:userID" + ], + "is_sensitive": false, + "minLength": 1, + "title": "HTTP Route", + "type": "string" + }, + "http.client_ip": { + "default": null, + "description": "\nThe IP address of the original client behind all proxies, if known (discovered from headers such as X-Forwarded-For).", + "examples": [ + "192.168.123.132" + ], + "is_sensitive": true, + "pattern": "^(?:[0-9]{1,3}\\.){3}[0-9]{1,3}|(?:[A-F0-9]{1,4}:){7}[A-F0-9]{1,4}$", + "title": "HTTP Client IP", + "type": "string" + }, + "http.useragent": { + "default": null, + "description": "\nThe user agent header received with the request.\nOnly when span.kind: server.", + "examples": [ + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36" + ], + "is_sensitive": true, + "minLength": 1, + "title": "HTTP User Agent", + "type": "string" + }, + "http.request.content_length": { + "default": null, + "description": "\nThe size of the request body.\nThe size of the request payload body in bytes. This is the number of bytes transferred excluding headers and is often, but not always, present as the Content-Length header.\nFor requests using transport encoding, this should be compressed size.", + "examples": [ + 1234 + ], + "exclusiveMinimum": 0, + "is_sensitive": true, + "title": "HTTP Request Content Length", + "type": "integer" + }, + "http.response.content_length": { + "default": null, + "description": "\nThe size of the response payload body in bytes.\nThe size of the response payload body in bytes. This is the number of bytes transferred excluding headers and is often, but not always, present as the Content-Length header.\nFor requests using transport encoding, this should be compressed size.", + "examples": [ + 1234 + ], + "exclusiveMinimum": 0, + "is_sensitive": true, + "title": "HTTP Response Content Length", + "type": "integer" + }, + "http.request.content_length_uncompressed": { + "default": null, + "description": "\nThe size of the request payload body after transport decoding. Not set if transport encoding not used.", + "examples": [ + 1234 + ], + "exclusiveMinimum": 0, + "is_sensitive": true, + "title": "HTTP Request Content Length Uncompressed", + "type": "integer" + }, + "http.response.content_length_uncompressed": { + "default": null, + "description": "\nThe size of the response payload body after transport decoding. Not set if transport encoding not used.", + "examples": [ + 1234 + ], + "exclusiveMinimum": 0, + "is_sensitive": true, + "title": "HTTP Response Content Length Uncompressed", + "type": "integer" + } + }, + "required": [ + "http.status_code", + "http.url", + "http.method", + "http.version" + ], + "title": "IntakeResolvedHttpSpan", + "type": "object", + "$schema": "https://json-schema.org/draft/2020-12/schema" +} \ No newline at end of file diff --git a/semantic-core/schema/releases/1.1.0/intake_resolved_span.json b/semantic-core/schema/releases/1.1.0/intake_resolved_span.json new file mode 100644 index 0000000..72c1b7b --- /dev/null +++ b/semantic-core/schema/releases/1.1.0/intake_resolved_span.json @@ -0,0 +1,117 @@ +{ + "$defs": { + "SpanLink": { + "properties": { + "traceID": { + "description": "\n Trace identifier, generated by the tracer library. The value of this field is a 64-bit integer, and uniquely identifies the trace within the org.", + "examples": [ + 0, + 12345, + 543210, + 9999999 + ], + "is_sensitive": false, + "title": "Trace ID", + "type": "integer" + }, + "traceID_High": { + "default": null, + "description": "\n Trace identifier, generated by the tracer library. The value of this field is a 64-bit integer, and uniquely identifies the trace within the org.", + "examples": [ + 0, + 12345, + 543210, + 9999999 + ], + "is_sensitive": false, + "title": "Trace ID High", + "type": "integer" + }, + "spanID": { + "default": null, + "description": "\n Span identifier, generated by the tracer library. The value of this field is a 64-bit integer, and uniquely identifies the span within the trace.", + "examples": [ + 0, + 12345, + 543210, + 9999999 + ], + "is_sensitive": false, + "title": "Span ID", + "type": "integer" + }, + "attributes": { + "default": null, + "description": "\n This field represents an arbitrary map of key-value pairs.", + "examples": [ + { + "foo": "bar", + "key": "value" + } + ], + "is_sensitive": false, + "title": "attributes", + "type": "object" + }, + "traceState": { + "default": null, + "description": "\n Additional vendor-specific trace identification information across different distributed tracing systems. The tracestate field may contain any opaque value in any of the keys. See https://www.w3.org/TR/trace-context/#tracestate-header.", + "examples": [ + "rojo=00f067aa0ba902b7", + "rojo=00f067aa0ba902b7,congo=t61rcWkgMzE" + ], + "is_sensitive": false, + "title": "Trace State", + "type": "string" + }, + "flags": { + "default": null, + "description": "\n An 32-bit integer that controls tracing flags such as sampling, trace level, etc. These flags are recommendations given by the caller rather than strict rules to follow. Flags may include zero as valid value. The 31th bit must thus be set to distinguish unset vs zero value.", + "examples": [ + 0, + 4, + 128, + 4294967296 + ], + "is_sensitive": false, + "maximum": 4294967295, + "minimum": 0, + "title": "Flags", + "type": "integer" + } + }, + "required": [ + "traceID" + ], + "title": "SpanLink", + "type": "object" + } + }, + "description": "Represents the generic information present in a span during intake.", + "properties": { + "_dd.hostname": { + "description": "\nWhen the DD_TRACE_REPORT_HOSTNAME=true environment variable, or report_hostname are set by the user the tracing clients will collect the hostname directly from the process or OS to report to the trace agent.\nWhen _dd.hostname is present the trace agent will not use it\u2019s hostname for the trace.\nNote: this tag should only be set if configured to do so. It is disabled by default.", + "examples": [ + "my-hostname" + ], + "is_sensitive": false, + "minLength": 0, + "title": "Hostname", + "type": "string" + }, + "spanLinks": { + "default": null, + "items": { + "$ref": "#/$defs/SpanLink" + }, + "title": "Span Links", + "type": "array" + } + }, + "required": [ + "_dd.hostname" + ], + "title": "IntakeResolvedSpan", + "type": "object", + "$schema": "https://json-schema.org/draft/2020-12/schema" +} \ No newline at end of file diff --git a/semantic-core/schema/releases/1.1.0/owners_registry.json b/semantic-core/schema/releases/1.1.0/owners_registry.json new file mode 100644 index 0000000..282a6d7 --- /dev/null +++ b/semantic-core/schema/releases/1.1.0/owners_registry.json @@ -0,0 +1,19 @@ +{ + "description": "Represents the registry of all Semantic Owners, i.e. the owners that maintain Semantic Properties.", + "properties": { + "trust_and_safety": { + "contacts": [], + "description": "This is the team responsible for the Trust and Safety of our customers.", + "id": "trust_and_safety", + "team": "Trust and Safety", + "title": "Trust And Safety", + "type": "string" + } + }, + "required": [ + "trust_and_safety" + ], + "title": "OwnersRegistry", + "type": "object", + "$schema": "https://json-schema.org/draft/2020-12/schema" +} \ No newline at end of file diff --git a/semantic-core/schema/releases/1.1.0/properties_registry.json b/semantic-core/schema/releases/1.1.0/properties_registry.json new file mode 100644 index 0000000..66653f3 --- /dev/null +++ b/semantic-core/schema/releases/1.1.0/properties_registry.json @@ -0,0 +1,41 @@ +{ + "$defs": { + "PoliciesEnum": { + "enum": [ + "GDPR", + "CCPA", + "HIPAA" + ], + "title": "PoliciesEnum", + "type": "string" + } + }, + "description": "Represents the registry of all Semantic Properties, i.e. the properties that can be used to define Semantic Types.", + "properties": { + "is_sensitive": { + "aspect": "security", + "description": "Indicates if the field associated with this property contains sensitive data or not.", + "internal_description": "Sensitive data has some implications that T&S must define.", + "is_internal": false, + "title": "Is Sensitive", + "type": "boolean" + }, + "data_policies": { + "aspect": "security", + "description": "A list of data policies that apply to the associated field.", + "is_internal": false, + "items": { + "$ref": "#/$defs/PoliciesEnum" + }, + "title": "Data Policies", + "type": "array" + } + }, + "required": [ + "is_sensitive", + "data_policies" + ], + "title": "PropertiesRegistry", + "type": "object", + "$schema": "https://json-schema.org/draft/2020-12/schema" +} \ No newline at end of file diff --git a/semantic-core/schema/releases/1.1.0/signals_registry.json b/semantic-core/schema/releases/1.1.0/signals_registry.json new file mode 100644 index 0000000..96902b3 --- /dev/null +++ b/semantic-core/schema/releases/1.1.0/signals_registry.json @@ -0,0 +1,16 @@ +{ + "description": "Represents the registry of all signals that can be used to define complex validations.", + "properties": { + "remove_query_string": { + "description": "True if the agent that sent a payload containing an http url is configured to remove the query string from the url before sending it to the backend.\nSee: https://docs.datadoghq.com/tracing/configure_data_security/?tab=http\n", + "title": "Remove Query String", + "type": "boolean" + } + }, + "required": [ + "remove_query_string" + ], + "title": "SignalsRegistry", + "type": "object", + "$schema": "https://json-schema.org/draft/2020-12/schema" +} \ No newline at end of file