mbuzz 0.1.1__tar.gz → 0.7.0__tar.gz

{mbuzz-0.1.1 → mbuzz-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mbuzz
-Version: 0.1.1
+Version: 0.7.0
 Summary: Multi-touch attribution SDK for Python
 Project-URL: Homepage, https://mbuzz.co
 Project-URL: Documentation, https://mbuzz.co/docs/getting-started

{mbuzz-0.1.1 → mbuzz-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mbuzz"
-version = "0.1.1"
+version = "0.7.0"
 description = "Multi-touch attribution SDK for Python"
 readme = "README.md"
 license = "MIT"

{mbuzz-0.1.1 → mbuzz-0.7.0}/src/mbuzz/__init__.py

@@ -1,4 +1,5 @@
 """Mbuzz - Multi-touch attribution SDK for Python."""
+# NOTE: Session ID removed in 0.7.0 - server handles session resolution
 
 from typing import Any, Dict, Optional, Union
 
@@ -8,7 +9,7 @@ from .client.track import track, TrackResult
 from .client.identify import identify
 from .client.conversion import conversion, ConversionResult
 
-__version__ = "0.1.0"
+__version__ = "0.7.0"
 
 
 def init(
@@ -61,12 +62,6 @@ def visitor_id() -> Optional[str]:
     return ctx.visitor_id if ctx else None
 
 
-def session_id() -> Optional[str]:
-    """Get current session ID from context."""
-    ctx = get_context()
-    return ctx.session_id if ctx else None
-
-
 def user_id() -> Optional[str]:
     """Get current user ID from context."""
     ctx = get_context()
@@ -79,7 +74,6 @@ __all__ = [
     "conversion",
     "identify",
     "visitor_id",
-    "session_id",
     "user_id",
     "TrackResult",
     "ConversionResult",

{mbuzz-0.1.1 → mbuzz-0.7.0}/src/mbuzz/client/conversion.py

@@ -1,4 +1,5 @@
 """Conversion request for tracking conversions."""
+# NOTE: Session ID removed in 0.7.0 - server handles session resolution
 
 from dataclasses import dataclass
 from typing import Any, Dict, Optional, Union
@@ -26,6 +27,9 @@ def conversion(
     is_acquisition: bool = False,
     inherit_acquisition: bool = False,
     properties: Optional[Dict[str, Any]] = None,
+    ip: Optional[str] = None,
+    user_agent: Optional[str] = None,
+    identifier: Optional[Dict[str, str]] = None,
 ) -> ConversionResult:
     """Track a conversion.
 
@@ -39,6 +43,9 @@ def conversion(
         is_acquisition: Whether this is a customer acquisition
         inherit_acquisition: Whether to inherit acquisition from previous conversion
         properties: Additional conversion properties
+        ip: Client IP address for server-side session resolution
+        user_agent: Client user agent for server-side session resolution
+        identifier: Cross-device identifier (email, user_id, etc.)
 
     Returns:
         ConversionResult with success status, conversion ID, and attribution data
@@ -47,22 +54,36 @@ def conversion(
 
     visitor_id = visitor_id or (ctx.visitor_id if ctx else None)
     user_id = user_id or (ctx.user_id if ctx else None)
+    ip = ip or (ctx.ip if ctx else None)
+    user_agent = user_agent or (ctx.user_agent if ctx else None)
 
     if not visitor_id and not user_id:
         return ConversionResult(success=False)
 
-    payload = {
+    payload: Dict[str, Any] = {
         "conversion_type": conversion_type,
-        "visitor_id": visitor_id,
-        "user_id": str(user_id) if user_id else None,
-        "event_id": event_id,
-        "revenue": revenue,
         "currency": currency,
         "is_acquisition": is_acquisition,
         "inherit_acquisition": inherit_acquisition,
         "properties": properties or {},
     }
 
+    # Only include non-None values
+    if visitor_id:
+        payload["visitor_id"] = visitor_id
+    if user_id:
+        payload["user_id"] = str(user_id)
+    if event_id:
+        payload["event_id"] = event_id
+    if revenue is not None:
+        payload["revenue"] = revenue
+    if ip:
+        payload["ip"] = ip
+    if user_agent:
+        payload["user_agent"] = user_agent
+    if identifier:
+        payload["identifier"] = identifier
+
     response = post_with_response("/conversions", payload)
     if not response:
         return ConversionResult(success=False)

{mbuzz-0.1.1 → mbuzz-0.7.0}/src/mbuzz/client/track.py

@@ -1,4 +1,5 @@
 """Track request for event tracking."""
+# NOTE: Session ID removed in 0.7.0 - server handles session resolution
 
 from dataclasses import dataclass
 from datetime import datetime, timezone
@@ -16,7 +17,6 @@ class TrackResult:
     event_id: Optional[str] = None
     event_type: Optional[str] = None
     visitor_id: Optional[str] = None
-    session_id: Optional[str] = None
 
 
 @dataclass
@@ -25,13 +25,15 @@ class TrackOptions:
 
     event_type: str
     visitor_id: Optional[str] = None
-    session_id: Optional[str] = None
     user_id: Optional[str] = None
     properties: Optional[Dict[str, Any]] = None
+    ip: Optional[str] = None
+    user_agent: Optional[str] = None
+    identifier: Optional[Dict[str, str]] = None
 
 
 def _resolve_ids(options: TrackOptions) -> TrackOptions:
-    """Resolve visitor/session/user IDs from context if not provided."""
+    """Resolve visitor/user IDs and ip/user_agent from context if not provided."""
     ctx = get_context()
     if not ctx:
         return options
@@ -39,9 +41,11 @@ def _resolve_ids(options: TrackOptions) -> TrackOptions:
     return TrackOptions(
         event_type=options.event_type,
         visitor_id=options.visitor_id or ctx.visitor_id,
-        session_id=options.session_id or ctx.session_id,
         user_id=options.user_id or ctx.user_id,
         properties=options.properties,
+        ip=options.ip or ctx.ip,
+        user_agent=options.user_agent or ctx.user_agent,
+        identifier=options.identifier,
     )
 
 
@@ -62,19 +66,26 @@ def _validate(options: TrackOptions) -> bool:
 
 def _build_payload(options: TrackOptions, properties: Dict[str, Any]) -> Dict[str, Any]:
     """Build API payload from options."""
-    return {
-        "events": [
-            {
-                "event_type": options.event_type,
-                "visitor_id": options.visitor_id,
-                "session_id": options.session_id,
-                "user_id": options.user_id,
-                "properties": properties,
-                "timestamp": datetime.now(timezone.utc).isoformat(),
-            }
-        ]
+    event: Dict[str, Any] = {
+        "event_type": options.event_type,
+        "properties": properties,
+        "timestamp": datetime.now(timezone.utc).isoformat(),
     }
 
+    # Only include non-None values
+    if options.visitor_id:
+        event["visitor_id"] = options.visitor_id
+    if options.user_id:
+        event["user_id"] = options.user_id
+    if options.ip:
+        event["ip"] = options.ip
+    if options.user_agent:
+        event["user_agent"] = options.user_agent
+    if options.identifier:
+        event["identifier"] = options.identifier
+
+    return {"events": [event]}
+
 
 def _parse_response(response: Optional[Dict[str, Any]], options: TrackOptions) -> TrackResult:
     """Parse API response into TrackResult."""
@@ -87,25 +98,28 @@ def _parse_response(response: Optional[Dict[str, Any]], options: TrackOptions) -
         event_id=event.get("id"),
         event_type=options.event_type,
         visitor_id=options.visitor_id,
-        session_id=options.session_id,
     )
 
 
 def track(
     event_type: str,
     visitor_id: Optional[str] = None,
-    session_id: Optional[str] = None,
     user_id: Optional[str] = None,
     properties: Optional[Dict[str, Any]] = None,
+    ip: Optional[str] = None,
+    user_agent: Optional[str] = None,
+    identifier: Optional[Dict[str, str]] = None,
 ) -> TrackResult:
     """Track an event.
 
     Args:
         event_type: Type of event (e.g., "page_view", "button_click")
         visitor_id: Visitor ID (uses context if not provided)
-        session_id: Session ID (uses context if not provided)
         user_id: User ID (uses context if not provided)
         properties: Additional event properties
+        ip: Client IP address for server-side session resolution
+        user_agent: Client user agent for server-side session resolution
+        identifier: Cross-device identifier (email, user_id, etc.)
 
     Returns:
         TrackResult with success status and event details
@@ -113,9 +127,11 @@ def track(
     options = TrackOptions(
         event_type=event_type,
         visitor_id=visitor_id,
-        session_id=session_id,
         user_id=user_id,
         properties=properties,
+        ip=ip,
+        user_agent=user_agent,
+        identifier=identifier,
     )
 
     options = _resolve_ids(options)

{mbuzz-0.1.1 → mbuzz-0.7.0}/src/mbuzz/context.py

@@ -1,4 +1,5 @@
 """Request context management using contextvars."""
+# NOTE: Session ID removed in 0.7.0 - server handles session resolution
 
 from contextvars import ContextVar
 from dataclasses import dataclass
@@ -10,7 +11,8 @@ class RequestContext:
     """Holds request-scoped data for tracking."""
 
     visitor_id: str
-    session_id: str
+    ip: str
+    user_agent: str
     user_id: Optional[str] = None
     url: Optional[str] = None
     referrer: Optional[str] = None

{mbuzz-0.1.1 → mbuzz-0.7.0}/src/mbuzz/cookies.py

@@ -1,7 +1,5 @@
 """Cookie constants for mbuzz SDK."""
+# NOTE: Session cookie removed in 0.7.0 - server handles session resolution
 
 VISITOR_COOKIE = "_mbuzz_vid"
-SESSION_COOKIE = "_mbuzz_sid"
-
 VISITOR_MAX_AGE = 63072000  # 2 years in seconds
-SESSION_MAX_AGE = 1800  # 30 minutes in seconds

{mbuzz-0.1.1 → mbuzz-0.7.0}/src/mbuzz/middleware/flask.py

@@ -1,15 +1,12 @@
 """Flask middleware for mbuzz tracking."""
+# NOTE: Session cookie removed in 0.7.0 - server handles session resolution
 
-import threading
 from flask import Flask, request, g, Response
-from typing import Optional
 
 from ..config import config
 from ..context import RequestContext, set_context, clear_context
-from ..cookies import VISITOR_COOKIE, SESSION_COOKIE, VISITOR_MAX_AGE, SESSION_MAX_AGE
+from ..cookies import VISITOR_COOKIE, VISITOR_MAX_AGE
 from ..utils.identifier import generate_id
-from ..utils.session_id import generate_deterministic, generate_from_fingerprint
-from ..client.session import create_session
 
 
 def init_app(app: Flask) -> None:
@@ -21,12 +18,11 @@ def init_app(app: Flask) -> None:
             return
 
         visitor_id = _get_or_create_visitor_id()
-        session_id = _get_or_create_session_id()
-        is_new_session = SESSION_COOKIE not in request.cookies
+        ip = _get_client_ip()
+        user_agent = _get_user_agent()
 
-        _set_request_context(visitor_id, session_id)
-        _store_in_g(visitor_id, session_id, is_new_session)
-        _create_session_if_new(visitor_id, session_id, is_new_session)
+        _set_request_context(visitor_id, ip, user_agent)
+        _store_in_g(visitor_id)
 
     @app.after_request
     def after_request(response: Response) -> Response:
@@ -55,19 +51,6 @@ def _get_or_create_visitor_id() -> str:
     return request.cookies.get(VISITOR_COOKIE) or generate_id()
 
 
-def _get_or_create_session_id() -> str:
-    """Get session ID from cookie or generate deterministic one."""
-    existing = request.cookies.get(SESSION_COOKIE)
-    if existing:
-        return existing
-
-    existing_visitor_id = request.cookies.get(VISITOR_COOKIE)
-    if existing_visitor_id:
-        return generate_deterministic(existing_visitor_id)
-    else:
-        return generate_from_fingerprint(_get_client_ip(), _get_user_agent())
-
-
 def _get_client_ip() -> str:
     """Get client IP from request headers."""
     forwarded = request.headers.get("X-Forwarded-For", "")
@@ -81,11 +64,12 @@ def _get_user_agent() -> str:
     return request.headers.get("User-Agent", "unknown")
 
 
-def _set_request_context(visitor_id: str, session_id: str) -> None:
+def _set_request_context(visitor_id: str, ip: str, user_agent: str) -> None:
     """Set request context for tracking calls."""
     ctx = RequestContext(
         visitor_id=visitor_id,
-        session_id=session_id,
+        ip=ip,
+        user_agent=user_agent,
         user_id=None,
         url=request.url,
         referrer=request.referrer,
@@ -93,34 +77,14 @@ def _set_request_context(visitor_id: str, session_id: str) -> None:
     set_context(ctx)
 
 
-def _store_in_g(visitor_id: str, session_id: str, is_new_session: bool) -> None:
+def _store_in_g(visitor_id: str) -> None:
     """Store tracking IDs in Flask g object for after_request."""
     g.mbuzz_visitor_id = visitor_id
-    g.mbuzz_session_id = session_id
     g.mbuzz_is_new_visitor = VISITOR_COOKIE not in request.cookies
-    g.mbuzz_is_new_session = is_new_session
-
-
-def _create_session_if_new(visitor_id: str, session_id: str, is_new_session: bool) -> None:
-    """Create session asynchronously if new session."""
-    if not is_new_session:
-        return
-
-    ctx = RequestContext(
-        visitor_id=visitor_id,
-        session_id=session_id,
-        url=request.url,
-        referrer=request.referrer,
-    )
-    threading.Thread(
-        target=create_session,
-        args=(visitor_id, session_id, ctx.url, ctx.referrer),
-        daemon=True
-    ).start()
 
 
 def _set_cookies(response: Response) -> None:
-    """Set visitor and session cookies on response."""
+    """Set visitor cookie on response."""
     secure = request.is_secure
 
     response.set_cookie(
@@ -131,11 +95,3 @@ def _set_cookies(response: Response) -> None:
         samesite="Lax",
         secure=secure,
     )
-    response.set_cookie(
-        SESSION_COOKIE,
-        g.mbuzz_session_id,
-        max_age=SESSION_MAX_AGE,
-        httponly=True,
-        samesite="Lax",
-        secure=secure,
-    )

{mbuzz-0.1.1 → mbuzz-0.7.0}/tests/test_client.py

@@ -7,7 +7,6 @@ from datetime import datetime, timezone
 from mbuzz.client.track import track, TrackResult
 from mbuzz.client.identify import identify
 from mbuzz.client.conversion import conversion, ConversionResult
-from mbuzz.client.session import create_session
 from mbuzz.context import RequestContext, set_context, clear_context
 from mbuzz.config import config
 
@@ -52,7 +51,11 @@ class TestTrack:
     def test_uses_context_visitor_id(self, mock_post):
         """Should use visitor_id from context."""
         mock_post.return_value = {"events": [{"id": "evt_123"}]}
-        set_context(RequestContext(visitor_id="ctx_vid", session_id="ctx_sid"))
+        set_context(RequestContext(
+            visitor_id="ctx_vid",
+            ip="192.168.1.1",
+            user_agent="Mozilla/5.0",
+        ))
 
         result = track(event_type="page_view")
         assert result.success is True
@@ -67,7 +70,8 @@ class TestTrack:
         mock_post.return_value = {"events": [{"id": "evt_123"}]}
         set_context(RequestContext(
             visitor_id="vid_123",
-            session_id="sid_456",
+            ip="192.168.1.1",
+            user_agent="Mozilla/5.0",
             url="https://example.com/page",
             referrer="https://google.com",
         ))
@@ -89,7 +93,6 @@ class TestTrack:
         track(
             event_type="button_click",
             visitor_id="vid_123",
-            session_id="sid_456",
             properties={"button": "signup"},
         )
 
@@ -100,7 +103,6 @@ class TestTrack:
         event = payload["events"][0]
         assert event["event_type"] == "button_click"
         assert event["visitor_id"] == "vid_123"
-        assert event["session_id"] == "sid_456"
         assert event["properties"]["button"] == "signup"
         assert "timestamp" in event
 
@@ -112,6 +114,112 @@ class TestTrack:
         result = track(event_type="page_view", visitor_id="vid_123")
         assert result.success is False
 
+    @patch("mbuzz.client.track.post_with_response")
+    def test_accepts_ip_parameter(self, mock_post):
+        """Should accept and forward ip parameter."""
+        mock_post.return_value = {"events": [{"id": "evt_123"}]}
+
+        result = track(
+            event_type="page_view",
+            visitor_id="vid_123",
+            ip="192.168.1.100"
+        )
+        assert result.success is True
+
+        call_args = mock_post.call_args[0]
+        payload = call_args[1]
+        assert payload["events"][0]["ip"] == "192.168.1.100"
+
+    @patch("mbuzz.client.track.post_with_response")
+    def test_accepts_user_agent_parameter(self, mock_post):
+        """Should accept and forward user_agent parameter."""
+        mock_post.return_value = {"events": [{"id": "evt_123"}]}
+
+        result = track(
+            event_type="page_view",
+            visitor_id="vid_123",
+            user_agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)"
+        )
+        assert result.success is True
+
+        call_args = mock_post.call_args[0]
+        payload = call_args[1]
+        assert payload["events"][0]["user_agent"] == "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)"
+
+    @patch("mbuzz.client.track.post_with_response")
+    def test_accepts_both_ip_and_user_agent(self, mock_post):
+        """Should accept both ip and user_agent parameters."""
+        mock_post.return_value = {"events": [{"id": "evt_123"}]}
+
+        result = track(
+            event_type="page_view",
+            visitor_id="vid_123",
+            ip="10.0.0.1",
+            user_agent="Chrome/120"
+        )
+        assert result.success is True
+
+        call_args = mock_post.call_args[0]
+        payload = call_args[1]
+        assert payload["events"][0]["ip"] == "10.0.0.1"
+        assert payload["events"][0]["user_agent"] == "Chrome/120"
+
+    @patch("mbuzz.client.track.post_with_response")
+    def test_uses_context_ip_and_user_agent(self, mock_post):
+        """Should use ip and user_agent from context if not explicitly provided."""
+        mock_post.return_value = {"events": [{"id": "evt_123"}]}
+        set_context(RequestContext(
+            visitor_id="ctx_vid",
+            ip="203.0.113.50",
+            user_agent="Safari/17.0",
+        ))
+
+        result = track(event_type="page_view")
+        assert result.success is True
+
+        call_args = mock_post.call_args[0]
+        payload = call_args[1]
+        assert payload["events"][0]["ip"] == "203.0.113.50"
+        assert payload["events"][0]["user_agent"] == "Safari/17.0"
+
+    @patch("mbuzz.client.track.post_with_response")
+    def test_explicit_ip_overrides_context(self, mock_post):
+        """Should use explicit ip/user_agent over context."""
+        mock_post.return_value = {"events": [{"id": "evt_123"}]}
+        set_context(RequestContext(
+            visitor_id="ctx_vid",
+            ip="context_ip",
+            user_agent="context_ua",
+        ))
+
+        result = track(
+            event_type="page_view",
+            ip="explicit_ip",
+            user_agent="explicit_ua"
+        )
+        assert result.success is True
+
+        call_args = mock_post.call_args[0]
+        payload = call_args[1]
+        assert payload["events"][0]["ip"] == "explicit_ip"
+        assert payload["events"][0]["user_agent"] == "explicit_ua"
+
+    @patch("mbuzz.client.track.post_with_response")
+    def test_accepts_identifier_parameter(self, mock_post):
+        """Should accept and forward identifier parameter."""
+        mock_post.return_value = {"events": [{"id": "evt_123"}]}
+
+        result = track(
+            event_type="page_view",
+            visitor_id="vid_123",
+            identifier={"email": "test@example.com"}
+        )
+        assert result.success is True
+
+        call_args = mock_post.call_args[0]
+        payload = call_args[1]
+        assert payload["events"][0]["identifier"] == {"email": "test@example.com"}
+
 
 class TestIdentify:
     """Test identify function."""
@@ -147,7 +255,11 @@ class TestIdentify:
     def test_uses_context_visitor_id(self, mock_post):
         """Should use visitor_id from context."""
         mock_post.return_value = True
-        set_context(RequestContext(visitor_id="ctx_vid", session_id="ctx_sid"))
+        set_context(RequestContext(
+            visitor_id="ctx_vid",
+            ip="192.168.1.1",
+            user_agent="Mozilla/5.0",
+        ))
 
         identify(user_id="user_123")
 
@@ -218,7 +330,11 @@ class TestConversion:
     def test_uses_context_visitor_id(self, mock_post):
         """Should use visitor_id from context."""
         mock_post.return_value = {"conversion": {"id": "conv_123"}}
-        set_context(RequestContext(visitor_id="ctx_vid", session_id="ctx_sid"))
+        set_context(RequestContext(
+            visitor_id="ctx_vid",
+            ip="192.168.1.1",
+            user_agent="Mozilla/5.0",
+        ))
 
         result = conversion(conversion_type="purchase")
         assert result.success is True
@@ -262,61 +378,36 @@ class TestConversion:
         result = conversion(conversion_type="purchase", visitor_id="vid_123")
         assert result.attribution == {"model": "linear", "sessions": []}
 
+    @patch("mbuzz.client.conversion.post_with_response")
+    def test_accepts_ip_and_user_agent(self, mock_post):
+        """Should accept and forward ip and user_agent parameters."""
+        mock_post.return_value = {"conversion": {"id": "conv_123"}}
 
-class TestCreateSession:
-    """Test create_session function."""
-
-    def setup_method(self):
-        """Set up before each test."""
-        config.reset()
-        config.init(api_key="sk_test_123", api_url="http://localhost:3000/api/v1")
-
-    def teardown_method(self):
-        """Clean up after each test."""
-        config.reset()
-
-    @patch("mbuzz.client.session.post")
-    def test_returns_true_on_success(self, mock_post):
-        """Should return True on success."""
-        mock_post.return_value = True
-
-        result = create_session(
+        result = conversion(
+            conversion_type="purchase",
             visitor_id="vid_123",
-            session_id="sid_456",
-            url="https://example.com",
+            ip="192.168.1.100",
+            user_agent="Mozilla/5.0",
         )
-        assert result is True
+        assert result.success is True
 
-    @patch("mbuzz.client.session.post")
-    def test_sends_correct_payload(self, mock_post):
-        """Should send correctly structured payload."""
-        mock_post.return_value = True
+        call_args = mock_post.call_args[0]
+        payload = call_args[1]
+        assert payload["ip"] == "192.168.1.100"
+        assert payload["user_agent"] == "Mozilla/5.0"
 
-        create_session(
-            visitor_id="vid_123",
-            session_id="sid_456",
-            url="https://example.com/page",
-            referrer="https://google.com",
-        )
+    @patch("mbuzz.client.conversion.post_with_response")
+    def test_accepts_identifier_parameter(self, mock_post):
+        """Should accept and forward identifier parameter."""
+        mock_post.return_value = {"conversion": {"id": "conv_123"}}
 
-        call_args = mock_post.call_args
-        assert call_args[0][0] == "/sessions"
-        payload = call_args[0][1]
-        session = payload["session"]
-        assert session["visitor_id"] == "vid_123"
-        assert session["session_id"] == "sid_456"
-        assert session["url"] == "https://example.com/page"
-        assert session["referrer"] == "https://google.com"
-        assert "started_at" in session
-
-    @patch("mbuzz.client.session.post")
-    def test_returns_false_on_api_error(self, mock_post):
-        """Should return False on API error."""
-        mock_post.return_value = False
-
-        result = create_session(
+        result = conversion(
+            conversion_type="purchase",
             visitor_id="vid_123",
-            session_id="sid_456",
-            url="https://example.com",
+            identifier={"email": "test@example.com"}
         )
-        assert result is False
+        assert result.success is True
+
+        call_args = mock_post.call_args[0]
+        payload = call_args[1]
+        assert payload["identifier"] == {"email": "test@example.com"}

{mbuzz-0.1.1 → mbuzz-0.7.0}/tests/test_context.py

@@ -8,14 +8,23 @@ class TestRequestContext:
     """Test RequestContext dataclass."""
 
     def test_creates_with_required_fields(self):
-        """Should create context with visitor and session IDs."""
-        ctx = RequestContext(visitor_id="vid_123", session_id="sid_456")
+        """Should create context with visitor_id, ip, and user_agent."""
+        ctx = RequestContext(
+            visitor_id="vid_123",
+            ip="192.168.1.1",
+            user_agent="Mozilla/5.0",
+        )
         assert ctx.visitor_id == "vid_123"
-        assert ctx.session_id == "sid_456"
+        assert ctx.ip == "192.168.1.1"
+        assert ctx.user_agent == "Mozilla/5.0"
 
     def test_optional_fields_default_to_none(self):
         """Should default optional fields to None."""
-        ctx = RequestContext(visitor_id="vid_123", session_id="sid_456")
+        ctx = RequestContext(
+            visitor_id="vid_123",
+            ip="192.168.1.1",
+            user_agent="Mozilla/5.0",
+        )
         assert ctx.user_id is None
         assert ctx.url is None
         assert ctx.referrer is None
@@ -24,13 +33,15 @@ class TestRequestContext:
         """Should accept all fields."""
         ctx = RequestContext(
             visitor_id="vid_123",
-            session_id="sid_456",
+            ip="192.168.1.1",
+            user_agent="Mozilla/5.0",
             user_id="user_789",
             url="https://example.com/page",
             referrer="https://google.com",
         )
         assert ctx.visitor_id == "vid_123"
-        assert ctx.session_id == "sid_456"
+        assert ctx.ip == "192.168.1.1"
+        assert ctx.user_agent == "Mozilla/5.0"
         assert ctx.user_id == "user_789"
         assert ctx.url == "https://example.com/page"
         assert ctx.referrer == "https://google.com"
@@ -43,7 +54,8 @@ class TestEnrichProperties:
         """Should add url to properties."""
         ctx = RequestContext(
             visitor_id="vid_123",
-            session_id="sid_456",
+            ip="192.168.1.1",
+            user_agent="Mozilla/5.0",
             url="https://example.com/page",
         )
         result = ctx.enrich_properties({})
@@ -53,7 +65,8 @@ class TestEnrichProperties:
         """Should add referrer to properties."""
         ctx = RequestContext(
             visitor_id="vid_123",
-            session_id="sid_456",
+            ip="192.168.1.1",
+            user_agent="Mozilla/5.0",
             referrer="https://google.com",
         )
         result = ctx.enrich_properties({})
@@ -63,7 +76,8 @@ class TestEnrichProperties:
         """Custom properties should override context values."""
         ctx = RequestContext(
             visitor_id="vid_123",
-            session_id="sid_456",
+            ip="192.168.1.1",
+            user_agent="Mozilla/5.0",
             url="https://example.com/page",
         )
         result = ctx.enrich_properties({"url": "custom_url"})
@@ -73,7 +87,8 @@ class TestEnrichProperties:
         """Should preserve custom properties."""
         ctx = RequestContext(
             visitor_id="vid_123",
-            session_id="sid_456",
+            ip="192.168.1.1",
+            user_agent="Mozilla/5.0",
             url="https://example.com/page",
         )
         result = ctx.enrich_properties({"custom": "value", "count": 42})
@@ -83,7 +98,11 @@ class TestEnrichProperties:
 
     def test_handles_empty_context(self):
         """Should work with no url or referrer in context."""
-        ctx = RequestContext(visitor_id="vid_123", session_id="sid_456")
+        ctx = RequestContext(
+            visitor_id="vid_123",
+            ip="192.168.1.1",
+            user_agent="Mozilla/5.0",
+        )
         result = ctx.enrich_properties({"custom": "value"})
         assert result == {"custom": "value"}
         assert "url" not in result
@@ -107,21 +126,37 @@ class TestContextVar:
 
     def test_set_context_stores_context(self):
         """Should store context."""
-        ctx = RequestContext(visitor_id="vid_123", session_id="sid_456")
+        ctx = RequestContext(
+            visitor_id="vid_123",
+            ip="192.168.1.1",
+            user_agent="Mozilla/5.0",
+        )
         set_context(ctx)
         assert get_context() is ctx
 
     def test_clear_context_removes_context(self):
         """Should clear stored context."""
-        ctx = RequestContext(visitor_id="vid_123", session_id="sid_456")
+        ctx = RequestContext(
+            visitor_id="vid_123",
+            ip="192.168.1.1",
+            user_agent="Mozilla/5.0",
+        )
         set_context(ctx)
         clear_context()
         assert get_context() is None
 
     def test_context_is_isolated_per_context(self):
         """Context should be isolated (uses contextvars)."""
-        ctx1 = RequestContext(visitor_id="vid_1", session_id="sid_1")
-        ctx2 = RequestContext(visitor_id="vid_2", session_id="sid_2")
+        ctx1 = RequestContext(
+            visitor_id="vid_1",
+            ip="192.168.1.1",
+            user_agent="Mozilla/5.0",
+        )
+        ctx2 = RequestContext(
+            visitor_id="vid_2",
+            ip="192.168.1.2",
+            user_agent="Chrome/120",
+        )
 
         set_context(ctx1)
         assert get_context().visitor_id == "vid_1"

{mbuzz-0.1.1 → mbuzz-0.7.0}/tests/test_middleware.py

@@ -7,7 +7,7 @@ from flask import Flask, g
 from mbuzz.middleware.flask import init_app
 from mbuzz.config import config
 from mbuzz.context import get_context, clear_context
-from mbuzz.cookies import VISITOR_COOKIE, SESSION_COOKIE, VISITOR_MAX_AGE, SESSION_MAX_AGE
+from mbuzz.cookies import VISITOR_COOKIE, VISITOR_MAX_AGE
 
 
 class TestFlaskMiddleware:
@@ -100,8 +100,8 @@ class TestFlaskMiddleware:
             assert visitor_cookie is not None
             assert VISITOR_COOKIE in visitor_cookie
 
-    def test_creates_session_id_for_new_visitor(self):
-        """Should create session ID for new visitor."""
+    def test_only_sets_visitor_cookie(self):
+        """Should only set visitor cookie (no session cookie)."""
         config.init(api_key="sk_test_123")
         init_app(self.app)
 
@@ -109,12 +109,10 @@ class TestFlaskMiddleware:
             response = client.get("/")
 
             cookies = response.headers.getlist("Set-Cookie")
-            session_cookie = next(
-                (c for c in cookies if SESSION_COOKIE in c), None
-            )
-
-            assert session_cookie is not None
-            assert SESSION_COOKIE in session_cookie
+            # Should only have one cookie (visitor)
+            mbuzz_cookies = [c for c in cookies if "_mbuzz_" in c]
+            assert len(mbuzz_cookies) == 1
+            assert VISITOR_COOKIE in mbuzz_cookies[0]
 
     def test_reuses_visitor_id_from_cookie(self):
         """Should reuse existing visitor ID from cookie."""
@@ -134,24 +132,6 @@ class TestFlaskMiddleware:
 
             assert existing_vid in visitor_cookie
 
-    def test_reuses_session_id_from_cookie(self):
-        """Should reuse existing session ID from cookie."""
-        config.init(api_key="sk_test_123")
-        init_app(self.app)
-
-        existing_sid = "xyz789" * 10 + "xyzw"
-
-        with self.app.test_client() as client:
-            client.set_cookie(SESSION_COOKIE, existing_sid)
-            response = client.get("/")
-
-            cookies = response.headers.getlist("Set-Cookie")
-            session_cookie = next(
-                (c for c in cookies if SESSION_COOKIE in c), None
-            )
-
-            assert existing_sid in session_cookie
-
     def test_sets_context_during_request(self):
         """Should set request context during request handling."""
         config.init(api_key="sk_test_123")
@@ -164,7 +144,8 @@ class TestFlaskMiddleware:
             ctx = get_context()
             if ctx:
                 captured_context["visitor_id"] = ctx.visitor_id
-                captured_context["session_id"] = ctx.session_id
+                captured_context["ip"] = ctx.ip
+                captured_context["user_agent"] = ctx.user_agent
                 captured_context["url"] = ctx.url
             return "captured"
 
@@ -172,9 +153,9 @@ class TestFlaskMiddleware:
             client.get("/capture")
 
             assert "visitor_id" in captured_context
-            assert "session_id" in captured_context
+            assert "ip" in captured_context
+            assert "user_agent" in captured_context
             assert len(captured_context["visitor_id"]) == 64
-            assert len(captured_context["session_id"]) == 64
 
     def test_clears_context_after_request(self):
         """Should clear context after request completes."""
@@ -225,33 +206,6 @@ class TestFlaskMiddleware:
 
             assert captured_referrer.get("referrer") == "https://google.com"
 
-    @patch("mbuzz.middleware.flask.create_session")
-    def test_calls_create_session_for_new_session(self, mock_create_session):
-        """Should call create_session for new sessions."""
-        config.init(api_key="sk_test_123")
-        init_app(self.app)
-
-        with self.app.test_client() as client:
-            client.get("/")
-
-            # Give thread time to start
-            import time
-            time.sleep(0.1)
-
-            assert mock_create_session.called
-
-    @patch("mbuzz.middleware.flask.create_session")
-    def test_does_not_call_create_session_for_existing_session(self, mock_create_session):
-        """Should not call create_session for existing sessions."""
-        config.init(api_key="sk_test_123")
-        init_app(self.app)
-
-        with self.app.test_client() as client:
-            client.set_cookie(SESSION_COOKIE, "existing_session_id_abc123")
-            client.get("/")
-
-            assert not mock_create_session.called
-
     def test_sets_visitor_cookie_max_age(self):
         """Should set visitor cookie with correct max age."""
         config.init(api_key="sk_test_123")
@@ -267,21 +221,6 @@ class TestFlaskMiddleware:
 
             assert f"Max-Age={VISITOR_MAX_AGE}" in visitor_cookie
 
-    def test_sets_session_cookie_max_age(self):
-        """Should set session cookie with correct max age."""
-        config.init(api_key="sk_test_123")
-        init_app(self.app)
-
-        with self.app.test_client() as client:
-            response = client.get("/")
-
-            cookies = response.headers.getlist("Set-Cookie")
-            session_cookie = next(
-                (c for c in cookies if SESSION_COOKIE in c), None
-            )
-
-            assert f"Max-Age={SESSION_MAX_AGE}" in session_cookie
-
     def test_sets_httponly_on_cookies(self):
         """Should set HttpOnly flag on cookies."""
         config.init(api_key="sk_test_123")
@@ -294,12 +233,8 @@ class TestFlaskMiddleware:
             visitor_cookie = next(
                 (c for c in cookies if VISITOR_COOKIE in c), None
             )
-            session_cookie = next(
-                (c for c in cookies if SESSION_COOKIE in c), None
-            )
 
             assert "HttpOnly" in visitor_cookie
-            assert "HttpOnly" in session_cookie
 
     def test_sets_samesite_lax_on_cookies(self):
         """Should set SameSite=Lax on cookies."""
@@ -313,12 +248,8 @@ class TestFlaskMiddleware:
             visitor_cookie = next(
                 (c for c in cookies if VISITOR_COOKIE in c), None
             )
-            session_cookie = next(
-                (c for c in cookies if SESSION_COOKIE in c), None
-            )
 
             assert "SameSite=Lax" in visitor_cookie
-            assert "SameSite=Lax" in session_cookie
 
     def test_generates_64_char_visitor_id(self):
         """Should generate 64-character visitor ID."""
@@ -339,24 +270,43 @@ class TestFlaskMiddleware:
 
             assert len(captured.get("visitor_id", "")) == 64
 
-    def test_generates_64_char_session_id(self):
-        """Should generate 64-character session ID."""
+    def test_captures_ip_from_x_forwarded_for(self):
+        """Should capture client IP from X-Forwarded-For header."""
         config.init(api_key="sk_test_123")
         init_app(self.app)
 
         captured = {}
 
-        @self.app.route("/check")
-        def check():
+        @self.app.route("/check-ip")
+        def check_ip():
             ctx = get_context()
             if ctx:
-                captured["session_id"] = ctx.session_id
+                captured["ip"] = ctx.ip
             return "ok"
 
         with self.app.test_client() as client:
-            client.get("/check")
+            client.get("/check-ip", headers={"X-Forwarded-For": "203.0.113.50, 198.51.100.1"})
+
+            assert captured.get("ip") == "203.0.113.50"
+
+    def test_captures_user_agent(self):
+        """Should capture user agent from request."""
+        config.init(api_key="sk_test_123")
+        init_app(self.app)
+
+        captured = {}
+
+        @self.app.route("/check-ua")
+        def check_ua():
+            ctx = get_context()
+            if ctx:
+                captured["user_agent"] = ctx.user_agent
+            return "ok"
+
+        with self.app.test_client() as client:
+            client.get("/check-ua", headers={"User-Agent": "Mozilla/5.0 Test"})
 
-            assert len(captured.get("session_id", "")) == 64
+            assert captured.get("user_agent") == "Mozilla/5.0 Test"
 
     def test_skips_custom_paths(self):
         """Should skip custom skip paths."""

mbuzz-0.1.1/src/mbuzz/client/session.py

@@ -1,38 +0,0 @@
-"""Session request for creating sessions."""
-
-from datetime import datetime, timezone
-from typing import Optional
-
-from ..api import post
-
-
-def create_session(
-    visitor_id: str,
-    session_id: str,
-    url: str,
-    referrer: Optional[str] = None,
-) -> bool:
-    """Create a new session.
-
-    Called async from middleware on first request.
-
-    Args:
-        visitor_id: Visitor ID
-        session_id: Session ID
-        url: Current page URL
-        referrer: Referring URL
-
-    Returns:
-        True on success, False on failure
-    """
-    payload = {
-        "session": {
-            "visitor_id": visitor_id,
-            "session_id": session_id,
-            "url": url,
-            "referrer": referrer,
-            "started_at": datetime.now(timezone.utc).isoformat(),
-        }
-    }
-
-    return post("/sessions", payload)

mbuzz-0.1.1/src/mbuzz/utils/session_id.py

@@ -1,39 +0,0 @@
-"""Deterministic session ID generation."""
-
-import hashlib
-import secrets
-import time
-
-SESSION_TIMEOUT_SECONDS = 1800
-SESSION_ID_LENGTH = 64
-FINGERPRINT_LENGTH = 32
-
-
-def generate_deterministic(visitor_id: str, timestamp: int | None = None) -> str:
-    """Generate session ID for returning visitors."""
-    if timestamp is None:
-        timestamp = int(time.time())
-    time_bucket = timestamp // SESSION_TIMEOUT_SECONDS
-    raw = f"{visitor_id}_{time_bucket}"
-    return hashlib.sha256(raw.encode()).hexdigest()[:SESSION_ID_LENGTH]
-
-
-def generate_from_fingerprint(
-    client_ip: str,
-    user_agent: str,
-    timestamp: int | None = None
-) -> str:
-    """Generate session ID for new visitors using IP+UA fingerprint."""
-    if timestamp is None:
-        timestamp = int(time.time())
-    fingerprint = hashlib.sha256(
-        f"{client_ip}|{user_agent}".encode()
-    ).hexdigest()[:FINGERPRINT_LENGTH]
-    time_bucket = timestamp // SESSION_TIMEOUT_SECONDS
-    raw = f"{fingerprint}_{time_bucket}"
-    return hashlib.sha256(raw.encode()).hexdigest()[:SESSION_ID_LENGTH]
-
-
-def generate_random() -> str:
-    """Generate random session ID (fallback)."""
-    return secrets.token_hex(32)

mbuzz-0.1.1/tests/test_session_id.py

@@ -1,146 +0,0 @@
-"""Tests for deterministic session ID generation."""
-
-import pytest
-from mbuzz.utils.session_id import (
-    generate_deterministic,
-    generate_from_fingerprint,
-    generate_random,
-)
-
-
-class TestGenerateDeterministic:
-    sample_visitor_id = "a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2"
-    sample_timestamp = 1735500000
-
-    def test_returns_64_char_hex_string(self):
-        result = generate_deterministic(self.sample_visitor_id, self.sample_timestamp)
-        assert len(result) == 64
-        assert all(c in "0123456789abcdef" for c in result)
-
-    def test_is_consistent(self):
-        result1 = generate_deterministic(self.sample_visitor_id, self.sample_timestamp)
-        result2 = generate_deterministic(self.sample_visitor_id, self.sample_timestamp)
-        assert result1 == result2
-
-    def test_same_within_time_bucket(self):
-        # bucket = timestamp / 1800
-        # 1735500000 / 1800 = 964166
-        # 1735500599 / 1800 = 964166 (last second of bucket)
-        timestamp1 = 1735500000
-        timestamp2 = 1735500001
-        timestamp3 = 1735500599
-
-        result1 = generate_deterministic(self.sample_visitor_id, timestamp1)
-        result2 = generate_deterministic(self.sample_visitor_id, timestamp2)
-        result3 = generate_deterministic(self.sample_visitor_id, timestamp3)
-
-        assert result1 == result2
-        assert result1 == result3
-
-    def test_different_across_time_buckets(self):
-        timestamp1 = 1735500000
-        timestamp2 = 1735501800  # Next bucket
-
-        result1 = generate_deterministic(self.sample_visitor_id, timestamp1)
-        result2 = generate_deterministic(self.sample_visitor_id, timestamp2)
-
-        assert result1 != result2
-
-    def test_different_for_different_visitors(self):
-        result1 = generate_deterministic("visitor_a", self.sample_timestamp)
-        result2 = generate_deterministic("visitor_b", self.sample_timestamp)
-
-        assert result1 != result2
-
-
-class TestGenerateFromFingerprint:
-    sample_ip = "203.0.113.42"
-    sample_user_agent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36"
-    sample_timestamp = 1735500000
-
-    def test_returns_64_char_hex_string(self):
-        result = generate_from_fingerprint(
-            self.sample_ip, self.sample_user_agent, self.sample_timestamp
-        )
-        assert len(result) == 64
-        assert all(c in "0123456789abcdef" for c in result)
-
-    def test_is_consistent(self):
-        result1 = generate_from_fingerprint(
-            self.sample_ip, self.sample_user_agent, self.sample_timestamp
-        )
-        result2 = generate_from_fingerprint(
-            self.sample_ip, self.sample_user_agent, self.sample_timestamp
-        )
-        assert result1 == result2
-
-    def test_same_within_time_bucket(self):
-        timestamp1 = 1735500000
-        timestamp2 = 1735500001
-
-        result1 = generate_from_fingerprint(
-            self.sample_ip, self.sample_user_agent, timestamp1
-        )
-        result2 = generate_from_fingerprint(
-            self.sample_ip, self.sample_user_agent, timestamp2
-        )
-
-        assert result1 == result2
-
-    def test_different_across_time_buckets(self):
-        timestamp1 = 1735500000
-        timestamp2 = 1735501800
-
-        result1 = generate_from_fingerprint(
-            self.sample_ip, self.sample_user_agent, timestamp1
-        )
-        result2 = generate_from_fingerprint(
-            self.sample_ip, self.sample_user_agent, timestamp2
-        )
-
-        assert result1 != result2
-
-    def test_different_for_different_ips(self):
-        result1 = generate_from_fingerprint(
-            "192.168.1.1", self.sample_user_agent, self.sample_timestamp
-        )
-        result2 = generate_from_fingerprint(
-            "192.168.1.2", self.sample_user_agent, self.sample_timestamp
-        )
-
-        assert result1 != result2
-
-    def test_different_for_different_user_agents(self):
-        result1 = generate_from_fingerprint(
-            self.sample_ip, "Mozilla/5.0 Chrome", self.sample_timestamp
-        )
-        result2 = generate_from_fingerprint(
-            self.sample_ip, "Mozilla/5.0 Safari", self.sample_timestamp
-        )
-
-        assert result1 != result2
-
-
-class TestGenerateRandom:
-    def test_returns_64_char_hex_string(self):
-        result = generate_random()
-        assert len(result) == 64
-        assert all(c in "0123456789abcdef" for c in result)
-
-    def test_returns_unique_ids(self):
-        result1 = generate_random()
-        result2 = generate_random()
-        assert result1 != result2
-
-
-class TestCrossMethod:
-    def test_deterministic_and_fingerprint_produce_different_ids(self):
-        visitor_id = "a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2"
-        ip = "203.0.113.42"
-        user_agent = "Mozilla/5.0"
-        timestamp = 1735500000
-
-        deterministic = generate_deterministic(visitor_id, timestamp)
-        fingerprint = generate_from_fingerprint(ip, user_agent, timestamp)
-
-        assert deterministic != fingerprint