semantic convention for httplib

Author: zhihali

util/opentelemetry-util-http/src/opentelemetry/util/http/__init__.py

@@ -19,9 +19,16 @@
 from re import IGNORECASE as RE_IGNORECASE
 from re import compile as re_compile
 from re import search
-from typing import Callable, Iterable, Optional
+from typing import Callable, Dict, Iterable, Optional
 from urllib.parse import urlparse, urlunparse
 
+from opentelemetry.instrumentation._semconv import (
+ _HTTPStabilityMode,
+ _OpenTelemetrySemanticConventionStability,
+ _OpenTelemetryStabilitySignalType,
+ _server_active_requests_count_attrs_new,
+ _server_duration_attrs_new,
+)
 from opentelemetry.semconv.trace import SpanAttributes
 
 OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SANITIZE_FIELDS = (
@@ -228,20 +235,44 @@ def get_custom_headers(env_var: str) -> list[str]:
  return []
 
 
-def _parse_active_request_count_attrs(req_attrs):
- active_requests_count_attrs = {
- key: req_attrs[key]
- for key in _active_requests_count_attrs.intersection(req_attrs.keys())
+def _parse_active_request_count_attrs(
+ req_attrs: Dict[str, str]
+) -> Dict[str, str]:
+ _OpenTelemetrySemanticConventionStability._initialize()
+ stability_mode = _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
+ _OpenTelemetryStabilitySignalType.HTTP
+ )
+
+ if stability_mode == _HTTPStabilityMode.DEFAULT:
+ attrs_set = _active_requests_count_attrs
+ elif stability_mode == _HTTPStabilityMode.HTTP:
+ attrs_set = _server_active_requests_count_attrs_new
+ else: # HTTP_DUP
+ attrs_set = _active_requests_count_attrs.union(
+ _server_active_requests_count_attrs_new
+ )
+
+ return {
+ key: req_attrs[key] for key in attrs_set.intersection(req_attrs.keys())
  }
- return active_requests_count_attrs
 
 
-def _parse_duration_attrs(req_attrs):
- duration_attrs = {
- key: req_attrs[key]
- for key in _duration_attrs.intersection(req_attrs.keys())
+def _parse_duration_attrs(req_attrs: Dict[str, str]) -> Dict[str, str]:
+ _OpenTelemetrySemanticConventionStability._initialize()
+ stability_mode = _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
+ _OpenTelemetryStabilitySignalType.HTTP
+ )
+
+ if stability_mode == _HTTPStabilityMode.DEFAULT:
+ attrs_set = _duration_attrs
+ elif stability_mode == _HTTPStabilityMode.HTTP:
+ attrs_set = _server_duration_attrs_new
+ else: # HTTP_DUP
+ attrs_set = _duration_attrs.union(_server_duration_attrs_new)
+
+ return {
+ key: req_attrs[key] for key in attrs_set.intersection(req_attrs.keys())
  }
- return duration_attrs
 
 
 def _parse_url_query(url: str):

util/opentelemetry-util-http/src/opentelemetry/util/http/httplib.py

@@ -27,6 +27,12 @@
 import wrapt
 
 from opentelemetry import context
+from opentelemetry.instrumentation._semconv import (
+ _OpenTelemetrySemanticConventionStability,
+ _OpenTelemetryStabilitySignalType,
+ _report_new,
+ _report_old,
+)
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.instrumentation.utils import unwrap
 from opentelemetry.semconv.trace import SpanAttributes
@@ -104,8 +110,15 @@ def trysetip(conn: http.client.HTTPConnection, loglevel=logging.DEBUG) -> bool:
  stack_info=True,
  )
  else:
+ _OpenTelemetrySemanticConventionStability._initialize()
+ stability_mode = _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
+ _OpenTelemetryStabilitySignalType.HTTP
+ )
  for span in spanlist:
- span.set_attribute(SpanAttributes.NET_PEER_IP, ip)
+ if _report_old(stability_mode):
+ span.set_attribute(SpanAttributes.NET_PEER_IP, ip)
+ if _report_new(stability_mode):
+ span.set_attribute(SpanAttributes.CLIENT_ADDRESS, ip)
  return True
 
 

util/opentelemetry-util-http/tests/test_http_base.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 from http.client import HTTPConnection, HTTPResponse, HTTPSConnection
+from typing import Tuple
 
 from opentelemetry import trace
 from opentelemetry.test.httptest import HttpTestBase
@@ -103,7 +104,7 @@ def test_with_only_nonrecording_span(self):
  assert body == b"Hello!"
  self.assert_span(num_spans=0)
 
- def perform_request(self, secure=False) -> HTTPResponse:
+ def perform_request(self, secure=False) -> Tuple[HTTPResponse, bytes]:
  conn_cls = HTTPSConnection if secure else HTTPConnection
  conn = conn_cls(self.server.server_address[0], self.server.server_port)
  resp = None

util/opentelemetry-util-http/tests/test_http_client_instrumentation.py

@@ -0,0 +1,116 @@
+import os
+from http.client import HTTPConnection, HTTPResponse, HTTPSConnection
+from typing import Tuple
+
+from opentelemetry import trace
+from opentelemetry.semconv.trace import SpanAttributes
+from opentelemetry.test.httptest import HttpTestBase
+from opentelemetry.test.test_base import TestBase
+from opentelemetry.util.http.httplib import (
+ HttpClientInstrumentor,
+ set_ip_on_next_http_connection,
+)
+
+
+class TestHttpBase(TestBase, HttpTestBase):
+ def setUp(self):
+ super().setUp()
+ self.server_thread, self.server = self.run_server()
+ self.http_instrumentor = HttpClientInstrumentor()
+
+ def tearDown(self):
+ self.server.shutdown()
+ self.server_thread.join()
+ super().tearDown()
+
+ def instrument_http(self, semconv_mode):
+ original = os.environ.get("OTEL_SEMCONV_STABILITY_OPT_IN")
+ os.environ["OTEL_SEMCONV_STABILITY_OPT_IN"] = semconv_mode
+ self.http_instrumentor.instrument()
+ return original
+
+ def uninstrument_http(self, original_value):
+ self.http_instrumentor.uninstrument()
+ if original_value is None:
+ del os.environ["OTEL_SEMCONV_STABILITY_OPT_IN"]
+ else:
+ os.environ["OTEL_SEMCONV_STABILITY_OPT_IN"] = original_value
+
+ def assert_span(self, exporter=None, num_spans=1):
+ if exporter is None:
+ exporter = self.memory_exporter
+ span_list = exporter.get_finished_spans()
+ self.assertEqual(num_spans, len(span_list))
+ if num_spans == 0:
+ return None
+ if num_spans == 1:
+ return span_list[0]
+ return span_list
+
+ def test_basic_with_span_default(self):
+ original = self.instrument_http("")
+ try:
+ tracer = trace.get_tracer(__name__)
+ with tracer.start_as_current_span(
+ "HTTP GET"
+ ) as span, set_ip_on_next_http_connection(span):
+ resp, body = self.perform_request()
+ assert resp.status == 200
+ assert body == b"Hello!"
+ span = self.assert_span(num_spans=1)
+ self.assertEqual(
+ span.attributes, {SpanAttributes.NET_PEER_IP: "127.0.0.1"}
+ )
+ finally:
+ self.uninstrument_http(original)
+
+ def test_basic_with_span_new(self):
+ original = self.instrument_http("http")
+ try:
+ tracer = trace.get_tracer(__name__)
+ with tracer.start_as_current_span(
+ "HTTP GET"
+ ) as span, set_ip_on_next_http_connection(span):
+ resp, body = self.perform_request()
+ assert resp.status == 200
+ assert body == b"Hello!"
+ span = self.assert_span(num_spans=1)
+ self.assertEqual(
+ span.attributes, {SpanAttributes.CLIENT_ADDRESS: "127.0.0.1"}
+ )
+ finally:
+ self.uninstrument_http(original)
+
+ def test_basic_with_span_both(self):
+ original = self.instrument_http("http/dup")
+ try:
+ tracer = trace.get_tracer(__name__)
+ with tracer.start_as_current_span(
+ "HTTP GET"
+ ) as span, set_ip_on_next_http_connection(span):
+ resp, body = self.perform_request()
+ assert resp.status == 200
+ assert body == b"Hello!"
+ span = self.assert_span(num_spans=1)
+ self.assertEqual(
+ span.attributes,
+ {
+ SpanAttributes.NET_PEER_IP: "127.0.0.1",
+ SpanAttributes.CLIENT_ADDRESS: "127.0.0.1",
+ },
+ )
+ finally:
+ self.uninstrument_http(original)
+
+ def perform_request(self, secure=False) -> Tuple[HTTPResponse, bytes]:
+ conn_cls = HTTPSConnection if secure else HTTPConnection
+ conn = conn_cls(self.server.server_address[0], self.server.server_port)
+ resp = None
+ try:
+ conn.request("GET", "/", headers={"Connection": "close"})
+ resp = conn.getresponse()
+ return resp, resp.read()
+ finally:
+ if resp:
+ resp.close()
+ conn.close()

util/opentelemetry-util-http/tests/test_remove_credentials.py

@@ -19,9 +19,13 @@ def test_remove_credentials(self):
  def test_remove_credentials_ipv4_literal(self):
  url = "http://someuser:somepass@127.0.0.1:8080/test/path?query=value"
  cleaned_url = remove_url_credentials(url)
- self.assertEqual(cleaned_url, "http://127.0.0.1:8080/test/path?query=value")
+ self.assertEqual(
+ cleaned_url, "http://127.0.0.1:8080/test/path?query=value"
+ )
 
  def test_remove_credentials_ipv6_literal(self):
  url = "http://someuser:somepass@[::1]:8080/test/path?query=value"
  cleaned_url = remove_url_credentials(url)
- self.assertEqual(cleaned_url, "http://[::1]:8080/test/path?query=value")
+ self.assertEqual(
+ cleaned_url, "http://[::1]:8080/test/path?query=value"
+ )