expose force http functionality and fix it (#212)

* expose force http functionality and fix it

* bump version to 0.7.22

Author: dinmukhamedm

pyproject.toml

@@ -6,7 +6,7 @@
 
 [project]
 name = "lmnr"
-version = "0.7.21"
+version = "0.7.22"
 description = "Python SDK for Laminar"
 authors = [
   { name = "lmnr.ai", email = "[email protected]" }

src/lmnr/opentelemetry_lib/tracing/exporter.py

@@ -1,6 +1,7 @@
 import grpc
 import re
 import threading
+from urllib.parse import urlparse, urlunparse
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
@@ -79,11 +80,42 @@ def __init__(
             )
         self._init_instance()
 
+    def _normalize_http_endpoint(self, endpoint: str) -> str:
+        """
+        Normalize HTTP endpoint URL by adding /v1/traces path if no path is present.
+
+        Args:
+            endpoint: The endpoint URL to normalize
+
+        Returns:
+            The normalized endpoint URL with /v1/traces path if needed
+        """
+        try:
+            parsed = urlparse(endpoint)
+            # Check if there's no path or only a trailing slash
+            if not parsed.path or parsed.path == "/":
+                # Add /v1/traces to the endpoint
+                new_parsed = parsed._replace(path="/v1/traces")
+                normalized_url = urlunparse(new_parsed)
+                logger.info(
+                    f"No path found in HTTP endpoint URL. "
+                    f"Adding default path /v1/traces: {endpoint} -> {normalized_url}"
+                )
+                return normalized_url
+            return endpoint
+        except Exception as e:
+            logger.warning(
+                f"Failed to parse endpoint URL '{endpoint}': {e}. Using as-is."
+            )
+            return endpoint
+
     def _init_instance(self):
         # Create new instance first (outside critical section for performance)
         if self.force_http:
+            # Normalize HTTP endpoint to ensure it has a path
+            http_endpoint = self._normalize_http_endpoint(self.endpoint)
             new_instance = HTTPOTLPSpanExporter(
-                endpoint=self.endpoint,
+                endpoint=http_endpoint,
                 headers=self.headers,
                 compression=HTTPCompression.Gzip,
                 timeout=self.timeout,

src/lmnr/sdk/laminar.py

@@ -81,6 +81,7 @@ def initialize(
         set_global_tracer_provider: bool = True,
         otel_logger_level: int = logging.ERROR,
         session_recording_options: SessionRecordingOptions | None = None,
+        force_http: bool = False,
     ):
         """Initialize Laminar context across the application.
         This method must be called before using any other Laminar methods or
@@ -131,7 +132,8 @@ def initialize(
                 for browser session recording. Currently supports 'mask_input'\
                 (bool) to control whether input fields are masked during recording.\
                 Defaults to None (uses default masking behavior).
-
+            force_http (bool, optional): If set to True, the HTTP OTEL exporter will be\
+                used instead of the gRPC OTEL exporter. Defaults to False.
         Raises:
             ValueError: If project API key is not set
         """
@@ -198,6 +200,7 @@ def initialize(
             set_global_tracer_provider=set_global_tracer_provider,
             otel_logger_level=otel_logger_level,
             session_recording_options=session_recording_options,
+            force_http=force_http,
         )
 
     @classmethod

src/lmnr/version.py

@@ -3,7 +3,7 @@
 from packaging import version
 
 
-__version__ = "0.7.21"
+__version__ = "0.7.22"
 PYTHON_VERSION = f"{sys.version_info.major}.{sys.version_info.minor}"
 
 

tests/test_exporter.py

@@ -0,0 +1,152 @@
+"""Unit tests for LaminarSpanExporter URL normalization."""
+
+import pytest
+from unittest.mock import patch, MagicMock
+from lmnr.opentelemetry_lib.tracing.exporter import LaminarSpanExporter
+
+
+class TestHttpEndpointNormalization:
+    """Test cases for HTTP endpoint URL normalization."""
+
+    @pytest.fixture
+    def mock_http_exporter(self):
+        """Mock HTTPOTLPSpanExporter to avoid actual initialization."""
+        with patch(
+            "lmnr.opentelemetry_lib.tracing.exporter.HTTPOTLPSpanExporter"
+        ) as mock:
+            mock.return_value = MagicMock()
+            yield mock
+
+    @pytest.fixture
+    def mock_grpc_exporter(self):
+        """Mock OTLPSpanExporter to avoid actual initialization."""
+        with patch("lmnr.opentelemetry_lib.tracing.exporter.OTLPSpanExporter") as mock:
+            mock.return_value = MagicMock()
+            yield mock
+
+    def test_http_endpoint_without_path_adds_v1_traces(
+        self, mock_http_exporter, mock_grpc_exporter
+    ):
+        """Test that endpoint without path gets /v1/traces added."""
+        exporter = LaminarSpanExporter(
+            base_url="http://localhost:8080",
+            api_key="test-key",
+            force_http=True,
+        )
+        assert exporter is not None
+
+        mock_http_exporter.assert_called_once()
+        call_kwargs = mock_http_exporter.call_args[1]
+        assert call_kwargs["endpoint"] == "http://localhost:8080/v1/traces"
+
+    def test_http_endpoint_with_trailing_slash_adds_v1_traces(
+        self, mock_http_exporter, mock_grpc_exporter
+    ):
+        """Test that endpoint with trailing slash gets /v1/traces added."""
+        exporter = LaminarSpanExporter(
+            base_url="http://localhost:8080/",
+            api_key="test-key",
+            force_http=True,
+        )
+        assert exporter is not None
+
+        mock_http_exporter.assert_called_once()
+        call_kwargs = mock_http_exporter.call_args[1]
+        assert call_kwargs["endpoint"] == "http://localhost:8080/v1/traces"
+
+    def test_grpc_endpoint_not_normalized(self, mock_http_exporter, mock_grpc_exporter):
+        """Test that gRPC endpoints are not normalized (only HTTP)."""
+        exporter = LaminarSpanExporter(
+            base_url="http://localhost:8443",
+            api_key="test-key",
+            force_http=False,
+        )
+        assert exporter is not None
+
+        mock_grpc_exporter.assert_called_once()
+        mock_http_exporter.assert_not_called()
+        call_kwargs = mock_grpc_exporter.call_args[1]
+        assert call_kwargs["endpoint"] == "http://localhost:8443"
+
+    def test_https_endpoint_without_path_adds_v1_traces(
+        self, mock_http_exporter, mock_grpc_exporter
+    ):
+        """Test that HTTPS endpoint without path gets /v1/traces added."""
+        exporter = LaminarSpanExporter(
+            base_url="https://api.example.com:443",
+            api_key="test-key",
+            force_http=True,
+        )
+        assert exporter is not None
+
+        mock_http_exporter.assert_called_once()
+        call_kwargs = mock_http_exporter.call_args[1]
+        assert call_kwargs["endpoint"] == "https://api.example.com:443/v1/traces"
+
+    def test_info_logging_when_path_added(self, mock_http_exporter, mock_grpc_exporter):
+        """Test that info message is logged when path is added."""
+        with patch("lmnr.opentelemetry_lib.tracing.exporter.logger") as mock_logger:
+            exporter = LaminarSpanExporter(
+                base_url="http://localhost:8080",
+                api_key="test-key",
+                force_http=True,
+            )
+            assert exporter is not None
+
+            mock_logger.info.assert_called_once()
+            call_args = mock_logger.info.call_args[0][0]
+            assert "No path found in HTTP endpoint URL" in call_args
+            assert "Adding default path /v1/traces" in call_args
+
+    def test_no_logging_when_path_exists(
+        self, mock_http_exporter, mock_grpc_exporter, caplog
+    ):
+        """Test that no info message is logged when path already exists."""
+        import logging
+
+        caplog.set_level(logging.INFO)
+
+        exporter = LaminarSpanExporter(
+            base_url="http://localhost:8080/custom/path",
+            api_key="test-key",
+            force_http=True,
+        )
+        assert exporter is not None
+
+        assert not any(
+            "No path found in HTTP endpoint URL" in record.message
+            for record in caplog.records
+        )
+
+    def test_normalize_http_endpoint_directly(self):
+        """Test the _normalize_http_endpoint method directly."""
+        with (
+            patch(
+                "lmnr.opentelemetry_lib.tracing.exporter.HTTPOTLPSpanExporter"
+            ) as mock_http,
+            patch(
+                "lmnr.opentelemetry_lib.tracing.exporter.OTLPSpanExporter"
+            ) as mock_grpc,
+        ):
+            mock_http.return_value = MagicMock()
+            mock_grpc.return_value = MagicMock()
+
+            exporter = LaminarSpanExporter(
+                base_url="http://localhost:8080",
+                api_key="test-key",
+                force_http=True,
+            )
+
+            test_cases = [
+                ("http://example.com", "http://example.com/v1/traces"),
+                ("http://example.com/", "http://example.com/v1/traces"),
+                ("https://example.com:443", "https://example.com:443/v1/traces"),
+                ("http://example.com/path", "http://example.com/path"),
+                ("http://example.com/v1/traces", "http://example.com/v1/traces"),
+            ]
+
+            for input_url, expected_url in test_cases:
+                result = exporter._normalize_http_endpoint(input_url)
+                assert (
+                    result == expected_url
+                ), f"Expected {expected_url}, got {result} for input {input_url}"