diff --git a/ddtrace/_trace/_inferred_proxy.py b/ddtrace/_trace/_inferred_proxy.py
index 57f19492311..1cacd600844 100644
--- a/ddtrace/_trace/_inferred_proxy.py
+++ b/ddtrace/_trace/_inferred_proxy.py
@@ -63,11 +63,11 @@ def finish_callback(_):
 
 
 def set_inferred_proxy_span_tags(span, proxy_context) -> Span:
-    span.set_tag_str(COMPONENT, supported_proxies[proxy_context["proxy_system_name"]]["component"])
+    span._set_tag_str(COMPONENT, supported_proxies[proxy_context["proxy_system_name"]]["component"])
 
-    span.set_tag_str(http.METHOD, proxy_context["method"])
-    span.set_tag_str(http.URL, f"{proxy_context['domain_name']}{proxy_context['path']}")
-    span.set_tag_str("stage", proxy_context["stage"])
+    span._set_tag_str(http.METHOD, proxy_context["method"])
+    span._set_tag_str(http.URL, f"{proxy_context['domain_name']}{proxy_context['path']}")
+    span._set_tag_str("stage", proxy_context["stage"])
 
     span.set_metric("_dd.inferred_span", 1)
     return span
diff --git a/ddtrace/_trace/processor/__init__.py b/ddtrace/_trace/processor/__init__.py
index 21d728d2f52..7b1fcec816e 100644
--- a/ddtrace/_trace/processor/__init__.py
+++ b/ddtrace/_trace/processor/__init__.py
@@ -224,11 +224,11 @@ class TraceTagsProcessor(TraceProcessor):
     def _set_git_metadata(self, chunk_root):
         repository_url, commit_sha, main_package = gitmetadata.get_git_tags()
         if repository_url:
-            chunk_root.set_tag_str("_dd.git.repository_url", repository_url)
+            chunk_root._set_tag_str("_dd.git.repository_url", repository_url)
         if commit_sha:
-            chunk_root.set_tag_str("_dd.git.commit.sha", commit_sha)
+            chunk_root._set_tag_str("_dd.git.commit.sha", commit_sha)
         if main_package:
-            chunk_root.set_tag_str("_dd.python_main_package", main_package)
+            chunk_root._set_tag_str("_dd.python_main_package", main_package)
 
     def process_trace(self, trace: List[Span]) -> Optional[List[Span]]:
         if not trace:
@@ -249,11 +249,11 @@ def process_trace(self, trace: List[Span]) -> Optional[List[Span]]:
         for span in spans_to_tag:
             span._update_tags_from_context()
             self._set_git_metadata(span)
-            span.set_tag_str("language", "python")
+            span._set_tag_str("language", "python")
             # for 128 bit trace ids
             if span.trace_id > MAX_UINT_64BITS:
                 trace_id_hob = _get_64_highest_order_bits_as_hex(span.trace_id)
-                span.set_tag_str(HIGHER_ORDER_TRACE_ID_BITS, trace_id_hob)
+                span._set_tag_str(HIGHER_ORDER_TRACE_ID_BITS, trace_id_hob)
 
             if LAST_DD_PARENT_ID_KEY in span._meta and span._parent is not None:
                 # we should only set the last parent id on local root spans
diff --git a/ddtrace/_trace/processor/resource_renaming.py b/ddtrace/_trace/processor/resource_renaming.py
index 6ee6c664f95..25a9f646795 100644
--- a/ddtrace/_trace/processor/resource_renaming.py
+++ b/ddtrace/_trace/processor/resource_renaming.py
@@ -74,4 +74,4 @@ def on_span_finish(self, span):
         if not route or config._trace_resource_renaming_always_simplified_endpoint:
             url = span.get_tag(http.URL)
             endpoint = self._compute_simplified_endpoint(url)
-            span.set_tag_str(http.ENDPOINT, endpoint)
+            span._set_tag_str(http.ENDPOINT, endpoint)
diff --git a/ddtrace/_trace/span.py b/ddtrace/_trace/span.py
index bc68f5e1d53..9e306f621bc 100644
--- a/ddtrace/_trace/span.py
+++ b/ddtrace/_trace/span.py
@@ -436,7 +436,7 @@ def get_struct_tag(self, key: str) -> Optional[Dict[str, Any]]:
         """
         return self._get_struct_tag(key)
 
-    def set_tag_str(self, key: _TagNameType, value: Text) -> None:
+    def _set_tag_str(self, key: _TagNameType, value: Text) -> None:
         """Set a value for a tag. Values are coerced to unicode in Python 2 and
         str in Python 3, with decoding errors in conversion being replaced with
         U+FFFD.
@@ -448,6 +448,11 @@ def set_tag_str(self, key: _TagNameType, value: Text) -> None:
                 raise e
             log.warning("Failed to set text tag '%s'", key, exc_info=True)
 
+    @removals.remove(message="use Span.set_tag instead", removal_version="4.0.0")
+    def set_tag_str(self, key: _TagNameType, value: Text) -> None:
+        """Deprecated: use `set_tag` instead."""
+        self._set_tag_str(key, value)
+
     def get_tag(self, key: _TagNameType) -> Optional[Text]:
         """Return the given tag or None if it doesn't exist."""
         return self._meta.get(key, None)
diff --git a/ddtrace/_trace/trace_handlers.py b/ddtrace/_trace/trace_handlers.py
index 75734de1dc1..6ba7c134067 100644
--- a/ddtrace/_trace/trace_handlers.py
+++ b/ddtrace/_trace/trace_handlers.py
@@ -187,8 +187,8 @@ def _finish_span(
 
 
 def _set_web_frameworks_tags(ctx, span, int_config):
-    span.set_tag_str(COMPONENT, int_config.integration_name)
-    span.set_tag_str(SPAN_KIND, SpanKind.SERVER)
+    span._set_tag_str(COMPONENT, int_config.integration_name)
+    span._set_tag_str(SPAN_KIND, SpanKind.SERVER)
     # PERF: avoid setting via Span.set_tag
     span.set_metric(_SPAN_MEASURED_KEY, 1)
 
@@ -223,7 +223,7 @@ def _on_web_framework_finish_request(
     )
     _set_inferred_proxy_tags(span, status_code)
     for tk, tv in core.get_item("additional_tags", default=dict()).items():
-        span.set_tag_str(tk, tv)
+        span._set_tag_str(tk, tv)
 
     if finish:
         span.finish()
@@ -308,7 +308,7 @@ def _maybe_start_http_response_span(ctx: core.ExecutionContext) -> None:
         request_span, middleware._config, status_code=status_code, response_headers=ctx.get_item("environ")
     )
     if ctx.get_item("start_span", False):
-        request_span.set_tag_str(http.STATUS_MSG, status_msg)
+        request_span._set_tag_str(http.STATUS_MSG, status_msg)
         _start_span(
             ctx,
             call_trace=False,
@@ -320,9 +320,9 @@ def _maybe_start_http_response_span(ctx: core.ExecutionContext) -> None:
 def _on_request_prepare(ctx, start_response):
     middleware = ctx.get_item("middleware")
     req_span = ctx.get_item("req_span")
-    req_span.set_tag_str(COMPONENT, middleware._config.integration_name)
+    req_span._set_tag_str(COMPONENT, middleware._config.integration_name)
     # set span.kind to the type of operation being performed
-    req_span.set_tag_str(SPAN_KIND, SpanKind.SERVER)
+    req_span._set_tag_str(SPAN_KIND, SpanKind.SERVER)
     if hasattr(middleware, "_request_call_modifier"):
         modifier = middleware._request_call_modifier
         args = [ctx]
@@ -336,7 +336,7 @@ def _on_request_prepare(ctx, start_response):
         else middleware._application_span_name
     )
 
-    app_span.set_tag_str(COMPONENT, middleware._config.integration_name)
+    app_span._set_tag_str(COMPONENT, middleware._config.integration_name)
     ctx.set_item("app_span", app_span)
 
     if hasattr(middleware, "_wrapped_start_response"):
@@ -385,7 +385,7 @@ def _on_request_complete(ctx, closing_iterable, app_is_iterator):
         activate=True,
     )
 
-    resp_span.set_tag_str(COMPONENT, middleware._config.integration_name)
+    resp_span._set_tag_str(COMPONENT, middleware._config.integration_name)
 
     modifier = (
         middleware._response_call_modifier
@@ -401,7 +401,7 @@ def _on_response_prepared(resp_span, response):
     if hasattr(response, "__class__"):
         resp_class = getattr(response.__class__, "__name__", None)
         if resp_class:
-            resp_span.set_tag_str("result_class", resp_class)
+            resp_span._set_tag_str("result_class", resp_class)
 
 
 def _on_request_prepared(middleware, req_span, url, request_headers, environ):
@@ -416,19 +416,19 @@ def _on_request_prepared(middleware, req_span, url, request_headers, environ):
 
 def _set_flask_request_tags(request, span, flask_config):
     try:
-        span.set_tag_str(COMPONENT, flask_config.integration_name)
+        span._set_tag_str(COMPONENT, flask_config.integration_name)
 
         if span.name.split(".")[-1] == "request":
-            span.set_tag_str(SPAN_KIND, SpanKind.SERVER)
+            span._set_tag_str(SPAN_KIND, SpanKind.SERVER)
 
         # DEV: This name will include the blueprint name as well (e.g. `bp.index`)
         if not span.get_tag(FLASK_ENDPOINT) and request.endpoint:
             span.resource = " ".join((request.method, request.endpoint))
-            span.set_tag_str(FLASK_ENDPOINT, request.endpoint)
+            span._set_tag_str(FLASK_ENDPOINT, request.endpoint)
 
         if not span.get_tag(FLASK_URL_RULE) and request.url_rule and request.url_rule.rule:
             span.resource = " ".join((request.method, request.url_rule.rule))
-            span.set_tag_str(FLASK_URL_RULE, request.url_rule.rule)
+            span._set_tag_str(FLASK_URL_RULE, request.url_rule.rule)
 
         if not span.get_tag(FLASK_VIEW_ARGS) and request.view_args and flask_config.get("collect_view_args"):
             for k, v in request.view_args.items():
@@ -487,7 +487,7 @@ def _on_flask_render(template, flask_config):
     name = maybe_stringify(getattr(template, "name", None) or flask_config.get("template_default_name"))
     if name is not None:
         span.resource = name
-        span.set_tag_str("flask.template_name", name)
+        span._set_tag_str("flask.template_name", name)
 
 
 def _on_request_span_modifier(
@@ -504,7 +504,7 @@ def _on_request_span_modifier(
     # PERF: avoid setting via Span.set_tag
     span.set_metric(_SPAN_MEASURED_KEY, 1)
 
-    span.set_tag_str(flask_version, flask_version_str)
+    span._set_tag_str(flask_version, flask_version_str)
 
 
 def _on_request_span_modifier_post(ctx, flask_config, request, req_body):
@@ -589,7 +589,7 @@ def _on_django_func_wrapped(_unused1, _unused2, _unused3, ctx, ignored_excs):
 
 def _on_django_block_request(ctx: core.ExecutionContext, metadata: Dict[str, str], django_config, url: str, query: str):
     for tk, tv in metadata.items():
-        ctx.span.set_tag_str(tk, tv)
+        ctx.span._set_tag_str(tk, tv)
     _set_url_tag(django_config, ctx.span, url, query)
 
 
@@ -717,8 +717,8 @@ def _on_botocore_patched_bedrock_api_call_started(ctx, request_params):
     integration = ctx.get_item("bedrock_integration")
     integration._tag_proxy_request(ctx)
 
-    span.set_tag_str("bedrock.request.model_provider", ctx.get_item("model_provider"))
-    span.set_tag_str("bedrock.request.model", ctx.get_item("model_name"))
+    span._set_tag_str("bedrock.request.model_provider", ctx.get_item("model_provider"))
+    span._set_tag_str("bedrock.request.model", ctx.get_item("model_name"))
 
     if "n" in request_params:
         ctx.set_item("num_generations", str(request_params["n"]))
@@ -749,7 +749,7 @@ def _after_job_execution(ctx, job_failed, span_tags):
         if job_failed:
             span.error = 1
         for k in span_tags.keys():
-            span.set_tag_str(k, span_tags[k])
+            span._set_tag_str(k, span_tags[k])
 
 
 def _on_end_of_traced_method_in_fork(ctx):
@@ -859,26 +859,26 @@ def _set_span_pointer(span: "Span", span_pointer_description: _SpanPointerDescri
 
 
 def _set_azure_function_tags(span, azure_functions_config, function_name, trigger, span_kind):
-    span.set_tag_str(COMPONENT, azure_functions_config.integration_name)
-    span.set_tag_str(SPAN_KIND, span_kind)
-    span.set_tag_str("aas.function.name", function_name)  # codespell:ignore
-    span.set_tag_str("aas.function.trigger", trigger)  # codespell:ignore
+    span._set_tag_str(COMPONENT, azure_functions_config.integration_name)
+    span._set_tag_str(SPAN_KIND, span_kind)
+    span._set_tag_str("aas.function.name", function_name)  # codespell:ignore
+    span._set_tag_str("aas.function.trigger", trigger)  # codespell:ignore
 
 
 def _set_azure_messaging_tags(ctx, entity_name, operation, system, fully_qualified_namespace, message_id, batch_count):
     span = ctx.span
-    span.set_tag_str(MESSAGING_DESTINATION_NAME, entity_name)
-    span.set_tag_str(MESSAGING_OPERATION, operation)
-    span.set_tag_str(MESSAGING_SYSTEM, system)
+    span._set_tag_str(MESSAGING_DESTINATION_NAME, entity_name)
+    span._set_tag_str(MESSAGING_OPERATION, operation)
+    span._set_tag_str(MESSAGING_SYSTEM, system)
 
     if fully_qualified_namespace is not None:
-        span.set_tag_str(net.TARGET_NAME, fully_qualified_namespace)
+        span._set_tag_str(net.TARGET_NAME, fully_qualified_namespace)
 
     if batch_count is not None:
-        span.set_tag_str(MESSAGING_BATCH_COUNT, batch_count)
+        span._set_tag_str(MESSAGING_BATCH_COUNT, batch_count)
 
     if message_id is not None:
-        span.set_tag_str(MESSAGING_MESSAGE_ID, message_id)
+        span._set_tag_str(MESSAGING_MESSAGE_ID, message_id)
 
 
 def _on_azure_functions_request_span_modifier(ctx, azure_functions_config, req):
@@ -943,8 +943,8 @@ def _on_azure_message_modifier(
     ctx, azure_config, operation, system, entity_name, fully_qualified_namespace, message_id, batch_count
 ):
     span = ctx.span
-    span.set_tag_str(COMPONENT, azure_config.integration_name)
-    span.set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
+    span._set_tag_str(COMPONENT, azure_config.integration_name)
+    span._set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
 
     _set_azure_messaging_tags(ctx, entity_name, operation, system, fully_qualified_namespace, message_id, batch_count)
 
@@ -960,17 +960,17 @@ def _on_router_match(route):
     MOLTEN_ROUTE = "molten.route"
 
     if not req_span.get_tag(MOLTEN_ROUTE):
-        req_span.set_tag_str(MOLTEN_ROUTE, route.name)
+        req_span._set_tag_str(MOLTEN_ROUTE, route.name)
     if not req_span.get_tag(http.ROUTE):
-        req_span.set_tag_str(http.ROUTE, route.template)
+        req_span._set_tag_str(http.ROUTE, route.template)
 
 
 def _set_websocket_message_tags_on_span(websocket_span: Span, message: Mapping[str, Any]):
     if "text" in message:
-        websocket_span.set_tag_str(websocket.MESSAGE_TYPE, "text")
+        websocket_span._set_tag_str(websocket.MESSAGE_TYPE, "text")
         websocket_span.set_metric(websocket.MESSAGE_LENGTH, len(message["text"].encode("utf-8")))
     elif "binary" in message:
-        websocket_span.set_tag_str(websocket.MESSAGE_TYPE, "binary")
+        websocket_span._set_tag_str(websocket.MESSAGE_TYPE, "binary")
         websocket_span.set_metric(websocket.MESSAGE_LENGTH, len(message["bytes"]))
 
 
@@ -987,10 +987,10 @@ def _set_client_ip_tags(scope: Mapping[str, Any], span: Span):
     client = scope.get("client")
     if len(client) >= 1:  # type: ignore[arg-type]
         client_ip = client[0]  # type: ignore[index]
-        span.set_tag_str(net.TARGET_HOST, client_ip)
+        span._set_tag_str(net.TARGET_HOST, client_ip)
         try:
             is_valid_ip(client_ip)
-            span.set_tag_str("network.client.ip", client_ip)
+            span._set_tag_str("network.client.ip", client_ip)
         except ValueError as e:
             log.debug("Could not validate client IP address for websocket send message: %s", str(e))
 
@@ -1005,9 +1005,9 @@ def _on_asgi_websocket_receive_message(ctx, scope, message):
     span = ctx.span
     integration_config = ctx.get_item("integration_config")
 
-    span.set_tag_str(COMPONENT, integration_config.integration_name)
-    span.set_tag_str(SPAN_KIND, SpanKind.CONSUMER)
-    span.set_tag_str(websocket.RECEIVE_DURATION_TYPE, "blocking")
+    span._set_tag_str(COMPONENT, integration_config.integration_name)
+    span._set_tag_str(SPAN_KIND, SpanKind.CONSUMER)
+    span._set_tag_str(websocket.RECEIVE_DURATION_TYPE, "blocking")
 
     _set_websocket_message_tags_on_span(span, message)
 
@@ -1036,8 +1036,8 @@ def _on_asgi_websocket_send_message(ctx, scope, message):
     span = ctx.span
     integration_config = ctx.get_item("integration_config")
 
-    span.set_tag_str(COMPONENT, integration_config.integration_name)
-    span.set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
+    span._set_tag_str(COMPONENT, integration_config.integration_name)
+    span._set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
     _set_client_ip_tags(scope, span)
     _set_websocket_message_tags_on_span(span, message)
 
@@ -1061,8 +1061,8 @@ def _on_asgi_websocket_close_message(ctx, scope, message):
     span = ctx.span
     integration_config = ctx.get_item("integration_config")
 
-    span.set_tag_str(COMPONENT, integration_config.integration_name)
-    span.set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
+    span._set_tag_str(COMPONENT, integration_config.integration_name)
+    span._set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
 
     _set_client_ip_tags(scope, span)
 
@@ -1090,8 +1090,8 @@ def _on_asgi_websocket_disconnect_message(ctx, scope, message):
     span = ctx.span
     integration_config = ctx.get_item("integration_config")
 
-    span.set_tag_str(COMPONENT, integration_config.integration_name)
-    span.set_tag_str(SPAN_KIND, SpanKind.CONSUMER)
+    span._set_tag_str(COMPONENT, integration_config.integration_name)
+    span._set_tag_str(SPAN_KIND, SpanKind.CONSUMER)
 
     _set_websocket_close_tags(span, message)
 
@@ -1119,7 +1119,7 @@ def _on_asgi_request(ctx: core.ExecutionContext) -> None:
     ctx.set_item("req_span", span)
 
     if scope["type"] == "websocket":
-        span.set_tag_str("http.upgraded", "websocket")
+        span._set_tag_str("http.upgraded", "websocket")
 
     if "datadog" not in scope:
         scope["datadog"] = {"request_spans": [span]}
diff --git a/ddtrace/_trace/tracer.py b/ddtrace/_trace/tracer.py
index d2d6201636e..8f66684a2cd 100644
--- a/ddtrace/_trace/tracer.py
+++ b/ddtrace/_trace/tracer.py
@@ -547,10 +547,10 @@ def _start_span(
                 on_finish=[self._on_span_finish],
             )
             if config._report_hostname:
-                span.set_tag_str(_HOSTNAME_KEY, hostname.get_hostname())
+                span._set_tag_str(_HOSTNAME_KEY, hostname.get_hostname())
 
         if not span._parent:
-            span.set_tag_str("runtime-id", get_runtime_id())
+            span._set_tag_str("runtime-id", get_runtime_id())
             span._metrics[PID] = self._pid
 
         # Apply default global tags.
@@ -558,7 +558,7 @@ def _start_span(
             span.set_tags(self._tags)
 
         if config.env:
-            span.set_tag_str(ENV_KEY, config.env)
+            span._set_tag_str(ENV_KEY, config.env)
 
         # Only set the version tag on internal spans.
         if config.version:
@@ -570,7 +570,7 @@ def _start_span(
             if (root_span is None and service == config.service) or (
                 root_span and root_span.service == service and root_span.get_tag(VERSION_KEY) is not None
             ):
-                span.set_tag_str(VERSION_KEY, config.version)
+                span._set_tag_str(VERSION_KEY, config.version)
 
         if activate:
             self.context_provider.activate(span)
diff --git a/ddtrace/_trace/utils_botocore/span_tags.py b/ddtrace/_trace/utils_botocore/span_tags.py
index b44f5eaad70..8724630d175 100644
--- a/ddtrace/_trace/utils_botocore/span_tags.py
+++ b/ddtrace/_trace/utils_botocore/span_tags.py
@@ -60,9 +60,9 @@ def _derive_peer_hostname(service: str, region: str, params: Optional[Dict[str,
 
 
 def set_botocore_patched_api_call_span_tags(span: Span, instance, args, params, endpoint_name, operation):
-    span.set_tag_str(COMPONENT, config.botocore.integration_name)
+    span._set_tag_str(COMPONENT, config.botocore.integration_name)
     # set span.kind to the type of request being performed
-    span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+    span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
     # PERF: avoid setting via Span.set_tag
     span.set_metric(_SPAN_MEASURED_KEY, 1)
 
@@ -86,20 +86,20 @@ def set_botocore_patched_api_call_span_tags(span: Span, instance, args, params,
 
     region_name = deep_getattr(instance, "meta.region_name")
 
-    span.set_tag_str("aws.agent", "botocore")
+    span._set_tag_str("aws.agent", "botocore")
     if operation is not None:
-        span.set_tag_str("aws.operation", operation)
+        span._set_tag_str("aws.operation", operation)
     if region_name is not None:
-        span.set_tag_str("aws.region", region_name)
-        span.set_tag_str("region", region_name)
-        span.set_tag_str("aws.partition", aws.get_aws_partition(region_name))
+        span._set_tag_str("aws.region", region_name)
+        span._set_tag_str("region", region_name)
+        span._set_tag_str("aws.partition", aws.get_aws_partition(region_name))
 
         # Derive peer hostname only in serverless environments to avoid
         # unnecessary tag noise in traditional hosts/containers.
         if in_aws_lambda():
             hostname = _derive_peer_hostname(endpoint_name, region_name, params)
             if hostname:
-                span.set_tag_str("peer.service", hostname)
+                span._set_tag_str("peer.service", hostname)
 
 
 def set_botocore_response_metadata_tags(
@@ -126,4 +126,4 @@ def set_botocore_response_metadata_tags(
         span.set_tag("retry_attempts", response_meta["RetryAttempts"])
 
     if "RequestId" in response_meta:
-        span.set_tag_str("aws.requestid", response_meta["RequestId"])
+        span._set_tag_str("aws.requestid", response_meta["RequestId"])
diff --git a/ddtrace/_trace/utils_valkey.py b/ddtrace/_trace/utils_valkey.py
index fb50a736258..ae66b45a82a 100644
--- a/ddtrace/_trace/utils_valkey.py
+++ b/ddtrace/_trace/utils_valkey.py
@@ -26,14 +26,14 @@
 def _set_span_tags(
     span, pin, config_integration, args: Optional[List], instance, query: Optional[List], is_cluster: bool = False
 ):
-    span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
-    span.set_tag_str(COMPONENT, config_integration.integration_name)
-    span.set_tag_str(db.SYSTEM, valkeyx.APP)
+    span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+    span._set_tag_str(COMPONENT, config_integration.integration_name)
+    span._set_tag_str(db.SYSTEM, valkeyx.APP)
     # PERF: avoid setting via Span.set_tag
     span.set_metric(_SPAN_MEASURED_KEY, 1)
     if query is not None:
         span_name = schematize_cache_operation(valkeyx.RAWCMD, cache_provider=valkeyx.APP)  # type: ignore[operator]
-        span.set_tag_str(span_name, query)
+        span._set_tag_str(span_name, query)
     if pin.tags:
         span.set_tags(pin.tags)
     # some valkey clients do not have a connection_pool attribute (ex. aiovalkey v1.3)
diff --git a/ddtrace/appsec/_asm_request_context.py b/ddtrace/appsec/_asm_request_context.py
index 42e5a419e56..634057b13c4 100644
--- a/ddtrace/appsec/_asm_request_context.py
+++ b/ddtrace/appsec/_asm_request_context.py
@@ -71,8 +71,8 @@ def report_error_on_entry_span(error: str, message: str) -> None:
     entry_span = get_entry_span()
     if not entry_span:
         return
-    entry_span.set_tag_str(APPSEC.ERROR_TYPE, error)
-    entry_span.set_tag_str(APPSEC.ERROR_MESSAGE, message)
+    entry_span._set_tag_str(APPSEC.ERROR_TYPE, error)
+    entry_span._set_tag_str(APPSEC.ERROR_MESSAGE, message)
 
 
 class ASM_Environment:
@@ -238,7 +238,7 @@ def flush_waf_triggers(env: ASM_Environment) -> None:
         env.waf_triggers = []
     telemetry_results: Telemetry_result = env.telemetry
 
-    entry_span.set_tag_str(APPSEC.WAF_VERSION, ddwaf_version)
+    entry_span._set_tag_str(APPSEC.WAF_VERSION, ddwaf_version)
     if env.downstream_requests:
         update_span_metrics(entry_span, APPSEC.DOWNSTREAM_REQUESTS, env.downstream_requests)
     if telemetry_results.total_duration:
@@ -278,10 +278,10 @@ def finalize_asm_env(env: ASM_Environment) -> None:
             info = env.waf_info()
             try:
                 if info.errors:
-                    entry_span.set_tag_str(APPSEC.EVENT_RULE_ERRORS, info.errors)
+                    entry_span._set_tag_str(APPSEC.EVENT_RULE_ERRORS, info.errors)
                     extra = {"product": "appsec", "more_info": info.errors, "stack_limit": 4}
                     logger.debug("asm_context::finalize_asm_env::waf_errors", extra=extra, stack_info=True)
-                entry_span.set_tag_str(APPSEC.EVENT_RULE_VERSION, info.version)
+                entry_span._set_tag_str(APPSEC.EVENT_RULE_VERSION, info.version)
                 entry_span.set_metric(APPSEC.EVENT_RULE_LOADED, info.loaded)
                 entry_span.set_metric(APPSEC.EVENT_RULE_ERROR_COUNT, info.failed)
             except Exception:
@@ -296,7 +296,7 @@ def finalize_asm_env(env: ASM_Environment) -> None:
         if res_headers:
             _set_headers(entry_span, res_headers, kind="response")
         if env.rc_products:
-            entry_span.set_tag_str(APPSEC.RC_PRODUCTS, env.rc_products)
+            entry_span._set_tag_str(APPSEC.RC_PRODUCTS, env.rc_products)
 
     core.discard_local_item(_ASM_CONTEXT)
 
diff --git a/ddtrace/appsec/_handlers.py b/ddtrace/appsec/_handlers.py
index 806e787cf93..78b8828ebdf 100644
--- a/ddtrace/appsec/_handlers.py
+++ b/ddtrace/appsec/_handlers.py
@@ -311,21 +311,21 @@ def _wsgi_make_block_content(ctx, construct_url):
         resp_headers = [("content-type", ctype)]
     status = block_config.get("status_code", 403)
     try:
-        req_span.set_tag_str(RESPONSE_HEADERS + ".content-length", str(len(content)))
+        req_span._set_tag_str(RESPONSE_HEADERS + ".content-length", str(len(content)))
         if ctype is not None:
-            req_span.set_tag_str(RESPONSE_HEADERS + ".content-type", ctype)
-        req_span.set_tag_str(http.STATUS_CODE, str(status))
+            req_span._set_tag_str(RESPONSE_HEADERS + ".content-type", ctype)
+        req_span._set_tag_str(http.STATUS_CODE, str(status))
         url = construct_url(environ)
         query_string = environ.get("QUERY_STRING")
         _set_url_tag(middleware._config, req_span, url, query_string)
         if query_string and middleware._config.trace_query_string:
-            req_span.set_tag_str(http.QUERY_STRING, query_string)
+            req_span._set_tag_str(http.QUERY_STRING, query_string)
         method = environ.get("REQUEST_METHOD")
         if method:
-            req_span.set_tag_str(http.METHOD, method)
+            req_span._set_tag_str(http.METHOD, method)
         user_agent = _get_request_header_user_agent(headers, headers_are_case_sensitive=True)
         if user_agent:
-            req_span.set_tag_str(http.USER_AGENT, user_agent)
+            req_span._set_tag_str(http.USER_AGENT, user_agent)
     except Exception as e:
         log.warning("Could not set some span tags on blocked request: %s", str(e))
     resp_headers.append(("Content-Length", str(len(content))))
@@ -355,20 +355,20 @@ def _asgi_make_block_content(ctx, url):
         resp_headers = [(b"content-type", ctype.encode())]
     status = block_config.get("status_code", 403)
     try:
-        req_span.set_tag_str(RESPONSE_HEADERS + ".content-length", str(len(content)))
+        req_span._set_tag_str(RESPONSE_HEADERS + ".content-length", str(len(content)))
         if ctype is not None:
-            req_span.set_tag_str(RESPONSE_HEADERS + ".content-type", ctype)
-        req_span.set_tag_str(http.STATUS_CODE, str(status))
+            req_span._set_tag_str(RESPONSE_HEADERS + ".content-type", ctype)
+        req_span._set_tag_str(http.STATUS_CODE, str(status))
         query_string = environ.get("QUERY_STRING")
         _set_url_tag(middleware.integration_config, req_span, url, query_string)
         if query_string and middleware._config.trace_query_string:
-            req_span.set_tag_str(http.QUERY_STRING, query_string)
+            req_span._set_tag_str(http.QUERY_STRING, query_string)
         method = environ.get("REQUEST_METHOD")
         if method:
-            req_span.set_tag_str(http.METHOD, method)
+            req_span._set_tag_str(http.METHOD, method)
         user_agent = _get_request_header_user_agent(headers, headers_are_case_sensitive=True)
         if user_agent:
-            req_span.set_tag_str(http.USER_AGENT, user_agent)
+            req_span._set_tag_str(http.USER_AGENT, user_agent)
     except Exception as e:
         log.warning("Could not set some span tags on blocked request: %s", str(e))
     resp_headers.append((b"Content-Length", str(len(content)).encode()))
@@ -376,7 +376,7 @@ def _asgi_make_block_content(ctx, url):
 
 
 def _on_flask_blocked_request(span):
-    span.set_tag_str(http.STATUS_CODE, "403")
+    span._set_tag_str(http.STATUS_CODE, "403")
     request = core.find_item("flask_request")
     try:
         base_url = getattr(request, "base_url", None)
@@ -384,12 +384,12 @@ def _on_flask_blocked_request(span):
         if base_url and query_string:
             _set_url_tag(core.find_item("flask_config"), span, base_url, query_string)
         if query_string and core.find_item("flask_config").trace_query_string:
-            span.set_tag_str(http.QUERY_STRING, query_string)
+            span._set_tag_str(http.QUERY_STRING, query_string)
         if request.method is not None:
-            span.set_tag_str(http.METHOD, request.method)
+            span._set_tag_str(http.METHOD, request.method)
         user_agent = _get_request_header_user_agent(request.headers)
         if user_agent:
-            span.set_tag_str(http.USER_AGENT, user_agent)
+            span._set_tag_str(http.USER_AGENT, user_agent)
     except Exception as e:
         log.warning("Could not set some span tags on blocked request: %s", str(e))
 
diff --git a/ddtrace/appsec/_iast/_iast_request_context.py b/ddtrace/appsec/_iast/_iast_request_context.py
index e0f45d5a70d..65d88b2fbe9 100644
--- a/ddtrace/appsec/_iast/_iast_request_context.py
+++ b/ddtrace/appsec/_iast/_iast_request_context.py
@@ -56,7 +56,7 @@ def _create_and_attach_iast_report_to_span(
                     source["origin"] = origin_to_str(source["origin"])
             req_span._set_struct_tag(IAST.STRUCT, data)
         else:
-            req_span.set_tag_str(IAST.JSON, report_data._to_str(data))
+            req_span._set_tag_str(IAST.JSON, report_data._to_str(data))
     _set_metric_iast_request_tainted()
     base._set_span_tag_iast_request_tainted(req_span)
     _set_span_tag_iast_executed_sink(req_span)
@@ -64,7 +64,7 @@ def _create_and_attach_iast_report_to_span(
     base._iast_finish_request(req_span)
 
     if req_span.get_tag(_ORIGIN_KEY) is None:
-        req_span.set_tag_str(_ORIGIN_KEY, APPSEC.ORIGIN_VALUE)
+        req_span._set_tag_str(_ORIGIN_KEY, APPSEC.ORIGIN_VALUE)
 
 
 def _iast_end_request(ctx=None, span=None, *args, **kwargs):
diff --git a/ddtrace/appsec/_processor.py b/ddtrace/appsec/_processor.py
index 178505f8f28..27f33e41d10 100644
--- a/ddtrace/appsec/_processor.py
+++ b/ddtrace/appsec/_processor.py
@@ -214,7 +214,7 @@ def on_span_start(self, span: Span) -> None:
         headers_case_sensitive = _asm_request_context.get_headers_case_sensitive()
         entry_span = span._service_entry_span
         entry_span.set_metric(APPSEC.ENABLED, 1.0)
-        entry_span.set_tag_str(_RUNTIME_FAMILY, "python")
+        entry_span._set_tag_str(_RUNTIME_FAMILY, "python")
 
         def waf_callable(custom_data=None, **kwargs):
             return self._waf_action(entry_span, ctx, custom_data, **kwargs)
@@ -308,13 +308,13 @@ def _waf_action(
             error_tag = APPSEC.RASP_ERROR if rule_type else APPSEC.WAF_ERROR
             previous = entry_span.get_tag(error_tag)
             if previous is None:
-                entry_span.set_tag_str(error_tag, str(waf_results.return_code))
+                entry_span._set_tag_str(error_tag, str(waf_results.return_code))
             else:
                 try:
                     int_previous = int(previous)
                 except ValueError:
                     int_previous = -128
-                entry_span.set_tag_str(error_tag, str(max(int_previous, waf_results.return_code)))
+                entry_span._set_tag_str(error_tag, str(max(int_previous, waf_results.return_code)))
 
         blocked = {}
         for action, parameters in waf_results.actions.items():
@@ -333,7 +333,7 @@ def _waf_action(
 
         # Trace tagging
         for key, value in waf_results.meta_tags.items():
-            entry_span.set_tag_str(key, value)
+            entry_span._set_tag_str(key, value)
         for key, value in waf_results.metrics.items():
             entry_span.set_metric(key, value)
 
@@ -361,18 +361,18 @@ def _waf_action(
                 entry_span.set_tag(APPSEC.BLOCKED, "true")
 
             # Partial DDAS-011-00
-            entry_span.set_tag_str(APPSEC.EVENT, "true")
+            entry_span._set_tag_str(APPSEC.EVENT, "true")
 
             remote_ip = _asm_request_context.get_waf_address(SPAN_DATA_NAMES.REQUEST_HTTP_IP)
             if remote_ip:
                 # Note that if the ip collection is disabled by the env var
                 # DD_TRACE_CLIENT_IP_HEADER_DISABLED actor.ip won't be sent
-                entry_span.set_tag_str("actor.ip", remote_ip)
+                entry_span._set_tag_str("actor.ip", remote_ip)
 
             # Right now, we overwrite any value that could be already there. We need to reconsider when ASM/AppSec's
             # specs are updated.
             if entry_span.get_tag(_ORIGIN_KEY) is None:
-                entry_span.set_tag_str(_ORIGIN_KEY, APPSEC.ORIGIN_VALUE)
+                entry_span._set_tag_str(_ORIGIN_KEY, APPSEC.ORIGIN_VALUE)
 
         if waf_results.keep and allowed:
             _asm_manual_keep(entry_span)
diff --git a/ddtrace/appsec/_trace_utils.py b/ddtrace/appsec/_trace_utils.py
index 7b90ba0f03b..83d47a0159d 100644
--- a/ddtrace/appsec/_trace_utils.py
+++ b/ddtrace/appsec/_trace_utils.py
@@ -30,10 +30,10 @@ def _asm_manual_keep(span: Span) -> None:
 
     span.set_tag(constants.MANUAL_KEEP_KEY)
     # set decision maker to ASM = -5
-    span.set_tag_str(SAMPLING_DECISION_TRACE_TAG_KEY, "-%d" % SamplingMechanism.APPSEC)
+    span._set_tag_str(SAMPLING_DECISION_TRACE_TAG_KEY, "-%d" % SamplingMechanism.APPSEC)
 
     # set Security propagation tag
-    span.set_tag_str(APPSEC.PROPAGATION_HEADER, "02")
+    span._set_tag_str(APPSEC.PROPAGATION_HEADER, "02")
     span.context._meta[APPSEC.PROPAGATION_HEADER] = "02"
 
 
@@ -55,7 +55,7 @@ def _handle_metadata(entry_span: Span, prefix: str, metadata: dict) -> None:
         else:
             if isinstance(data, bool):
                 data = "true" if data else "false"
-            entry_span.set_tag_str(f"{prefix}", str(data))
+            entry_span._set_tag_str(f"{prefix}", str(data))
 
 
 def _track_user_login_common(
@@ -77,35 +77,35 @@ def _track_user_login_common(
         tag_prefix = "%s.%s" % (APPSEC.USER_LOGIN_EVENT_PREFIX, success_str)
 
         if success:
-            span.set_tag_str(APPSEC.USER_LOGIN_EVENT_SUCCESS_TRACK, "true")
+            span._set_tag_str(APPSEC.USER_LOGIN_EVENT_SUCCESS_TRACK, "true")
         else:
-            span.set_tag_str(APPSEC.USER_LOGIN_EVENT_FAILURE_TRACK, "true")
+            span._set_tag_str(APPSEC.USER_LOGIN_EVENT_FAILURE_TRACK, "true")
 
         # This is used to mark if the call was done from the SDK of the automatic login events
         if login_events_mode in (LOGIN_EVENTS_MODE.SDK, LOGIN_EVENTS_MODE.AUTO):
-            span.set_tag_str("%s.sdk" % tag_prefix, "true")
+            span._set_tag_str("%s.sdk" % tag_prefix, "true")
             reported_mode = asm_config._user_event_mode
         else:
             reported_mode = login_events_mode
 
         mode_tag = APPSEC.AUTO_LOGIN_EVENTS_SUCCESS_MODE if success else APPSEC.AUTO_LOGIN_EVENTS_FAILURE_MODE
-        span.set_tag_str(mode_tag, reported_mode)
+        span._set_tag_str(mode_tag, reported_mode)
 
         tag_metadata_prefix = "%s.%s" % (APPSEC.USER_LOGIN_EVENT_PREFIX_PUBLIC, success_str)
         if metadata is not None:
             _handle_metadata(span, tag_metadata_prefix, metadata)
 
         if login:
-            span.set_tag_str(f"{APPSEC.USER_LOGIN_EVENT_PREFIX_PUBLIC}.{success_str}.usr.login", login)
+            span._set_tag_str(f"{APPSEC.USER_LOGIN_EVENT_PREFIX_PUBLIC}.{success_str}.usr.login", login)
             if login_events_mode != LOGIN_EVENTS_MODE.SDK:
-                span.set_tag_str(APPSEC.USER_LOGIN_USERNAME, login)
-            span.set_tag_str("%s.login" % tag_prefix, login)
+                span._set_tag_str(APPSEC.USER_LOGIN_USERNAME, login)
+            span._set_tag_str("%s.login" % tag_prefix, login)
 
         if email:
-            span.set_tag_str("%s.email" % tag_prefix, email)
+            span._set_tag_str("%s.email" % tag_prefix, email)
 
         if name:
-            span.set_tag_str("%s.username" % tag_prefix, name)
+            span._set_tag_str("%s.username" % tag_prefix, name)
 
         _asm_manual_keep(span)
         return span
@@ -156,12 +156,12 @@ def track_user_login_success_event(
         return
     if real_mode == LOGIN_EVENTS_MODE.ANON and isinstance(user_id, str):
         user_id = _hash_user_id(user_id)
-    span.set_tag_str(APPSEC.AUTO_LOGIN_EVENTS_COLLECTION_MODE, real_mode)
+    span._set_tag_str(APPSEC.AUTO_LOGIN_EVENTS_COLLECTION_MODE, real_mode)
     if user_id:
         if login_events_mode != LOGIN_EVENTS_MODE.SDK:
-            span.set_tag_str(APPSEC.USER_LOGIN_USERID, str(user_id))
+            span._set_tag_str(APPSEC.USER_LOGIN_USERID, str(user_id))
         else:
-            span.set_tag_str(f"{APPSEC.USER_LOGIN_EVENT_PREFIX_PUBLIC}.success.usr.id", str(user_id))
+            span._set_tag_str(f"{APPSEC.USER_LOGIN_EVENT_PREFIX_PUBLIC}.success.usr.id", str(user_id))
     set_user(None, user_id or "", name, email, scope, role, session_id, propagate, span, may_block=False)
     if in_asm_context():
         custom_data = {
@@ -207,22 +207,22 @@ def track_user_login_failure_event(
         return
     if exists is not None:
         exists_str = "true" if exists else "false"
-        span.set_tag_str("%s.failure.%s" % (APPSEC.USER_LOGIN_EVENT_PREFIX_PUBLIC, user.EXISTS), exists_str)
+        span._set_tag_str("%s.failure.%s" % (APPSEC.USER_LOGIN_EVENT_PREFIX_PUBLIC, user.EXISTS), exists_str)
     if user_id:
         if real_mode == LOGIN_EVENTS_MODE.ANON and isinstance(user_id, str):
             user_id = _hash_user_id(user_id)
         if login_events_mode != LOGIN_EVENTS_MODE.SDK:
-            span.set_tag_str(APPSEC.USER_LOGIN_USERID, str(user_id))
-        span.set_tag_str("%s.failure.%s" % (APPSEC.USER_LOGIN_EVENT_PREFIX_PUBLIC, user.ID), str(user_id))
-    span.set_tag_str(APPSEC.AUTO_LOGIN_EVENTS_COLLECTION_MODE, real_mode)
+            span._set_tag_str(APPSEC.USER_LOGIN_USERID, str(user_id))
+        span._set_tag_str("%s.failure.%s" % (APPSEC.USER_LOGIN_EVENT_PREFIX_PUBLIC, user.ID), str(user_id))
+    span._set_tag_str(APPSEC.AUTO_LOGIN_EVENTS_COLLECTION_MODE, real_mode)
     # if called from the SDK, set the login, email and name
     if login_events_mode in (LOGIN_EVENTS_MODE.SDK, LOGIN_EVENTS_MODE.AUTO):
         if login:
-            span.set_tag_str("%s.failure.login" % APPSEC.USER_LOGIN_EVENT_PREFIX_PUBLIC, login)
+            span._set_tag_str("%s.failure.login" % APPSEC.USER_LOGIN_EVENT_PREFIX_PUBLIC, login)
         if email:
-            span.set_tag_str("%s.failure.email" % APPSEC.USER_LOGIN_EVENT_PREFIX_PUBLIC, email)
+            span._set_tag_str("%s.failure.email" % APPSEC.USER_LOGIN_EVENT_PREFIX_PUBLIC, email)
         if name:
-            span.set_tag_str("%s.failure.username" % APPSEC.USER_LOGIN_EVENT_PREFIX_PUBLIC, name)
+            span._set_tag_str("%s.failure.username" % APPSEC.USER_LOGIN_EVENT_PREFIX_PUBLIC, name)
     if in_asm_context():
         custom_data: dict[str, Any] = {"LOGIN_FAILURE": None}
         if login:
@@ -242,25 +242,25 @@ def track_user_signup_event(
     span = _asm_request_context.get_entry_span()
     if span:
         success_str = "true" if success else "false"
-        span.set_tag_str(APPSEC.USER_SIGNUP_EVENT, success_str)
+        span._set_tag_str(APPSEC.USER_SIGNUP_EVENT, success_str)
         if user_id:
             if login_events_mode == LOGIN_EVENTS_MODE.ANON and isinstance(user_id, str):
                 user_id = _hash_user_id(user_id)
-            span.set_tag_str(user.ID, str(user_id))
-            span.set_tag_str(APPSEC.USER_SIGNUP_EVENT_USERID, str(user_id))
-            span.set_tag_str(APPSEC.USER_LOGIN_USERID, str(user_id))
+            span._set_tag_str(user.ID, str(user_id))
+            span._set_tag_str(APPSEC.USER_SIGNUP_EVENT_USERID, str(user_id))
+            span._set_tag_str(APPSEC.USER_LOGIN_USERID, str(user_id))
         if login:
             if login_events_mode == LOGIN_EVENTS_MODE.ANON and isinstance(login, str):
                 login = _hash_user_id(login)
-            span.set_tag_str(APPSEC.USER_SIGNUP_EVENT_USERNAME, str(login))
-            span.set_tag_str(APPSEC.USER_LOGIN_USERNAME, str(login))
+            span._set_tag_str(APPSEC.USER_SIGNUP_EVENT_USERNAME, str(login))
+            span._set_tag_str(APPSEC.USER_LOGIN_USERNAME, str(login))
         _asm_manual_keep(span)
 
         # This is used to mark if the call was done from the SDK of the automatic login events
         if login_events_mode == LOGIN_EVENTS_MODE.SDK:
-            span.set_tag_str("%s.sdk" % APPSEC.USER_SIGNUP_EVENT, "true")
+            span._set_tag_str("%s.sdk" % APPSEC.USER_SIGNUP_EVENT, "true")
         else:
-            span.set_tag_str("%s.auto.mode" % APPSEC.USER_SIGNUP_EVENT_MODE, str(login_events_mode))
+            span._set_tag_str("%s.auto.mode" % APPSEC.USER_SIGNUP_EVENT_MODE, str(login_events_mode))
 
         return
     else:
@@ -298,7 +298,7 @@ def track_custom_event(tracer: Any, event_name: str, metadata: Dict[str, Any]) -
         )
         return
 
-    span.set_tag_str("%s.%s.track" % (APPSEC.CUSTOM_EVENT_PREFIX, event_name), "true")
+    span._set_tag_str("%s.%s.track" % (APPSEC.CUSTOM_EVENT_PREFIX, event_name), "true")
     if metadata:
         _handle_metadata(span, f"{APPSEC.CUSTOM_EVENT_PREFIX}.{event_name}", metadata)
     _asm_manual_keep(span)
@@ -365,14 +365,14 @@ def block_request_if_user_blocked(
         mode = asm_config._user_event_mode
     entry_span = _asm_request_context.get_entry_span()
     if entry_span:
-        entry_span.set_tag_str(APPSEC.AUTO_LOGIN_EVENTS_COLLECTION_MODE, mode)
+        entry_span._set_tag_str(APPSEC.AUTO_LOGIN_EVENTS_COLLECTION_MODE, mode)
         if userid:
             if mode == LOGIN_EVENTS_MODE.ANON:
                 userid = _hash_user_id(str(userid))
-            entry_span.set_tag_str(APPSEC.AUTO_LOGIN_EVENTS_COLLECTION_MODE, mode)
+            entry_span._set_tag_str(APPSEC.AUTO_LOGIN_EVENTS_COLLECTION_MODE, mode)
             if mode != LOGIN_EVENTS_MODE.SDK:
-                entry_span.set_tag_str(APPSEC.USER_LOGIN_USERID, str(userid))
-            entry_span.set_tag_str(user.ID, str(userid))
+                entry_span._set_tag_str(APPSEC.USER_LOGIN_USERID, str(userid))
+            entry_span._set_tag_str(user.ID, str(userid))
     if should_block_user(None, userid, session_id):
         _asm_request_context.block_request()
 
@@ -469,18 +469,18 @@ def _on_django_process(result_user, session_key, mode, kwargs, info_retriever, d
             hash_id = ""
             if isinstance(user_id, str):
                 hash_id = _hash_user_id(user_id)
-                span.set_tag_str(APPSEC.USER_LOGIN_USERID, hash_id)
+                span._set_tag_str(APPSEC.USER_LOGIN_USERID, hash_id)
             if isinstance(user_login, str):
                 hash_login = _hash_user_id(user_login)
-                span.set_tag_str(APPSEC.USER_LOGIN_USERNAME, hash_login)
-            span.set_tag_str(APPSEC.AUTO_LOGIN_EVENTS_COLLECTION_MODE, mode)
+                span._set_tag_str(APPSEC.USER_LOGIN_USERNAME, hash_login)
+            span._set_tag_str(APPSEC.AUTO_LOGIN_EVENTS_COLLECTION_MODE, mode)
             set_user(None, hash_id, propagate=True, may_block=False, span=span)
         elif mode == LOGIN_EVENTS_MODE.IDENT:
             if user_id:
-                span.set_tag_str(APPSEC.USER_LOGIN_USERID, str(user_id))
+                span._set_tag_str(APPSEC.USER_LOGIN_USERID, str(user_id))
             if user_login:
-                span.set_tag_str(APPSEC.USER_LOGIN_USERNAME, str(user_login))
-            span.set_tag_str(APPSEC.AUTO_LOGIN_EVENTS_COLLECTION_MODE, mode)
+                span._set_tag_str(APPSEC.USER_LOGIN_USERNAME, str(user_login))
+            span._set_tag_str(APPSEC.AUTO_LOGIN_EVENTS_COLLECTION_MODE, mode)
             set_user(
                 None,
                 str(user_id),
@@ -515,20 +515,20 @@ def _on_django_signup_user(django_config, pin, func, instance, args, kwargs, use
         if span is None:
             return
         _asm_manual_keep(span)
-        span.set_tag_str(APPSEC.USER_SIGNUP_EVENT_MODE, str(asm_config._user_event_mode))
-        span.set_tag_str(APPSEC.USER_SIGNUP_EVENT, "true")
+        span._set_tag_str(APPSEC.USER_SIGNUP_EVENT_MODE, str(asm_config._user_event_mode))
+        span._set_tag_str(APPSEC.USER_SIGNUP_EVENT, "true")
         if "login" in user_extra:
             login = user_extra["login"]
             if asm_config._user_event_mode == LOGIN_EVENTS_MODE.ANON:
                 login = _hash_user_id(login)
-            span.set_tag_str(APPSEC.USER_SIGNUP_EVENT_USERNAME, login)
-            span.set_tag_str(APPSEC.USER_LOGIN_USERNAME, login)
+            span._set_tag_str(APPSEC.USER_SIGNUP_EVENT_USERNAME, login)
+            span._set_tag_str(APPSEC.USER_LOGIN_USERNAME, login)
         if user_id:
             user_id = str(user_id)
             if asm_config._user_event_mode == LOGIN_EVENTS_MODE.ANON:
                 user_id = _hash_user_id(str(user_id))
-            span.set_tag_str(APPSEC.USER_SIGNUP_EVENT_USERID, user_id)
-            span.set_tag_str(APPSEC.USER_LOGIN_USERID, user_id)
+            span._set_tag_str(APPSEC.USER_SIGNUP_EVENT_USERID, user_id)
+            span._set_tag_str(APPSEC.USER_LOGIN_USERID, user_id)
 
 
 def listen():
diff --git a/ddtrace/appsec/track_user_sdk.py b/ddtrace/appsec/track_user_sdk.py
index d420af95a25..d32b8c1a7fb 100644
--- a/ddtrace/appsec/track_user_sdk.py
+++ b/ddtrace/appsec/track_user_sdk.py
@@ -88,9 +88,9 @@ def track_user(
     if span is None:
         return
     if user_id:
-        span.set_tag_str(_constants.APPSEC.USER_LOGIN_USERID, str(user_id))
+        span._set_tag_str(_constants.APPSEC.USER_LOGIN_USERID, str(user_id))
     if login:
-        span.set_tag_str(_constants.APPSEC.USER_LOGIN_USERNAME, str(login))
+        span._set_tag_str(_constants.APPSEC.USER_LOGIN_USERNAME, str(login))
     meta = metadata or {}
     usr_name = meta.pop("name", None) or meta.pop("usr.name", None)
     usr_email = meta.pop("email", None) or meta.pop("usr.email", None)
@@ -111,7 +111,7 @@ def track_user(
     if meta:
         _trace_utils.track_custom_event(None, "auth_sdk", metadata=meta)
     if not _auto:
-        span.set_tag_str(_constants.APPSEC.AUTO_LOGIN_EVENTS_COLLECTION_MODE, _constants.LOGIN_EVENTS_MODE.SDK)
+        span._set_tag_str(_constants.APPSEC.AUTO_LOGIN_EVENTS_COLLECTION_MODE, _constants.LOGIN_EVENTS_MODE.SDK)
         if _asm_request_context.in_asm_context():
             custom_data = {
                 "REQUEST_USER_ID": str(user_id) if user_id else None,
@@ -142,7 +142,7 @@ def track_user_id(
     if span is None:
         return
     if user_id:
-        span.set_tag_str(_constants.APPSEC.USER_LOGIN_USERID, str(user_id))
+        span._set_tag_str(_constants.APPSEC.USER_LOGIN_USERID, str(user_id))
     meta = metadata or {}
     usr_name = meta.pop("name", None) or meta.pop("usr.name", None)
     usr_email = meta.pop("email", None) or meta.pop("usr.email", None)
@@ -163,7 +163,7 @@ def track_user_id(
     if meta:
         _trace_utils.track_custom_event(None, "auth_sdk", metadata=meta)
     if not _auto:
-        span.set_tag_str(_constants.APPSEC.AUTO_LOGIN_EVENTS_COLLECTION_MODE, _constants.LOGIN_EVENTS_MODE.SDK)
+        span._set_tag_str(_constants.APPSEC.AUTO_LOGIN_EVENTS_COLLECTION_MODE, _constants.LOGIN_EVENTS_MODE.SDK)
         if _asm_request_context.in_asm_context():
             custom_data = {
                 "REQUEST_USER_ID": str(user_id) if user_id else None,
diff --git a/ddtrace/contrib/dbapi.py b/ddtrace/contrib/dbapi.py
index 94671ec164a..e364c542a22 100644
--- a/ddtrace/contrib/dbapi.py
+++ b/ddtrace/contrib/dbapi.py
@@ -95,10 +95,10 @@ def _trace_method(self, method, name, resource, extra_tags, dbm_propagator, *arg
             s.set_tags(pin.tags)
             s.set_tags(extra_tags)
 
-            s.set_tag_str(COMPONENT, self._self_config.integration_name)
+            s._set_tag_str(COMPONENT, self._self_config.integration_name)
 
             # set span.kind to the type of request being performed
-            s.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+            s._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
             # Security and IAST validations
             core.dispatch("db_query_check", (args, kwargs, self._self_config.integration_name, method))
@@ -295,10 +295,10 @@ def _trace_method(self, method, name, extra_tags, *args, **kwargs):
             return method(*args, **kwargs)
 
         with pin.tracer.trace(name, service=ext_service(pin, self._self_config)) as s:
-            s.set_tag_str(COMPONENT, self._self_config.integration_name)
+            s._set_tag_str(COMPONENT, self._self_config.integration_name)
 
             # set span.kind to the type of request being performed
-            s.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+            s._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
             s.set_tags(pin.tags)
             s.set_tags(extra_tags)
diff --git a/ddtrace/contrib/dbapi_async.py b/ddtrace/contrib/dbapi_async.py
index 0cc6d755f9a..05c4ea9282e 100644
--- a/ddtrace/contrib/dbapi_async.py
+++ b/ddtrace/contrib/dbapi_async.py
@@ -70,10 +70,10 @@ async def _trace_method(self, method, name, resource, extra_tags, dbm_propagator
             s.set_tags(pin.tags)
             s.set_tags(extra_tags)
 
-            s.set_tag_str(COMPONENT, self._self_config.integration_name)
+            s._set_tag_str(COMPONENT, self._self_config.integration_name)
 
             # set span.kind to the type of request being performed
-            s.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+            s._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
             # Security and IAST validations
             core.dispatch("db_query_check", (args, kwargs, self._self_config.integration_name, method))
@@ -235,10 +235,10 @@ async def _trace_method(self, method, name, extra_tags, *args, **kwargs):
             return await method(*args, **kwargs)
 
         with pin.tracer.trace(name, service=ext_service(pin, self._self_config)) as s:
-            s.set_tag_str(COMPONENT, self._self_config.integration_name)
+            s._set_tag_str(COMPONENT, self._self_config.integration_name)
 
             # set span.kind to the type of request being performed
-            s.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+            s._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
             s.set_tags(pin.tags)
             s.set_tags(extra_tags)
diff --git a/ddtrace/contrib/internal/aiobotocore/patch.py b/ddtrace/contrib/internal/aiobotocore/patch.py
index b4576f695a6..23de86908c4 100644
--- a/ddtrace/contrib/internal/aiobotocore/patch.py
+++ b/ddtrace/contrib/internal/aiobotocore/patch.py
@@ -83,10 +83,10 @@ async def read(self, *args, **kwargs):
         operation_name = "{}.read".format(self._self_parent_span.name)
 
         with self._self_pin.tracer.start_span(operation_name, child_of=self._self_parent_span) as span:
-            span.set_tag_str(COMPONENT, config.aiobotocore.integration_name)
+            span._set_tag_str(COMPONENT, config.aiobotocore.integration_name)
 
             # set span.kind tag equal to type of request
-            span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+            span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
             # inherit parent attributes
             span.resource = self._self_parent_span.resource
@@ -126,10 +126,10 @@ async def _wrapped_api_call(original_func, instance, args, kwargs):
         service=ext_service(pin, config.aiobotocore, default=schematize_service_name(fallback_service)),
         span_type=SpanTypes.HTTP,
     ) as span:
-        span.set_tag_str(COMPONENT, config.aiobotocore.integration_name)
+        span._set_tag_str(COMPONENT, config.aiobotocore.integration_name)
 
         # set span.kind tag equal to type of request
-        span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+        span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
         # PERF: avoid setting via Span.set_tag
         span.set_metric(_SPAN_MEASURED_KEY, 1)
@@ -152,7 +152,7 @@ async def _wrapped_api_call(original_func, instance, args, kwargs):
             # Derive the peer hostname now that we have both service and region.
             hostname = _derive_peer_hostname(endpoint_name, region_name, params)
             if hostname:
-                span.set_tag_str("peer.service", hostname)
+                span._set_tag_str("peer.service", hostname)
 
         meta = {
             "aws.agent": "aiobotocore",
@@ -185,10 +185,10 @@ async def _wrapped_api_call(original_func, instance, args, kwargs):
 
         request_id = response_meta.get("RequestId")
         if request_id:
-            span.set_tag_str("aws.requestid", request_id)
+            span._set_tag_str("aws.requestid", request_id)
 
         request_id2 = response_headers.get("x-amz-id-2")
         if request_id2:
-            span.set_tag_str("aws.requestid2", request_id2)
+            span._set_tag_str("aws.requestid2", request_id2)
 
         return result
diff --git a/ddtrace/contrib/internal/aiohttp/middlewares.py b/ddtrace/contrib/internal/aiohttp/middlewares.py
index 77f16e9d57d..72fc7a7058d 100644
--- a/ddtrace/contrib/internal/aiohttp/middlewares.py
+++ b/ddtrace/contrib/internal/aiohttp/middlewares.py
@@ -97,7 +97,7 @@ def finish_request_span(request, response):
     if trace_query_string is None:
         trace_query_string = config._http.trace_query_string
     if trace_query_string:
-        request_span.set_tag_str(http.QUERY_STRING, request.query_string)
+        request_span._set_tag_str(http.QUERY_STRING, request.query_string)
 
     # The match info object provided by aiohttp's default (and only) router
     # has a `route` attribute, but routers are susceptible to being replaced/hand-rolled
diff --git a/ddtrace/contrib/internal/aiohttp/patch.py b/ddtrace/contrib/internal/aiohttp/patch.py
index c6ee26ef26d..0a488c734b2 100644
--- a/ddtrace/contrib/internal/aiohttp/patch.py
+++ b/ddtrace/contrib/internal/aiohttp/patch.py
@@ -101,10 +101,10 @@ async def _traced_clientsession_request(aiohttp, pin, func, instance, args, kwar
             HTTPPropagator.inject(span.context, headers)
             kwargs["headers"] = headers
 
-        span.set_tag_str(COMPONENT, config.aiohttp_client.integration_name)
+        span._set_tag_str(COMPONENT, config.aiohttp_client.integration_name)
 
         # set span.kind tag equal to type of request
-        span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+        span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
         # Params can be included separate of the URL so the URL has to be constructed
         # with the passed params.
diff --git a/ddtrace/contrib/internal/aiohttp_jinja2/patch.py b/ddtrace/contrib/internal/aiohttp_jinja2/patch.py
index 8460c5be4a4..2cd05a386c8 100644
--- a/ddtrace/contrib/internal/aiohttp_jinja2/patch.py
+++ b/ddtrace/contrib/internal/aiohttp_jinja2/patch.py
@@ -43,9 +43,9 @@ def traced_render_template(aiohttp_jinja2, pin, func, instance, args, kwargs):
     template_meta = "%s/%s" % (template_prefix, template_name)
 
     with pin.tracer.trace("aiohttp.template", span_type=SpanTypes.TEMPLATE) as span:
-        span.set_tag_str(COMPONENT, config.aiohttp_jinja2.integration_name)
+        span._set_tag_str(COMPONENT, config.aiohttp_jinja2.integration_name)
 
-        span.set_tag_str("aiohttp.template", template_meta)
+        span._set_tag_str("aiohttp.template", template_meta)
         return func(*args, **kwargs)
 
 
diff --git a/ddtrace/contrib/internal/aiomysql/patch.py b/ddtrace/contrib/internal/aiomysql/patch.py
index 619c44faee3..66656f2c63d 100644
--- a/ddtrace/contrib/internal/aiomysql/patch.py
+++ b/ddtrace/contrib/internal/aiomysql/patch.py
@@ -82,10 +82,10 @@ async def _trace_method(self, method, resource, extra_tags, *args, **kwargs):
             resource=resource,
             span_type=SpanTypes.SQL,
         ) as s:
-            s.set_tag_str(COMPONENT, config.aiomysql.integration_name)
+            s._set_tag_str(COMPONENT, config.aiomysql.integration_name)
 
             # set span.kind to the type of request being performed
-            s.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+            s._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
             # PERF: avoid setting via Span.set_tag
             s.set_metric(_SPAN_MEASURED_KEY, 1)
diff --git a/ddtrace/contrib/internal/aiopg/connection.py b/ddtrace/contrib/internal/aiopg/connection.py
index 3bdf3be5280..eb04de10f56 100644
--- a/ddtrace/contrib/internal/aiopg/connection.py
+++ b/ddtrace/contrib/internal/aiopg/connection.py
@@ -40,11 +40,11 @@ async def _trace_method(self, method, resource, extra_tags, *args, **kwargs):
             resource=resource,
             span_type=SpanTypes.SQL,
         ) as s:
-            s.set_tag_str(COMPONENT, config.aiopg.integration_name)
-            s.set_tag_str(db.SYSTEM, "postgresql")
+            s._set_tag_str(COMPONENT, config.aiopg.integration_name)
+            s._set_tag_str(db.SYSTEM, "postgresql")
 
             # set span.kind to the type of request being performed
-            s.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+            s._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
             # PERF: avoid setting via Span.set_tag
             s.set_metric(_SPAN_MEASURED_KEY, 1)
diff --git a/ddtrace/contrib/internal/aioredis/patch.py b/ddtrace/contrib/internal/aioredis/patch.py
index 2aa31154b68..3ce4629620f 100644
--- a/ddtrace/contrib/internal/aioredis/patch.py
+++ b/ddtrace/contrib/internal/aioredis/patch.py
@@ -148,13 +148,13 @@ def traced_13_execute_command(func, instance, args, kwargs):
         child_of=parent,
     )
     # set span.kind to the type of request being performed
-    span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+    span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
-    span.set_tag_str(COMPONENT, config.aioredis.integration_name)
-    span.set_tag_str(db.SYSTEM, redisx.APP)
+    span._set_tag_str(COMPONENT, config.aioredis.integration_name)
+    span._set_tag_str(db.SYSTEM, redisx.APP)
     # PERF: avoid setting via Span.set_tag
     span.set_metric(_SPAN_MEASURED_KEY, 1)
-    span.set_tag_str(redisx.RAWCMD, query)
+    span._set_tag_str(redisx.RAWCMD, query)
     if pin.tags:
         span.set_tags(pin.tags)
 
@@ -215,10 +215,10 @@ async def traced_13_execute_pipeline(func, instance, args, kwargs):
         span_type=SpanTypes.REDIS,
     ) as span:
         # set span.kind to the type of request being performed
-        span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+        span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
-        span.set_tag_str(COMPONENT, config.aioredis.integration_name)
-        span.set_tag_str(db.SYSTEM, redisx.APP)
+        span._set_tag_str(COMPONENT, config.aioredis.integration_name)
+        span._set_tag_str(db.SYSTEM, redisx.APP)
         span.set_tags(
             {
                 net.TARGET_HOST: instance._pool_or_conn.address[0],
@@ -229,7 +229,7 @@ async def traced_13_execute_pipeline(func, instance, args, kwargs):
 
         # PERF: avoid setting via Span.set_tag
         span.set_metric(_SPAN_MEASURED_KEY, 1)
-        span.set_tag_str(redisx.RAWCMD, cmds_string)
+        span._set_tag_str(redisx.RAWCMD, cmds_string)
         span.set_metric(redisx.PIPELINE_LEN, len(instance._pipeline))
 
         return await func(*args, **kwargs)
diff --git a/ddtrace/contrib/internal/algoliasearch/patch.py b/ddtrace/contrib/internal/algoliasearch/patch.py
index 32591e88518..5b8571457be 100644
--- a/ddtrace/contrib/internal/algoliasearch/patch.py
+++ b/ddtrace/contrib/internal/algoliasearch/patch.py
@@ -129,10 +129,10 @@ def _patched_search(func, instance, wrapt_args, wrapt_kwargs):
         service=trace_utils.ext_service(pin, config.algoliasearch),
         span_type=SpanTypes.HTTP,
     ) as span:
-        span.set_tag_str(COMPONENT, config.algoliasearch.integration_name)
+        span._set_tag_str(COMPONENT, config.algoliasearch.integration_name)
 
         # set span.kind to the type of request being performed
-        span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+        span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
         # PERF: avoid setting via Span.set_tag
         span.set_metric(_SPAN_MEASURED_KEY, 1)
@@ -140,7 +140,7 @@ def _patched_search(func, instance, wrapt_args, wrapt_kwargs):
             return func(*wrapt_args, **wrapt_kwargs)
 
         if config.algoliasearch.collect_query_text:
-            span.set_tag_str("query.text", wrapt_kwargs.get("query", wrapt_args[0]))
+            span._set_tag_str("query.text", wrapt_kwargs.get("query", wrapt_args[0]))
 
         query_args = wrapt_kwargs.get(function_query_arg_name, wrapt_args[1] if len(wrapt_args) > 1 else None)
 
diff --git a/ddtrace/contrib/internal/asgi/middleware.py b/ddtrace/contrib/internal/asgi/middleware.py
index 61e196fd075..0c2166f0526 100644
--- a/ddtrace/contrib/internal/asgi/middleware.py
+++ b/ddtrace/contrib/internal/asgi/middleware.py
@@ -110,7 +110,7 @@ def _extract_headers(scope: Mapping[str, Any]) -> Mapping[str, Any]:
 
 def _default_handle_exception_span(exc, span):
     """Default handler for exception for span"""
-    span.set_tag_str(http.STATUS_CODE, "500")
+    span._set_tag_str(http.STATUS_CODE, "500")
 
 
 def span_from_scope(scope: Mapping[str, Any]) -> Optional[Span]:
@@ -287,7 +287,7 @@ async def __call__(self, scope: Mapping[str, Any], receive: Callable, send: Call
             )
             tags = _extract_versions_from_scope(scope, self.integration_config)
             for name, value in tags.items():
-                span.set_tag_str(name, value)
+                span._set_tag_str(name, value)
 
             @wraps(receive)
             async def wrapped_receive():
diff --git a/ddtrace/contrib/internal/asyncpg/patch.py b/ddtrace/contrib/internal/asyncpg/patch.py
index 5356e77ff50..586b751a1a0 100644
--- a/ddtrace/contrib/internal/asyncpg/patch.py
+++ b/ddtrace/contrib/internal/asyncpg/patch.py
@@ -100,11 +100,11 @@ async def _traced_connect(asyncpg, pin, func, instance, args, kwargs):
     with pin.tracer.trace(
         "postgres.connect", span_type=SpanTypes.SQL, service=ext_service(pin, config.asyncpg)
     ) as span:
-        span.set_tag_str(COMPONENT, config.asyncpg.integration_name)
-        span.set_tag_str(db.SYSTEM, DBMS_NAME)
+        span._set_tag_str(COMPONENT, config.asyncpg.integration_name)
+        span._set_tag_str(db.SYSTEM, DBMS_NAME)
 
         # set span.kind to the type of request being performed
-        span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+        span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
         raw_conn = await func(*args, **kwargs)
         if is_pool_context:
@@ -132,11 +132,11 @@ async def _traced_query(pin, method, query, args, kwargs):
         service=ext_service(pin, config.asyncpg),
         span_type=SpanTypes.SQL,
     ) as span:
-        span.set_tag_str(COMPONENT, config.asyncpg.integration_name)
-        span.set_tag_str(db.SYSTEM, DBMS_NAME)
+        span._set_tag_str(COMPONENT, config.asyncpg.integration_name)
+        span._set_tag_str(db.SYSTEM, DBMS_NAME)
 
         # set span.kind to the type of request being performed
-        span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+        span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
         # PERF: avoid setting via Span.set_tag
         span.set_metric(_SPAN_MEASURED_KEY, 1)
         span.set_tags(pin.tags)
diff --git a/ddtrace/contrib/internal/aws_lambda/patch.py b/ddtrace/contrib/internal/aws_lambda/patch.py
index 5b071655344..a7aa0c0515b 100644
--- a/ddtrace/contrib/internal/aws_lambda/patch.py
+++ b/ddtrace/contrib/internal/aws_lambda/patch.py
@@ -96,8 +96,8 @@ def _crash_flush(self, _, __):
         root_span = tracer.current_root_span()
         if root_span is not None:
             root_span.error = 1
-            root_span.set_tag_str(ERROR_MSG, "Datadog detected an Impending Timeout")
-            root_span.set_tag_str(ERROR_TYPE, "Impending Timeout")
+            root_span._set_tag_str(ERROR_MSG, "Datadog detected an Impending Timeout")
+            root_span._set_tag_str(ERROR_TYPE, "Impending Timeout")
         else:
             log.warning("An impending timeout was reached, but no root span was found. No error will be tagged.")
 
diff --git a/ddtrace/contrib/internal/boto/patch.py b/ddtrace/contrib/internal/boto/patch.py
index 59a7153edf6..d8294fede30 100644
--- a/ddtrace/contrib/internal/boto/patch.py
+++ b/ddtrace/contrib/internal/boto/patch.py
@@ -94,10 +94,10 @@ def patched_query_request(original_func, instance, args, kwargs):
         service=schematize_service_name("{}.{}".format(pin.service, endpoint_name)),
         span_type=SpanTypes.HTTP,
     ) as span:
-        span.set_tag_str(COMPONENT, config.boto.integration_name)
+        span._set_tag_str(COMPONENT, config.boto.integration_name)
 
         # set span.kind to the type of request being performed
-        span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+        span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
         # PERF: avoid setting via Span.set_tag
         span.set_metric(_SPAN_MEASURED_KEY, 1)
@@ -137,7 +137,7 @@ def patched_query_request(original_func, instance, args, kwargs):
         # Original func returns a boto.connection.HTTPResponse object
         result = original_func(*args, **kwargs)
         span.set_tag(http.STATUS_CODE, result.status)
-        span.set_tag_str(http.METHOD, result._method)
+        span._set_tag_str(http.METHOD, result._method)
 
         return result
 
@@ -206,12 +206,12 @@ def patched_auth_request(original_func, instance, args, kwargs):
         # Original func returns a boto.connection.HTTPResponse object
         result = original_func(*args, **kwargs)
         span.set_tag(http.STATUS_CODE, result.status)
-        span.set_tag_str(http.METHOD, result._method)
+        span._set_tag_str(http.METHOD, result._method)
 
-        span.set_tag_str(COMPONENT, config.boto.integration_name)
+        span._set_tag_str(COMPONENT, config.boto.integration_name)
 
         # set span.kind to the type of request being performed
-        span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+        span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
         return result
 
diff --git a/ddtrace/contrib/internal/cassandra/session.py b/ddtrace/contrib/internal/cassandra/session.py
index ed1b56ea251..92b0bf989bc 100644
--- a/ddtrace/contrib/internal/cassandra/session.py
+++ b/ddtrace/contrib/internal/cassandra/session.py
@@ -107,8 +107,8 @@ def _close_span_on_error(exc, future):
         # handling the exception manually because we
         # don't have an ongoing exception here
         span.error = 1
-        span.set_tag_str(ERROR_MSG, exc.args[0])
-        span.set_tag_str(ERROR_TYPE, exc.__class__.__name__)
+        span._set_tag_str(ERROR_MSG, exc.args[0])
+        span._set_tag_str(ERROR_TYPE, exc.__class__.__name__)
     except Exception:
         log.debug("traced_set_final_exception was not able to set the error, failed with error", exc_info=True)
     finally:
@@ -210,14 +210,14 @@ def _start_span_and_set_tags(
         service=pin.service,
         span_type=SpanTypes.CASSANDRA,
     )
-    span.set_tag_str(COMPONENT, config.cassandra.integration_name)
-    span.set_tag_str(db.SYSTEM, "cassandra")
-    span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+    span._set_tag_str(COMPONENT, config.cassandra.integration_name)
+    span._set_tag_str(db.SYSTEM, "cassandra")
+    span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
     # PERF: avoid setting via Span.set_tag
     span.set_metric(_SPAN_MEASURED_KEY, 1)
     span.set_tags(additional_tags)
     if query is not None:
-        span.set_tag_str("cassandra.query", query)
+        span._set_tag_str("cassandra.query", query)
     if statements_and_parameters is not None:
         span.set_metric("cassandra.batch_size", len(statements_and_parameters))
     span.resource = resource[:RESOURCE_MAX_LENGTH]
diff --git a/ddtrace/contrib/internal/celery/app.py b/ddtrace/contrib/internal/celery/app.py
index a27eb298194..0bc5bc13b21 100644
--- a/ddtrace/contrib/internal/celery/app.py
+++ b/ddtrace/contrib/internal/celery/app.py
@@ -97,7 +97,7 @@ def _traced_beat_inner(func, instance, args, kwargs):
         ) as span:
             if resource_fn:
                 span.resource = resource_fn(args)
-            span.set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
+            span._set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
             # PERF: avoid setting via Span.set_tag
             span.set_metric(_SPAN_MEASURED_KEY, 1)
 
diff --git a/ddtrace/contrib/internal/celery/signals.py b/ddtrace/contrib/internal/celery/signals.py
index 41733f5fc66..9eaab27f1bf 100644
--- a/ddtrace/contrib/internal/celery/signals.py
+++ b/ddtrace/contrib/internal/celery/signals.py
@@ -54,10 +54,10 @@ def trace_prerun(*args, **kwargs):
     span = pin.tracer.trace(c.WORKER_ROOT_SPAN, service=service, resource=task.name, span_type=SpanTypes.WORKER)
 
     # set span.kind to the type of request being performed
-    span.set_tag_str(SPAN_KIND, SpanKind.CONSUMER)
+    span._set_tag_str(SPAN_KIND, SpanKind.CONSUMER)
 
     # set component tag equal to name of integration
-    span.set_tag_str(COMPONENT, config.celery.integration_name)
+    span._set_tag_str(COMPONENT, config.celery.integration_name)
 
     # PERF: avoid setting via Span.set_tag
     span.set_metric(_SPAN_MEASURED_KEY, 1)
@@ -83,7 +83,7 @@ def trace_postrun(*args, **kwargs):
         return
     else:
         # request context tags
-        span.set_tag_str(c.TASK_TAG_KEY, c.TASK_RUN)
+        span._set_tag_str(c.TASK_TAG_KEY, c.TASK_RUN)
         set_tags_from_context(span, kwargs)
         set_tags_from_context(span, task.request.__dict__)
         span.finish()
@@ -124,15 +124,15 @@ def trace_before_publish(*args, **kwargs):
     # Store an item called "task span" in case after_task_publish doesn't get called
     core.set_item("task_span", span)
 
-    span.set_tag_str(COMPONENT, config.celery.integration_name)
+    span._set_tag_str(COMPONENT, config.celery.integration_name)
 
     # set span.kind to the type of request being performed
-    span.set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
+    span._set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
 
     # PERF: avoid setting via Span.set_tag
     span.set_metric(_SPAN_MEASURED_KEY, 1)
-    span.set_tag_str(c.TASK_TAG_KEY, c.TASK_APPLY_ASYNC)
-    span.set_tag_str("celery.id", task_id)
+    span._set_tag_str(c.TASK_TAG_KEY, c.TASK_APPLY_ASYNC)
+    span._set_tag_str("celery.id", task_id)
     set_tags_from_context(span, kwargs)
     if kwargs.get("headers") is not None:
         # required to extract hostname from origin header on `celery>=4.0`
@@ -191,7 +191,7 @@ def trace_after_publish(*args, **kwargs):
             span.set_metric(net.TARGET_PORT, parsed_url.port)
 
     if host:
-        span.set_tag_str(net.TARGET_HOST, host)
+        span._set_tag_str(net.TARGET_HOST, host)
 
     span.finish()
     detach_span(task, task_id, is_publish=True)
@@ -254,4 +254,4 @@ def trace_retry(*args, **kwargs):
 
     # Add retry reason metadata to span
     # DEV: Use `str(reason)` instead of `reason.message` in case we get something that isn't an `Exception`
-    span.set_tag_str(c.TASK_RETRY_REASON_KEY, str(reason))
+    span._set_tag_str(c.TASK_RETRY_REASON_KEY, str(reason))
diff --git a/ddtrace/contrib/internal/cherrypy/patch.py b/ddtrace/contrib/internal/cherrypy/patch.py
index d99f5245b43..b657192a4f4 100644
--- a/ddtrace/contrib/internal/cherrypy/patch.py
+++ b/ddtrace/contrib/internal/cherrypy/patch.py
@@ -106,9 +106,9 @@ def _after_error_response(self):
             return
 
         span.error = 1
-        span.set_tag_str(ERROR_TYPE, str(cherrypy._cperror._exc_info()[0]))
-        span.set_tag_str(ERROR_MSG, str(cherrypy._cperror._exc_info()[1]))
-        span.set_tag_str(ERROR_STACK, cherrypy._cperror.format_exc())
+        span._set_tag_str(ERROR_TYPE, str(cherrypy._cperror._exc_info()[0]))
+        span._set_tag_str(ERROR_MSG, str(cherrypy._cperror._exc_info()[1]))
+        span._set_tag_str(ERROR_STACK, cherrypy._cperror.format_exc())
 
         self._close_span(span)
 
diff --git a/ddtrace/contrib/internal/consul/patch.py b/ddtrace/contrib/internal/consul/patch.py
index 4850d8fd40c..38515ff06b9 100644
--- a/ddtrace/contrib/internal/consul/patch.py
+++ b/ddtrace/contrib/internal/consul/patch.py
@@ -71,17 +71,17 @@ def trace_func(wrapped, instance, args, kwargs):
             resource=resource,
             span_type=SpanTypes.HTTP,
         ) as span:
-            span.set_tag_str(COMPONENT, config.consul.integration_name)
+            span._set_tag_str(COMPONENT, config.consul.integration_name)
 
-            span.set_tag_str(net.TARGET_HOST, instance.agent.http.host)
+            span._set_tag_str(net.TARGET_HOST, instance.agent.http.host)
 
             # set span.kind to the type of request being performed
-            span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+            span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
             # PERF: avoid setting via Span.set_tag
             span.set_metric(_SPAN_MEASURED_KEY, 1)
-            span.set_tag_str(consulx.KEY, path)
-            span.set_tag_str(consulx.CMD, resource)
+            span._set_tag_str(consulx.KEY, path)
+            span._set_tag_str(consulx.CMD, resource)
             return wrapped(*args, **kwargs)
 
     return trace_func
diff --git a/ddtrace/contrib/internal/django/patch.py b/ddtrace/contrib/internal/django/patch.py
index fc9e0358167..c3e6d13ced6 100644
--- a/ddtrace/contrib/internal/django/patch.py
+++ b/ddtrace/contrib/internal/django/patch.py
@@ -348,7 +348,7 @@ def traced_get_asgi_application(django, pin, func, instance, args, kwargs):
 
     def django_asgi_modifier(span, scope):
         span.name = schematize_url_operation("django.request", protocol="http", direction=SpanDirection.INBOUND)
-        span.set_tag_str(COMPONENT, config_django.integration_name)
+        span._set_tag_str(COMPONENT, config_django.integration_name)
 
     return TraceMiddleware(func(*args, **kwargs), integration_config=config_django, span_modifier=django_asgi_modifier)
 
diff --git a/ddtrace/contrib/internal/django/utils.py b/ddtrace/contrib/internal/django/utils.py
index a4c3ccee1ec..045f18f50d0 100644
--- a/ddtrace/contrib/internal/django/utils.py
+++ b/ddtrace/contrib/internal/django/utils.py
@@ -115,11 +115,11 @@ def set_tag_array(span, prefix, value):
 
     if len(value) == 1:
         if value[0]:
-            span.set_tag_str(prefix, value[0])
+            span._set_tag_str(prefix, value[0])
     else:
         for i, v in enumerate(value, start=0):
             if v:
-                span.set_tag_str("".join((prefix, ".", str(i))), v)
+                span._set_tag_str("".join((prefix, ".", str(i))), v)
 
 
 def get_request_uri(request):
@@ -205,7 +205,7 @@ def _set_resolver_tags(pin, span, request):
             # Determine the resolver and resource name for this request
             route = get_django_2_route(request, resolver_match)
             if route:
-                span.set_tag_str("http.route", route)
+                span._set_tag_str("http.route", route)
 
         if config.django.use_handler_resource_format:
             resource = " ".join((request.method, handler))
@@ -223,7 +223,7 @@ def _set_resolver_tags(pin, span, request):
 
                 resource = " ".join((request.method, handler))
 
-        span.set_tag_str("django.view", resolver_match.view_name)
+        span._set_tag_str("django.view", resolver_match.view_name)
         set_tag_array(span, "django.namespace", resolver_match.namespaces)
 
         # Django >= 2.0.0
@@ -256,7 +256,7 @@ def _before_request_tags(pin, span, request):
     span.span_type = SpanTypes.WEB
     span._metrics[_SPAN_MEASURED_KEY] = 1
 
-    span.set_tag_str("django.request.class", func_name(request))
+    span._set_tag_str("django.request.class", func_name(request))
 
 
 def _extract_body(request):
@@ -326,16 +326,16 @@ def _after_request_tags(pin, span: Span, request, response):
             # - use a thread or sync_to_async.
             try:
                 if hasattr(user, "is_authenticated"):
-                    span.set_tag_str("django.user.is_authenticated", str(user_is_authenticated(user)))
+                    span._set_tag_str("django.user.is_authenticated", str(user_is_authenticated(user)))
 
                 uid = getattr(user, "pk", None)
                 if uid and isinstance(uid, int):
-                    span.set_tag_str("django.user.id", str(uid))
-                    span.set_tag_str(_user.ID, str(uid))
+                    span._set_tag_str("django.user.id", str(uid))
+                    span._set_tag_str(_user.ID, str(uid))
                 if config.django.include_user_name:
                     username = getattr(user, "username", None)
                     if username:
-                        span.set_tag_str("django.user.name", username)
+                        span._set_tag_str("django.user.name", username)
             except Exception:
                 log.debug("Error retrieving authentication information for user", exc_info=True)
 
@@ -344,7 +344,7 @@ def _after_request_tags(pin, span: Span, request, response):
         _set_resolver_tags(pin, span, request)
         if response:
             status = response.status_code
-            span.set_tag_str("django.response.class", func_name(response))
+            span._set_tag_str("django.response.class", func_name(response))
             if hasattr(response, "template_name"):
                 # template_name is a bit of a misnomer, as it could be any of:
                 # a list of strings, a tuple of strings, a single string, or an instance of Template
diff --git a/ddtrace/contrib/internal/dogpile_cache/region.py b/ddtrace/contrib/internal/dogpile_cache/region.py
index 96c67024b87..e1f325f103d 100644
--- a/ddtrace/contrib/internal/dogpile_cache/region.py
+++ b/ddtrace/contrib/internal/dogpile_cache/region.py
@@ -22,7 +22,7 @@ def _wrap_get_create(func, instance, args, kwargs):
         resource="get_or_create",
         span_type=SpanTypes.CACHE,
     ) as span:
-        span.set_tag_str(COMPONENT, "dogpile_cache")
+        span._set_tag_str(COMPONENT, "dogpile_cache")
         # PERF: avoid setting via Span.set_tag
         span.set_metric(_SPAN_MEASURED_KEY, 1)
         span.set_tag("key", key)
@@ -45,7 +45,7 @@ def _wrap_get_create_multi(func, instance, args, kwargs):
         resource="get_or_create_multi",
         span_type="cache",
     ) as span:
-        span.set_tag_str(COMPONENT, "dogpile_cache")
+        span._set_tag_str(COMPONENT, "dogpile_cache")
         # PERF: avoid setting via Span.set_tag
         span.set_metric(_SPAN_MEASURED_KEY, 1)
         span.set_tag("keys", keys)
diff --git a/ddtrace/contrib/internal/elasticsearch/patch.py b/ddtrace/contrib/internal/elasticsearch/patch.py
index 40fa9d379ac..c1761266b72 100644
--- a/ddtrace/contrib/internal/elasticsearch/patch.py
+++ b/ddtrace/contrib/internal/elasticsearch/patch.py
@@ -145,10 +145,10 @@ def _perform_request(func, instance, args, kwargs):
             if pin.tags:
                 span.set_tags(pin.tags)
 
-            span.set_tag_str(COMPONENT, config.elasticsearch.integration_name)
+            span._set_tag_str(COMPONENT, config.elasticsearch.integration_name)
 
             # set span.kind to the type of request being performed
-            span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+            span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
             # PERF: avoid setting via Span.set_tag
             span.set_metric(_SPAN_MEASURED_KEY, 1)
@@ -165,9 +165,9 @@ def _perform_request(func, instance, args, kwargs):
             else:
                 encoded_params = parsed.query
 
-            span.set_tag_str(metadata.METHOD, method)
-            span.set_tag_str(metadata.URL, url)
-            span.set_tag_str(metadata.PARAMS, encoded_params)
+            span._set_tag_str(metadata.METHOD, method)
+            span._set_tag_str(metadata.URL, url)
+            span._set_tag_str(metadata.PARAMS, encoded_params)
             try:
                 # elasticsearch<8
                 connections = instance.connection_pool.connections
@@ -177,12 +177,12 @@ def _perform_request(func, instance, args, kwargs):
             for connection in connections:
                 hostname, _ = extract_netloc_and_query_info_from_url(connection.host)
                 if hostname:
-                    span.set_tag_str(net.TARGET_HOST, hostname)
-                    span.set_tag_str(net.SERVER_ADDRESS, hostname)
+                    span._set_tag_str(net.TARGET_HOST, hostname)
+                    span._set_tag_str(net.SERVER_ADDRESS, hostname)
                     break
 
             if config.elasticsearch.trace_query_string:
-                span.set_tag_str(http.QUERY_STRING, encoded_params)
+                span._set_tag_str(http.QUERY_STRING, encoded_params)
 
             if method in ["GET", "POST"]:
                 try:
@@ -197,9 +197,9 @@ def _perform_request(func, instance, args, kwargs):
                 # Ideally the body should be truncated, however we cannot truncate as the obfuscation
                 # logic for the body lives in the agent and truncating would make the body undecodable.
                 if len(ser_body) <= _limits.MAX_SPAN_META_VALUE_LEN:
-                    span.set_tag_str(metadata.BODY, ser_body)
+                    span._set_tag_str(metadata.BODY, ser_body)
                 else:
-                    span.set_tag_str(
+                    span._set_tag_str(
                         metadata.BODY,
                         "<body size %s exceeds limit of %s>" % (len(ser_body), _limits.MAX_SPAN_META_VALUE_LEN),
                     )
diff --git a/ddtrace/contrib/internal/flask_cache/patch.py b/ddtrace/contrib/internal/flask_cache/patch.py
index aa1e8b59cd8..b48ff93e881 100644
--- a/ddtrace/contrib/internal/flask_cache/patch.py
+++ b/ddtrace/contrib/internal/flask_cache/patch.py
@@ -90,12 +90,12 @@ def __trace(self, cmd):
                 service=self._datadog_service,
             )
 
-            s.set_tag_str(COMPONENT, config.flask_cache.integration_name)
+            s._set_tag_str(COMPONENT, config.flask_cache.integration_name)
 
             # PERF: avoid setting via Span.set_tag
             s.set_metric(_SPAN_MEASURED_KEY, 1)
             # set span tags
-            s.set_tag_str(CACHE_BACKEND, self.config.get("CACHE_TYPE"))
+            s._set_tag_str(CACHE_BACKEND, self.config.get("CACHE_TYPE"))
             s.set_tags(self._datadog_meta)
             # add connection meta if there is one
             client = _extract_client(self.cache)
@@ -114,7 +114,7 @@ def get(self, *args, **kwargs):
             with self.__trace("flask_cache.cmd") as span:
                 span.resource = _resource_from_cache_prefix("GET", self.config)
                 if len(args) > 0:
-                    span.set_tag_str(COMMAND_KEY, args[0])
+                    span._set_tag_str(COMMAND_KEY, args[0])
                 result = super(TracedCache, self).get(*args, **kwargs)
                 span.set_metric(db.ROWCOUNT, 1 if result else 0)
                 return result
@@ -126,7 +126,7 @@ def set(self, *args, **kwargs):
             with self.__trace("flask_cache.cmd") as span:
                 span.resource = _resource_from_cache_prefix("SET", self.config)
                 if len(args) > 0:
-                    span.set_tag_str(COMMAND_KEY, args[0])
+                    span._set_tag_str(COMMAND_KEY, args[0])
                 return super(TracedCache, self).set(*args, **kwargs)
 
         def add(self, *args, **kwargs):
@@ -136,7 +136,7 @@ def add(self, *args, **kwargs):
             with self.__trace("flask_cache.cmd") as span:
                 span.resource = _resource_from_cache_prefix("ADD", self.config)
                 if len(args) > 0:
-                    span.set_tag_str(COMMAND_KEY, args[0])
+                    span._set_tag_str(COMMAND_KEY, args[0])
                 return super(TracedCache, self).add(*args, **kwargs)
 
         def delete(self, *args, **kwargs):
@@ -146,7 +146,7 @@ def delete(self, *args, **kwargs):
             with self.__trace("flask_cache.cmd") as span:
                 span.resource = _resource_from_cache_prefix("DELETE", self.config)
                 if len(args) > 0:
-                    span.set_tag_str(COMMAND_KEY, args[0])
+                    span._set_tag_str(COMMAND_KEY, args[0])
                 return super(TracedCache, self).delete(*args, **kwargs)
 
         def delete_many(self, *args, **kwargs):
diff --git a/ddtrace/contrib/internal/graphql/patch.py b/ddtrace/contrib/internal/graphql/patch.py
index efed64563f5..e51fc4d236c 100644
--- a/ddtrace/contrib/internal/graphql/patch.py
+++ b/ddtrace/contrib/internal/graphql/patch.py
@@ -141,9 +141,9 @@ def _traced_parse(func, args, kwargs):
         service=trace_utils.int_service(pin, config.graphql),
         span_type=SpanTypes.GRAPHQL,
     ) as span:
-        span.set_tag_str(COMPONENT, config.graphql.integration_name)
+        span._set_tag_str(COMPONENT, config.graphql.integration_name)
 
-        span.set_tag_str(_GRAPHQL_SOURCE, source_str)
+        span._set_tag_str(_GRAPHQL_SOURCE, source_str)
         return func(*args, **kwargs)
 
 
@@ -161,9 +161,9 @@ def _traced_validate(func, args, kwargs):
         service=trace_utils.int_service(pin, config.graphql),
         span_type=SpanTypes.GRAPHQL,
     ) as span:
-        span.set_tag_str(COMPONENT, config.graphql.integration_name)
+        span._set_tag_str(COMPONENT, config.graphql.integration_name)
 
-        span.set_tag_str(_GRAPHQL_SOURCE, source_str)
+        span._set_tag_str(_GRAPHQL_SOURCE, source_str)
         errors = func(*args, **kwargs)
         _set_span_errors(errors, span)
         return errors
@@ -191,13 +191,13 @@ def _traced_execute(func, args, kwargs):
         service=trace_utils.int_service(pin, config.graphql),
         span_type=SpanTypes.GRAPHQL,
     ) as span:
-        span.set_tag_str(COMPONENT, config.graphql.integration_name)
+        span._set_tag_str(COMPONENT, config.graphql.integration_name)
 
         # PERF: avoid setting via Span.set_tag
         span.set_metric(_SPAN_MEASURED_KEY, 1)
 
         _set_span_operation_tags(span, document)
-        span.set_tag_str(_GRAPHQL_SOURCE, source_str)
+        span._set_tag_str(_GRAPHQL_SOURCE, source_str)
 
         result = func(*args, **kwargs)
         if isinstance(result, ExecutionResult):
@@ -221,7 +221,7 @@ def _traced_query(func, args, kwargs):
         service=trace_utils.int_service(pin, config.graphql),
         span_type=SpanTypes.GRAPHQL,
     ) as span:
-        span.set_tag_str(COMPONENT, config.graphql.integration_name)
+        span._set_tag_str(COMPONENT, config.graphql.integration_name)
 
         # mark span as measured and set sample rate
         # PERF: avoid setting via Span.set_tag
@@ -250,7 +250,7 @@ def _resolver_middleware(next_middleware, root, info, **args):
         resource=info.field_name,
         span_type=SpanTypes.GRAPHQL,
     ) as span:
-        span.set_tag_str(COMPONENT, config.graphql.integration_name)
+        span._set_tag_str(COMPONENT, config.graphql.integration_name)
 
         return next_middleware(root, info, **args)
 
@@ -330,9 +330,9 @@ def _set_span_errors(errors: List[GraphQLError], span: Span) -> None:
     span.error = 1
 
     exc_type_str = "%s.%s" % (GraphQLError.__module__, GraphQLError.__name__)
-    span.set_tag_str(ERROR_TYPE, exc_type_str)
+    span._set_tag_str(ERROR_TYPE, exc_type_str)
     error_msgs = "\n".join([str(error) for error in errors])
-    span.set_tag_str(ERROR_MSG, error_msgs)
+    span._set_tag_str(ERROR_MSG, error_msgs)
     for error in errors:
         attributes = {
             "message": error.message,
@@ -349,7 +349,7 @@ def _set_span_errors(errors: List[GraphQLError], span: Span) -> None:
             tb = buff.getvalue()
 
             attributes["stacktrace"] = tb
-            span.set_tag_str(ERROR_STACK, tb)
+            span._set_tag_str(ERROR_STACK, tb)
 
         if error.path is not None:
             path = ",".join([str(path_obj) for path_obj in error.path])
@@ -374,10 +374,10 @@ def _set_span_operation_tags(span, document):
 
     # operation_def.operation should never be None
     if _graphql_version < (3, 0):
-        span.set_tag_str(_GRAPHQL_OPERATION_TYPE, operation_def.operation)
+        span._set_tag_str(_GRAPHQL_OPERATION_TYPE, operation_def.operation)
     else:
         # OperationDefinition.operation is an Enum in graphql-core>=3
-        span.set_tag_str(_GRAPHQL_OPERATION_TYPE, operation_def.operation.value)
+        span._set_tag_str(_GRAPHQL_OPERATION_TYPE, operation_def.operation.value)
 
     if operation_def.name:
-        span.set_tag_str(_GRAPHQL_OPERATION_NAME, operation_def.name.value)
+        span._set_tag_str(_GRAPHQL_OPERATION_NAME, operation_def.name.value)
diff --git a/ddtrace/contrib/internal/grpc/aio_client_interceptor.py b/ddtrace/contrib/internal/grpc/aio_client_interceptor.py
index cdbe247b17e..482301705a2 100644
--- a/ddtrace/contrib/internal/grpc/aio_client_interceptor.py
+++ b/ddtrace/contrib/internal/grpc/aio_client_interceptor.py
@@ -58,7 +58,7 @@ def _done_callback_unary(span, code, details):
     def func(call):
         # type: (aio.Call) -> None
         try:
-            span.set_tag_str(constants.GRPC_STATUS_CODE_KEY, str(code))
+            span._set_tag_str(constants.GRPC_STATUS_CODE_KEY, str(code))
 
             # Handle server-side error in unary response RPCs
             if code != grpc.StatusCode.OK:
@@ -83,7 +83,7 @@ def func(call):
                     # we need to call __repr__ as we cannot call code() or details() since they are both async
                     code, details = utils._parse_rpc_repr_string(call.__repr__(), grpc)
 
-                    span.set_tag_str(constants.GRPC_STATUS_CODE_KEY, str(code))
+                    span._set_tag_str(constants.GRPC_STATUS_CODE_KEY, str(code))
 
                     # Handle server-side error in unary response RPCs
                     if code != grpc.StatusCode.OK:
@@ -102,22 +102,22 @@ def func(call):
 def _handle_error(span, code, details):
     # type: (Span, grpc.StatusCode, str) -> None
     span.error = 1
-    span.set_tag_str(ERROR_MSG, details)
-    span.set_tag_str(ERROR_TYPE, str(code))
+    span._set_tag_str(ERROR_MSG, details)
+    span._set_tag_str(ERROR_TYPE, str(code))
 
 
 def _handle_rpc_error(span, rpc_error):
     # type: (Span, aio.AioRpcError) -> None
     code = str(rpc_error.code())
     span.error = 1
-    span.set_tag_str(constants.GRPC_STATUS_CODE_KEY, code)
+    span._set_tag_str(constants.GRPC_STATUS_CODE_KEY, code)
     details = rpc_error.details()
     if isinstance(details, bytes):
         details = details.decode("utf-8", errors="ignore")
     else:
         details = str(details)
-    span.set_tag_str(ERROR_MSG, details)
-    span.set_tag_str(ERROR_TYPE, code)
+    span._set_tag_str(ERROR_MSG, details)
+    span._set_tag_str(ERROR_TYPE, code)
     span.finish()
 
 
@@ -125,9 +125,9 @@ async def _handle_cancelled_error(call, span):
     # type: (aio.Call, Span) -> None
     code = str(await call.code())
     span.error = 1
-    span.set_tag_str(constants.GRPC_STATUS_CODE_KEY, code)
-    span.set_tag_str(ERROR_MSG, await call.details())
-    span.set_tag_str(ERROR_TYPE, code)
+    span._set_tag_str(constants.GRPC_STATUS_CODE_KEY, code)
+    span._set_tag_str(ERROR_MSG, await call.details())
+    span._set_tag_str(ERROR_TYPE, code)
     span.finish()
 
 
@@ -149,17 +149,17 @@ def _intercept_client_call(self, method_kind, client_call_details):
             resource=method_as_str,
         )
 
-        span.set_tag_str(COMPONENT, config.grpc_aio_client.integration_name)
+        span._set_tag_str(COMPONENT, config.grpc_aio_client.integration_name)
 
         # set span.kind to the type of operation being performed
-        span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+        span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
         # PERF: avoid setting via Span.set_tag
         span.set_metric(_SPAN_MEASURED_KEY, 1)
 
         utils.set_grpc_method_meta(span, method_as_str, method_kind)
         utils.set_grpc_client_meta(span, self._host, self._port)
-        span.set_tag_str(constants.GRPC_SPAN_KIND_KEY, constants.GRPC_SPAN_KIND_VALUE_CLIENT)
+        span._set_tag_str(constants.GRPC_SPAN_KIND_KEY, constants.GRPC_SPAN_KIND_VALUE_CLIENT)
 
         # inject tags from pin
         if self._pin.tags:
diff --git a/ddtrace/contrib/internal/grpc/aio_server_interceptor.py b/ddtrace/contrib/internal/grpc/aio_server_interceptor.py
index 427c9979fa7..913b6708254 100644
--- a/ddtrace/contrib/internal/grpc/aio_server_interceptor.py
+++ b/ddtrace/contrib/internal/grpc/aio_server_interceptor.py
@@ -101,9 +101,9 @@ def _handle_server_exception(
             details = details.decode("utf-8", errors="ignore")
         else:
             details = str(details)
-        span.set_tag_str(ERROR_MSG, details)
+        span._set_tag_str(ERROR_MSG, details)
     if hasattr(servicer_context, "code") and servicer_context.code() != 0 and servicer_context.code() in _INT2CODE:
-        span.set_tag_str(ERROR_TYPE, str(_INT2CODE[servicer_context.code()]))
+        span._set_tag_str(ERROR_TYPE, str(_INT2CODE[servicer_context.code()]))
 
 
 async def _wrap_aio_stream_response(
@@ -189,16 +189,16 @@ def _create_span(pin, method, invocation_metadata, method_kind):
         resource=method,
     )
 
-    span.set_tag_str(COMPONENT, config.grpc_aio_server.integration_name)
+    span._set_tag_str(COMPONENT, config.grpc_aio_server.integration_name)
 
     # set span.kind to the type of operation being performed
-    span.set_tag_str(SPAN_KIND, SpanKind.SERVER)
+    span._set_tag_str(SPAN_KIND, SpanKind.SERVER)
 
     # PERF: avoid setting via Span.set_tag
     span.set_metric(_SPAN_MEASURED_KEY, 1)
 
     set_grpc_method_meta(span, method, method_kind)
-    span.set_tag_str(constants.GRPC_SPAN_KIND_KEY, constants.GRPC_SPAN_KIND_VALUE_SERVER)
+    span._set_tag_str(constants.GRPC_SPAN_KIND_KEY, constants.GRPC_SPAN_KIND_VALUE_SERVER)
 
     if pin.tags:
         span.set_tags(pin.tags)
diff --git a/ddtrace/contrib/internal/grpc/client_interceptor.py b/ddtrace/contrib/internal/grpc/client_interceptor.py
index 24e85307a21..e55ea67fc50 100644
--- a/ddtrace/contrib/internal/grpc/client_interceptor.py
+++ b/ddtrace/contrib/internal/grpc/client_interceptor.py
@@ -64,7 +64,7 @@ def func(response):
             # pull out response code from gRPC response to use both for `grpc.status.code`
             # tag and the error type tag if the response is an exception
             response_code = response.code()
-            span.set_tag_str(constants.GRPC_STATUS_CODE_KEY, str(response_code))
+            span._set_tag_str(constants.GRPC_STATUS_CODE_KEY, str(response_code))
 
             if response_code != grpc.StatusCode.OK:
                 _handle_error(span, response, response_code)
@@ -101,8 +101,8 @@ def _handle_error(span, response_error, status_code):
         # handle cancelled futures separately to avoid raising grpc.FutureCancelledError
         span.error = 1
         exc_val = str(response_error.details())
-        span.set_tag_str(ERROR_MSG, exc_val)
-        span.set_tag_str(ERROR_TYPE, str(status_code))
+        span._set_tag_str(ERROR_MSG, exc_val)
+        span._set_tag_str(ERROR_TYPE, str(status_code))
         return
 
     exception = response_error.exception()
@@ -114,9 +114,9 @@ def _handle_error(span, response_error, status_code):
             # handle internal gRPC exceptions separately to get status code and
             # details as tags properly
             exc_val = str(response_error.details())
-            span.set_tag_str(ERROR_MSG, exc_val)
-            span.set_tag_str(ERROR_TYPE, str(status_code))
-            span.set_tag_str(ERROR_STACK, str(traceback))
+            span._set_tag_str(ERROR_MSG, exc_val)
+            span._set_tag_str(ERROR_TYPE, str(status_code))
+            span._set_tag_str(ERROR_STACK, str(traceback))
         else:
             exc_type = type(exception)
             span.set_exc_info(exc_type, exception, traceback)
@@ -206,17 +206,17 @@ def _intercept_client_call(self, method_kind, client_call_details):
             child_of=parent,
         )
 
-        span.set_tag_str(COMPONENT, config.grpc.integration_name)
+        span._set_tag_str(COMPONENT, config.grpc.integration_name)
 
         # set span.kind to the type of operation being performed
-        span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+        span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
         # PERF: avoid setting via Span.set_tag
         span.set_metric(_SPAN_MEASURED_KEY, 1)
 
         utils.set_grpc_method_meta(span, client_call_details.method, method_kind)
         utils.set_grpc_client_meta(span, self._host, self._port)
-        span.set_tag_str(constants.GRPC_SPAN_KIND_KEY, constants.GRPC_SPAN_KIND_VALUE_CLIENT)
+        span._set_tag_str(constants.GRPC_SPAN_KIND_KEY, constants.GRPC_SPAN_KIND_VALUE_CLIENT)
 
         # inject tags from pin
         if self._pin.tags:
diff --git a/ddtrace/contrib/internal/grpc/server_interceptor.py b/ddtrace/contrib/internal/grpc/server_interceptor.py
index a6deb1d5333..93306f853d9 100644
--- a/ddtrace/contrib/internal/grpc/server_interceptor.py
+++ b/ddtrace/contrib/internal/grpc/server_interceptor.py
@@ -45,8 +45,8 @@ def _handle_server_exception(server_context, span):
             details = details.decode("utf-8", errors="ignore")
         else:
             details = str(details)
-        span.set_tag_str(ERROR_MSG, details)
-        span.set_tag_str(ERROR_TYPE, code)
+        span._set_tag_str(ERROR_MSG, details)
+        span._set_tag_str(ERROR_TYPE, code)
 
 
 def _wrap_response_iterator(response_iterator, server_context, span):
@@ -97,16 +97,16 @@ def _fn(self, method_kind, behavior, args, kwargs):
             resource=self._handler_call_details.method,
         )
 
-        span.set_tag_str(COMPONENT, config.grpc_server.integration_name)
+        span._set_tag_str(COMPONENT, config.grpc_server.integration_name)
 
         # set span.kind tag equal to type of span
-        span.set_tag_str(SPAN_KIND, SpanKind.SERVER)
+        span._set_tag_str(SPAN_KIND, SpanKind.SERVER)
 
         # PERF: avoid setting via Span.set_tag
         span.set_metric(_SPAN_MEASURED_KEY, 1)
 
         set_grpc_method_meta(span, self._handler_call_details.method, method_kind)
-        span.set_tag_str(constants.GRPC_SPAN_KIND_KEY, constants.GRPC_SPAN_KIND_VALUE_SERVER)
+        span._set_tag_str(constants.GRPC_SPAN_KIND_KEY, constants.GRPC_SPAN_KIND_VALUE_SERVER)
 
         # access server context by taking second argument as server context
         # if not found, skip using context to tag span with server state information
diff --git a/ddtrace/contrib/internal/grpc/utils.py b/ddtrace/contrib/internal/grpc/utils.py
index a01dcce5d7c..1f80b7875ba 100644
--- a/ddtrace/contrib/internal/grpc/utils.py
+++ b/ddtrace/contrib/internal/grpc/utils.py
@@ -28,31 +28,31 @@ def set_grpc_method_meta(span, method, method_kind):
     method_path = method
     method_package_service, method_package, method_service, method_name = parse_method_path(method_path)
     if method_package_service is not None:
-        span.set_tag_str(constants.GRPC_METHOD_PACKAGE_SERVICE_KEY, method_package_service)
+        span._set_tag_str(constants.GRPC_METHOD_PACKAGE_SERVICE_KEY, method_package_service)
     if method_path is not None:
-        span.set_tag_str(constants.GRPC_METHOD_PATH_KEY, method_path)
+        span._set_tag_str(constants.GRPC_METHOD_PATH_KEY, method_path)
     if method_package is not None:
-        span.set_tag_str(constants.GRPC_METHOD_PACKAGE_KEY, method_package)
+        span._set_tag_str(constants.GRPC_METHOD_PACKAGE_KEY, method_package)
     if method_service is not None:
-        span.set_tag_str(constants.GRPC_METHOD_SERVICE_KEY, method_service)
+        span._set_tag_str(constants.GRPC_METHOD_SERVICE_KEY, method_service)
     if method_name is not None:
-        span.set_tag_str(constants.GRPC_METHOD_NAME_KEY, method_name)
+        span._set_tag_str(constants.GRPC_METHOD_NAME_KEY, method_name)
     if method_kind is not None:
-        span.set_tag_str(constants.GRPC_METHOD_KIND_KEY, method_kind)
+        span._set_tag_str(constants.GRPC_METHOD_KIND_KEY, method_kind)
 
 
 def set_grpc_client_meta(span, host, port):
     if host:
-        span.set_tag_str(constants.GRPC_HOST_KEY, host)
+        span._set_tag_str(constants.GRPC_HOST_KEY, host)
         try:
             ipaddress.ip_address(host)
         except ValueError:
-            span.set_tag_str(net.PEER_HOSTNAME, host)
+            span._set_tag_str(net.PEER_HOSTNAME, host)
         else:
-            span.set_tag_str(net.TARGET_IP, host)
+            span._set_tag_str(net.TARGET_IP, host)
     if port:
-        span.set_tag_str(net.TARGET_PORT, str(port))
-    span.set_tag_str(constants.GRPC_SPAN_KIND_KEY, constants.GRPC_SPAN_KIND_VALUE_CLIENT)
+        span._set_tag_str(net.TARGET_PORT, str(port))
+    span._set_tag_str(constants.GRPC_SPAN_KIND_KEY, constants.GRPC_SPAN_KIND_VALUE_CLIENT)
 
 
 def _parse_target_from_args(args, kwargs):
diff --git a/ddtrace/contrib/internal/httplib/patch.py b/ddtrace/contrib/internal/httplib/patch.py
index 33b0216c87a..cc82045a76f 100644
--- a/ddtrace/contrib/internal/httplib/patch.py
+++ b/ddtrace/contrib/internal/httplib/patch.py
@@ -102,10 +102,10 @@ def _wrap_request(func, instance, args, kwargs):
         # Create a new span and attach to this instance (so we can retrieve/update/close later on the response)
         span = pin.tracer.trace(span_name, span_type=SpanTypes.HTTP)
 
-        span.set_tag_str(COMPONENT, config.httplib.integration_name)
+        span._set_tag_str(COMPONENT, config.httplib.integration_name)
 
         # set span.kind to the type of operation being performed
-        span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+        span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
         instance._datadog_span = span
 
@@ -147,10 +147,10 @@ def _wrap_putrequest(func, instance, args, kwargs):
             # Create a new span and attach to this instance (so we can retrieve/update/close later on the response)
             span = pin.tracer.trace(span_name, span_type=SpanTypes.HTTP)
 
-            span.set_tag_str(COMPONENT, config.httplib.integration_name)
+            span._set_tag_str(COMPONENT, config.httplib.integration_name)
 
             # set span.kind to the type of operation being performed
-            span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+            span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
             instance._datadog_span = span
 
diff --git a/ddtrace/contrib/internal/httpx/patch.py b/ddtrace/contrib/internal/httpx/patch.py
index 68ca8d1422b..fde64d83c7d 100644
--- a/ddtrace/contrib/internal/httpx/patch.py
+++ b/ddtrace/contrib/internal/httpx/patch.py
@@ -127,10 +127,10 @@ async def _wrapped_async_send(
 
     operation_name = schematize_url_operation("http.request", protocol="http", direction=SpanDirection.OUTBOUND)
     with pin.tracer.trace(operation_name, service=_get_service_name(pin, req), span_type=SpanTypes.HTTP) as span:
-        span.set_tag_str(COMPONENT, config.httpx.integration_name)
+        span._set_tag_str(COMPONENT, config.httpx.integration_name)
 
         # set span.kind to the operation type being performed
-        span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+        span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
         _init_span(span, req)
         resp = None
@@ -156,10 +156,10 @@ def _wrapped_sync_send(
 
     operation_name = schematize_url_operation("http.request", protocol="http", direction=SpanDirection.OUTBOUND)
     with pin.tracer.trace(operation_name, service=_get_service_name(pin, req), span_type=SpanTypes.HTTP) as span:
-        span.set_tag_str(COMPONENT, config.httpx.integration_name)
+        span._set_tag_str(COMPONENT, config.httpx.integration_name)
 
         # set span.kind to the operation type being performed
-        span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+        span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
         _init_span(span, req)
         resp = None
diff --git a/ddtrace/contrib/internal/jinja2/patch.py b/ddtrace/contrib/internal/jinja2/patch.py
index 153763e8392..78f1eb0f634 100644
--- a/ddtrace/contrib/internal/jinja2/patch.py
+++ b/ddtrace/contrib/internal/jinja2/patch.py
@@ -67,7 +67,7 @@ def _wrap_render(wrapped, instance, args, kwargs):
 
     template_name = str(instance.name or DEFAULT_TEMPLATE_NAME)
     with pin.tracer.trace("jinja2.render", pin.service, span_type=SpanTypes.TEMPLATE) as span:
-        span.set_tag_str(COMPONENT, config.jinja2.integration_name)
+        span._set_tag_str(COMPONENT, config.jinja2.integration_name)
 
         # PERF: avoid setting via Span.set_tag
         span.set_metric(_SPAN_MEASURED_KEY, 1)
@@ -75,7 +75,7 @@ def _wrap_render(wrapped, instance, args, kwargs):
             return wrapped(*args, **kwargs)
         finally:
             span.resource = template_name
-            span.set_tag_str("jinja2.template_name", template_name)
+            span._set_tag_str("jinja2.template_name", template_name)
 
 
 def _wrap_compile(wrapped, instance, args, kwargs):
@@ -92,10 +92,10 @@ def _wrap_compile(wrapped, instance, args, kwargs):
         try:
             return wrapped(*args, **kwargs)
         finally:
-            span.set_tag_str(COMPONENT, config.jinja2.integration_name)
+            span._set_tag_str(COMPONENT, config.jinja2.integration_name)
 
             span.resource = template_name
-            span.set_tag_str("jinja2.template_name", template_name)
+            span._set_tag_str("jinja2.template_name", template_name)
 
 
 def _wrap_load_template(wrapped, instance, args, kwargs):
@@ -111,6 +111,6 @@ def _wrap_load_template(wrapped, instance, args, kwargs):
             return template
         finally:
             span.resource = template_name
-            span.set_tag_str("jinja2.template_name", template_name)
+            span._set_tag_str("jinja2.template_name", template_name)
             if template:
-                span.set_tag_str("jinja2.template_path", template.filename)
+                span._set_tag_str("jinja2.template_path", template.filename)
diff --git a/ddtrace/contrib/internal/kafka/patch.py b/ddtrace/contrib/internal/kafka/patch.py
index dff5853c599..cfe3533aa6a 100644
--- a/ddtrace/contrib/internal/kafka/patch.py
+++ b/ddtrace/contrib/internal/kafka/patch.py
@@ -184,31 +184,31 @@ def traced_produce(func, instance, args, kwargs):
         cluster_id = _get_cluster_id(instance, topic)
         core.set_item("kafka_cluster_id", cluster_id)
         if cluster_id:
-            span.set_tag_str(kafkax.CLUSTER_ID, cluster_id)
+            span._set_tag_str(kafkax.CLUSTER_ID, cluster_id)
 
         core.dispatch("kafka.produce.start", (instance, args, kwargs, isinstance(instance, _SerializingProducer), span))
 
-        span.set_tag_str(MESSAGING_SYSTEM, kafkax.SERVICE)
-        span.set_tag_str(COMPONENT, config.kafka.integration_name)
-        span.set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
-        span.set_tag_str(kafkax.TOPIC, topic)
+        span._set_tag_str(MESSAGING_SYSTEM, kafkax.SERVICE)
+        span._set_tag_str(COMPONENT, config.kafka.integration_name)
+        span._set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
+        span._set_tag_str(kafkax.TOPIC, topic)
         if topic:
             # Should fall back to broker id if topic is not provided but it is not readily available here
-            span.set_tag_str(MESSAGING_DESTINATION_NAME, topic)
+            span._set_tag_str(MESSAGING_DESTINATION_NAME, topic)
 
         if _SerializingProducer is not None and isinstance(instance, _SerializingProducer):
             serialized_key = serialize_key(instance, topic, message_key, headers)
             if serialized_key is not None:
-                span.set_tag_str(kafkax.MESSAGE_KEY, serialized_key)
+                span._set_tag_str(kafkax.MESSAGE_KEY, serialized_key)
         else:
-            span.set_tag_str(kafkax.MESSAGE_KEY, message_key)
+            span._set_tag_str(kafkax.MESSAGE_KEY, message_key)
 
         span.set_tag(kafkax.PARTITION, partition)
-        span.set_tag_str(kafkax.TOMBSTONE, str(value is None))
+        span._set_tag_str(kafkax.TOMBSTONE, str(value is None))
         # PERF: avoid setting via Span.set_tag
         span.set_metric(_SPAN_MEASURED_KEY, 1)
         if instance._dd_bootstrap_servers is not None:
-            span.set_tag_str(kafkax.HOST_LIST, instance._dd_bootstrap_servers)
+            span._set_tag_str(kafkax.HOST_LIST, instance._dd_bootstrap_servers)
 
         # inject headers with Datadog tags if trace propagation is enabled
         if config.kafka.distributed_tracing_enabled:
@@ -272,19 +272,19 @@ def _instrument_message(messages, pin, start_ns, instance, err):
                 core.set_item("kafka_topic", str(first_message.topic()))
                 core.dispatch("kafka.consume.start", (instance, first_message, span))
 
-        span.set_tag_str(MESSAGING_SYSTEM, kafkax.SERVICE)
-        span.set_tag_str(COMPONENT, config.kafka.integration_name)
-        span.set_tag_str(SPAN_KIND, SpanKind.CONSUMER)
+        span._set_tag_str(MESSAGING_SYSTEM, kafkax.SERVICE)
+        span._set_tag_str(COMPONENT, config.kafka.integration_name)
+        span._set_tag_str(SPAN_KIND, SpanKind.CONSUMER)
         if cluster_id:
-            span.set_tag_str(kafkax.CLUSTER_ID, cluster_id)
-        span.set_tag_str(kafkax.RECEIVED_MESSAGE, str(first_message is not None))
-        span.set_tag_str(kafkax.GROUP_ID, instance._group_id)
+            span._set_tag_str(kafkax.CLUSTER_ID, cluster_id)
+        span._set_tag_str(kafkax.RECEIVED_MESSAGE, str(first_message is not None))
+        span._set_tag_str(kafkax.GROUP_ID, instance._group_id)
         if first_message is not None:
             message_key = first_message.key() or ""
             message_offset = first_message.offset() or -1
             topic = str(first_message.topic())
-            span.set_tag_str(kafkax.TOPIC, topic)
-            span.set_tag_str(MESSAGING_DESTINATION_NAME, topic)
+            span._set_tag_str(kafkax.TOPIC, topic)
+            span._set_tag_str(MESSAGING_DESTINATION_NAME, topic)
 
             # If this is a deserializing consumer, do not set the key as a tag since we
             # do not have the serialization function
@@ -293,14 +293,14 @@ def _instrument_message(messages, pin, start_ns, instance, err):
                 or isinstance(message_key, str)
                 or isinstance(message_key, bytes)
             ):
-                span.set_tag_str(kafkax.MESSAGE_KEY, message_key)
+                span._set_tag_str(kafkax.MESSAGE_KEY, message_key)
             span.set_tag(kafkax.PARTITION, first_message.partition())
             is_tombstone = False
             try:
                 is_tombstone = len(first_message) == 0
             except TypeError:  # https://github.com/confluentinc/confluent-kafka-python/issues/1192
                 pass
-            span.set_tag_str(kafkax.TOMBSTONE, str(is_tombstone))
+            span._set_tag_str(kafkax.TOMBSTONE, str(is_tombstone))
             span.set_tag(kafkax.MESSAGE_OFFSET, message_offset)
         # PERF: avoid setting via Span.set_tag
         span.set_metric(_SPAN_MEASURED_KEY, 1)
diff --git a/ddtrace/contrib/internal/kombu/patch.py b/ddtrace/contrib/internal/kombu/patch.py
index 92961401851..02e00a9e1bd 100644
--- a/ddtrace/contrib/internal/kombu/patch.py
+++ b/ddtrace/contrib/internal/kombu/patch.py
@@ -116,20 +116,20 @@ def traced_receive(func, instance, args, kwargs):
         service=pin.service,
         span_type=SpanTypes.WORKER,
     ) as s:
-        s.set_tag_str(COMPONENT, config.kombu.integration_name)
+        s._set_tag_str(COMPONENT, config.kombu.integration_name)
 
         # set span.kind to the type of operation being performed
-        s.set_tag_str(SPAN_KIND, SpanKind.CONSUMER)
+        s._set_tag_str(SPAN_KIND, SpanKind.CONSUMER)
 
         # PERF: avoid setting via Span.set_tag
         s.set_metric(_SPAN_MEASURED_KEY, 1)
         # run the command
         exchange = message.delivery_info["exchange"]
         s.resource = exchange
-        s.set_tag_str(kombux.EXCHANGE, exchange)
+        s._set_tag_str(kombux.EXCHANGE, exchange)
 
         s.set_tags(extract_conn_tags(message.channel.connection))
-        s.set_tag_str(kombux.ROUTING_KEY, message.delivery_info["routing_key"])
+        s._set_tag_str(kombux.ROUTING_KEY, message.delivery_info["routing_key"])
         result = func(*args, **kwargs)
         core.dispatch("kombu.amqp.receive.post", [instance, message, s])
         return result
@@ -145,19 +145,19 @@ def traced_publish(func, instance, args, kwargs):
         service=pin.service,
         span_type=SpanTypes.WORKER,
     ) as s:
-        s.set_tag_str(COMPONENT, config.kombu.integration_name)
+        s._set_tag_str(COMPONENT, config.kombu.integration_name)
 
         # set span.kind to the type of operation being performed
-        s.set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
+        s._set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
 
         # PERF: avoid setting via Span.set_tag
         s.set_metric(_SPAN_MEASURED_KEY, 1)
         exchange_name = get_exchange_from_args(args)
         s.resource = exchange_name
-        s.set_tag_str(kombux.EXCHANGE, exchange_name)
+        s._set_tag_str(kombux.EXCHANGE, exchange_name)
         if pin.tags:
             s.set_tags(pin.tags)
-        s.set_tag_str(kombux.ROUTING_KEY, get_routing_key_from_args(args))
+        s._set_tag_str(kombux.ROUTING_KEY, get_routing_key_from_args(args))
         s.set_tags(extract_conn_tags(instance.channel.connection))
         s.set_metric(kombux.BODY_LEN, get_body_length_from_args(args))
         # run the command
diff --git a/ddtrace/contrib/internal/mako/patch.py b/ddtrace/contrib/internal/mako/patch.py
index cc0d638628f..7d1f7886f33 100644
--- a/ddtrace/contrib/internal/mako/patch.py
+++ b/ddtrace/contrib/internal/mako/patch.py
@@ -67,7 +67,7 @@ def _wrap_render(wrapped, instance, args, kwargs):
     with pin.tracer.trace(
         func_name(wrapped), int_service(pin, config.mako, schematize_service_name("mako")), span_type=SpanTypes.TEMPLATE
     ) as span:
-        span.set_tag_str(COMPONENT, "mako")
+        span._set_tag_str(COMPONENT, "mako")
 
         # PERF: avoid setting via Span.set_tag
         span.set_metric(_SPAN_MEASURED_KEY, 1)
diff --git a/ddtrace/contrib/internal/mysqldb/patch.py b/ddtrace/contrib/internal/mysqldb/patch.py
index a345793d205..fefccec7776 100644
--- a/ddtrace/contrib/internal/mysqldb/patch.py
+++ b/ddtrace/contrib/internal/mysqldb/patch.py
@@ -102,10 +102,10 @@ def _connect(func, instance, args, kwargs):
         with pin.tracer.trace(
             "MySQLdb.connection.connect", service=ext_service(pin, config.mysqldb), span_type=SpanTypes.SQL
         ) as span:
-            span.set_tag_str(COMPONENT, config.mysqldb.integration_name)
+            span._set_tag_str(COMPONENT, config.mysqldb.integration_name)
 
             # set span.kind to the type of operation being performed
-            span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+            span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
             # PERF: avoid setting via Span.set_tag
             span.set_metric(_SPAN_MEASURED_KEY, 1)
diff --git a/ddtrace/contrib/internal/openai/_endpoint_hooks.py b/ddtrace/contrib/internal/openai/_endpoint_hooks.py
index 68cdd92c7e4..b8995a0fc57 100644
--- a/ddtrace/contrib/internal/openai/_endpoint_hooks.py
+++ b/ddtrace/contrib/internal/openai/_endpoint_hooks.py
@@ -45,8 +45,8 @@ def _record_request(self, pin, integration, instance, span, args, kwargs):
         endpoint = self.ENDPOINT_NAME
         if endpoint is None:
             endpoint = "%s" % getattr(instance, "OBJECT_NAME", "")
-        span.set_tag_str("openai.request.endpoint", "/%s/%s" % (API_VERSION, endpoint))
-        span.set_tag_str("openai.request.method", self.HTTP_METHOD_TYPE)
+        span._set_tag_str("openai.request.endpoint", "/%s/%s" % (API_VERSION, endpoint))
+        span._set_tag_str("openai.request.method", self.HTTP_METHOD_TYPE)
 
         if self._request_arg_params and len(self._request_arg_params) > 1:
             for idx, arg in enumerate(self._request_arg_params):
@@ -55,16 +55,16 @@ def _record_request(self, pin, integration, instance, span, args, kwargs):
                 if arg is None or args[idx] is None:
                     continue
                 if arg in self._base_level_tag_args:
-                    span.set_tag_str("openai.%s" % arg, str(args[idx]))
+                    span._set_tag_str("openai.%s" % arg, str(args[idx]))
         for kw_attr in self._request_kwarg_params:
             if kw_attr not in kwargs:
                 continue
 
             if isinstance(kwargs[kw_attr], dict):
                 for k, v in kwargs[kw_attr].items():
-                    span.set_tag_str("openai.request.%s.%s" % (kw_attr, k), str(v))
+                    span._set_tag_str("openai.request.%s.%s" % (kw_attr, k), str(v))
             elif kw_attr == "engine" or kw_attr == "model":  # Azure OpenAI requires using "engine" instead of "model"
-                span.set_tag_str("openai.request.model", str(kwargs[kw_attr]))
+                span._set_tag_str("openai.request.model", str(kwargs[kw_attr]))
 
     def handle_request(self, pin, integration, instance, span, args, kwargs):
         self._record_request(pin, integration, instance, span, args, kwargs)
@@ -79,7 +79,7 @@ def handle_request(self, pin, integration, instance, span, args, kwargs):
     def _record_response(self, pin, integration, span, args, kwargs, resp, error):
         for resp_attr in self._response_attrs:
             if hasattr(resp, resp_attr):
-                span.set_tag_str("openai.response.%s" % resp_attr, str(getattr(resp, resp_attr, "")))
+                span._set_tag_str("openai.response.%s" % resp_attr, str(getattr(resp, resp_attr, "")))
         return resp
 
 
@@ -313,16 +313,16 @@ def _record_request(self, pin, integration, instance, span, args, kwargs):
         if endpoint.endswith("/models"):
             span.resource = "retrieveModel"
             if len(args) >= 1:
-                span.set_tag_str("openai.request.model", args[0])
+                span._set_tag_str("openai.request.model", args[0])
             else:
-                span.set_tag_str("openai.request.model", kwargs.get("model", kwargs.get("id", "")))
+                span._set_tag_str("openai.request.model", kwargs.get("model", kwargs.get("id", "")))
         elif endpoint.endswith("/files"):
             span.resource = "retrieveFile"
             if len(args) >= 1:
-                span.set_tag_str("openai.request.file_id", args[0])
+                span._set_tag_str("openai.request.file_id", args[0])
             else:
-                span.set_tag_str("openai.request.file_id", kwargs.get("file_id", kwargs.get("id", "")))
-        span.set_tag_str("openai.request.endpoint", "%s/*" % endpoint)
+                span._set_tag_str("openai.request.file_id", kwargs.get("file_id", kwargs.get("id", "")))
+        span._set_tag_str("openai.request.endpoint", "%s/*" % endpoint)
 
     def _record_response(self, pin, integration, span, args, kwargs, resp, error):
         resp = super()._record_response(pin, integration, span, args, kwargs, resp, error)
@@ -362,16 +362,16 @@ def _record_request(self, pin, integration, instance, span, args, kwargs):
         if endpoint.endswith("/models"):
             span.resource = "deleteModel"
             if len(args) >= 1:
-                span.set_tag_str("openai.request.model", args[0])
+                span._set_tag_str("openai.request.model", args[0])
             else:
-                span.set_tag_str("openai.request.model", kwargs.get("model", kwargs.get("sid", "")))
+                span._set_tag_str("openai.request.model", kwargs.get("model", kwargs.get("sid", "")))
         elif endpoint.endswith("/files"):
             span.resource = "deleteFile"
             if len(args) >= 1:
-                span.set_tag_str("openai.request.file_id", args[0])
+                span._set_tag_str("openai.request.file_id", args[0])
             else:
-                span.set_tag_str("openai.request.file_id", kwargs.get("file_id", kwargs.get("sid", "")))
-        span.set_tag_str("openai.request.endpoint", "%s/*" % endpoint)
+                span._set_tag_str("openai.request.file_id", kwargs.get("file_id", kwargs.get("sid", "")))
+        span._set_tag_str("openai.request.endpoint", "%s/*" % endpoint)
 
     def _record_response(self, pin, integration, span, args, kwargs, resp, error):
         resp = super()._record_response(pin, integration, span, args, kwargs, resp, error)
@@ -379,12 +379,12 @@ def _record_response(self, pin, integration, span, args, kwargs, resp, error):
             return
         if hasattr(resp, "data"):
             if resp._headers.get("openai-organization"):
-                span.set_tag_str("openai.organization.name", resp._headers.get("openai-organization"))
-            span.set_tag_str("openai.response.id", resp.data.get("id", ""))
-            span.set_tag_str("openai.response.deleted", str(resp.data.get("deleted", "")))
+                span._set_tag_str("openai.organization.name", resp._headers.get("openai-organization"))
+            span._set_tag_str("openai.response.id", resp.data.get("id", ""))
+            span._set_tag_str("openai.response.deleted", str(resp.data.get("deleted", "")))
         else:
-            span.set_tag_str("openai.response.id", str(resp.id))
-            span.set_tag_str("openai.response.deleted", str(resp.deleted))
+            span._set_tag_str("openai.response.id", str(resp.id))
+            span._set_tag_str("openai.response.deleted", str(resp.deleted))
         return resp
 
 
@@ -411,7 +411,7 @@ class _ImageHook(_EndpointHook):
 
     def _record_request(self, pin, integration, instance, span, args, kwargs):
         super()._record_request(pin, integration, instance, span, args, kwargs)
-        span.set_tag_str("openai.request.model", "dall-e")
+        span._set_tag_str("openai.request.model", "dall-e")
 
 
 class _ImageCreateHook(_ImageHook):
@@ -479,9 +479,9 @@ def _record_request(self, pin, integration, instance, span, args, kwargs):
         super()._record_request(pin, integration, instance, span, args, kwargs)
         fp = args[0] if len(args) >= 1 else kwargs.get("file", "")
         if fp and hasattr(fp, "name"):
-            span.set_tag_str("openai.request.filename", fp.name.split("/")[-1])
+            span._set_tag_str("openai.request.filename", fp.name.split("/")[-1])
         else:
-            span.set_tag_str("openai.request.filename", "")
+            span._set_tag_str("openai.request.filename", "")
 
     def _record_response(self, pin, integration, span, args, kwargs, resp, error):
         resp = super()._record_response(pin, integration, span, args, kwargs, resp, error)
@@ -496,7 +496,7 @@ class _FileDownloadHook(_BaseFileHook):
 
     def _record_request(self, pin, integration, instance, span, args, kwargs):
         super()._record_request(pin, integration, instance, span, args, kwargs)
-        span.set_tag_str("openai.request.file_id", args[0] if len(args) >= 1 else kwargs.get("file_id", ""))
+        span._set_tag_str("openai.request.file_id", args[0] if len(args) >= 1 else kwargs.get("file_id", ""))
 
     def _record_response(self, pin, integration, span, args, kwargs, resp, error):
         resp = super()._record_response(pin, integration, span, args, kwargs, resp, error)
diff --git a/ddtrace/contrib/internal/openai/patch.py b/ddtrace/contrib/internal/openai/patch.py
index c0c7b5990d9..49ca9bd5f19 100644
--- a/ddtrace/contrib/internal/openai/patch.py
+++ b/ddtrace/contrib/internal/openai/patch.py
@@ -345,7 +345,7 @@ def patched_convert(openai, pin, func, instance, args, kwargs):
         return func(*args, **kwargs)
     if headers.get("openai-organization"):
         org_name = headers.get("openai-organization")
-        span.set_tag_str("openai.organization.name", org_name)
+        span._set_tag_str("openai.organization.name", org_name)
 
     # Gauge total rate limit
     if headers.get("x-ratelimit-limit-requests"):
diff --git a/ddtrace/contrib/internal/openai/utils.py b/ddtrace/contrib/internal/openai/utils.py
index d6c5467cb4d..24f248894d5 100644
--- a/ddtrace/contrib/internal/openai/utils.py
+++ b/ddtrace/contrib/internal/openai/utils.py
@@ -122,7 +122,7 @@ def _loop_handler(span, chunk, streamed_chunks):
             model = getattr(response, "model", "")
         else:
             model = getattr(chunk, "model", "")
-        span.set_tag_str("openai.response.model", model)
+        span._set_tag_str("openai.response.model", model)
 
     response = getattr(chunk, "response", None)
     if response is not None:
diff --git a/ddtrace/contrib/internal/pylibmc/client.py b/ddtrace/contrib/internal/pylibmc/client.py
index 342fd88f5e2..ffaa129a7ff 100644
--- a/ddtrace/contrib/internal/pylibmc/client.py
+++ b/ddtrace/contrib/internal/pylibmc/client.py
@@ -122,7 +122,7 @@ def _trace_cmd(self, method_name, *args, **kwargs):
                 return result
 
             if args:
-                span.set_tag_str(memcached.QUERY, "%s %s" % (method_name, args[0]))
+                span._set_tag_str(memcached.QUERY, "%s %s" % (method_name, args[0]))
             if method_name == "get":
                 span.set_metric(db.ROWCOUNT, 1 if result else 0)
             elif method_name == "gets":
@@ -140,7 +140,7 @@ def _trace_multi_cmd(self, method_name, *args, **kwargs):
 
             pre = kwargs.get("key_prefix")
             if pre:
-                span.set_tag_str(memcached.QUERY, "%s %s" % (method_name, pre))
+                span._set_tag_str(memcached.QUERY, "%s %s" % (method_name, pre))
 
             if method_name == "get_multi":
                 # returns mapping of key -> value if key exists, but does not include a missing key. Empty result = {}
@@ -166,11 +166,11 @@ def _span(self, cmd_name):
             span_type=SpanTypes.CACHE,
         )
 
-        span.set_tag_str(COMPONENT, config.pylibmc.integration_name)
-        span.set_tag_str(db.SYSTEM, memcached.DBMS_NAME)
+        span._set_tag_str(COMPONENT, config.pylibmc.integration_name)
+        span._set_tag_str(db.SYSTEM, memcached.DBMS_NAME)
 
         # set span.kind to the type of operation being performed
-        span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+        span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
         # PERF: avoid setting via Span.set_tag
         span.set_metric(_SPAN_MEASURED_KEY, 1)
@@ -186,6 +186,6 @@ def _tag_span(self, span):
         # using, so fallback to randomly choosing one. can we do better?
         if self._addresses:
             _, host, port, _ = random.choice(self._addresses)  # nosec
-            span.set_tag_str(net.TARGET_HOST, host)
+            span._set_tag_str(net.TARGET_HOST, host)
             span.set_tag(net.TARGET_PORT, port)
-            span.set_tag_str(net.SERVER_ADDRESS, host)
+            span._set_tag_str(net.SERVER_ADDRESS, host)
diff --git a/ddtrace/contrib/internal/pymemcache/client.py b/ddtrace/contrib/internal/pymemcache/client.py
index 525476fda0a..ef805f8452a 100644
--- a/ddtrace/contrib/internal/pymemcache/client.py
+++ b/ddtrace/contrib/internal/pymemcache/client.py
@@ -312,11 +312,11 @@ def _trace(func, p, method_name, *args, **kwargs):
         resource=method_name,
         span_type=SpanTypes.CACHE,
     ) as span:
-        span.set_tag_str(COMPONENT, config.pymemcache.integration_name)
-        span.set_tag_str(db.SYSTEM, memcachedx.DBMS_NAME)
+        span._set_tag_str(COMPONENT, config.pymemcache.integration_name)
+        span._set_tag_str(db.SYSTEM, memcachedx.DBMS_NAME)
 
         # set span.kind to the type of operation being performed
-        span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+        span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
         # PERF: avoid setting via Span.set_tag
         span.set_metric(_SPAN_MEASURED_KEY, 1)
@@ -328,7 +328,7 @@ def _trace(func, p, method_name, *args, **kwargs):
             if config.pymemcache.command_enabled:
                 vals = _get_query_string(args)
                 query = "{}{}{}".format(method_name, " " if vals else "", vals)
-                span.set_tag_str(memcachedx.QUERY, query)
+                span._set_tag_str(memcachedx.QUERY, query)
         except Exception:
             log.debug("Error setting relevant pymemcache tags")
 
diff --git a/ddtrace/contrib/internal/pymongo/client.py b/ddtrace/contrib/internal/pymongo/client.py
index ff7bd0d33ca..47a22e211b7 100644
--- a/ddtrace/contrib/internal/pymongo/client.py
+++ b/ddtrace/contrib/internal/pymongo/client.py
@@ -137,16 +137,16 @@ def _datadog_trace_operation(operation, wrapped):
         service=trace_utils.ext_service(pin, config.pymongo),
     )
 
-    span.set_tag_str(COMPONENT, config.pymongo.integration_name)
+    span._set_tag_str(COMPONENT, config.pymongo.integration_name)
 
     # set span.kind to the operation type being performed
-    span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+    span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
     # PERF: avoid setting via Span.set_tag
     span.set_metric(_SPAN_MEASURED_KEY, 1)
-    span.set_tag_str(mongox.DB, cmd.db)
-    span.set_tag_str(mongox.COLLECTION, cmd.coll)
-    span.set_tag_str(db.SYSTEM, mongox.SERVICE)
+    span._set_tag_str(mongox.DB, cmd.db)
+    span._set_tag_str(mongox.COLLECTION, cmd.coll)
+    span._set_tag_str(db.SYSTEM, mongox.SERVICE)
     span.set_tags(cmd.tags)
 
     # set `mongodb.query` tag and resource for span
@@ -260,16 +260,16 @@ def _trace_cmd(cmd, socket_instance, address):
         service=trace_utils.ext_service(pin, config.pymongo),
     )
 
-    s.set_tag_str(COMPONENT, config.pymongo.integration_name)
-    s.set_tag_str(db.SYSTEM, mongox.SERVICE)
+    s._set_tag_str(COMPONENT, config.pymongo.integration_name)
+    s._set_tag_str(db.SYSTEM, mongox.SERVICE)
 
     # set span.kind to the type of operation being performed
-    s.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+    s._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
     # PERF: avoid setting via Span.set_tag
     s.set_metric(_SPAN_MEASURED_KEY, 1)
     if cmd.db:
-        s.set_tag_str(mongox.DB, cmd.db)
+        s._set_tag_str(mongox.DB, cmd.db)
     if cmd:
         s.set_tag(mongox.COLLECTION, cmd.coll)
         s.set_tags(cmd.tags)
@@ -314,8 +314,8 @@ def normalize_filter(f=None):
 def set_address_tags(span, address):
     # the address is only set after the cursor is done.
     if address:
-        span.set_tag_str(netx.TARGET_HOST, address[0])
-        span.set_tag_str(netx.SERVER_ADDRESS, address[0])
+        span._set_tag_str(netx.TARGET_HOST, address[0])
+        span._set_tag_str(netx.SERVER_ADDRESS, address[0])
         span.set_tag(netx.TARGET_PORT, address[1])
 
 
diff --git a/ddtrace/contrib/internal/pymongo/patch.py b/ddtrace/contrib/internal/pymongo/patch.py
index c37315b8ebd..544e1aab963 100644
--- a/ddtrace/contrib/internal/pymongo/patch.py
+++ b/ddtrace/contrib/internal/pymongo/patch.py
@@ -138,11 +138,11 @@ def traced_get_socket(func, args, kwargs):
         service=trace_utils.ext_service(pin, config.pymongo),
         span_type=SpanTypes.MONGODB,
     ) as span:
-        span.set_tag_str(COMPONENT, config.pymongo.integration_name)
-        span.set_tag_str(db.SYSTEM, mongo.SERVICE)
+        span._set_tag_str(COMPONENT, config.pymongo.integration_name)
+        span._set_tag_str(db.SYSTEM, mongo.SERVICE)
 
         # set span.kind tag equal to type of operation being performed
-        span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+        span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
         with func(*args, **kwargs) as sock_info:
             set_address_tags(span, sock_info.address)
diff --git a/ddtrace/contrib/internal/pynamodb/patch.py b/ddtrace/contrib/internal/pynamodb/patch.py
index 96a9309e061..1d2eb8176a3 100644
--- a/ddtrace/contrib/internal/pynamodb/patch.py
+++ b/ddtrace/contrib/internal/pynamodb/patch.py
@@ -69,11 +69,11 @@ def patched_api_call(original_func, instance, args, kwargs):
         service=trace_utils.ext_service(pin, config.pynamodb, "pynamodb"),
         span_type=SpanTypes.HTTP,
     ) as span:
-        span.set_tag_str(COMPONENT, config.pynamodb.integration_name)
-        span.set_tag_str(db.SYSTEM, "dynamodb")
+        span._set_tag_str(COMPONENT, config.pynamodb.integration_name)
+        span._set_tag_str(db.SYSTEM, "dynamodb")
 
         # set span.kind to the type of operation being performed
-        span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+        span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
         # PERF: avoid setting via Span.set_tag
         span.set_metric(_SPAN_MEASURED_KEY, 1)
@@ -84,8 +84,8 @@ def patched_api_call(original_func, instance, args, kwargs):
 
             if args[1] and "TableName" in args[1]:
                 table_name = args[1]["TableName"]
-                span.set_tag_str("table_name", table_name)
-                span.set_tag_str("tablename", table_name)
+                span._set_tag_str("table_name", table_name)
+                span._set_tag_str("tablename", table_name)
                 span.resource = span.resource + " " + table_name
 
         except ArgumentError:
diff --git a/ddtrace/contrib/internal/pyramid/trace.py b/ddtrace/contrib/internal/pyramid/trace.py
index 81ae0bae953..d80a7200c88 100644
--- a/ddtrace/contrib/internal/pyramid/trace.py
+++ b/ddtrace/contrib/internal/pyramid/trace.py
@@ -50,7 +50,7 @@ def trace_render(func, instance, args, kwargs):
         return func(*args, **kwargs)
 
     with tracer.trace("pyramid.render", span_type=SpanTypes.TEMPLATE) as span:
-        span.set_tag_str(COMPONENT, config.pyramid.integration_name)
+        span._set_tag_str(COMPONENT, config.pyramid.integration_name)
 
         return func(*args, **kwargs)
 
@@ -104,7 +104,7 @@ def trace_tween(request):
                     # set request tags
                     if request.matched_route:
                         req_span.resource = "{} {}".format(request.method, request.matched_route.name)
-                        req_span.set_tag_str("pyramid.route.name", request.matched_route.name)
+                        req_span._set_tag_str("pyramid.route.name", request.matched_route.name)
                     # set response tags
                     if response:
                         status = response.status_code
diff --git a/ddtrace/contrib/internal/pytest/_pytest_bdd_subplugin.py b/ddtrace/contrib/internal/pytest/_pytest_bdd_subplugin.py
index 4349f10654e..94adf2cead7 100644
--- a/ddtrace/contrib/internal/pytest/_pytest_bdd_subplugin.py
+++ b/ddtrace/contrib/internal/pytest/_pytest_bdd_subplugin.py
@@ -8,6 +8,7 @@
 The plugin is only instantiated and added if the pytest-bdd plugin itself is installed and enabled, because the hook
 implementations will cause errors unless the hookspecs are added by the original plugin.
 """
+
 from pathlib import Path
 import sys
 
@@ -72,7 +73,7 @@ def pytest_bdd_before_step(self, request, feature, scenario, step, step_func):
             child_of=feature_span,
             activate=True,
         )
-        span.set_tag_str("component", "pytest_bdd")
+        span._set_tag_str("component", "pytest_bdd")
 
         span.set_tag(test.FRAMEWORK, FRAMEWORK)
         span.set_tag(test.FRAMEWORK_VERSION, self.framework_version)
diff --git a/ddtrace/contrib/internal/pytest_bdd/_plugin.py b/ddtrace/contrib/internal/pytest_bdd/_plugin.py
index eb7bcc1028a..9f9183c22df 100644
--- a/ddtrace/contrib/internal/pytest_bdd/_plugin.py
+++ b/ddtrace/contrib/internal/pytest_bdd/_plugin.py
@@ -97,7 +97,7 @@ def pytest_bdd_before_step(self, request, feature, scenario, step, step_func):
                 child_of=feature_span,
                 activate=True,
             )
-            span.set_tag_str("component", "pytest_bdd")
+            span._set_tag_str("component", "pytest_bdd")
 
             span.set_tag(test.FRAMEWORK, FRAMEWORK)
             span.set_tag(test.FRAMEWORK_VERSION, self.framework_version)
diff --git a/ddtrace/contrib/internal/pytest_benchmark/_plugin.py b/ddtrace/contrib/internal/pytest_benchmark/_plugin.py
index ee54660afc8..2b08969ac21 100644
--- a/ddtrace/contrib/internal/pytest_benchmark/_plugin.py
+++ b/ddtrace/contrib/internal/pytest_benchmark/_plugin.py
@@ -18,11 +18,11 @@ def pytest_runtest_makereport(self, item, call):
             if span is None:
                 return
 
-            span.set_tag_str(TEST_TYPE, "benchmark")
-            span.set_tag_str(BENCHMARK_INFO, "Time")
+            span._set_tag_str(TEST_TYPE, "benchmark")
+            span._set_tag_str(BENCHMARK_INFO, "Time")
             for span_path, tag in PLUGIN_METRICS.items():
                 if hasattr(stat_object, tag):
                     if tag == PLUGIN_OUTLIERS:
-                        span.set_tag_str(span_path, getattr(stat_object, tag))
+                        span._set_tag_str(span_path, getattr(stat_object, tag))
                         continue
                     span.set_tag(span_path, getattr(stat_object, tag))
diff --git a/ddtrace/contrib/internal/ray/patch.py b/ddtrace/contrib/internal/ray/patch.py
index 8dadc9b7aba..a29d43c6dad 100644
--- a/ddtrace/contrib/internal/ray/patch.py
+++ b/ddtrace/contrib/internal/ray/patch.py
@@ -130,13 +130,13 @@ def _wrap_task_execution(wrapped, *args, **kwargs):
 
             result = wrapped(*args, **kwargs)
 
-            task_execute_span.set_tag_str(RAY_TASK_STATUS, RAY_STATUS_SUCCESS)
+            task_execute_span._set_tag_str(RAY_TASK_STATUS, RAY_STATUS_SUCCESS)
             return result
         except BaseException as e:
             log.debug(
                 "Ray task %s execution failed: %s", f"{wrapped.__module__}.{wrapped.__qualname__}", e, exc_info=True
             )
-            task_execute_span.set_tag_str(RAY_TASK_STATUS, RAY_STATUS_ERROR)
+            task_execute_span._set_tag_str(RAY_TASK_STATUS, RAY_STATUS_ERROR)
             raise
 
 
@@ -163,7 +163,7 @@ def traced_submit_task(wrapped, instance, args, kwargs):
         service=RAY_SERVICE_NAME,
         span_type=SpanTypes.RAY,
     ) as span:
-        span.set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
+        span._set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
         _inject_ray_span_tags_and_metrics(span)
 
         try:
@@ -174,11 +174,11 @@ def traced_submit_task(wrapped, instance, args, kwargs):
 
             resp = wrapped(*args, **kwargs)
 
-            span.set_tag_str(RAY_TASK_SUBMIT_STATUS, RAY_STATUS_SUCCESS)
+            span._set_tag_str(RAY_TASK_SUBMIT_STATUS, RAY_STATUS_SUCCESS)
             return resp
         except BaseException as e:
             log.debug("Failed to submit Ray task %s : %s", f"{instance._function_name}.remote()", e, exc_info=True)
-            span.set_tag_str(RAY_TASK_SUBMIT_STATUS, RAY_STATUS_ERROR)
+            span._set_tag_str(RAY_TASK_SUBMIT_STATUS, RAY_STATUS_ERROR)
             raise e
 
 
@@ -212,9 +212,9 @@ def traced_submit_job(wrapped, instance, args, kwargs):
     try:
         # Root span creation
         _inject_ray_span_tags_and_metrics(job_span)
-        job_span.set_tag_str(RAY_SUBMISSION_ID_TAG, submission_id)
+        job_span._set_tag_str(RAY_SUBMISSION_ID_TAG, submission_id)
         if entrypoint:
-            job_span.set_tag_str(RAY_ENTRYPOINT, entrypoint)
+            job_span._set_tag_str(RAY_ENTRYPOINT, entrypoint)
 
         metadata = kwargs.get("metadata", {})
         dot_paths = flatten_metadata_dict(metadata)
@@ -228,8 +228,8 @@ def traced_submit_job(wrapped, instance, args, kwargs):
             "ray.job.submit", service=job_name or DEFAULT_JOB_NAME, span_type=SpanTypes.RAY
         ) as submit_span:
             _inject_ray_span_tags_and_metrics(submit_span)
-            submit_span.set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
-            submit_span.set_tag_str(RAY_SUBMISSION_ID_TAG, submission_id)
+            submit_span._set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
+            submit_span._set_tag_str(RAY_SUBMISSION_ID_TAG, submission_id)
 
             # Inject the context of the job so that ray.job.run is its child
             runtime_env = kwargs.get("runtime_env") or {}
@@ -244,14 +244,14 @@ def traced_submit_job(wrapped, instance, args, kwargs):
 
             try:
                 resp = wrapped(*args, **kwargs)
-                submit_span.set_tag_str(RAY_JOB_SUBMIT_STATUS, RAY_STATUS_SUCCESS)
+                submit_span._set_tag_str(RAY_JOB_SUBMIT_STATUS, RAY_STATUS_SUCCESS)
                 return resp
             except BaseException as e:
                 log.debug("Failed to submit Ray Job %s : %s", job_name, e, exc_info=True)
-                submit_span.set_tag_str(RAY_JOB_SUBMIT_STATUS, RAY_STATUS_ERROR)
+                submit_span._set_tag_str(RAY_JOB_SUBMIT_STATUS, RAY_STATUS_ERROR)
                 raise
     except BaseException as e:
-        job_span.set_tag_str(RAY_JOB_STATUS, RAY_STATUS_ERROR)
+        job_span._set_tag_str(RAY_JOB_STATUS, RAY_STATUS_ERROR)
         job_span.error = 1
         job_span.set_exc_info(type(e), e, e.__traceback__)
         stop_long_running_job(submission_id)
@@ -282,7 +282,7 @@ def traced_actor_method_call(wrapped, instance, args, kwargs):
         span_type=SpanTypes.RAY,
         resource=f"{actor_name}.{method_name}.remote",
     ) as span:
-        span.set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
+        span._set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
         if config.ray.trace_args_kwargs:
             set_tag_or_truncate(span, RAY_ACTOR_METHOD_ARGS, get_argument_value(args, kwargs, 0, "args"))
             set_tag_or_truncate(span, RAY_ACTOR_METHOD_KWARGS, get_argument_value(args, kwargs, 1, "kwargs"))
@@ -309,13 +309,13 @@ def traced_get(wrapped, instance, args, kwargs):
         child_of=tracer.context_provider.active(),
         activate=True,
     ) as span:
-        span.set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
+        span._set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
         timeout = kwargs.get("timeout")
         if timeout is not None:
-            span.set_tag_str("ray.get.timeout_s", str(timeout))
+            span._set_tag_str("ray.get.timeout_s", str(timeout))
         _inject_ray_span_tags_and_metrics(span)
         get_value = get_argument_value(args, kwargs, 0, "object_refs")
-        span.set_tag_str(RAY_GET_VALUE_SIZE_BYTES, str(sys.getsizeof(get_value)))
+        span._set_tag_str(RAY_GET_VALUE_SIZE_BYTES, str(sys.getsizeof(get_value)))
         return wrapped(*args, **kwargs)
 
 
@@ -330,12 +330,12 @@ def traced_put(wrapped, instance, args, kwargs):
         tracer.context_provider.activate(_extract_tracing_context_from_env())
 
     with tracer.trace("ray.put", service=RAY_SERVICE_NAME or DEFAULT_JOB_NAME, span_type=SpanTypes.RAY) as span:
-        span.set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
+        span._set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
         _inject_ray_span_tags_and_metrics(span)
 
         put_value = get_argument_value(args, kwargs, 0, "value")
-        span.set_tag_str(RAY_PUT_VALUE_TYPE, str(type(put_value).__name__))
-        span.set_tag_str(RAY_PUT_VALUE_SIZE_BYTES, str(sys.getsizeof(put_value)))
+        span._set_tag_str(RAY_PUT_VALUE_TYPE, str(type(put_value).__name__))
+        span._set_tag_str(RAY_PUT_VALUE_SIZE_BYTES, str(sys.getsizeof(put_value)))
 
         return wrapped(*args, **kwargs)
 
@@ -358,18 +358,18 @@ def traced_wait(wrapped, instance, args, kwargs):
         child_of=tracer.context_provider.active(),
         activate=True,
     ) as span:
-        span.set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
+        span._set_tag_str(SPAN_KIND, SpanKind.PRODUCER)
         _inject_ray_span_tags_and_metrics(span)
 
         timeout = kwargs.get("timeout")
         num_returns = kwargs.get("num_returns")
         fetch_local = kwargs.get("fetch_local")
         if timeout is not None:
-            span.set_tag_str(RAY_WAIT_TIMEOUT, str(timeout))
+            span._set_tag_str(RAY_WAIT_TIMEOUT, str(timeout))
         if num_returns is not None:
-            span.set_tag_str(RAY_WAIT_NUM_RETURNS, str(num_returns))
+            span._set_tag_str(RAY_WAIT_NUM_RETURNS, str(num_returns))
         if fetch_local is not None:
-            span.set_tag_str(RAY_WAIT_FETCH_LOCAL, str(fetch_local))
+            span._set_tag_str(RAY_WAIT_FETCH_LOCAL, str(fetch_local))
         return wrapped(*args, **kwargs)
 
 
@@ -426,7 +426,7 @@ def _traced_exec_entrypoint_method(self: Any, *args: Any, _dd_ray_trace_ctx=None
             service=os.environ.get(RAY_JOB_NAME, DEFAULT_JOB_NAME),
             span_type=SpanTypes.RAY,
         ) as span:
-            span.set_tag_str(SPAN_KIND, SpanKind.CONSUMER)
+            span._set_tag_str(SPAN_KIND, SpanKind.CONSUMER)
             _inject_ray_span_tags_and_metrics(span)
 
             return method(self, *args, **kwargs)
diff --git a/ddtrace/contrib/internal/ray/span_manager.py b/ddtrace/contrib/internal/ray/span_manager.py
index 4aaf8bdadd3..c0c40a4aa2c 100644
--- a/ddtrace/contrib/internal/ray/span_manager.py
+++ b/ddtrace/contrib/internal/ray/span_manager.py
@@ -48,7 +48,7 @@ def long_running_ray_span(
     with tracer.start_span(
         name=span_name, service=service, resource=resource, span_type=span_type, child_of=child_of, activate=activate
     ) as span:
-        span.set_tag_str(SPAN_KIND, SpanKind.CONSUMER)
+        span._set_tag_str(SPAN_KIND, SpanKind.CONSUMER)
         _inject_ray_span_tags_and_metrics(span)
         start_long_running_span(span)
 
@@ -104,10 +104,10 @@ def _emit_partial_span(self, span: Span) -> None:
         partial_version = time.time_ns()
         if span.get_metric(DD_PARTIAL_VERSION) is None:
             span.set_metric(DD_PARTIAL_VERSION, partial_version)
-            span.set_tag_str(RAY_JOB_STATUS, RAY_STATUS_RUNNING)
+            span._set_tag_str(RAY_JOB_STATUS, RAY_STATUS_RUNNING)
 
         partial_span = self._recreate_job_span(span)
-        partial_span.set_tag_str(RAY_JOB_STATUS, RAY_STATUS_RUNNING)
+        partial_span._set_tag_str(RAY_JOB_STATUS, RAY_STATUS_RUNNING)
         partial_span.set_metric(DD_PARTIAL_VERSION, partial_version)
         partial_span.finish()
 
@@ -167,7 +167,7 @@ def _recreate_job_span(self, job_span: Span) -> Span:
             parent_id=job_span.parent_id,
             context=job_span.context,
         )
-        new_span.set_tag_str("component", RAY_COMPONENT)
+        new_span._set_tag_str("component", RAY_COMPONENT)
         new_span.start_ns = job_span.start_ns
         new_span._meta = job_span._meta.copy()
         new_span._metrics = job_span._metrics.copy()
@@ -193,10 +193,10 @@ def _finish_span(self, span: Span, job_info: Optional[JobInfo] = None) -> None:
             del span._metrics[DD_PARTIAL_VERSION]
 
             span.set_metric(DD_WAS_LONG_RUNNING, 1)
-            span.set_tag_str(RAY_JOB_STATUS, RAY_STATUS_FINISHED)
+            span._set_tag_str(RAY_JOB_STATUS, RAY_STATUS_FINISHED)
 
         if job_info:
-            span.set_tag_str(RAY_JOB_STATUS, job_info.status)
+            span._set_tag_str(RAY_JOB_STATUS, job_info.status)
             span.set_tag(RAY_JOB_MESSAGE, job_info.message)
 
             if str(job_info.status) == RAY_STATUS_FAILED:
diff --git a/ddtrace/contrib/internal/ray/utils.py b/ddtrace/contrib/internal/ray/utils.py
index 71cef546170..d6405e45320 100644
--- a/ddtrace/contrib/internal/ray/utils.py
+++ b/ddtrace/contrib/internal/ray/utils.py
@@ -87,8 +87,8 @@ def _extract_tracing_context_from_env() -> Optional[Context]:
 
 
 def _inject_ray_span_tags_and_metrics(span: Span) -> None:
-    span.set_tag_str("component", RAY_COMPONENT)
-    span.set_tag_str(RAY_HOSTNAME, socket.gethostname())
+    span._set_tag_str("component", RAY_COMPONENT)
+    span._set_tag_str(RAY_HOSTNAME, socket.gethostname())
     span.set_metric(_AI_OBS_ENABLED_KEY, 1)
     span.set_metric(_DJM_ENABLED_KEY, 1)
     span.set_metric(_FILTER_KEPT_KEY, 1)
@@ -97,26 +97,26 @@ def _inject_ray_span_tags_and_metrics(span: Span) -> None:
 
     submission_id = os.environ.get(RAY_SUBMISSION_ID)
     if submission_id is not None:
-        span.set_tag_str(RAY_SUBMISSION_ID_TAG, submission_id)
+        span._set_tag_str(RAY_SUBMISSION_ID_TAG, submission_id)
 
     if ray.is_initialized():
         runtime_context = get_runtime_context()
 
-        span.set_tag_str(RAY_JOB_ID, runtime_context.get_job_id())
-        span.set_tag_str(RAY_NODE_ID, runtime_context.get_node_id())
+        span._set_tag_str(RAY_JOB_ID, runtime_context.get_job_id())
+        span._set_tag_str(RAY_NODE_ID, runtime_context.get_node_id())
 
         worker_id = runtime_context.get_worker_id()
         if worker_id is not None:
-            span.set_tag_str(RAY_WORKER_ID, worker_id)
+            span._set_tag_str(RAY_WORKER_ID, worker_id)
 
         if runtime_context.worker.mode == ray._private.worker.WORKER_MODE:
             task_id = runtime_context.get_task_id()
             if task_id is not None:
-                span.set_tag_str(RAY_TASK_ID, task_id)
+                span._set_tag_str(RAY_TASK_ID, task_id)
 
         actor_id = runtime_context.get_actor_id()
         if actor_id is not None:
-            span.set_tag_str(RAY_ACTOR_ID, actor_id)
+            span._set_tag_str(RAY_ACTOR_ID, actor_id)
 
 
 def set_tag_or_truncate(span: Span, tag_name: str, tag_value: Any = None) -> None:
diff --git a/ddtrace/contrib/internal/rediscluster/patch.py b/ddtrace/contrib/internal/rediscluster/patch.py
index 6debd0da53b..35a5b84cbc7 100644
--- a/ddtrace/contrib/internal/rediscluster/patch.py
+++ b/ddtrace/contrib/internal/rediscluster/patch.py
@@ -103,12 +103,12 @@ def traced_execute_pipeline(func, instance, args, kwargs):
         service=trace_utils.ext_service(pin, config.rediscluster, "rediscluster"),
         span_type=SpanTypes.REDIS,
     ) as s:
-        s.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
-        s.set_tag_str(COMPONENT, config.rediscluster.integration_name)
-        s.set_tag_str(db.SYSTEM, redisx.APP)
+        s._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+        s._set_tag_str(COMPONENT, config.rediscluster.integration_name)
+        s._set_tag_str(db.SYSTEM, redisx.APP)
         # PERF: avoid setting via Span.set_tag
         s.set_metric(_SPAN_MEASURED_KEY, 1)
-        s.set_tag_str(redisx.RAWCMD, resource)
+        s._set_tag_str(redisx.RAWCMD, resource)
         s.set_metric(redisx.PIPELINE_LEN, len(instance.command_stack))
 
         return func(*args, **kwargs)
diff --git a/ddtrace/contrib/internal/requests/connection.py b/ddtrace/contrib/internal/requests/connection.py
index 077bf4af8ab..4c01e02dfe5 100644
--- a/ddtrace/contrib/internal/requests/connection.py
+++ b/ddtrace/contrib/internal/requests/connection.py
@@ -94,10 +94,10 @@ def _wrap_send(func, instance, args, kwargs):
 
     operation_name = schematize_url_operation("requests.request", protocol="http", direction=SpanDirection.OUTBOUND)
     with tracer.trace(operation_name, service=service, resource=f"{method} {path}", span_type=SpanTypes.HTTP) as span:
-        span.set_tag_str(COMPONENT, config.requests.integration_name)
+        span._set_tag_str(COMPONENT, config.requests.integration_name)
 
         # set span.kind to the type of operation being performed
-        span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+        span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
         # PERF: avoid setting via Span.set_tag
         span.set_metric(_SPAN_MEASURED_KEY, 1)
diff --git a/ddtrace/contrib/internal/sanic/patch.py b/ddtrace/contrib/internal/sanic/patch.py
index c461fc33520..3389b99d00f 100644
--- a/ddtrace/contrib/internal/sanic/patch.py
+++ b/ddtrace/contrib/internal/sanic/patch.py
@@ -254,7 +254,7 @@ async def sanic_http_routing_after(request, route, kwargs, handler):
         pattern = route.pattern
 
     span.resource = "{} {}".format(request.method, pattern)
-    span.set_tag_str("sanic.route.name", route.name)
+    span._set_tag_str("sanic.route.name", route.name)
 
 
 async def sanic_http_lifecycle_response(request, response):
diff --git a/ddtrace/contrib/internal/snowflake/patch.py b/ddtrace/contrib/internal/snowflake/patch.py
index 0670af5ba90..bab4c6f06bc 100644
--- a/ddtrace/contrib/internal/snowflake/patch.py
+++ b/ddtrace/contrib/internal/snowflake/patch.py
@@ -47,7 +47,7 @@ def _supported_versions() -> Dict[str, str]:
 class _SFTracedCursor(TracedCursor):
     def _set_post_execute_tags(self, span):
         super(_SFTracedCursor, self)._set_post_execute_tags(span)
-        span.set_tag_str("sfqid", self.__wrapped__.sfqid)
+        span._set_tag_str("sfqid", self.__wrapped__.sfqid)
 
 
 def patch():
diff --git a/ddtrace/contrib/internal/sqlalchemy/engine.py b/ddtrace/contrib/internal/sqlalchemy/engine.py
index 270f3b08716..f9912cec2c8 100644
--- a/ddtrace/contrib/internal/sqlalchemy/engine.py
+++ b/ddtrace/contrib/internal/sqlalchemy/engine.py
@@ -93,10 +93,10 @@ def _before_cur_exec(self, conn, cursor, statement, *args):
             span_type=SpanTypes.SQL,
             resource=statement,
         )
-        span.set_tag_str(COMPONENT, config.sqlalchemy.integration_name)
+        span._set_tag_str(COMPONENT, config.sqlalchemy.integration_name)
 
         # set span.kind to the type of operation being performed
-        span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+        span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
         # PERF: avoid setting via Span.set_tag
         span.set_metric(_SPAN_MEASURED_KEY, 1)
@@ -139,12 +139,12 @@ def _handle_db_error(self, *args):
 def _set_tags_from_url(span, url):
     """set connection tags from the url. return true if successful."""
     if url.host:
-        span.set_tag_str(netx.TARGET_HOST, url.host)
-        span.set_tag_str(netx.SERVER_ADDRESS, url.host)
+        span._set_tag_str(netx.TARGET_HOST, url.host)
+        span._set_tag_str(netx.SERVER_ADDRESS, url.host)
     if url.port:
         span.set_tag(netx.TARGET_PORT, url.port)
     if url.database:
-        span.set_tag_str(sqlx.DB, url.database)
+        span._set_tag_str(sqlx.DB, url.database)
 
     return bool(span.get_tag(netx.TARGET_HOST))
 
@@ -156,7 +156,7 @@ def _set_tags_from_cursor(span, vendor, cursor):
             dsn = getattr(cursor.connection, "dsn", None)
             if dsn:
                 d = sqlx.parse_pg_dsn(dsn)
-                span.set_tag_str(sqlx.DB, d.get("dbname"))
-                span.set_tag_str(netx.TARGET_HOST, d.get("host"))
-                span.set_tag_str(netx.SERVER_ADDRESS, d.get("host"))
+                span._set_tag_str(sqlx.DB, d.get("dbname"))
+                span._set_tag_str(netx.TARGET_HOST, d.get("host"))
+                span._set_tag_str(netx.SERVER_ADDRESS, d.get("host"))
                 span.set_metric(netx.TARGET_PORT, int(d.get("port")))
diff --git a/ddtrace/contrib/internal/starlette/patch.py b/ddtrace/contrib/internal/starlette/patch.py
index 6739c0e8a37..fbf30b541a3 100644
--- a/ddtrace/contrib/internal/starlette/patch.py
+++ b/ddtrace/contrib/internal/starlette/patch.py
@@ -176,7 +176,7 @@ def traced_handler(wrapped, instance, args, kwargs):
                 span.resource = path
             # route should only be in the root span
             if index == 0:
-                span.set_tag_str(http.ROUTE, path)
+                span._set_tag_str(http.ROUTE, path)
     # at least always update the root asgi span resource name request_spans[0].resource = "".join(resource_paths)
     elif request_spans and resource_paths:
         route = "".join(resource_paths)
@@ -184,7 +184,7 @@ def traced_handler(wrapped, instance, args, kwargs):
             request_spans[0].resource = "{} {}".format(scope["method"], route)
         else:
             request_spans[0].resource = route
-        request_spans[0].set_tag_str(http.ROUTE, route)
+        request_spans[0]._set_tag_str(http.ROUTE, route)
     else:
         log.debug(
             "unable to update the request span resource name, request_spans:%r, resource_paths:%r",
diff --git a/ddtrace/contrib/internal/subprocess/patch.py b/ddtrace/contrib/internal/subprocess/patch.py
index 29e5ba5b3b1..66e0a8dac7b 100644
--- a/ddtrace/contrib/internal/subprocess/patch.py
+++ b/ddtrace/contrib/internal/subprocess/patch.py
@@ -483,12 +483,12 @@ def _traced_ossystem(module, pin, wrapped, instance, args, kwargs):
             return wrapped(*args, **kwargs)
 
         with pin.tracer.trace(COMMANDS.SPAN_NAME, resource=shellcmd.binary, span_type=SpanTypes.SYSTEM) as span:
-            span.set_tag_str(COMMANDS.SHELL, shellcmd.as_string())
+            span._set_tag_str(COMMANDS.SHELL, shellcmd.as_string())
             if shellcmd.truncated:
-                span.set_tag_str(COMMANDS.TRUNCATED, "yes")
-            span.set_tag_str(COMMANDS.COMPONENT, "os")
+                span._set_tag_str(COMMANDS.TRUNCATED, "yes")
+            span._set_tag_str(COMMANDS.COMPONENT, "os")
             ret = wrapped(*args, **kwargs)
-            span.set_tag_str(COMMANDS.EXIT_CODE, str(ret))
+            span._set_tag_str(COMMANDS.EXIT_CODE, str(ret))
             return ret
     else:
         return wrapped(*args, **kwargs)
@@ -508,7 +508,7 @@ def _traced_fork(module, pin, wrapped, instance, args, kwargs):
 
     with pin.tracer.trace(COMMANDS.SPAN_NAME, resource="fork", span_type=SpanTypes.SYSTEM) as span:
         span.set_tag(COMMANDS.EXEC, ["os.fork"])
-        span.set_tag_str(COMMANDS.COMPONENT, "os")
+        span._set_tag_str(COMMANDS.COMPONENT, "os")
         return wrapped(*args, **kwargs)
 
 
@@ -537,12 +537,12 @@ def _traced_osspawn(module, pin, wrapped, instance, args, kwargs):
     with pin.tracer.trace(COMMANDS.SPAN_NAME, resource=shellcmd.binary, span_type=SpanTypes.SYSTEM) as span:
         span.set_tag(COMMANDS.EXEC, shellcmd.as_list())
         if shellcmd.truncated:
-            span.set_tag_str(COMMANDS.TRUNCATED, "true")
-        span.set_tag_str(COMMANDS.COMPONENT, "os")
+            span._set_tag_str(COMMANDS.TRUNCATED, "true")
+        span._set_tag_str(COMMANDS.COMPONENT, "os")
 
         ret = wrapped(*args, **kwargs)
         if mode == os.P_WAIT:
-            span.set_tag_str(COMMANDS.EXIT_CODE, str(ret))
+            span._set_tag_str(COMMANDS.EXIT_CODE, str(ret))
         return ret
 
 
@@ -602,16 +602,16 @@ def _traced_subprocess_wait(module, pin, wrapped, instance, args, kwargs):
 
         with pin.tracer.trace(COMMANDS.SPAN_NAME, resource=binary, span_type=SpanTypes.SYSTEM) as span:
             if core.find_item(COMMANDS.CTX_SUBP_IS_SHELL):
-                span.set_tag_str(COMMANDS.SHELL, core.find_item(COMMANDS.CTX_SUBP_LINE))
+                span._set_tag_str(COMMANDS.SHELL, core.find_item(COMMANDS.CTX_SUBP_LINE))
             else:
                 span.set_tag(COMMANDS.EXEC, core.find_item(COMMANDS.CTX_SUBP_LINE))
 
             truncated = core.find_item(COMMANDS.CTX_SUBP_TRUNCATED)
             if truncated:
-                span.set_tag_str(COMMANDS.TRUNCATED, "yes")
-            span.set_tag_str(COMMANDS.COMPONENT, "subprocess")
+                span._set_tag_str(COMMANDS.TRUNCATED, "yes")
+            span._set_tag_str(COMMANDS.COMPONENT, "subprocess")
             ret = wrapped(*args, **kwargs)
-            span.set_tag_str(COMMANDS.EXIT_CODE, str(ret))
+            span._set_tag_str(COMMANDS.EXIT_CODE, str(ret))
             return ret
     else:
         return wrapped(*args, **kwargs)
diff --git a/ddtrace/contrib/internal/tornado/decorators.py b/ddtrace/contrib/internal/tornado/decorators.py
index 83969629316..16e45f5b983 100644
--- a/ddtrace/contrib/internal/tornado/decorators.py
+++ b/ddtrace/contrib/internal/tornado/decorators.py
@@ -59,7 +59,7 @@ def wrap_executor(tracer, fn, args, kwargs, span_name, service=None, resource=No
     """
     span = tracer.trace(span_name, service=service, resource=resource, span_type=span_type)
 
-    span.set_tag_str(COMPONENT, config.tornado.integration_name)
+    span._set_tag_str(COMPONENT, config.tornado.integration_name)
 
     # catch standard exceptions raised in synchronous executions
     try:
diff --git a/ddtrace/contrib/internal/tornado/handlers.py b/ddtrace/contrib/internal/tornado/handlers.py
index b98118e1223..a737487ca61 100644
--- a/ddtrace/contrib/internal/tornado/handlers.py
+++ b/ddtrace/contrib/internal/tornado/handlers.py
@@ -48,7 +48,7 @@ def execute(func, handler, args, kwargs):
 
             http_route = _find_route(handler.application.default_router.rules, handler.request)
             if http_route is not None and isinstance(http_route, str):
-                req_span.set_tag_str("http.route", http_route)
+                req_span._set_tag_str("http.route", http_route)
             setattr(handler.request, REQUEST_SPAN_KEY, req_span)
 
             return func(*args, **kwargs)
diff --git a/ddtrace/contrib/internal/tornado/template.py b/ddtrace/contrib/internal/tornado/template.py
index e604b0eac60..eb5730dfa8a 100644
--- a/ddtrace/contrib/internal/tornado/template.py
+++ b/ddtrace/contrib/internal/tornado/template.py
@@ -28,7 +28,7 @@ def generate(func, renderer, args, kwargs):
     with pin.tracer.trace(
         "tornado.template", service=pin.service, resource=resource, span_type=SpanTypes.TEMPLATE
     ) as span:
-        span.set_tag_str(COMPONENT, config.tornado.integration_name)
+        span._set_tag_str(COMPONENT, config.tornado.integration_name)
 
-        span.set_tag_str("tornado.template_name", template_name)
+        span._set_tag_str("tornado.template_name", template_name)
         return func(*args, **kwargs)
diff --git a/ddtrace/contrib/internal/trace_utils.py b/ddtrace/contrib/internal/trace_utils.py
index 55213a08bc0..9f3050cc2f9 100644
--- a/ddtrace/contrib/internal/trace_utils.py
+++ b/ddtrace/contrib/internal/trace_utils.py
@@ -106,7 +106,7 @@ def _store_headers(headers, span, integration_config, request_or_response):
         if tag_name is None:
             continue
         # An empty tag defaults to a http.<request or response>.headers.<header name> tag
-        span.set_tag_str(tag_name or _normalize_tag_name(request_or_response, header_name), header_value)
+        span._set_tag_str(tag_name or _normalize_tag_name(request_or_response, header_name), header_value)
 
 
 def _get_request_header_referrer_host(headers, headers_are_case_sensitive=False):
@@ -429,17 +429,17 @@ def set_http_meta(
          { "id": <int_value> }
     """
     if method is not None:
-        span.set_tag_str(http.METHOD, method)
+        span._set_tag_str(http.METHOD, method)
 
     if url is not None:
         url = _sanitized_url(url)
         _set_url_tag(integration_config, span, url, query)
 
     if target_host is not None:
-        span.set_tag_str(net.TARGET_HOST, target_host)
+        span._set_tag_str(net.TARGET_HOST, target_host)
 
     if server_address is not None:
-        span.set_tag_str(net.SERVER_ADDRESS, server_address)
+        span._set_tag_str(net.SERVER_ADDRESS, server_address)
 
     if status_code is not None:
         try:
@@ -447,26 +447,26 @@ def set_http_meta(
         except (TypeError, ValueError):
             log.debug("failed to convert http status code %r to int", status_code)
         else:
-            span.set_tag_str(http.STATUS_CODE, str(status_code))
+            span._set_tag_str(http.STATUS_CODE, str(status_code))
             if config._http_server.is_error_code(int_status_code):
                 span.error = 1
 
     if status_msg is not None:
-        span.set_tag_str(http.STATUS_MSG, status_msg)
+        span._set_tag_str(http.STATUS_MSG, status_msg)
 
     if query is not None and integration_config.trace_query_string:
-        span.set_tag_str(http.QUERY_STRING, query)
+        span._set_tag_str(http.QUERY_STRING, query)
 
     request_ip = peer_ip
     if request_headers:
         user_agent = _get_request_header_user_agent(request_headers, headers_are_case_sensitive)
         if user_agent:
-            span.set_tag_str(http.USER_AGENT, user_agent)
+            span._set_tag_str(http.USER_AGENT, user_agent)
 
         # Extract referrer host if referer header is present
         referrer_host = _get_request_header_referrer_host(request_headers, headers_are_case_sensitive)
         if referrer_host:
-            span.set_tag_str(http.REFERRER_HOSTNAME, referrer_host)
+            span._set_tag_str(http.REFERRER_HOSTNAME, referrer_host)
 
         # We always collect the IP if appsec is enabled to report it on potential vulnerabilities.
         # https://datadoghq.atlassian.net/wiki/spaces/APS/pages/2118779066/Client+IP+addresses+resolution
@@ -481,8 +481,8 @@ def set_http_meta(
                 )
 
             if request_ip:
-                span.set_tag_str(http.CLIENT_IP, request_ip)
-                span.set_tag_str("network.client.ip", request_ip)
+                span._set_tag_str(http.CLIENT_IP, request_ip)
+                span._set_tag_str("network.client.ip", request_ip)
 
         if integration_config.is_header_tracing_configured:
             """We should store both http.<request_or_response>.headers.<header_name> and
@@ -494,7 +494,7 @@ def set_http_meta(
         _store_response_headers(dict(response_headers), span, integration_config)
 
     if retries_remain is not None:
-        span.set_tag_str(http.RETRIES_REMAIN, str(retries_remain))
+        span._set_tag_str(http.RETRIES_REMAIN, str(retries_remain))
 
     core.dispatch(
         "set_http_meta_for_asm",
@@ -516,7 +516,7 @@ def set_http_meta(
     )
 
     if route is not None:
-        span.set_tag_str(http.ROUTE, route)
+        span._set_tag_str(http.ROUTE, route)
 
 
 def activate_distributed_headers(tracer, int_config=None, request_headers=None, override=None):
@@ -576,16 +576,16 @@ def _copy_trace_level_tags(target_span: Span, parent: Span):
     """
     for key, value in parent.context._baggage.items():
         target_span.context.set_baggage_item(key, value)
-        target_span.set_tag_str(f"baggage.{key}", value)
+        target_span._set_tag_str(f"baggage.{key}", value)
 
     if parent.context.sampling_priority is not None:
         target_span.context.sampling_priority = parent.context.sampling_priority
 
     if parent.context._meta.get(_ORIGIN_KEY):
-        target_span.set_tag_str(_ORIGIN_KEY, parent.context._meta[_ORIGIN_KEY])
+        target_span._set_tag_str(_ORIGIN_KEY, parent.context._meta[_ORIGIN_KEY])
 
     if parent.context._meta.get(SAMPLING_DECISION_TRACE_TAG_KEY):
-        target_span.set_tag_str(SAMPLING_DECISION_TRACE_TAG_KEY, parent.context._meta[SAMPLING_DECISION_TRACE_TAG_KEY])
+        target_span._set_tag_str(SAMPLING_DECISION_TRACE_TAG_KEY, parent.context._meta[SAMPLING_DECISION_TRACE_TAG_KEY])
 
 
 def _flatten(
diff --git a/ddtrace/contrib/internal/trace_utils_base.py b/ddtrace/contrib/internal/trace_utils_base.py
index ca10b620925..3d784b37325 100644
--- a/ddtrace/contrib/internal/trace_utils_base.py
+++ b/ddtrace/contrib/internal/trace_utils_base.py
@@ -111,21 +111,21 @@ def set_user(
     if span:
         if user_id:
             str_user_id = str(user_id)
-            span.set_tag_str(user.ID, str_user_id)
+            span._set_tag_str(user.ID, str_user_id)
             if propagate:
                 span.context.dd_user_id = str_user_id
 
         # All other fields are optional
         if name:
-            span.set_tag_str(user.NAME, name)
+            span._set_tag_str(user.NAME, name)
         if email:
-            span.set_tag_str(user.EMAIL, email)
+            span._set_tag_str(user.EMAIL, email)
         if scope:
-            span.set_tag_str(user.SCOPE, scope)
+            span._set_tag_str(user.SCOPE, scope)
         if role:
-            span.set_tag_str(user.ROLE, role)
+            span._set_tag_str(user.ROLE, role)
         if session_id:
-            span.set_tag_str(user.SESSION_ID, session_id)
+            span._set_tag_str(user.SESSION_ID, session_id)
 
         if (may_block or mode == "auto") and asm_config._asm_enabled:
             exc = core.dispatch_with_results(  # ast-grep-ignore: core-dispatch-with-results
@@ -144,14 +144,14 @@ def set_user(
 
 def _set_url_tag(integration_config: IntegrationConfig, span: Span, url: str, query: str) -> None:
     if not integration_config.http_tag_query_string:
-        span.set_tag_str(http.URL, strip_query_string(url))
+        span._set_tag_str(http.URL, strip_query_string(url))
     elif config._global_query_string_obfuscation_disabled:
         # TODO(munir): This case exists for backwards compatibility. To remove query strings from URLs,
         # users should set ``DD_TRACE_HTTP_CLIENT_TAG_QUERY_STRING=False``. This case should be
         # removed when config.global_query_string_obfuscation_disabled is removed (v3.0).
-        span.set_tag_str(http.URL, url)
+        span._set_tag_str(http.URL, url)
     elif getattr(config._obfuscation_query_string_pattern, "pattern", None) == b"":
         # obfuscation is disabled when DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP=""
-        span.set_tag_str(http.URL, strip_query_string(url))
+        span._set_tag_str(http.URL, strip_query_string(url))
     else:
-        span.set_tag_str(http.URL, redact_url(url, config._obfuscation_query_string_pattern, query))
+        span._set_tag_str(http.URL, redact_url(url, config._obfuscation_query_string_pattern, query))
diff --git a/ddtrace/contrib/internal/unittest/patch.py b/ddtrace/contrib/internal/unittest/patch.py
index 76a9552ebcf..69cf6a2a804 100644
--- a/ddtrace/contrib/internal/unittest/patch.py
+++ b/ddtrace/contrib/internal/unittest/patch.py
@@ -151,11 +151,11 @@ def _update_skipped_elements_and_set_tags(test_module_span: ddtrace.trace.Span,
     _global_skipped_elements += 1
 
     test_module_span._metrics[test.ITR_TEST_SKIPPING_COUNT] += 1
-    test_module_span.set_tag_str(test.ITR_TEST_SKIPPING_TESTS_SKIPPED, "true")
-    test_module_span.set_tag_str(test.ITR_DD_CI_ITR_TESTS_SKIPPED, "true")
+    test_module_span._set_tag_str(test.ITR_TEST_SKIPPING_TESTS_SKIPPED, "true")
+    test_module_span._set_tag_str(test.ITR_DD_CI_ITR_TESTS_SKIPPED, "true")
 
-    test_session_span.set_tag_str(test.ITR_TEST_SKIPPING_TESTS_SKIPPED, "true")
-    test_session_span.set_tag_str(test.ITR_DD_CI_ITR_TESTS_SKIPPED, "true")
+    test_session_span._set_tag_str(test.ITR_TEST_SKIPPING_TESTS_SKIPPED, "true")
+    test_session_span._set_tag_str(test.ITR_DD_CI_ITR_TESTS_SKIPPED, "true")
 
 
 def _store_test_span(item, span: ddtrace.trace.Span):
@@ -227,7 +227,7 @@ def _update_status_item(item: ddtrace.trace.Span, status: str):
     existing_status = item.get_tag(test.STATUS)
     if existing_status and (status == test.Status.SKIP.value or existing_status == test.Status.FAIL.value):
         return None
-    item.set_tag_str(test.STATUS, status)
+    item._set_tag_str(test.STATUS, status)
     return None
 
 
@@ -284,12 +284,12 @@ def _generate_session_resource(test_command: str) -> str:
 
 
 def _set_test_skipping_tags_to_span(span: ddtrace.trace.Span):
-    span.set_tag_str(test.ITR_TEST_SKIPPING_ENABLED, "true")
-    span.set_tag_str(test.ITR_TEST_SKIPPING_TYPE, TEST)
-    span.set_tag_str(test.ITR_TEST_SKIPPING_TESTS_SKIPPED, "false")
-    span.set_tag_str(test.ITR_DD_CI_ITR_TESTS_SKIPPED, "false")
-    span.set_tag_str(test.ITR_FORCED_RUN, "false")
-    span.set_tag_str(test.ITR_UNSKIPPABLE, "false")
+    span._set_tag_str(test.ITR_TEST_SKIPPING_ENABLED, "true")
+    span._set_tag_str(test.ITR_TEST_SKIPPING_TYPE, TEST)
+    span._set_tag_str(test.ITR_TEST_SKIPPING_TESTS_SKIPPED, "false")
+    span._set_tag_str(test.ITR_DD_CI_ITR_TESTS_SKIPPED, "false")
+    span._set_tag_str(test.ITR_FORCED_RUN, "false")
+    span._set_tag_str(test.ITR_UNSKIPPABLE, "false")
 
 
 def _set_identifier(item, name: str):
@@ -470,11 +470,11 @@ def _set_test_span_status(test_item, status: str, exc_info: Optional[str] = None
     if not span:
         log.debug("Tried setting test result for test but could not find span for %s", test_item)
         return None
-    span.set_tag_str(test.STATUS, status)
+    span._set_tag_str(test.STATUS, status)
     if exc_info:
         span.set_exc_info(exc_info[0], exc_info[1], exc_info[2])
     if status == test.Status.SKIP.value:
-        span.set_tag_str(test.SKIP_REASON, skip_reason)
+        span._set_tag_str(test.SKIP_REASON, skip_reason)
 
 
 def _set_test_xpass_xfail_result(test_item, result: str):
@@ -485,13 +485,13 @@ def _set_test_xpass_xfail_result(test_item, result: str):
     if not span:
         log.debug("Tried setting test result for an xpass or xfail test but could not find span for %s", test_item)
         return None
-    span.set_tag_str(test.RESULT, result)
+    span._set_tag_str(test.RESULT, result)
     status = span.get_tag(test.STATUS)
     if result == test.Status.XFAIL.value:
         if status == test.Status.PASS.value:
-            span.set_tag_str(test.STATUS, test.Status.FAIL.value)
+            span._set_tag_str(test.STATUS, test.Status.FAIL.value)
         elif status == test.Status.FAIL.value:
-            span.set_tag_str(test.STATUS, test.Status.PASS.value)
+            span._set_tag_str(test.STATUS, test.Status.PASS.value)
 
 
 def add_success_test_wrapper(func, instance: unittest.TextTestRunner, args: tuple, kwargs: dict):
@@ -576,27 +576,27 @@ def handle_test_wrapper(func, instance, args: tuple, kwargs: dict):
 
             if _CIVisibility.test_skipping_enabled():
                 if ITR_CORRELATION_ID_TAG_NAME in _CIVisibility._instance._itr_meta:
-                    span.set_tag_str(
+                    span._set_tag_str(
                         ITR_CORRELATION_ID_TAG_NAME, _CIVisibility._instance._itr_meta[ITR_CORRELATION_ID_TAG_NAME]
                     )
 
                 if _is_marked_as_unskippable(instance):
-                    span.set_tag_str(test.ITR_UNSKIPPABLE, "true")
-                    test_module_span.set_tag_str(test.ITR_UNSKIPPABLE, "true")
-                    test_session_span.set_tag_str(test.ITR_UNSKIPPABLE, "true")
+                    span._set_tag_str(test.ITR_UNSKIPPABLE, "true")
+                    test_module_span._set_tag_str(test.ITR_UNSKIPPABLE, "true")
+                    test_session_span._set_tag_str(test.ITR_UNSKIPPABLE, "true")
                 test_module_suite_path_without_extension = "{}/{}".format(
                     os.path.splitext(test_module_path)[0], test_suite_name
                 )
                 if _should_be_skipped_by_itr(args, test_module_suite_path_without_extension, test_name, instance):
                     if _is_marked_as_unskippable(instance):
-                        span.set_tag_str(test.ITR_FORCED_RUN, "true")
-                        test_module_span.set_tag_str(test.ITR_FORCED_RUN, "true")
-                        test_session_span.set_tag_str(test.ITR_FORCED_RUN, "true")
+                        span._set_tag_str(test.ITR_FORCED_RUN, "true")
+                        test_module_span._set_tag_str(test.ITR_FORCED_RUN, "true")
+                        test_session_span._set_tag_str(test.ITR_FORCED_RUN, "true")
                     else:
                         _update_skipped_elements_and_set_tags(test_module_span, test_session_span)
                         instance._dd_itr_skip = True
-                        span.set_tag_str(test.ITR_SKIPPED, "true")
-                        span.set_tag_str(test.SKIP_REASON, SKIPPED_BY_ITR_REASON)
+                        span._set_tag_str(test.ITR_SKIPPED, "true")
+                        span._set_tag_str(test.SKIP_REASON, SKIPPED_BY_ITR_REASON)
 
             if _is_skipped_by_itr(instance):
                 result = args[0]
@@ -655,18 +655,18 @@ def _start_test_session_span(instance) -> ddtrace.trace.Span:
         span_type=SpanTypes.TEST,
         resource=resource_name,
     )
-    test_session_span.set_tag_str(_EVENT_TYPE, _SESSION_TYPE)
-    test_session_span.set_tag_str(_SESSION_ID, str(test_session_span.span_id))
+    test_session_span._set_tag_str(_EVENT_TYPE, _SESSION_TYPE)
+    test_session_span._set_tag_str(_SESSION_ID, str(test_session_span.span_id))
 
-    test_session_span.set_tag_str(COMPONENT, COMPONENT_VALUE)
-    test_session_span.set_tag_str(SPAN_KIND, KIND)
+    test_session_span._set_tag_str(COMPONENT, COMPONENT_VALUE)
+    test_session_span._set_tag_str(SPAN_KIND, KIND)
 
-    test_session_span.set_tag_str(test.COMMAND, test_command)
-    test_session_span.set_tag_str(test.FRAMEWORK, FRAMEWORK)
-    test_session_span.set_tag_str(test.FRAMEWORK_VERSION, _get_runtime_and_os_metadata()[RUNTIME_VERSION])
+    test_session_span._set_tag_str(test.COMMAND, test_command)
+    test_session_span._set_tag_str(test.FRAMEWORK, FRAMEWORK)
+    test_session_span._set_tag_str(test.FRAMEWORK_VERSION, _get_runtime_and_os_metadata()[RUNTIME_VERSION])
 
-    test_session_span.set_tag_str(test.TEST_TYPE, SpanTypes.TEST)
-    test_session_span.set_tag_str(
+    test_session_span._set_tag_str(test.TEST_TYPE, SpanTypes.TEST)
+    test_session_span._set_tag_str(
         test.ITR_TEST_CODE_COVERAGE_ENABLED,
         "true" if _CIVisibility._instance._collect_coverage_enabled else "false",
     )
@@ -676,7 +676,7 @@ def _start_test_session_span(instance) -> ddtrace.trace.Span:
     if _CIVisibility.test_skipping_enabled():
         _set_test_skipping_tags_to_span(test_session_span)
     else:
-        test_session_span.set_tag_str(test.ITR_TEST_SKIPPING_ENABLED, "false")
+        test_session_span._set_tag_str(test.ITR_TEST_SKIPPING_ENABLED, "false")
     _store_module_identifier(instance)
     if _is_coverage_invoked_by_coverage_run():
         patch_coverage()
@@ -699,21 +699,21 @@ def _start_test_module_span(instance) -> ddtrace.trace.Span:
         child_of=test_session_span,
         resource=resource_name,
     )
-    test_module_span.set_tag_str(_EVENT_TYPE, _MODULE_TYPE)
-    test_module_span.set_tag_str(_SESSION_ID, str(test_session_span.span_id))
-    test_module_span.set_tag_str(_MODULE_ID, str(test_module_span.span_id))
+    test_module_span._set_tag_str(_EVENT_TYPE, _MODULE_TYPE)
+    test_module_span._set_tag_str(_SESSION_ID, str(test_session_span.span_id))
+    test_module_span._set_tag_str(_MODULE_ID, str(test_module_span.span_id))
 
-    test_module_span.set_tag_str(COMPONENT, COMPONENT_VALUE)
-    test_module_span.set_tag_str(SPAN_KIND, KIND)
+    test_module_span._set_tag_str(COMPONENT, COMPONENT_VALUE)
+    test_module_span._set_tag_str(SPAN_KIND, KIND)
 
-    test_module_span.set_tag_str(test.COMMAND, test_session_span.get_tag(test.COMMAND))
-    test_module_span.set_tag_str(test.FRAMEWORK, FRAMEWORK)
-    test_module_span.set_tag_str(test.FRAMEWORK_VERSION, _get_runtime_and_os_metadata()[RUNTIME_VERSION])
+    test_module_span._set_tag_str(test.COMMAND, test_session_span.get_tag(test.COMMAND))
+    test_module_span._set_tag_str(test.FRAMEWORK, FRAMEWORK)
+    test_module_span._set_tag_str(test.FRAMEWORK_VERSION, _get_runtime_and_os_metadata()[RUNTIME_VERSION])
 
-    test_module_span.set_tag_str(test.TEST_TYPE, SpanTypes.TEST)
-    test_module_span.set_tag_str(test.MODULE, test_module_name)
-    test_module_span.set_tag_str(test.MODULE_PATH, _extract_module_file_path(instance))
-    test_module_span.set_tag_str(
+    test_module_span._set_tag_str(test.TEST_TYPE, SpanTypes.TEST)
+    test_module_span._set_tag_str(test.MODULE, test_module_name)
+    test_module_span._set_tag_str(test.MODULE_PATH, _extract_module_file_path(instance))
+    test_module_span._set_tag_str(
         test.ITR_TEST_CODE_COVERAGE_ENABLED,
         "true" if _CIVisibility._instance._collect_coverage_enabled else "false",
     )
@@ -721,7 +721,7 @@ def _start_test_module_span(instance) -> ddtrace.trace.Span:
         _set_test_skipping_tags_to_span(test_module_span)
         test_module_span.set_metric(test.ITR_TEST_SKIPPING_COUNT, 0)
     else:
-        test_module_span.set_tag_str(test.ITR_TEST_SKIPPING_ENABLED, "false")
+        test_module_span._set_tag_str(test.ITR_TEST_SKIPPING_ENABLED, "false")
     _store_suite_identifier(instance)
     return test_module_span
 
@@ -743,22 +743,22 @@ def _start_test_suite_span(instance) -> ddtrace.trace.Span:
         activate=True,
         resource=resource_name,
     )
-    test_suite_span.set_tag_str(_EVENT_TYPE, _SUITE_TYPE)
-    test_suite_span.set_tag_str(_SESSION_ID, test_module_span.get_tag(_SESSION_ID))
-    test_suite_span.set_tag_str(_SUITE_ID, str(test_suite_span.span_id))
-    test_suite_span.set_tag_str(_MODULE_ID, str(test_module_span.span_id))
-
-    test_suite_span.set_tag_str(COMPONENT, COMPONENT_VALUE)
-    test_suite_span.set_tag_str(SPAN_KIND, KIND)
-
-    test_suite_span.set_tag_str(test.COMMAND, test_module_span.get_tag(test.COMMAND))
-    test_suite_span.set_tag_str(test.FRAMEWORK, FRAMEWORK)
-    test_suite_span.set_tag_str(test.FRAMEWORK_VERSION, _get_runtime_and_os_metadata()[RUNTIME_VERSION])
-
-    test_suite_span.set_tag_str(test.TEST_TYPE, SpanTypes.TEST)
-    test_suite_span.set_tag_str(test.SUITE, test_suite_name)
-    test_suite_span.set_tag_str(test.MODULE, test_module_span.get_tag(test.MODULE))
-    test_suite_span.set_tag_str(test.MODULE_PATH, test_module_path)
+    test_suite_span._set_tag_str(_EVENT_TYPE, _SUITE_TYPE)
+    test_suite_span._set_tag_str(_SESSION_ID, test_module_span.get_tag(_SESSION_ID))
+    test_suite_span._set_tag_str(_SUITE_ID, str(test_suite_span.span_id))
+    test_suite_span._set_tag_str(_MODULE_ID, str(test_module_span.span_id))
+
+    test_suite_span._set_tag_str(COMPONENT, COMPONENT_VALUE)
+    test_suite_span._set_tag_str(SPAN_KIND, KIND)
+
+    test_suite_span._set_tag_str(test.COMMAND, test_module_span.get_tag(test.COMMAND))
+    test_suite_span._set_tag_str(test.FRAMEWORK, FRAMEWORK)
+    test_suite_span._set_tag_str(test.FRAMEWORK_VERSION, _get_runtime_and_os_metadata()[RUNTIME_VERSION])
+
+    test_suite_span._set_tag_str(test.TEST_TYPE, SpanTypes.TEST)
+    test_suite_span._set_tag_str(test.SUITE, test_suite_name)
+    test_suite_span._set_tag_str(test.MODULE, test_module_span.get_tag(test.MODULE))
+    test_suite_span._set_tag_str(test.MODULE_PATH, test_module_path)
     return test_suite_span
 
 
@@ -779,25 +779,25 @@ def _start_test_span(instance, test_suite_span: ddtrace.trace.Span) -> ddtrace.t
         child_of=test_suite_span,
         activate=True,
     )
-    span.set_tag_str(_EVENT_TYPE, SpanTypes.TEST)
-    span.set_tag_str(_SESSION_ID, test_suite_span.get_tag(_SESSION_ID))
-    span.set_tag_str(_MODULE_ID, test_suite_span.get_tag(_MODULE_ID))
-    span.set_tag_str(_SUITE_ID, test_suite_span.get_tag(_SUITE_ID))
-
-    span.set_tag_str(COMPONENT, COMPONENT_VALUE)
-    span.set_tag_str(SPAN_KIND, KIND)
-
-    span.set_tag_str(test.COMMAND, test_suite_span.get_tag(test.COMMAND))
-    span.set_tag_str(test.FRAMEWORK, FRAMEWORK)
-    span.set_tag_str(test.FRAMEWORK_VERSION, _get_runtime_and_os_metadata()[RUNTIME_VERSION])
-
-    span.set_tag_str(test.TYPE, SpanTypes.TEST)
-    span.set_tag_str(test.NAME, test_name)
-    span.set_tag_str(test.SUITE, test_suite_name)
-    span.set_tag_str(test.MODULE, test_suite_span.get_tag(test.MODULE))
-    span.set_tag_str(test.MODULE_PATH, test_suite_span.get_tag(test.MODULE_PATH))
-    span.set_tag_str(test.STATUS, test.Status.FAIL.value)
-    span.set_tag_str(test.CLASS_HIERARCHY, test_suite_name)
+    span._set_tag_str(_EVENT_TYPE, SpanTypes.TEST)
+    span._set_tag_str(_SESSION_ID, test_suite_span.get_tag(_SESSION_ID))
+    span._set_tag_str(_MODULE_ID, test_suite_span.get_tag(_MODULE_ID))
+    span._set_tag_str(_SUITE_ID, test_suite_span.get_tag(_SUITE_ID))
+
+    span._set_tag_str(COMPONENT, COMPONENT_VALUE)
+    span._set_tag_str(SPAN_KIND, KIND)
+
+    span._set_tag_str(test.COMMAND, test_suite_span.get_tag(test.COMMAND))
+    span._set_tag_str(test.FRAMEWORK, FRAMEWORK)
+    span._set_tag_str(test.FRAMEWORK_VERSION, _get_runtime_and_os_metadata()[RUNTIME_VERSION])
+
+    span._set_tag_str(test.TYPE, SpanTypes.TEST)
+    span._set_tag_str(test.NAME, test_name)
+    span._set_tag_str(test.SUITE, test_suite_name)
+    span._set_tag_str(test.MODULE, test_suite_span.get_tag(test.MODULE))
+    span._set_tag_str(test.MODULE_PATH, test_suite_span.get_tag(test.MODULE_PATH))
+    span._set_tag_str(test.STATUS, test.Status.FAIL.value)
+    span._set_tag_str(test.CLASS_HIERARCHY, test_suite_name)
 
     _CIVisibility.set_codeowners_of(_extract_test_file_name(instance), span=span)
 
@@ -816,7 +816,7 @@ def _finish_span(current_span: ddtrace.trace.Span):
     if current_status and parent_span:
         _update_status_item(parent_span, current_status)
     elif not current_status:
-        current_span.set_tag_str(test.SUITE, test.Status.FAIL.value)
+        current_span._set_tag_str(test.SUITE, test.Status.FAIL.value)
     current_span.finish()
 
 
diff --git a/ddtrace/contrib/internal/urllib3/patch.py b/ddtrace/contrib/internal/urllib3/patch.py
index d4d2f9060e0..fa2de26e876 100644
--- a/ddtrace/contrib/internal/urllib3/patch.py
+++ b/ddtrace/contrib/internal/urllib3/patch.py
@@ -124,10 +124,10 @@ def _wrap_urlopen(func, instance, args, kwargs):
         service=trace_utils.ext_service(pin, config.urllib3),
         span_type=SpanTypes.HTTP,
     ) as span:
-        span.set_tag_str(COMPONENT, config.urllib3.integration_name)
+        span._set_tag_str(COMPONENT, config.urllib3.integration_name)
 
         # set span.kind to the type of operation being performed
-        span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+        span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
         if config.urllib3.split_by_domain:
             span.service = hostname
@@ -158,6 +158,6 @@ def _wrap_urlopen(func, instance, args, kwargs):
                 response_headers={} if response is None else dict(response.headers),
                 retries_remain=retries,
             )
-            span.set_tag_str(net.SERVER_ADDRESS, instance.host)
+            span._set_tag_str(net.SERVER_ADDRESS, instance.host)
 
         return response
diff --git a/ddtrace/contrib/internal/vertica/patch.py b/ddtrace/contrib/internal/vertica/patch.py
index c6d4e0bb662..297dc17436f 100644
--- a/ddtrace/contrib/internal/vertica/patch.py
+++ b/ddtrace/contrib/internal/vertica/patch.py
@@ -235,11 +235,11 @@ def wrapper(wrapped, instance, args, kwargs):
                 service=trace_utils.ext_service(pin, config),
                 span_type=conf.get("span_type"),
             ) as span:
-                span.set_tag_str(COMPONENT, config.integration_name)
-                span.set_tag_str(dbx.SYSTEM, "vertica")
+                span._set_tag_str(COMPONENT, config.integration_name)
+                span._set_tag_str(dbx.SYSTEM, "vertica")
 
                 # set span.kind to the type of operation being performed
-                span.set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+                span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
 
                 if conf.get("measured", False):
                     # PERF: avoid setting via Span.set_tag
diff --git a/ddtrace/debugging/_exception/replay.py b/ddtrace/debugging/_exception/replay.py
index da8206c14df..d8f89f6a425 100644
--- a/ddtrace/debugging/_exception/replay.py
+++ b/ddtrace/debugging/_exception/replay.py
@@ -223,7 +223,7 @@ def can_capture(span: Span) -> bool:
             # If we are in a debug session we always capture
             return True
         result = GLOBAL_RATE_LIMITER.limit() is not RateLimitExceeded
-        root.set_tag_str(CAPTURE_TRACE_TAG, str(result).lower())
+        root._set_tag_str(CAPTURE_TRACE_TAG, str(result).lower())
         return result
 
     msg = f"unexpected value for {CAPTURE_TRACE_TAG}: {info_captured}"
@@ -289,10 +289,10 @@ def _attach_tb_frame_snapshot_to_span(
                 frame.f_locals[SNAPSHOT_KEY] = snapshot_id = snapshot.uuid
 
             # Add correlation tags on the span
-            span.set_tag_str(FRAME_SNAPSHOT_ID_TAG % seq_nr, snapshot_id)
-            span.set_tag_str(FRAME_FUNCTION_TAG % seq_nr, code.co_name)
-            span.set_tag_str(FRAME_FILE_TAG % seq_nr, code.co_filename)
-            span.set_tag_str(FRAME_LINE_TAG % seq_nr, str(tb.tb_lineno))
+            span._set_tag_str(FRAME_SNAPSHOT_ID_TAG % seq_nr, snapshot_id)
+            span._set_tag_str(FRAME_FUNCTION_TAG % seq_nr, code.co_name)
+            span._set_tag_str(FRAME_FILE_TAG % seq_nr, code.co_filename)
+            span._set_tag_str(FRAME_LINE_TAG % seq_nr, str(tb.tb_lineno))
 
             return snapshot is not None
         except Exception:  # noqa: F841
@@ -347,9 +347,9 @@ def on_span_exception(
             frames_captured += self._attach_tb_frame_snapshot_to_span(span, tb, exc_id, only_user_code=False)
 
         if frames_captured:
-            span.set_tag_str(DEBUG_INFO_TAG, "true")
-            span.set_tag_str(EXCEPTION_HASH_TAG, str(exc_ident))
-            span.set_tag_str(EXCEPTION_ID_TAG, str(exc_id))
+            span._set_tag_str(DEBUG_INFO_TAG, "true")
+            span._set_tag_str(EXCEPTION_HASH_TAG, str(exc_ident))
+            span._set_tag_str(EXCEPTION_ID_TAG, str(exc_id))
 
             # Update the snapshot count
             root = span._local_root
diff --git a/ddtrace/debugging/_origin/span.py b/ddtrace/debugging/_origin/span.py
index 7d30ba47f0b..1d5904ebd46 100644
--- a/ddtrace/debugging/_origin/span.py
+++ b/ddtrace/debugging/_origin/span.py
@@ -147,12 +147,12 @@ def __enter__(self):
 
         # Add tags to the local root
         for s in (root, span):
-            s.set_tag_str("_dd.code_origin.type", "entry")
+            s._set_tag_str("_dd.code_origin.type", "entry")
 
-            s.set_tag_str("_dd.code_origin.frames.0.file", location.file)
-            s.set_tag_str("_dd.code_origin.frames.0.line", str(location.line))
-            s.set_tag_str("_dd.code_origin.frames.0.type", location.module)
-            s.set_tag_str("_dd.code_origin.frames.0.method", location.name)
+            s._set_tag_str("_dd.code_origin.frames.0.file", location.file)
+            s._set_tag_str("_dd.code_origin.frames.0.line", str(location.line))
+            s._set_tag_str("_dd.code_origin.frames.0.type", location.module)
+            s._set_tag_str("_dd.code_origin.frames.0.method", location.name)
 
         self.set("start_time", monotonic_ns())
 
@@ -179,8 +179,8 @@ def _close_signal(self, retval=None, exc_info=(None, None, None)):
             snapshot.do_enter()
 
             # Correlate the snapshot with the span
-            root.set_tag_str("_dd.code_origin.frames.0.snapshot_id", snapshot.uuid)
-            span.set_tag_str("_dd.code_origin.frames.0.snapshot_id", snapshot.uuid)
+            root._set_tag_str("_dd.code_origin.frames.0.snapshot_id", snapshot.uuid)
+            span._set_tag_str("_dd.code_origin.frames.0.snapshot_id", snapshot.uuid)
 
             snapshot.do_exit(retval, exc_info, monotonic_ns() - self.get("start_time"))
 
@@ -240,7 +240,7 @@ def on_span_start(self, span: Span) -> None:
         if span.span_type not in EXIT_SPAN_TYPES:
             return
 
-        span.set_tag_str("_dd.code_origin.type", "exit")
+        span._set_tag_str("_dd.code_origin.type", "exit")
 
         # Add call stack information to the exit span. Report only the part of
         # the stack that belongs to user code.
@@ -254,8 +254,8 @@ def on_span_start(self, span: Span) -> None:
                 if n >= co_config.max_user_frames:
                     break
 
-                span.set_tag_str(f"_dd.code_origin.frames.{n}.file", filename)
-                span.set_tag_str(f"_dd.code_origin.frames.{n}.line", str(code.co_firstlineno))
+                span._set_tag_str(f"_dd.code_origin.frames.{n}.file", filename)
+                span._set_tag_str(f"_dd.code_origin.frames.{n}.line", str(code.co_firstlineno))
 
                 # Get the module and function name from the frame and code object. In Python3.11+ qualname
                 # is available, otherwise we'll fallback to the unqualified name.
@@ -265,8 +265,8 @@ def on_span_start(self, span: Span) -> None:
                     name = code.co_name
 
                 mod = frame.f_globals.get("__name__")
-                span.set_tag_str(f"_dd.code_origin.frames.{n}.type", mod) if mod else None
-                span.set_tag_str(f"_dd.code_origin.frames.{n}.method", name) if name else None
+                span._set_tag_str(f"_dd.code_origin.frames.{n}.type", mod) if mod else None
+                span._set_tag_str(f"_dd.code_origin.frames.{n}.method", name) if name else None
 
                 # Check if we have any level 2 debugging sessions running for
                 # the current trace
@@ -286,7 +286,7 @@ def on_span_start(self, span: Span) -> None:
                     self.__uploader__.get_collector().push(snapshot)
 
                     # Correlate the snapshot with the span
-                    span.set_tag_str(f"_dd.code_origin.frames.{n}.snapshot_id", snapshot.uuid)
+                    span._set_tag_str(f"_dd.code_origin.frames.{n}.snapshot_id", snapshot.uuid)
 
     def on_span_finish(self, span: Span) -> None:
         pass
diff --git a/ddtrace/debugging/_signal/tracing.py b/ddtrace/debugging/_signal/tracing.py
index 37d90c918c1..e1c85b27746 100644
--- a/ddtrace/debugging/_signal/tracing.py
+++ b/ddtrace/debugging/_signal/tracing.py
@@ -51,8 +51,8 @@ def enter(self, scope: t.Mapping[str, t.Any]) -> None:
         span = self._span_cm.__enter__()
 
         span.set_tags(probe.tags)  # type: ignore[arg-type]
-        span.set_tag_str(PROBE_ID_TAG_NAME, probe.probe_id)
-        span.set_tag_str(_ORIGIN_KEY, "di")
+        span._set_tag_str(PROBE_ID_TAG_NAME, probe.probe_id)
+        span._set_tag_str(_ORIGIN_KEY, "di")
 
     def exit(self, retval: t.Any, exc_info: ExcInfoType, duration: float, scope: t.Mapping[str, t.Any]) -> None:
         if self._span_cm is not None:
@@ -93,12 +93,12 @@ def _decorate_span(self, scope: t.Mapping[str, t.Any]) -> None:
                     try:
                         tag_value = tag.value.render(scope, serialize)
                     except DDExpressionEvaluationError as e:
-                        span.set_tag_str(
+                        span._set_tag_str(
                             "_dd.di.%s.evaluation_error" % tag.name, ", ".join([serialize(v) for v in e.args])
                         )
                     else:
-                        span.set_tag_str(tag.name, tag_value if _isinstance(tag_value, str) else serialize(tag_value))
-                        span.set_tag_str("_dd.di.%s.probe_id" % tag.name, t.cast(Probe, probe).probe_id)
+                        span._set_tag_str(tag.name, tag_value if _isinstance(tag_value, str) else serialize(tag_value))
+                        span._set_tag_str("_dd.di.%s.probe_id" % tag.name, t.cast(Probe, probe).probe_id)
 
     def enter(self, scope: t.Mapping[str, t.Any]) -> None:
         self._decorate_span(scope)
diff --git a/ddtrace/errortracking/_handled_exceptions/collector.py b/ddtrace/errortracking/_handled_exceptions/collector.py
index eaab13ac028..20e0545c76e 100644
--- a/ddtrace/errortracking/_handled_exceptions/collector.py
+++ b/ddtrace/errortracking/_handled_exceptions/collector.py
@@ -23,7 +23,7 @@ def _add_span_events(span: Span) -> None:
     """
     span_exc_events = list(HandledExceptionCollector.get_exception_events(span.span_id).values())
     if span_exc_events:
-        span.set_tag_str(SPAN_EVENTS_HAS_EXCEPTION, "true")
+        span._set_tag_str(SPAN_EVENTS_HAS_EXCEPTION, "true")
         span._events.extend(span_exc_events)
     HandledExceptionCollector.clear_exception_events(span.span_id)
 
diff --git a/ddtrace/ext/aws.py b/ddtrace/ext/aws.py
index 2b63b78bc00..3164aabd9a6 100644
--- a/ddtrace/ext/aws.py
+++ b/ddtrace/ext/aws.py
@@ -25,38 +25,38 @@ def _add_api_param_span_tags(span, endpoint_name, params):
     if endpoint_name == "cloudwatch":
         log_group_name = params.get("logGroupName")
         if log_group_name:
-            span.set_tag_str("aws.cloudwatch.logs.log_group_name", log_group_name)
-            span.set_tag_str("loggroupname", log_group_name)
+            span._set_tag_str("aws.cloudwatch.logs.log_group_name", log_group_name)
+            span._set_tag_str("loggroupname", log_group_name)
     elif endpoint_name == "dynamodb":
         table_name = params.get("TableName")
         if table_name:
-            span.set_tag_str("aws.dynamodb.table_name", table_name)
-            span.set_tag_str("tablename", table_name)
+            span._set_tag_str("aws.dynamodb.table_name", table_name)
+            span._set_tag_str("tablename", table_name)
     elif endpoint_name == "kinesis":
         stream_name = params.get("StreamName")
         if stream_name:
-            span.set_tag_str("aws.kinesis.stream_name", stream_name)
-            span.set_tag_str("streamname", stream_name)
+            span._set_tag_str("aws.kinesis.stream_name", stream_name)
+            span._set_tag_str("streamname", stream_name)
     elif endpoint_name == "redshift":
         cluster_identifier = params.get("ClusterIdentifier")
         if cluster_identifier:
-            span.set_tag_str("aws.redshift.cluster_identifier", cluster_identifier)
-            span.set_tag_str("clusteridentifier", cluster_identifier)
+            span._set_tag_str("aws.redshift.cluster_identifier", cluster_identifier)
+            span._set_tag_str("clusteridentifier", cluster_identifier)
     elif endpoint_name == "s3":
         bucket_name = params.get("Bucket")
         if bucket_name:
-            span.set_tag_str("aws.s3.bucket_name", bucket_name)
-            span.set_tag_str("bucketname", bucket_name)
+            span._set_tag_str("aws.s3.bucket_name", bucket_name)
+            span._set_tag_str("bucketname", bucket_name)
 
     elif endpoint_name == "sns":
         topic_arn = params.get("TopicArn")
         if topic_arn:
             # example topicArn: arn:aws:sns:sa-east-1:1234:topicname
-            span.set_tag_str("aws.sns.topic_arn", topic_arn)
+            span._set_tag_str("aws.sns.topic_arn", topic_arn)
             topicname = topic_arn.split(":")[-1]
             aws_account = topic_arn.split(":")[-2]
-            span.set_tag_str("aws_account", aws_account)
-            span.set_tag_str("topicname", topicname)
+            span._set_tag_str("aws_account", aws_account)
+            span._set_tag_str("topicname", topicname)
 
     elif endpoint_name == "sqs":
         queue_name = params.get("QueueName", "")
@@ -65,21 +65,21 @@ def _add_api_param_span_tags(span, endpoint_name, params):
             # example queue_url: https://sqs.sa-east-1.amazonaws.com/12345678/queuename
             queue_name = queue_url.split("/")[-1]
             aws_account = queue_url.split("/")[-2]
-            span.set_tag_str("aws_account", aws_account)
-        span.set_tag_str("aws.sqs.queue_name", queue_name)
-        span.set_tag_str("queuename", queue_name)
+            span._set_tag_str("aws_account", aws_account)
+        span._set_tag_str("aws.sqs.queue_name", queue_name)
+        span._set_tag_str("queuename", queue_name)
 
     elif endpoint_name == "lambda":
         function_name = params.get("FunctionName", "")
-        span.set_tag_str("functionname", function_name)
+        span._set_tag_str("functionname", function_name)
 
     elif endpoint_name == "events":
         rule_name = params.get("Name", "")
-        span.set_tag_str("rulename", rule_name)
+        span._set_tag_str("rulename", rule_name)
 
     elif endpoint_name == "states":
         state_machine_arn = params.get("stateMachineArn", "")
-        span.set_tag_str("statemachinearn", state_machine_arn)
+        span._set_tag_str("statemachinearn", state_machine_arn)
 
 
 def get_aws_partition(region_name):
diff --git a/ddtrace/internal/ci_visibility/api/_base.py b/ddtrace/internal/ci_visibility/api/_base.py
index 973166225d8..ce801ce0c71 100644
--- a/ddtrace/internal/ci_visibility/api/_base.py
+++ b/ddtrace/internal/ci_visibility/api/_base.py
@@ -170,9 +170,9 @@ def _add_all_tags_to_span(self) -> None:
         for tag, tag_value in self._tags.items():
             try:
                 if isinstance(tag_value, str):
-                    self._span.set_tag_str(tag, tag_value)
+                    self._span._set_tag_str(tag, tag_value)
                 elif isinstance(tag_value, bool):
-                    self._span.set_tag_str(tag, "true" if tag_value else "false")
+                    self._span._set_tag_str(tag, "true" if tag_value else "false")
                 else:
                     self._span.set_tag(tag, tag_value)
             except Exception as e:
diff --git a/ddtrace/internal/ci_visibility/coverage.py b/ddtrace/internal/ci_visibility/coverage.py
index 8b0dcbcbfe8..de09dc44dcb 100644
--- a/ddtrace/internal/ci_visibility/coverage.py
+++ b/ddtrace/internal/ci_visibility/coverage.py
@@ -142,7 +142,7 @@ def _report_coverage_to_span(
             files = ModuleCodeCollector.report_seen_lines(workspace_path, include_imported=True)
             if not files:
                 return
-            span.set_tag_str(
+            span._set_tag_str(
                 COVERAGE_TAG_NAME,
                 json.dumps({"files": files}),
             )
@@ -156,7 +156,7 @@ def _report_coverage_to_span(
         record_code_coverage_error()
         return
     record_code_coverage_finished(COVERAGE_LIBRARY.COVERAGEPY, framework)
-    span.set_tag_str(
+    span._set_tag_str(
         COVERAGE_TAG_NAME,
         build_payload(coverage_data, root_dir, span_id),
     )
diff --git a/ddtrace/internal/ci_visibility/filters.py b/ddtrace/internal/ci_visibility/filters.py
index ca3505c9fda..83297787a18 100644
--- a/ddtrace/internal/ci_visibility/filters.py
+++ b/ddtrace/internal/ci_visibility/filters.py
@@ -35,6 +35,6 @@ def process_trace(self, trace):
         _set_sampling_tags(local_root, True, 1.0, SamplingMechanism.DEFAULT)
         for span in trace:
             span.set_tags(self._tags)
-            span.set_tag_str(ci.LIBRARY_VERSION, ddtrace.__version__)
+            span._set_tag_str(ci.LIBRARY_VERSION, ddtrace.__version__)
 
         return trace
diff --git a/ddtrace/internal/ci_visibility/utils.py b/ddtrace/internal/ci_visibility/utils.py
index d67fce8fd30..22b748693a8 100644
--- a/ddtrace/internal/ci_visibility/utils.py
+++ b/ddtrace/internal/ci_visibility/utils.py
@@ -68,7 +68,7 @@ def _add_start_end_source_file_path_data_to_span(
     start_line, end_line = get_source_lines_for_test_method(test_method_object)
     if not start_line or not end_line:
         log.debug("Tried to collect source start/end lines for test method %s but an exception was raised", test_name)
-    span.set_tag_str(test.SOURCE_FILE, source_file_path)
+    span._set_tag_str(test.SOURCE_FILE, source_file_path)
     if start_line:
         span.set_tag(test.SOURCE_START, start_line)
     if end_line:
diff --git a/ddtrace/internal/datastreams/processor.py b/ddtrace/internal/datastreams/processor.py
index 511d3543e0f..3863d962b16 100644
--- a/ddtrace/internal/datastreams/processor.py
+++ b/ddtrace/internal/datastreams/processor.py
@@ -495,7 +495,7 @@ def set_checkpoint(
         parent_hash = self.hash
         hash_value = self._compute_hash(tags, parent_hash)
         if span:
-            span.set_tag_str("pathway.hash", str(hash_value))
+            span._set_tag_str("pathway.hash", str(hash_value))
         edge_latency_sec = max(now_sec - self.current_edge_start_sec, 0.0)
         pathway_latency_sec = max(now_sec - self.pathway_start_sec, 0.0)
         self.hash = hash_value
diff --git a/ddtrace/internal/peer_service/processor.py b/ddtrace/internal/peer_service/processor.py
index eae78f9b541..e82ce961d76 100644
--- a/ddtrace/internal/peer_service/processor.py
+++ b/ddtrace/internal/peer_service/processor.py
@@ -28,15 +28,15 @@ def _update_peer_service_tags(self, span):
         tag = span.get_tag(self._config.tag_name)
 
         if tag:  # If the tag already exists, assume it is user generated
-            span.set_tag_str(self._config.source_tag_name, self._config.tag_name)
+            span._set_tag_str(self._config.source_tag_name, self._config.tag_name)
         else:
             for data_source in self._config.prioritized_data_sources:
                 tag = span.get_tag(data_source)
                 if tag:
-                    span.set_tag_str(self._config.tag_name, tag)
-                    span.set_tag_str(self._config.source_tag_name, data_source)
+                    span._set_tag_str(self._config.tag_name, tag)
+                    span._set_tag_str(self._config.source_tag_name, data_source)
                     break
 
         if tag in self._mapping:
-            span.set_tag_str(self._config.remap_tag_name, tag)
-            span.set_tag_str(self._config.tag_name, self._config.peer_service_mapping[tag])
+            span._set_tag_str(self._config.remap_tag_name, tag)
+            span._set_tag_str(self._config.tag_name, self._config.peer_service_mapping[tag])
diff --git a/ddtrace/internal/sampling.py b/ddtrace/internal/sampling.py
index 1fe27bd8f67..eb1129ae26e 100644
--- a/ddtrace/internal/sampling.py
+++ b/ddtrace/internal/sampling.py
@@ -249,10 +249,10 @@ def _set_sampling_tags(span: Span, sampled: bool, sample_rate: float, mechanism:
         SamplingMechanism.REMOTE_DYNAMIC_TRACE_SAMPLING_RULE,
     ):
         span.set_metric(_SAMPLING_RULE_DECISION, sample_rate)
-        span.set_tag_str(KNUTH_SAMPLE_RATE_KEY, f"{sample_rate:.6g}")
+        span._set_tag_str(KNUTH_SAMPLE_RATE_KEY, f"{sample_rate:.6g}")
     elif mechanism == SamplingMechanism.AGENT_RATE_BY_SERVICE:
         span.set_metric(_SAMPLING_AGENT_DECISION, sample_rate)
-        span.set_tag_str(KNUTH_SAMPLE_RATE_KEY, f"{sample_rate:.6g}")
+        span._set_tag_str(KNUTH_SAMPLE_RATE_KEY, f"{sample_rate:.6g}")
     # Set the sampling priority
     priorities = SAMPLING_MECHANISM_TO_PRIORITIES[mechanism]
     priority_index = _KEEP_PRIORITY_INDEX if sampled else _REJECT_PRIORITY_INDEX
@@ -263,8 +263,8 @@ def _set_sampling_tags(span: Span, sampled: bool, sample_rate: float, mechanism:
 def _inherit_sampling_tags(target: Span, source: Span):
     """Set sampling tags from source span on target span."""
     target.set_metric(SAMPLING_DECISION_MAKER_INHERITED, 1)
-    target.set_tag_str(SAMPLING_DECISION_MAKER_SERVICE, source.service)  # type: ignore[arg-type]
-    target.set_tag_str(SAMPLING_DECISION_MAKER_RESOURCE, source.resource)
+    target._set_tag_str(SAMPLING_DECISION_MAKER_SERVICE, source.service)  # type: ignore[arg-type]
+    target._set_tag_str(SAMPLING_DECISION_MAKER_RESOURCE, source.resource)
 
 
 def _get_highest_precedence_rule_matching(span: Span, rules: List[SamplingRule]) -> Optional[SamplingRule]:
diff --git a/ddtrace/internal/schema/processor.py b/ddtrace/internal/schema/processor.py
index 1cdf204279b..9c6ea16b7df 100644
--- a/ddtrace/internal/schema/processor.py
+++ b/ddtrace/internal/schema/processor.py
@@ -26,4 +26,4 @@ def process_trace(self, trace):
         return trace
 
     def _update_dd_base_service(self, span):
-        span.set_tag_str(key=_BASE_SERVICE_KEY, value=self._global_service)
+        span._set_tag_str(key=_BASE_SERVICE_KEY, value=self._global_service)
diff --git a/ddtrace/internal/tracemethods.py b/ddtrace/internal/tracemethods.py
index 99dd1384ea7..7b7ed7feb3e 100644
--- a/ddtrace/internal/tracemethods.py
+++ b/ddtrace/internal/tracemethods.py
@@ -90,11 +90,11 @@ def trace_wrapper(wrapped, instance, args, kwargs):
 
         async def async_wrapper(*a, **kw):
             with tracer.trace("trace.annotation", resource=resource) as span:
-                span.set_tag_str("component", "trace")
+                span._set_tag_str("component", "trace")
                 return await wrapped(*a, **kw)
 
         return async_wrapper(*args, **kwargs)
 
     with tracer.trace("trace.annotation", resource=resource) as span:
-        span.set_tag_str("component", "trace")
+        span._set_tag_str("component", "trace")
         return wrapped(*args, **kwargs)
diff --git a/ddtrace/llmobs/_integrations/anthropic.py b/ddtrace/llmobs/_integrations/anthropic.py
index ac506bcd97c..6c69f4f8df0 100644
--- a/ddtrace/llmobs/_integrations/anthropic.py
+++ b/ddtrace/llmobs/_integrations/anthropic.py
@@ -49,7 +49,7 @@ def _set_base_span_tags(
     ) -> None:
         """Set base level tags that should be present on all Anthropic spans (if they are not None)."""
         if model is not None:
-            span.set_tag_str(MODEL, model)
+            span._set_tag_str(MODEL, model)
 
     def _llmobs_set_tags(
         self,
diff --git a/ddtrace/llmobs/_integrations/gemini.py b/ddtrace/llmobs/_integrations/gemini.py
index 664f9b7dfb9..eb87f95df46 100644
--- a/ddtrace/llmobs/_integrations/gemini.py
+++ b/ddtrace/llmobs/_integrations/gemini.py
@@ -31,9 +31,9 @@ def _set_base_span_tags(
         self, span: Span, provider: Optional[str] = None, model: Optional[str] = None, **kwargs: Dict[str, Any]
     ) -> None:
         if provider is not None:
-            span.set_tag_str("google_generativeai.request.provider", str(provider))
+            span._set_tag_str("google_generativeai.request.provider", str(provider))
         if model is not None:
-            span.set_tag_str("google_generativeai.request.model", str(model))
+            span._set_tag_str("google_generativeai.request.model", str(model))
 
     def _llmobs_set_tags(
         self,
diff --git a/ddtrace/llmobs/_integrations/google_adk.py b/ddtrace/llmobs/_integrations/google_adk.py
index 5e6d974bad7..50a12dd1b86 100644
--- a/ddtrace/llmobs/_integrations/google_adk.py
+++ b/ddtrace/llmobs/_integrations/google_adk.py
@@ -28,7 +28,7 @@ class GoogleAdkIntegration(BaseLLMIntegration):
     def _set_base_span_tags(
         self, span: Span, model: Optional[Any] = None, provider: Optional[Any] = None, **kwargs
     ) -> None:
-        span.set_tag_str(COMPONENT, self._integration_name)
+        span._set_tag_str(COMPONENT, self._integration_name)
         if model:
             span.set_tag("google_adk.request.model", model)
         if provider:
diff --git a/ddtrace/llmobs/_integrations/google_genai.py b/ddtrace/llmobs/_integrations/google_genai.py
index 4a230e1c905..c46f9f197f5 100644
--- a/ddtrace/llmobs/_integrations/google_genai.py
+++ b/ddtrace/llmobs/_integrations/google_genai.py
@@ -61,9 +61,9 @@ def _set_base_span_tags(
         self, span: Span, provider: Optional[str] = None, model: Optional[str] = None, **kwargs: Dict[str, Any]
     ) -> None:
         if provider is not None:
-            span.set_tag_str("google_genai.request.provider", provider)
+            span._set_tag_str("google_genai.request.provider", provider)
         if model is not None:
-            span.set_tag_str("google_genai.request.model", model)
+            span._set_tag_str("google_genai.request.model", model)
 
     def _llmobs_set_tags(
         self,
diff --git a/ddtrace/llmobs/_integrations/langchain.py b/ddtrace/llmobs/_integrations/langchain.py
index de970144082..7c3c34813d6 100644
--- a/ddtrace/llmobs/_integrations/langchain.py
+++ b/ddtrace/llmobs/_integrations/langchain.py
@@ -778,9 +778,9 @@ def _set_base_span_tags(
     ) -> None:
         """Set base level tags that should be present on all LangChain spans (if they are not None)."""
         if provider is not None:
-            span.set_tag_str(PROVIDER, provider)
+            span._set_tag_str(PROVIDER, provider)
         if model is not None:
-            span.set_tag_str(MODEL, model)
+            span._set_tag_str(MODEL, model)
 
     def _extract_tool_call_args_from_inputs(self, tool_inputs: Dict[str, Any]) -> Tuple[str, str, str]:
         """
diff --git a/ddtrace/llmobs/_integrations/litellm.py b/ddtrace/llmobs/_integrations/litellm.py
index e808103509c..43fd4400f15 100644
--- a/ddtrace/llmobs/_integrations/litellm.py
+++ b/ddtrace/llmobs/_integrations/litellm.py
@@ -54,9 +54,9 @@ def _set_base_span_tags(
         self, span: Span, model: Optional[str] = None, host: Optional[str] = None, **kwargs: Dict[str, Any]
     ) -> None:
         if model is not None:
-            span.set_tag_str("litellm.request.model", model)
+            span._set_tag_str("litellm.request.model", model)
         if host is not None:
-            span.set_tag_str("litellm.request.host", host)
+            span._set_tag_str("litellm.request.host", host)
 
     def _llmobs_set_tags(
         self,
diff --git a/ddtrace/llmobs/_integrations/openai.py b/ddtrace/llmobs/_integrations/openai.py
index 314818e74a7..f9743907656 100644
--- a/ddtrace/llmobs/_integrations/openai.py
+++ b/ddtrace/llmobs/_integrations/openai.py
@@ -74,14 +74,14 @@ def trace(self, pin: Pin, operation_id: str, submit_to_llmobs: bool = False, **k
         return super().trace(pin, operation_id, submit_to_llmobs, **kwargs)
 
     def _set_base_span_tags(self, span: Span, **kwargs) -> None:
-        span.set_tag_str(COMPONENT, self.integration_config.integration_name)
+        span._set_tag_str(COMPONENT, self.integration_config.integration_name)
 
         client = "OpenAI"
         if self._is_provider(span, "azure"):
             client = "AzureOpenAI"
         elif self._is_provider(span, "deepseek"):
             client = "Deepseek"
-        span.set_tag_str("openai.request.provider", client)
+        span._set_tag_str("openai.request.provider", client)
 
     def _is_provider(self, span, provider):
         """Check if the traced operation is from the given provider."""
diff --git a/ddtrace/llmobs/_integrations/vertexai.py b/ddtrace/llmobs/_integrations/vertexai.py
index f392e608bc7..05c30e46c8e 100644
--- a/ddtrace/llmobs/_integrations/vertexai.py
+++ b/ddtrace/llmobs/_integrations/vertexai.py
@@ -33,9 +33,9 @@ def _set_base_span_tags(
         self, span: Span, provider: Optional[str] = None, model: Optional[str] = None, **kwargs: Dict[str, Any]
     ) -> None:
         if provider is not None:
-            span.set_tag_str("vertexai.request.provider", provider)
+            span._set_tag_str("vertexai.request.provider", provider)
         if model is not None:
-            span.set_tag_str("vertexai.request.model", model)
+            span._set_tag_str("vertexai.request.model", model)
 
     def _llmobs_set_tags(
         self,
diff --git a/ddtrace/opentracer/span.py b/ddtrace/opentracer/span.py
index 75bb522d06f..3aea2eda580 100644
--- a/ddtrace/opentracer/span.py
+++ b/ddtrace/opentracer/span.py
@@ -147,7 +147,7 @@ def set_tag(self, key, value):
         elif key == Tags.RESOURCE_NAME or key == OTTags.DATABASE_STATEMENT:
             self._dd_span.resource = value
         elif key == OTTags.PEER_HOSTNAME:
-            self._dd_span.set_tag_str(Tags.TARGET_HOST, value)
+            self._dd_span._set_tag_str(Tags.TARGET_HOST, value)
         elif key == OTTags.PEER_PORT:
             self._dd_span.set_tag(Tags.TARGET_PORT, value)
         elif key == Tags.SAMPLING_PRIORITY:
diff --git a/ddtrace/propagation/_database_monitoring.py b/ddtrace/propagation/_database_monitoring.py
index 295e34a82b6..9d3c6cf594c 100644
--- a/ddtrace/propagation/_database_monitoring.py
+++ b/ddtrace/propagation/_database_monitoring.py
@@ -125,7 +125,7 @@ def _get_dbm_comment(self, db_span):
             dbm_tags[DBM_PEER_SERVICE_KEY] = peer_service
 
         if dbm_config.propagation_mode == "full":
-            db_span.set_tag_str(DBM_TRACE_INJECTED_TAG, "true")
+            db_span._set_tag_str(DBM_TRACE_INJECTED_TAG, "true")
             dbm_tags[DBM_TRACE_PARENT_KEY] = db_span.context._traceparent
 
         sql_comment = self.comment_generator(**dbm_tags)
diff --git a/releasenotes/notes/deprecate-span-set-tag-str-451bf8951a998dfc.yaml b/releasenotes/notes/deprecate-span-set-tag-str-451bf8951a998dfc.yaml
new file mode 100644
index 00000000000..aebe9ddf15e
--- /dev/null
+++ b/releasenotes/notes/deprecate-span-set-tag-str-451bf8951a998dfc.yaml
@@ -0,0 +1,5 @@
+---
+deprecations:
+  - |
+    tracing: ``Span.set_tag_str`` is deprecated and will be removed in version 4.0.0.
+            As an alternative to ``Span.set_tag_str``, you can use ``Span.set_tag`` instead.
diff --git a/tests/ci_visibility/test_encoder.py b/tests/ci_visibility/test_encoder.py
index 8bf16cc4392..a5c66d73d9f 100644
--- a/tests/ci_visibility/test_encoder.py
+++ b/tests/ci_visibility/test_encoder.py
@@ -58,8 +58,8 @@ def test_encode_traces_civisibility_v0():
         ],
     ]
     test_trace = traces[2]
-    test_trace[0].set_tag_str("type", "test")
-    test_trace[1].set_tag_str("type", "test")
+    test_trace[0]._set_tag_str("type", "test")
+    test_trace[1]._set_tag_str("type", "test")
 
     encoder = CIVisibilityEncoderV01(0, 0)
     encoder.set_metadata("*", {"language": "python"})
@@ -169,7 +169,7 @@ def test_build_payload_large_trace_splitting():
         for j in range(50):  # Each trace has many spans
             span = Span(name=f"large_test_{i}_{j}", span_id=0x100000 + i * 100 + j, service="test")
             # Add large metadata to increase payload size
-            span.set_tag_str("large_data", "x" * 1000)  # 1KB per span
+            span._set_tag_str("large_data", "x" * 1000)  # 1KB per span
             trace.append(span)
         large_traces.append(trace)
 
@@ -201,7 +201,7 @@ def test_build_payload_recursive_splitting():
         trace = []
         for j in range(10):  # Each with 10 spans
             span = Span(name=f"test_{i}_{j}", span_id=0x200000 + i * 100 + j, service="test")
-            span.set_tag_str("data", "x" * 500)  # Make each span moderately large
+            span._set_tag_str("data", "x" * 500)  # Make each span moderately large
             trace.append(span)
         traces.append(trace)
 
@@ -239,7 +239,7 @@ def test_build_payload_with_filtered_spans():
 
     try:
         # Add session type tag to trigger filtering
-        traces[0][0].set_tag_str(EVENT_TYPE, SESSION_TYPE)
+        traces[0][0]._set_tag_str(EVENT_TYPE, SESSION_TYPE)
 
         encoder = CIVisibilityEncoderV01(0, 0)
         payloads = encoder._build_payload(traces)
@@ -276,7 +276,7 @@ def test_build_payload_all_spans_filtered():
     try:
         # Make both spans session types to trigger filtering
         for trace in traces:
-            trace[0].set_tag_str(EVENT_TYPE, SESSION_TYPE)
+            trace[0]._set_tag_str(EVENT_TYPE, SESSION_TYPE)
 
         encoder = CIVisibilityEncoderV01(0, 0)
         payloads = encoder._build_payload(traces)
@@ -297,7 +297,7 @@ def test_build_payload_no_infinite_recursion():
     large_trace = []
     for i in range(100):
         span = Span(name=f"large_span_{i}", span_id=0x400000 + i, service="test")
-        span.set_tag_str("large_data", "x" * 1000)
+        span._set_tag_str("large_data", "x" * 1000)
         large_trace.append(span)
 
     encoder = CIVisibilityEncoderV01(0, 0)
diff --git a/tests/contrib/fastapi/app.py b/tests/contrib/fastapi/app.py
index e613eb36fe9..cd4ff3eb6a8 100644
--- a/tests/contrib/fastapi/app.py
+++ b/tests/contrib/fastapi/app.py
@@ -44,7 +44,7 @@ async def websocket(websocket: WebSocket):
         await websocket.accept()
         root_span = tracer.current_root_span()
         if root_span:
-            root_span.set_tag_str(SAMPLING_DECISION_TRACE_TAG_KEY, "-1")
+            root_span._set_tag_str(SAMPLING_DECISION_TRACE_TAG_KEY, "-1")
             root_span.context.set_baggage_item("foo", "bar")
             root_span.context.sampling_priority = 1
         await websocket.send_json({"test": "Hello WebSocket"})
diff --git a/tests/contrib/grpc/test_grpc_utils.py b/tests/contrib/grpc/test_grpc_utils.py
index f1ff4034045..634cd20430e 100644
--- a/tests/contrib/grpc/test_grpc_utils.py
+++ b/tests/contrib/grpc/test_grpc_utils.py
@@ -91,7 +91,7 @@ def test_parse_target_from_args(mock_log, args, kwargs, result, log_warning_call
 def test_set_grpc_client_meta(host, port, calls):
     span = mock.MagicMock()
     utils.set_grpc_client_meta(span, host, port)
-    span.set_tag_str.assert_has_calls(calls)
+    span._set_tag_str.assert_has_calls(calls)
 
 
 @pytest.mark.parametrize(
@@ -125,4 +125,4 @@ def test_set_grpc_client_meta(host, port, calls):
 def test_set_grpc_method_meta(method, method_kind, calls):
     span = mock.MagicMock()
     utils.set_grpc_method_meta(span, method, method_kind)
-    span.set_tag_str.assert_has_calls(calls)
+    span._set_tag_str.assert_has_calls(calls)
diff --git a/tests/contrib/openai/conftest.py b/tests/contrib/openai/conftest.py
index 728e7653a14..059a6b62843 100644
--- a/tests/contrib/openai/conftest.py
+++ b/tests/contrib/openai/conftest.py
@@ -88,7 +88,7 @@ def process_trace(self, trace):
         # type: (List[Span]) -> Optional[List[Span]]
         for span in trace:
             if span.get_tag("organization"):
-                span.set_tag_str("organization", "not-a-real-org")
+                span._set_tag_str("organization", "not-a-real-org")
         return trace
 
 
diff --git a/tests/contrib/pytest/test_pytest_xdist_itr.py b/tests/contrib/pytest/test_pytest_xdist_itr.py
index 76f06005ccd..315cd2ff354 100644
--- a/tests/contrib/pytest/test_pytest_xdist_itr.py
+++ b/tests/contrib/pytest/test_pytest_xdist_itr.py
@@ -730,13 +730,13 @@ def test_pytest_sessionfinish_aggregates_worker_itr_results(self):
             if skipped_count > 0:
                 session_span = mock_session_span  # Use our mock directly
                 if session_span:
-                    session_span.set_tag_str(test.ITR_TEST_SKIPPING_TESTS_SKIPPED, "true")
-                    session_span.set_tag_str(test.ITR_DD_CI_ITR_TESTS_SKIPPED, "true")
+                    session_span._set_tag_str(test.ITR_TEST_SKIPPING_TESTS_SKIPPED, "true")
+                    session_span._set_tag_str(test.ITR_DD_CI_ITR_TESTS_SKIPPED, "true")
                     session_span.set_metric(test.ITR_TEST_SKIPPING_COUNT, skipped_count)
 
         # Verify the session span was tagged with ITR results
-        mock_session_span.set_tag_str.assert_any_call(test.ITR_TEST_SKIPPING_TESTS_SKIPPED, "true")
-        mock_session_span.set_tag_str.assert_any_call(test.ITR_DD_CI_ITR_TESTS_SKIPPED, "true")
+        mock_session_span._set_tag_str.assert_any_call(test.ITR_TEST_SKIPPING_TESTS_SKIPPED, "true")
+        mock_session_span._set_tag_str.assert_any_call(test.ITR_DD_CI_ITR_TESTS_SKIPPED, "true")
         mock_session_span.set_metric.assert_called_with(test.ITR_TEST_SKIPPING_COUNT, 10)
 
         # Clean up
@@ -760,7 +760,7 @@ def test_pytest_sessionfinish_no_aggregation_for_worker_process(self):
             _pytest_sessionfinish(mock_session, 0)
 
             # Verify no ITR tags were set (worker shouldn't aggregate)
-            mock_session_span.set_tag_str.assert_not_called()
+            mock_session_span._set_tag_str.assert_not_called()
             mock_session_span.set_metric.assert_not_called()
 
         # Clean up
@@ -785,7 +785,7 @@ def test_pytest_sessionfinish_no_aggregation_when_no_global_results(self):
             _pytest_sessionfinish(mock_session, 0)
 
             # Verify no ITR tags were set (no global results to aggregate)
-            mock_session_span.set_tag_str.assert_not_called()
+            mock_session_span._set_tag_str.assert_not_called()
             mock_session_span.set_metric.assert_not_called()
 
     def test_pytest_sessionfinish_no_aggregation_when_zero_skipped(self):
@@ -806,7 +806,7 @@ def test_pytest_sessionfinish_no_aggregation_when_zero_skipped(self):
             _pytest_sessionfinish(mock_session, 0)
 
             # Verify no ITR tags were set (zero tests skipped)
-            mock_session_span.set_tag_str.assert_not_called()
+            mock_session_span._set_tag_str.assert_not_called()
             mock_session_span.set_metric.assert_not_called()
 
         # Clean up
diff --git a/tests/contrib/ray/test_long_running_span.py b/tests/contrib/ray/test_long_running_span.py
index 62476d952cc..624eaddb79d 100644
--- a/tests/contrib/ray/test_long_running_span.py
+++ b/tests/contrib/ray/test_long_running_span.py
@@ -49,7 +49,7 @@ def test_long_running_span_basic_lifecycle(self):
         """Test basic lifecycle of a long running span"""
 
         span = self.tracer.start_span("test.long.running", service="test-service")
-        span.set_tag_str("ray.submission_id", "test-submission-123")
+        span._set_tag_str("ray.submission_id", "test-submission-123")
 
         start_long_running_span(span)
 
@@ -76,7 +76,7 @@ def test_long_running_span_basic_lifecycle(self):
     def test_not_long_running_span(self):
         """Test when a potential long running span lasts less then register_treshold"""
         span = self.tracer.start_span("test.not.long.running", service="test-service")
-        span.set_tag_str("ray.submission_id", "test-submission-123")
+        span._set_tag_str("ray.submission_id", "test-submission-123")
 
         start_long_running_span(span)
 
@@ -103,10 +103,10 @@ def test_multiple_long_running_spans_same_submission(self):
         submission_id = "test-multi-submission-999"
 
         span1 = self.tracer.start_span("test.span1", service="test-service")
-        span1.set_tag_str("ray.submission_id", submission_id)
+        span1._set_tag_str("ray.submission_id", submission_id)
 
         span2 = self.tracer.start_span("test.span2", service="test-service")
-        span2.set_tag_str("ray.submission_id", submission_id)
+        span2._set_tag_str("ray.submission_id", submission_id)
 
         start_long_running_span(span1)
         start_long_running_span(span2)
@@ -136,11 +136,11 @@ def test_long_running_span_hierarchies_and_context(self):
         """Test parent/child relationships with mixed long-running and non-long-running spans."""
         submission_id = "test-parent-child-hierarchy-456"
         parent_span = self.tracer.start_span(name="test.long.parent", service="test-service")
-        parent_span.set_tag_str("ray.submission_id", submission_id)
+        parent_span._set_tag_str("ray.submission_id", submission_id)
         start_long_running_span(parent_span)
 
         child1 = self.tracer.start_span(name="test.child1.long", service="test-service", child_of=parent_span)
-        child1.set_tag_str("ray.submission_id", submission_id)
+        child1._set_tag_str("ray.submission_id", submission_id)
         start_long_running_span(child1)
 
         time.sleep(3)
@@ -154,7 +154,7 @@ def test_long_running_span_hierarchies_and_context(self):
         self.assertIsNone(child2.get_metric("_dd.partial_version"))
 
         child3 = self.tracer.start_span(name="test.child3.long", service="test-service", child_of=parent_span)
-        child3.set_tag_str("ray.submission_id", submission_id)
+        child3._set_tag_str("ray.submission_id", submission_id)
         start_long_running_span(child3)
 
         with _ray_span_manager._lock:
diff --git a/tests/internal/test_database_monitoring.py b/tests/internal/test_database_monitoring.py
index 33afb475710..171118c7791 100644
--- a/tests/internal/test_database_monitoring.py
+++ b/tests/internal/test_database_monitoring.py
@@ -145,7 +145,7 @@ def test_dbm_dddbs_peer_service_enabled():
         ), sqlcomment
 
         with tracer.trace("dbname") as dbspan_with_peer_service:
-            dbspan_with_peer_service.set_tag_str("db.name", "db-name-test")
+            dbspan_with_peer_service._set_tag_str("db.name", "db-name-test")
 
             # when dbm propagation mode is full sql comments should be generated with dbm tags and traceparent keys
             dbm_popagator = _database_monitoring._DBM_Propagator(0, "procedure")
diff --git a/tests/llmobs/test_llmobs_service.py b/tests/llmobs/test_llmobs_service.py
index 5a0c233002b..92ac2950d7a 100644
--- a/tests/llmobs/test_llmobs_service.py
+++ b/tests/llmobs/test_llmobs_service.py
@@ -46,7 +46,7 @@
 
 def run_llmobs_trace_filter(dummy_tracer):
     with dummy_tracer.trace("span1", span_type=SpanTypes.LLM) as span:
-        span.set_tag_str(SPAN_KIND, "llm")
+        span._set_tag_str(SPAN_KIND, "llm")
     return dummy_tracer._span_aggregator.writer.pop()
 
 
diff --git a/tests/tracer/test_encoders.py b/tests/tracer/test_encoders.py
index 2388507afc0..079b3260c32 100644
--- a/tests/tracer/test_encoders.py
+++ b/tests/tracer/test_encoders.py
@@ -299,7 +299,7 @@ def test_msgpack_encoding_after_an_exception_was_raised():
     trace = gen_trace(nspans=1, ntags=100, nmetrics=100, key_size=10, value_size=10)
     rand_string = rands(size=20, chars=string.ascii_letters)
     # trace only has one span
-    trace[0].set_tag_str("some_tag", rand_string)
+    trace[0]._set_tag_str("some_tag", rand_string)
     try:
         # Encode a trace that will trigger a rollback/BufferItemTooLarge exception
         # BufferFull is not raised since only one span is being encoded
@@ -311,7 +311,7 @@ def test_msgpack_encoding_after_an_exception_was_raised():
     # Successfully encode a small trace
     small_trace = gen_trace(nspans=1, ntags=0, nmetrics=0)
     # Add a tag to the small trace that was previously encoded in the encoder's StringTable
-    small_trace[0].set_tag_str("previously_encoded_string", rand_string)
+    small_trace[0]._set_tag_str("previously_encoded_string", rand_string)
     rolledback_encoder.put(small_trace)
 
     # Encode a trace without triggering a rollback/BufferFull exception
diff --git a/tests/tracer/test_span.py b/tests/tracer/test_span.py
index ee5245c8600..a47391ef3da 100644
--- a/tests/tracer/test_span.py
+++ b/tests/tracer/test_span.py
@@ -721,8 +721,8 @@ def test_span_unicode_set_tag():
     span = Span(None)
     span.set_tag("key", "😌")
     span.set_tag("😐", "😌")
-    span.set_tag_str("key", "😌")
-    span.set_tag_str("😐", "😌")
+    span._set_tag_str("key", "😌")
+    span._set_tag_str("😐", "😌")
 
 
 @pytest.mark.skipif(sys.version_info.major != 2, reason="This test only applies Python 2")
@@ -730,7 +730,7 @@ def test_span_unicode_set_tag():
 def test_span_binary_unicode_set_tag(span_log):
     span = Span(None)
     span.set_tag("key", "🤔")
-    span.set_tag_str("key_str", "🤔")
+    span._set_tag_str("key_str", "🤔")
     # only span.set_tag() will fail
     span_log.warning.assert_called_once_with("error setting tag %s, ignoring it", "key", exc_info=True)
     assert "key" not in span.get_tags()
@@ -742,7 +742,7 @@ def test_span_binary_unicode_set_tag(span_log):
 def test_span_bytes_string_set_tag(span_log):
     span = Span(None)
     span.set_tag("key", b"\xf0\x9f\xa4\x94")
-    span.set_tag_str("key_str", b"\xf0\x9f\xa4\x94")
+    span._set_tag_str("key_str", b"\xf0\x9f\xa4\x94")
     assert span.get_tag("key") == "b'\\xf0\\x9f\\xa4\\x94'"
     assert span.get_tag("key_str") == "🤔"
     span_log.warning.assert_not_called()
@@ -751,7 +751,7 @@ def test_span_bytes_string_set_tag(span_log):
 @mock.patch("ddtrace._trace.span.log")
 def test_span_encoding_set_str_tag(span_log):
     span = Span(None)
-    span.set_tag_str("foo", "/?foo=bar&baz=정상처리".encode("euc-kr"))
+    span._set_tag_str("foo", "/?foo=bar&baz=정상처리".encode("euc-kr"))
     span_log.warning.assert_not_called()
     assert span.get_tag("foo") == "/?foo=bar&baz=����ó��"
 
@@ -759,7 +759,7 @@ def test_span_encoding_set_str_tag(span_log):
 def test_span_nonstring_set_str_tag_exc():
     span = Span(None)
     with pytest.raises(TypeError):
-        span.set_tag_str("foo", dict(a=1))
+        span._set_tag_str("foo", dict(a=1))
     assert "foo" not in span.get_tags()
 
 
@@ -767,7 +767,7 @@ def test_span_nonstring_set_str_tag_exc():
 def test_span_nonstring_set_str_tag_warning(span_log):
     with override_global_config(dict(_raise=False)):
         span = Span(None)
-        span.set_tag_str("foo", dict(a=1))
+        span._set_tag_str("foo", dict(a=1))
         span_log.warning.assert_called_once_with(
             "Failed to set text tag '%s'",
             "foo",
diff --git a/tests/tracer/test_writer.py b/tests/tracer/test_writer.py
index 75de6dba81f..bdd33810883 100644
--- a/tests/tracer/test_writer.py
+++ b/tests/tracer/test_writer.py
@@ -102,7 +102,7 @@ def test_metrics_trace_too_big(self):
                 for j in range(50):
                     key = "opqr012|~" + str(i) + str(j)
                     val = "stuv345!@#" + str(i) + str(j)
-                    span.set_tag_str(key, val)
+                    span._set_tag_str(key, val)
                 massive_trace.append(span)
 
             writer.write(massive_trace)
@@ -495,7 +495,7 @@ def test_metrics_trace_too_big(self):
                 for j in range(50):
                     key = "opqr012|~" + str(i) + str(j)
                     val = "stuv345!@#" + str(i) + str(j)
-                    span.set_tag_str(key, val)
+                    span._set_tag_str(key, val)
                 massive_trace.append(span)
 
             writer.write(massive_trace)