growthbook 1.3.0__tar.gz → 1.4.0__tar.gz

{growthbook-1.3.0/growthbook.egg-info → growthbook-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: growthbook
-Version: 1.3.0
+Version: 1.4.0
 Summary: Powerful Feature flagging and A/B testing for Python apps
 Home-page: https://github.com/growthbook/growthbook-python
 Author: GrowthBook

{growthbook-1.3.0 → growthbook-1.4.0}/growthbook/__init__.py

@@ -18,5 +18,5 @@ from .plugins import (
 )
 
 # x-release-please-start-version
-__version__ = "1.3.0"
+__version__ = "1.4.0"
 # x-release-please-end

{growthbook-1.3.0 → growthbook-1.4.0}/growthbook/common_types.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 
 import sys
+from token import OP
 # Only require typing_extensions if using Python 3.7 or earlier
 if sys.version_info >= (3, 8):
     from typing import TypedDict
@@ -8,7 +9,7 @@ else:
     from typing_extensions import TypedDict
 
 from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional, Union, Set, Tuple
+from typing import Any, Callable, Dict, List, Optional, Union, Set, Tuple
 from enum import Enum
 from abc import ABC, abstractmethod
 
@@ -400,6 +401,15 @@ class StackContext:
 class FeatureRefreshStrategy(Enum):
     STALE_WHILE_REVALIDATE = 'HTTP_REFRESH'
     SERVER_SENT_EVENTS = 'SSE'
+@dataclass
+class UserContext:
+    # user_id: Optional[str] = None
+    url: str = ""
+    attributes: Dict[str, Any] = field(default_factory=dict)
+    groups: Dict[str, str] = field(default_factory=dict)
+    forced_variations: Dict[str, Any] = field(default_factory=dict)
+    overrides: Dict[str, Any] = field(default_factory=dict)
+    sticky_bucket_assignment_docs: Dict[str, Any] = field(default_factory=dict)
 
 @dataclass
 class Options:
@@ -415,17 +425,9 @@ class Options:
     refresh_strategy: Optional[FeatureRefreshStrategy] = FeatureRefreshStrategy.STALE_WHILE_REVALIDATE
     sticky_bucket_service: Optional[AbstractStickyBucketService] = None
     sticky_bucket_identifier_attributes: Optional[List[str]] = None
-    on_experiment_viewed=None
+    on_experiment_viewed: Optional[Callable[[Experiment, Result, Optional[UserContext]], None]] = None
+    tracking_plugins: Optional[List[Any]] = None
 
-@dataclass
-class UserContext:
-    # user_id: Optional[str] = None
-    url: str = ""
-    attributes: Dict[str, Any] = field(default_factory=dict)
-    groups: Dict[str, str] = field(default_factory=dict)
-    forced_variations: Dict[str, Any] = field(default_factory=dict)
-    overrides: Dict[str, Any] = field(default_factory=dict)
-    sticky_bucket_assignment_docs: Dict[str, Any] = field(default_factory=dict)
 
 @dataclass
 class GlobalContext:

{growthbook-1.3.0 → growthbook-1.4.0}/growthbook/core.py

@@ -4,7 +4,7 @@ import json
 
 from urllib.parse import urlparse, parse_qs
 from typing import Callable, Optional, Any, Set, Tuple, List, Dict
-from .common_types import EvaluationContext, FeatureResult, Experiment, Filter, Result, VariationMeta
+from .common_types import EvaluationContext, FeatureResult, Experiment, Filter, Result, UserContext, VariationMeta
 
 
 logger = logging.getLogger("growthbook.core")
@@ -413,7 +413,8 @@ def getBucketRanges(
 def eval_feature(
     key: str,
     evalContext: EvaluationContext = None,
-    callback_subscription: Callable[[Experiment, Result], None] = None
+    callback_subscription: Callable[[Experiment, Result], None] = None,
+    tracking_cb: Callable[[Experiment, Result, UserContext], None] = None
 ) -> FeatureResult:
     """Core feature evaluation logic as a standalone function"""
 
@@ -506,7 +507,7 @@ def eval_feature(
             minBucketVersion=rule.minBucketVersion,
         )
 
-        result = run_experiment(experiment=exp, featureId=key, evalContext=evalContext)
+        result = run_experiment(experiment=exp, featureId=key, evalContext=evalContext, tracking_cb=tracking_cb)
 
         if callback_subscription:
             callback_subscription(exp, result)
@@ -633,7 +634,7 @@ def _get_sticky_bucket_variation(
 def run_experiment(experiment: Experiment, 
                    featureId: Optional[str] = None, 
                    evalContext: EvaluationContext = None, 
-                   tracking_cb: Callable[[Experiment, Result], None] = None
+                   tracking_cb: Callable[[Experiment, Result, UserContext], None] = None
                 ) -> Result:
     if evalContext is None:
         raise ValueError("evalContext is required - run_experiment")
@@ -858,7 +859,7 @@ def run_experiment(experiment: Experiment,
 
     # 14. Fire the tracking callback if set
     if tracking_cb:
-        tracking_cb(experiment, result)
+        tracking_cb(experiment, result, evalContext.user)
 
     # 15. Return the result
     logger.debug("Assigned variation %d in experiment %s", assigned, experiment.key)

{growthbook-1.3.0 → growthbook-1.4.0}/growthbook/growthbook.py

@@ -671,7 +671,7 @@ class GrowthBook(object):
         return self.get_feature_value(key, fallback)
 
     def get_feature_value(self, key: str, fallback):
-        res = self.evalFeature(key)
+        res = self.eval_feature(key)
         return res.value if res.value is not None else fallback
 
     # @deprecated, use eval_feature
@@ -708,7 +708,8 @@ class GrowthBook(object):
     def eval_feature(self, key: str) -> FeatureResult:
         return core_eval_feature(key=key, 
                                  evalContext=self._get_eval_context(), 
-                                 callback_subscription=self._fireSubscriptions
+                                 callback_subscription=self._fireSubscriptions,
+                                 tracking_cb=self._track
                                  )
 
     # @deprecated, use get_all_results
@@ -752,7 +753,7 @@ class GrowthBook(object):
         self._subscriptions.add(callback)
         return lambda: self._subscriptions.remove(callback)
 
-    def _track(self, experiment: Experiment, result: Result) -> None:
+    def _track(self, experiment: Experiment, result: Result, user_context: UserContext) -> None:
         if not self._trackingCallback:
             return None
         key = (
@@ -763,7 +764,7 @@ class GrowthBook(object):
         )
         if not self._tracked.get(key):
             try:
-                self._trackingCallback(experiment=experiment, result=result)
+                self._trackingCallback(experiment=experiment, result=result, user_context=user_context)
                 self._tracked[key] = True
             except Exception:
                 pass

{growthbook-1.3.0 → growthbook-1.4.0}/growthbook/growthbook_client.py

@@ -317,6 +317,10 @@ class GrowthBookClient:
         }
         self._sticky_bucket_cache_lock = False
         
+        # Plugin support
+        self._tracking_plugins: List[Any] = self.options.tracking_plugins or []
+        self._initialized_plugins: List[Any] = []
+        
         self._features_repository = (
             EnhancedFeatureRepository(
                 self.options.api_host or "https://cdn.growthbook.io", 
@@ -330,9 +334,12 @@ class GrowthBookClient:
         
         self._global_context: Optional[GlobalContext] = None
         self._context_lock = asyncio.Lock()
+        
+        # Initialize plugins
+        self._initialize_plugins()
 
 
-    def _track(self, experiment: Experiment, result: Result) -> None:
+    def _track(self, experiment: Experiment, result: Result, user_context: UserContext) -> None:
         """Thread-safe tracking implementation"""
         if not self.options.on_experiment_viewed:
             return
@@ -348,7 +355,7 @@ class GrowthBookClient:
         with self._tracked_lock:
             if not self._tracked.get(key):
                 try:
-                    self.options.on_experiment_viewed(experiment=experiment, result=result)
+                    self.options.on_experiment_viewed(experiment, result, user_context)
                     self._tracked[key] = True
                 except Exception:
                     logger.exception("Error in tracking callback")
@@ -492,25 +499,25 @@ class GrowthBookClient:
         """Evaluate a feature with proper async context management"""
         async with self._context_lock:
             context = await self.create_evaluation_context(user_context)
-            result = core_eval_feature(key=key, evalContext=context)
+            result = core_eval_feature(key=key, evalContext=context, tracking_cb=self._track)
             return result
 
     async def is_on(self, key: str, user_context: UserContext) -> bool:
         """Check if a feature is enabled with proper async context management"""
         async with self._context_lock:
             context = await self.create_evaluation_context(user_context)
-            return core_eval_feature(key=key, evalContext=context).on
+            return core_eval_feature(key=key, evalContext=context, tracking_cb=self._track).on
     
     async def is_off(self, key: str, user_context: UserContext) -> bool:
         """Check if a feature is set to off with proper async context management"""
         async with self._context_lock:
             context = await self.create_evaluation_context(user_context)
-            return core_eval_feature(key=key, evalContext=context).off
+            return core_eval_feature(key=key, evalContext=context, tracking_cb=self._track).off
     
     async def get_feature_value(self, key: str, fallback: Any, user_context: UserContext) -> Any:
         async with self._context_lock:
             context = await self.create_evaluation_context(user_context)
-            result = core_eval_feature(key=key, evalContext=context)
+            result = core_eval_feature(key=key, evalContext=context, tracking_cb=self._track)
             return result.value if result.value is not None else fallback
 
     async def run(self, experiment: Experiment, user_context: UserContext) -> Result:
@@ -539,4 +546,37 @@ class GrowthBookClient:
 
         # Clear context
         async with self._context_lock:
-            self._global_context = None
+            self._global_context = None
+            
+        # Cleanup plugins
+        self._cleanup_plugins()
+
+    def _initialize_plugins(self) -> None:
+        """Initialize all tracking plugins with this GrowthBookClient instance."""
+        for plugin in self._tracking_plugins:
+            try:
+                if hasattr(plugin, 'initialize'):
+                    # Plugin is a class instance with initialize method
+                    plugin.initialize(self)
+                    self._initialized_plugins.append(plugin)
+                    logger.debug(f"Initialized plugin: {plugin.__class__.__name__}")
+                elif callable(plugin):
+                    # Plugin is a callable function
+                    plugin(self)
+                    self._initialized_plugins.append(plugin)
+                    logger.debug(f"Initialized callable plugin: {plugin.__name__}")
+                else:
+                    logger.warning(f"Plugin {plugin} is neither callable nor has initialize method")
+            except Exception as e:
+                logger.error(f"Failed to initialize plugin {plugin}: {e}")
+
+    def _cleanup_plugins(self) -> None:
+        """Cleanup all initialized plugins."""
+        for plugin in self._initialized_plugins:
+            try:
+                if hasattr(plugin, 'cleanup'):
+                    plugin.cleanup()
+                    logger.debug(f"Cleaned up plugin: {plugin.__class__.__name__}")
+            except Exception as e:
+                logger.error(f"Error cleaning up plugin {plugin}: {e}")
+        self._initialized_plugins.clear()

{growthbook-1.3.0 → growthbook-1.4.0}/growthbook/plugins/growthbook_tracking.py

@@ -2,14 +2,16 @@ import json
 import logging
 import threading
 import time
-from typing import Dict, Any, Optional, List, Callable
+from typing import Dict, Any, Optional, List, Callable, TYPE_CHECKING
 from .base import GrowthBookPlugin
 
-requests: Any = None
-try:
-    import requests
-except ImportError:
-    pass
+if TYPE_CHECKING:
+    import requests  # type: ignore
+else:
+    try:
+        import requests  # type: ignore
+    except ImportError:
+        requests = None
 
 logger = logging.getLogger("growthbook.plugins.growthbook_tracking")
 
@@ -88,22 +90,43 @@ class GrowthBookTrackingPlugin(GrowthBookPlugin):
         super().cleanup()
     
     def _setup_experiment_tracking(self, gb_instance) -> None:
-        """Setup experiment tracking."""
-        original_callback = getattr(gb_instance, '_trackingCallback', None)
+        """Setup experiment tracking for both legacy and async clients."""
         
-        def tracking_wrapper(experiment, result):
+        def tracking_wrapper(experiment, result, user_context=None):
             # Track to ingestor
             self._track_experiment_viewed(experiment, result)
             
             # Call additional callback
             if self.additional_callback:
-                self._safe_execute(self.additional_callback, experiment, result)
+                self._safe_execute(self.additional_callback, experiment, result, user_context)
+        
+        # Check if it's the legacy GrowthBook client (has _trackingCallback)
+        if hasattr(gb_instance, '_trackingCallback'):
+            # Legacy GrowthBook client
+            original_callback = getattr(gb_instance, '_trackingCallback', None)
+            
+            def legacy_wrapper(experiment, result, user_context=None):
+                tracking_wrapper(experiment, result, user_context)
+                # Call original callback
+                if original_callback:
+                    self._safe_execute(original_callback, experiment, result, user_context)
+            
+            gb_instance._trackingCallback = legacy_wrapper
+            
+        elif hasattr(gb_instance, 'options') and hasattr(gb_instance.options, 'on_experiment_viewed'):
+            # New GrowthBookClient (async)
+            original_callback = gb_instance.options.on_experiment_viewed
+            
+            def async_wrapper(experiment, result, user_context):
+                tracking_wrapper(experiment, result, user_context)
+                # Call original callback
+                if original_callback:
+                    self._safe_execute(original_callback, experiment, result, user_context)
             
-            # Call original callback
-            if original_callback:
-                self._safe_execute(original_callback, experiment, result)
+            gb_instance.options.on_experiment_viewed = async_wrapper
         
-        gb_instance._trackingCallback = tracking_wrapper
+        else:
+            self.logger.warning("_trackingCallback or on_experiment_viewed properties not found - tracking may not work properly")
     
     def _setup_feature_tracking(self, gb_instance):
         """Setup feature evaluation tracking."""

{growthbook-1.3.0 → growthbook-1.4.0}/growthbook/plugins/request_context.py

@@ -77,6 +77,7 @@ class RequestContextPlugin(GrowthBookPlugin):
         self.client_side_attributes = client_side_attributes
         self.extract_utm = extract_utm
         self.extract_user_agent = extract_user_agent
+        self._extracted_attributes: Dict[str, Any] = {}
         
     def initialize(self, gb_instance) -> None:
         """Initialize plugin - extract attributes from request context."""
@@ -87,18 +88,33 @@ class RequestContextPlugin(GrowthBookPlugin):
             request_attributes = self._extract_all_attributes()
             
             if request_attributes:
-                # Merge with existing attributes (existing take precedence)
-                current_attributes = gb_instance.get_attributes()
-                merged_attributes = {**request_attributes, **current_attributes}
-                gb_instance.set_attributes(merged_attributes)
-                
-                self.logger.info(f"Extracted {len(request_attributes)} request attributes")
+                # Check client type and merge attributes accordingly
+                if hasattr(gb_instance, 'get_attributes') and hasattr(gb_instance, 'set_attributes'):
+                    # Legacy GrowthBook client
+                    current_attributes = gb_instance.get_attributes()
+                    merged_attributes = {**request_attributes, **current_attributes}
+                    gb_instance.set_attributes(merged_attributes)
+                    self.logger.info(f"Extracted {len(request_attributes)} request attributes for legacy client")
+                    
+                elif hasattr(gb_instance, 'options'):
+                    # New GrowthBookClient - store attributes for future use
+                    # Note: GrowthBookClient doesn't have get/set_attributes, but we can store
+                    # the extracted attributes for potential future use or logging
+                    self._extracted_attributes = request_attributes
+                    self.logger.info(f"Extracted {len(request_attributes)} request attributes for async client (stored for reference)")
+                    
+                else:
+                    self.logger.warning("Unknown client type - cannot set attributes")
             else:
                 self.logger.debug("No request context available")
                 
         except Exception as e:
             self.logger.error(f"Failed to extract request attributes: {e}")
     
+    def get_extracted_attributes(self) -> Dict[str, Any]:
+        """Get the attributes extracted from request context."""
+        return self._extracted_attributes.copy()
+    
     def _extract_all_attributes(self) -> Dict[str, Any]:
         """Extract all available attributes from request context."""
         attributes = {}

{growthbook-1.3.0 → growthbook-1.4.0/growthbook.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: growthbook
-Version: 1.3.0
+Version: 1.4.0
 Summary: Powerful Feature flagging and A/B testing for Python apps
 Home-page: https://github.com/growthbook/growthbook-python
 Author: GrowthBook

{growthbook-1.3.0 → growthbook-1.4.0}/setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 1.3.0
+current_version = 1.4.0
 commit = True
 tag = True
 

{growthbook-1.3.0 → growthbook-1.4.0}/tests/test_growthbook.py

@@ -177,8 +177,8 @@ def test_stickyBucket(stickyBucket_data):
 def getTrackingMock(gb: GrowthBook):
     calls = []
 
-    def track(experiment, result):
-        return calls.append([experiment, result])
+    def track(experiment, result, user_context):
+        return calls.append([experiment, result, user_context])
 
     gb._trackingCallback = track
     return lambda: calls
@@ -207,9 +207,10 @@ def test_tracking():
 
     calls = getMockedCalls()
     assert len(calls) == 3
-    assert calls[0] == [exp1, res1]
-    assert calls[1] == [exp2, res4]
-    assert calls[2] == [exp2, res5]
+    # validate experiment and result only
+    assert calls[0][0] == exp1 and calls[0][1] == res1
+    assert calls[1][0] == exp2 and calls[1][1] == res4
+    assert calls[2][0] == exp2 and calls[2][1] == res5
 
     gb.destroy()
 

{growthbook-1.3.0 → growthbook-1.4.0}/tests/test_growthbook_client.py

@@ -657,8 +657,8 @@ async def getTrackingMock(client: GrowthBookClient):
     """Helper function to mock tracking for tests"""
     calls = []
 
-    def track(experiment, result):
-        calls.append([experiment, result])
+    def track(experiment, result, user_context):
+        calls.append([experiment, result, user_context])
 
     client.options.on_experiment_viewed = track
     return lambda: calls
@@ -713,13 +713,24 @@ async def test_tracking():
             # Verify tracking calls
             calls = getMockedCalls()
             assert len(calls) == 3, "Expected exactly 3 tracking calls"
-            assert calls[0] == [exp1, res1], "First tracking call mismatch"
-            assert calls[1] == [exp2, res4], "Second tracking call mismatch"
-            assert calls[2] == [exp2, res5], "Third tracking call mismatch"
+            assert calls[0] == [exp1, res1, user_context], "First tracking call mismatch"
+            assert calls[1] == [exp2, res4, user_context], "Second tracking call mismatch"
+            assert calls[2] == [exp2, res5, user_context], "Third tracking call mismatch"
 
     finally:
         await client.close()
 
+async def getFailedTrackingMock(client: GrowthBookClient):
+    """Helper function to mock tracking for tests"""
+    calls = []
+    # Set up tracking callback that raises an error
+    def failing_track(experiment, result, user_context):
+        calls.append([experiment, result, user_context])
+        raise Exception("Tracking failed")
+
+    client.options.on_experiment_viewed = failing_track
+    return lambda: calls
+
 @pytest.mark.asyncio
 async def test_handles_tracking_errors():
     """Test graceful handling of tracking callback errors"""
@@ -729,11 +740,7 @@ async def test_handles_tracking_errors():
         enabled=True
     ))
 
-    # Set up tracking callback that raises an error
-    def failing_track(experiment, result):
-        raise Exception("Tracking failed")
-
-    client.options.on_experiment_viewed = failing_track
+    getMockedTrackingCalls = await getFailedTrackingMock(client)
 
     # Create test experiment
     exp = Experiment(
@@ -757,5 +764,8 @@ async def test_handles_tracking_errors():
             result = await client.run(exp, user_context)
             assert result is not None, "Experiment should run despite tracking error"
 
+            calls = getMockedTrackingCalls()
+            assert len(calls) == 1, "Expected exactly 1 tracking call"
+
     finally:
         await client.close()

{growthbook-1.3.0 → growthbook-1.4.0}/tests/test_plugins.py

@@ -178,11 +178,12 @@ class TestTrackingPlugin(unittest.TestCase):
         """Test that tracking plugin calls callback when experiments run."""
         tracked_experiments = []
         
-        def track_callback(experiment, result):
+        def track_callback(experiment, result, user_context):
             tracked_experiments.append({
                 'key': experiment.key,
                 'value': result.value,
-                'inExperiment': result.inExperiment
+                'inExperiment': result.inExperiment,
+                'user_context': user_context
             })
         
         gb = GrowthBook(
@@ -254,4 +255,174 @@ class TestTrackingPlugin(unittest.TestCase):
             self.assertEqual(flag_track['value'], True)
             self.assertEqual(string_track['value'], 'hello')
             
-            gb.destroy()
+            gb.destroy()
+
+
+class TestGrowthBookClientPlugins(unittest.TestCase):
+    """Test plugin integration with GrowthBookClient (async client)."""
+    
+    def setUp(self):
+        """Set up test fixtures."""
+        self.tracked_events = []
+        
+    def tearDown(self):
+        """Clean up after tests."""
+        self.tracked_events.clear()
+        # Clear request context
+        clear_request_context()
+    
+    def test_plugins_work_with_both_client_types(self):
+        """Test that plugins work with both legacy GrowthBook and async GrowthBookClient."""
+        import asyncio
+        from unittest.mock import patch, AsyncMock
+        from growthbook.growthbook_client import GrowthBookClient
+        from growthbook.common_types import Options, Experiment, UserContext
+        from growthbook import GrowthBook
+        
+        # Set up request context for testing
+        mock_request = MockDjangoRequest()
+        set_request_context(mock_request)
+        
+        async def test_async_client():
+            """Test with async GrowthBookClient."""
+            tracked_events = []
+            
+            def track_callback(experiment, result, user_context):
+                tracked_events.append({
+                    'client_type': 'async',
+                    'experiment_key': experiment.key,
+                    'result_value': result.value,
+                    'user_id': user_context.attributes.get('id') if user_context else None
+                })
+            
+            # Create plugins
+            tracking_plugin = growthbook_tracking_plugin(
+                ingestor_host="https://test.growthbook.io",
+                additional_callback=track_callback,
+                batch_size=1
+            )
+            
+            context_plugin = request_context_plugin(
+                extract_utm=True,
+                extract_user_agent=True
+            )
+            
+            # Create async client with plugins
+            client = GrowthBookClient(
+                Options(
+                    api_host="https://cdn.growthbook.io",
+                    client_key="test-key",
+                    tracking_plugins=[context_plugin, tracking_plugin]
+                )
+            )
+            
+            try:
+                # Verify plugins initialized
+                self.assertEqual(len(client._initialized_plugins), 2)
+                self.assertTrue(tracking_plugin.is_initialized())
+                self.assertTrue(context_plugin.is_initialized())
+                
+                # Verify context plugin extracted attributes (stored for async client)
+                extracted_attrs = context_plugin.get_extracted_attributes()
+                self.assertIn('utmSource', extracted_attrs)
+                self.assertEqual(extracted_attrs['utmSource'], 'google')
+                
+                with patch('growthbook.FeatureRepository.load_features_async', 
+                          new_callable=AsyncMock, return_value={"features": {}, "savedGroups": {}}), \
+                     patch('growthbook.growthbook_client.EnhancedFeatureRepository.start_feature_refresh',
+                          new_callable=AsyncMock), \
+                     patch('growthbook.growthbook_client.EnhancedFeatureRepository.stop_refresh',
+                          new_callable=AsyncMock), \
+                     patch('requests.post') as mock_post:
+                    
+                    mock_post.return_value.status_code = 200
+                    
+                    await client.initialize()
+                    
+                    # Run experiment
+                    exp = Experiment(key="dual-client-test", variations=[0, 1])
+                    user_context = UserContext(attributes={"id": "async-user"})
+                    
+                    result = await client.run(exp, user_context)
+                    await asyncio.sleep(0.1)  # Wait for async tracking
+                    
+                    # Verify tracking worked
+                    self.assertEqual(len(tracked_events), 1)
+                    self.assertEqual(tracked_events[0]['client_type'], 'async')
+                    self.assertEqual(tracked_events[0]['experiment_key'], 'dual-client-test')
+                    
+            finally:
+                await client.close()
+            
+            return tracked_events
+        
+        def test_legacy_client():
+            """Test with legacy GrowthBook client."""
+            tracked_events = []
+            
+            def track_callback(experiment, result, user_context):
+                tracked_events.append({
+                    'client_type': 'legacy',
+                    'experiment_key': experiment.key,
+                    'result_value': result.value,
+                    'user_id': user_context.attributes.get('id') if user_context else None
+                })
+            
+            # Create plugins (same instances can be reused)
+            tracking_plugin = growthbook_tracking_plugin(
+                ingestor_host="https://test.growthbook.io",
+                additional_callback=track_callback,
+                batch_size=1
+            )
+            
+            context_plugin = request_context_plugin(
+                extract_utm=True,
+                extract_user_agent=True
+            )
+            
+            # Create legacy client with plugins
+            gb = GrowthBook(
+                attributes={"id": "legacy-user"},
+                plugins=[context_plugin, tracking_plugin]
+            )
+            
+            try:
+                # Verify plugins initialized
+                self.assertTrue(tracking_plugin.is_initialized())
+                self.assertTrue(context_plugin.is_initialized())
+                
+                # Verify context plugin set attributes on legacy client
+                attrs = gb.get_attributes()
+                self.assertIn('utmSource', attrs)
+                self.assertEqual(attrs['utmSource'], 'google')
+                self.assertEqual(attrs['id'], 'legacy-user')  # Original should be preserved
+                
+                with patch('requests.post') as mock_post:
+                    mock_post.return_value.status_code = 200
+                    
+                    # Run experiment
+                    exp = Experiment(key="dual-client-test", variations=[0, 1])
+                    result = gb.run(exp)
+                    
+                    # Verify tracking worked
+                    self.assertEqual(len(tracked_events), 1)
+                    self.assertEqual(tracked_events[0]['client_type'], 'legacy')
+                    self.assertEqual(tracked_events[0]['experiment_key'], 'dual-client-test')
+                    
+            finally:
+                gb.destroy()
+            
+            return tracked_events
+        
+        # Test both client types
+        async_events = asyncio.run(test_async_client())
+        legacy_events = test_legacy_client()
+        
+        # Verify both worked
+        self.assertEqual(len(async_events), 1)
+        self.assertEqual(len(legacy_events), 1)
+        self.assertEqual(async_events[0]['client_type'], 'async')
+        self.assertEqual(legacy_events[0]['client_type'], 'legacy')
+        
+        # Clean up request context
+        clear_request_context()