rudder-sdk-python 2.1.2__tar.gz → 2.1.4__tar.gz

{rudder_sdk_python-2.1.2 → rudder_sdk_python-2.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rudder-sdk-python
-Version: 2.1.2
+Version: 2.1.4
 Summary: RudderStack is an open-source Segment alternative written in Go, built for the enterprise.
 Home-page: https://github.com/rudderlabs/rudder-sdk-python
 Author: RudderStack
@@ -27,10 +27,12 @@ License-File: LICENSE.md
 Requires-Dist: requests<3.0,>=2.32.3
 Requires-Dist: monotonic<2.0,>=1.6
 Requires-Dist: backoff<3.0,>=2.2.1
+Requires-Dist: python-dateutil<3.0,>=2.2
+Requires-Dist: python-dotenv<2.0.0,>=1.0.1
 Requires-Dist: deprecation<3.0.0,>=2.1.0
 Provides-Extra: test
-Requires-Dist: mock==4.0.3; extra == "test"
-Requires-Dist: flake8==7.1.0; extra == "test"
+Requires-Dist: mock==5.1.0; extra == "test"
+Requires-Dist: flake8==7.1.1; extra == "test"
 
 # RudderStack Python SDK
 

{rudder_sdk_python-2.1.2 → rudder_sdk_python-2.1.4}/rudder_sdk_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rudder-sdk-python
-Version: 2.1.2
+Version: 2.1.4
 Summary: RudderStack is an open-source Segment alternative written in Go, built for the enterprise.
 Home-page: https://github.com/rudderlabs/rudder-sdk-python
 Author: RudderStack
@@ -27,10 +27,12 @@ License-File: LICENSE.md
 Requires-Dist: requests<3.0,>=2.32.3
 Requires-Dist: monotonic<2.0,>=1.6
 Requires-Dist: backoff<3.0,>=2.2.1
+Requires-Dist: python-dateutil<3.0,>=2.2
+Requires-Dist: python-dotenv<2.0.0,>=1.0.1
 Requires-Dist: deprecation<3.0.0,>=2.1.0
 Provides-Extra: test
-Requires-Dist: mock==4.0.3; extra == "test"
-Requires-Dist: flake8==7.1.0; extra == "test"
+Requires-Dist: mock==5.1.0; extra == "test"
+Requires-Dist: flake8==7.1.1; extra == "test"
 
 # RudderStack Python SDK
 

rudder_sdk_python-2.1.4/rudder_sdk_python.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+LICENSE.md
+README.md
+setup.cfg
+setup.py
+rudder_sdk_python.egg-info/PKG-INFO
+rudder_sdk_python.egg-info/SOURCES.txt
+rudder_sdk_python.egg-info/dependency_links.txt
+rudder_sdk_python.egg-info/not-zip-safe
+rudder_sdk_python.egg-info/requires.txt
+rudder_sdk_python.egg-info/top_level.txt
+rudderstack/analytics/__init__.py
+rudderstack/analytics/client.py
+rudderstack/analytics/consumer.py
+rudderstack/analytics/get_env.py
+rudderstack/analytics/request.py
+rudderstack/analytics/utils.py
+rudderstack/analytics/version.py
+rudderstack/analytics/test/__init__.py
+rudderstack/analytics/test/test_client.py
+rudderstack/analytics/test/test_constants.py
+rudderstack/analytics/test/test_consumer.py
+rudderstack/analytics/test/test_module.py
+rudderstack/analytics/test/test_request.py
+rudderstack/analytics/test/test_utils.py

{rudder_sdk_python-2.1.2 → rudder_sdk_python-2.1.4}/rudder_sdk_python.egg-info/requires.txt

@@ -1,8 +1,10 @@
 requests<3.0,>=2.32.3
 monotonic<2.0,>=1.6
 backoff<3.0,>=2.2.1
+python-dateutil<3.0,>=2.2
+python-dotenv<2.0.0,>=1.0.1
 deprecation<3.0.0,>=2.1.0
 
 [test]
-mock==4.0.3
-flake8==7.1.0
+mock==5.1.0
+flake8==7.1.1

rudder_sdk_python-2.1.4/rudder_sdk_python.egg-info/top_level.txt

@@ -0,0 +1 @@
+rudderstack

rudder_sdk_python-2.1.4/rudderstack/analytics/__init__.py

@@ -0,0 +1,113 @@
+
+import warnings
+from rudderstack.analytics.version import VERSION
+from rudderstack.analytics.client import Client
+import deprecation
+__version__ = VERSION
+
+"""Settings."""
+write_key = Client.DefaultConfig.write_key
+
+@property
+@deprecation.deprecated(deprecated_in="2.0",
+                        current_version=__version__,
+                        details="Use the dataPlaneUrl property instead")
+def host(self):
+    warnings.warn('The use of host is deprecated. Use dataPlaneUrl instead', DeprecationWarning)
+    return host
+
+@host.setter
+@deprecation.deprecated(deprecated_in="2.0",
+                        current_version=__version__,
+                        details="Use the dataPlaneUrl property instead")
+def host(self, value: str):
+    warnings.warn('The use of host is deprecated. Use dataPlaneUrl instead', DeprecationWarning)
+    self.host = value
+    
+host = Client.DefaultConfig.host
+
+@property
+def dataPlaneUrl(self):
+    return dataPlaneUrl
+
+@dataPlaneUrl.setter
+def dataPlaneUrl(self, value: str):
+     self.host = value   
+
+on_error = Client.DefaultConfig.on_error
+debug = Client.DefaultConfig.debug
+send = Client.DefaultConfig.send
+sync_mode = Client.DefaultConfig.sync_mode
+max_queue_size = Client.DefaultConfig.max_queue_size
+gzip = Client.DefaultConfig.gzip
+timeout = Client.DefaultConfig.timeout
+upload_interval = Client.DefaultConfig.upload_interval
+upload_size = Client.DefaultConfig.upload_size
+max_retries = Client.DefaultConfig.max_retries
+
+default_client = None
+
+
+def track(*args, **kwargs):
+    """Send a track call."""
+    _proxy('track', *args, **kwargs)
+
+
+def identify(*args, **kwargs):
+    """Send a identify call."""
+    _proxy('identify', *args, **kwargs)
+
+
+def group(*args, **kwargs):
+    """Send a group call."""
+    _proxy('group', *args, **kwargs)
+
+
+def alias(*args, **kwargs):
+    """Send a alias call."""
+    _proxy('alias', *args, **kwargs)
+
+
+def page(*args, **kwargs):
+    """Send a page call."""
+    _proxy('page', *args, **kwargs)
+
+
+def screen(*args, **kwargs):
+    """Send a screen call."""
+    _proxy('screen', *args, **kwargs)
+
+
+def flush():
+    """Tell the client to flush."""
+    _proxy('flush')
+
+
+def join():
+    """Block program until the client clears the queue"""
+    _proxy('join')
+
+
+def shutdown():
+    """Flush all messages and cleanly shutdown the client"""
+    _proxy('flush')
+    _proxy('join')
+
+
+def _proxy(method, *args, **kwargs):
+    """Create an analytics client if one doesn't exist and send to it."""
+    global default_client
+    if not default_client:
+        if isinstance(dataPlaneUrl,str) and dataPlaneUrl != "":
+            finalDataplaneUrl = dataPlaneUrl
+        else:
+            finalDataplaneUrl = host    
+        
+        default_client = Client(write_key, host=finalDataplaneUrl, debug=debug,
+                                max_queue_size=max_queue_size,
+                                send=send, on_error=on_error,
+                                gzip=gzip, max_retries=max_retries,
+                                sync_mode=sync_mode, timeout=timeout)
+
+    fn = getattr(default_client, method)
+    fn(*args, **kwargs)

rudder_sdk_python-2.1.4/rudderstack/analytics/client.py

@@ -0,0 +1,338 @@
+from datetime import datetime, timezone
+from uuid import uuid4
+import logging
+import numbers
+import atexit
+import json
+
+from dateutil.tz import tzutc
+from rudderstack.analytics.get_env import TEST_DATA_PLANE_URL
+
+from rudderstack.analytics.utils import guess_timezone, clean
+from rudderstack.analytics.consumer import Consumer, MAX_MSG_SIZE
+from rudderstack.analytics.request import post, DatetimeSerializer
+from rudderstack.analytics.version import VERSION
+
+import queue
+
+ID_TYPES = (numbers.Number, str)
+CHANNEL = 'server'
+
+class Client(object):
+    class DefaultConfig(object):
+        write_key = None
+        host = TEST_DATA_PLANE_URL
+        on_error = None
+        debug = False
+        send = True
+        sync_mode = False
+        max_queue_size = 10000
+        gzip = True
+        timeout = 15
+        max_retries = 10
+        proxies = None
+        thread = 1
+        upload_interval = 0.5
+        upload_size = 100
+
+    """Create a new rudderstack client."""
+    log = logging.getLogger('rudderstack')
+    def __init__(self,
+                 write_key=DefaultConfig.write_key,
+                 host=DefaultConfig.host,
+                 debug=DefaultConfig.debug,
+                 max_queue_size=DefaultConfig.max_queue_size,
+                 send=DefaultConfig.send,
+                 on_error=DefaultConfig.on_error,
+                 gzip=DefaultConfig.gzip,
+                 max_retries=DefaultConfig.max_retries,
+                 sync_mode=DefaultConfig.sync_mode,
+                 timeout=DefaultConfig.timeout,
+                 proxies=DefaultConfig.proxies,
+                 thread=DefaultConfig.thread,
+                 upload_size=DefaultConfig.upload_size,
+                 upload_interval=DefaultConfig.upload_interval,):
+        require('write_key', write_key, str)
+
+        self.queue = queue.Queue(max_queue_size)
+        self.write_key = write_key
+        self.on_error = on_error
+        self.debug = debug
+        self.send = send
+        self.sync_mode = sync_mode
+        self.host = host
+        self.gzip = gzip
+        self.timeout = timeout
+        self.proxies = proxies
+
+        if debug:
+            self.log.setLevel(logging.DEBUG)
+
+        if sync_mode:
+            self.consumers = None
+        else:
+            # On program exit, allow the consumer thread to exit cleanly.
+            # This prevents exceptions and a messy shutdown when the
+            # interpreter is destroyed before the daemon thread finishes
+            # execution. However, it is *not* the same as flushing the queue!
+            # To guarantee all messages have been delivered, you'll still need
+            # to call flush().
+            if send:
+                atexit.register(self.join)
+            for _ in range(thread):
+                self.consumers = []
+                consumer = Consumer(
+                    self.queue, write_key, host=host, on_error=on_error,
+                    upload_size=upload_size, upload_interval=upload_interval,
+                    gzip=gzip, retries=max_retries, timeout=timeout,
+                    proxies=proxies,
+                )
+                self.consumers.append(consumer)
+
+                # if we've disabled sending, just don't start the consumer
+                if send:
+                    consumer.start()
+
+    def identify(self, user_id=None, traits=None, context=None, timestamp=None,
+                 anonymous_id=None, integrations=None, message_id=None):
+        traits = traits or {}
+        context = context or {}
+        # putting traits inside context
+        context['traits'] = traits
+        integrations = integrations or {}
+        require('user_id or anonymous_id', user_id or anonymous_id, ID_TYPES)
+        require('traits', traits, dict)
+
+        msg = {
+            'integrations': integrations,
+            'anonymousId': anonymous_id,
+            'timestamp': timestamp,
+            'context': context,
+            'type': 'identify',
+            'userId': user_id,
+            # 'traits': traits, #traits not needed at root level
+            'messageId': message_id,
+        }
+
+        return self._enqueue(msg)
+
+    def track(self, user_id=None, event=None, properties=None, context=None,
+              timestamp=None, anonymous_id=None, integrations=None,
+              message_id=None):
+        properties = properties or {}
+        context = context or {}
+        integrations = integrations or {}
+        require('user_id or anonymous_id', user_id or anonymous_id, ID_TYPES)
+        require('properties', properties, dict)
+        require('event', event, str)
+
+        msg = {
+            'integrations': integrations,
+            'anonymousId': anonymous_id,
+            'properties': properties,
+            'timestamp': timestamp,
+            'context': context,
+            'userId': user_id,
+            'type': 'track',
+            'event': event,
+            'messageId': message_id,
+        }
+
+        return self._enqueue(msg)
+
+    def alias(self, previous_id=None, user_id=None, context=None,
+              timestamp=None, integrations=None, message_id=None):
+        context = context or {}
+        integrations = integrations or {}
+        require('previous_id', previous_id, ID_TYPES)
+        require('user_id', user_id, ID_TYPES)
+
+        msg = {
+            'integrations': integrations,
+            'previousId': previous_id,
+            'timestamp': timestamp,
+            'context': context,
+            'userId': user_id,
+            'type': 'alias',
+            'messageId': message_id,
+        }
+
+        return self._enqueue(msg)
+
+    def group(self, user_id=None, group_id=None, traits=None, context=None,
+              timestamp=None, anonymous_id=None, integrations=None,
+              message_id=None):
+        traits = traits or {}
+        context = context or {}
+        integrations = integrations or {}
+        require('user_id or anonymous_id', user_id or anonymous_id, ID_TYPES)
+        require('group_id', group_id, ID_TYPES)
+        require('traits', traits, dict)
+
+        msg = {
+            'integrations': integrations,
+            'anonymousId': anonymous_id,
+            'timestamp': timestamp,
+            'groupId': group_id,
+            'context': context,
+            'userId': user_id,
+            'traits': traits,
+            'type': 'group',
+            'messageId': message_id,
+        }
+
+        return self._enqueue(msg)
+
+    def page(self, user_id=None, category=None, name=None, properties=None,
+             context=None, timestamp=None, anonymous_id=None,
+             integrations=None, message_id=None):
+        properties = properties or {}
+        context = context or {}
+        integrations = integrations or {}
+        require('user_id or anonymous_id', user_id or anonymous_id, ID_TYPES)
+        require('properties', properties, dict)
+
+        if name:
+            require('name', name, str)
+        if category:
+            require('category', category, str)
+
+        msg = {
+            'integrations': integrations,
+            'anonymousId': anonymous_id,
+            'properties': properties,
+            'timestamp': timestamp,
+            'category': category,
+            'context': context,
+            'userId': user_id,
+            'type': 'page',
+            'name': name,
+            'messageId': message_id,
+        }
+
+        return self._enqueue(msg)
+
+    def screen(self, user_id=None, category=None, name=None, properties=None,
+               context=None, timestamp=None, anonymous_id=None,
+               integrations=None, message_id=None):
+        properties = properties or {}
+        context = context or {}
+        integrations = integrations or {}
+        require('user_id or anonymous_id', user_id or anonymous_id, ID_TYPES)
+        require('properties', properties, dict)
+
+        if name:
+            require('name', name, str)
+        if category:
+            require('category', category, str)
+
+        msg = {
+            'integrations': integrations,
+            'anonymousId': anonymous_id,
+            'properties': properties,
+            'timestamp': timestamp,
+            'category': category,
+            'context': context,
+            'userId': user_id,
+            'type': 'screen',
+            'name': name,
+            'messageId': message_id,
+        }
+
+        return self._enqueue(msg)
+    
+    def _enqueue(self, msg):
+        """Push a new `msg` onto the queue, return `(success, msg)`"""
+        timestamp = msg['timestamp']
+        if timestamp is None:
+            timestamp = datetime.now(timezone.utc).replace(tzinfo=tzutc())
+        message_id = msg.get('messageId')
+        if message_id is None:
+            message_id = uuid4()
+
+        # default integrations should be "All": True
+        if msg['integrations'] == {} :
+            msg['integrations'] = {"All" : True}
+            
+        require('integrations', msg['integrations'], dict)
+        require('type', msg['type'], str)
+        require('timestamp', timestamp, datetime)
+        require('context', msg['context'], dict)
+
+        # add common
+        timestamp = guess_timezone(timestamp)
+        msg['timestamp'] = timestamp.isoformat()
+        msg['messageId'] = stringify_id(message_id)
+        msg['context']['library'] = {
+            'name': 'analytics-python',
+            'version': VERSION
+        }
+        msg['userId'] = stringify_id(msg.get('userId', None))
+        msg['anonymousId'] = stringify_id(msg.get('anonymousId', None))
+        msg['channel'] = CHANNEL
+        msg = clean(msg)
+        self.log.debug('queueing: %s', msg)
+
+        # Check message size.
+        msg_size = len(json.dumps(msg, cls=DatetimeSerializer).encode())
+        if msg_size > MAX_MSG_SIZE:
+            raise RuntimeError(f'Message exceeds {str(int(MAX_MSG_SIZE / 1024))}kb limit. ({str(msg)})')
+
+        # if send is False, return msg as if it was successfully queued
+        if not self.send:
+            return True, msg
+
+        if self.sync_mode:
+            self.log.debug('enqueued with blocking %s.', msg['type'])
+            post(self.write_key, self.host, gzip=self.gzip,
+                 timeout=self.timeout, proxies=self.proxies, batch=[msg])
+
+            return True, msg
+
+        try:
+            self.queue.put(msg, block=False)
+            self.log.debug('enqueued %s.', msg['type'])
+            return True, msg
+        except queue.Full:
+            self.log.warning('analytics-python queue is full')
+            return False, msg
+
+    def flush(self):
+        """Forces a flush from the internal queue to the server"""
+        queue = self.queue
+        size = queue.qsize()
+        queue.join()
+        # Note that this message may not be precise, because of threading.
+        self.log.debug('successfully flushed about %s items.', size)
+
+    def join(self):
+        """Ends the consumer thread once the queue is empty.
+        Blocks execution until finished
+        """
+        for consumer in self.consumers:
+            consumer.pause()
+            try:
+                consumer.join()
+            except RuntimeError:
+                # consumer thread has not started
+                pass
+
+    def shutdown(self):
+        """Flush all messages and cleanly shutdown the client"""
+        self.flush()
+        self.join()
+
+
+def require(name, field, data_type):
+    """Require that the named `field` has the right `data_type`"""
+    if not isinstance(field, data_type):
+        msg = '{0} must have {1}, got: {2}'.format(name, data_type, field)
+        raise AssertionError(msg)
+
+
+def stringify_id(val):
+    if val is None:
+        return None
+    if isinstance(val, str):
+        return val
+    return str(val)

rudder_sdk_python-2.1.4/rudderstack/analytics/consumer.py

@@ -0,0 +1,133 @@
+import logging
+from threading import Thread
+import monotonic
+import backoff
+import json
+
+from rudderstack.analytics.request import post, APIError, DatetimeSerializer
+
+from queue import Empty
+
+# Our servers only accept payloads within this limit. Here limit is set slightly
+# lower to leave space for extra data that will be added later, eg. "sentAt".
+MAX_MSG_SIZE = 4 << 10 << 10  ## 4 mb
+BATCH_SIZE_LIMIT = 4 << 10 << 10 ## 4 mb
+
+
+class Consumer(Thread):
+    """Consumes the messages from the client's queue."""
+    log = logging.getLogger('rudderstack')
+
+    def __init__(self, queue, write_key, upload_size=100, host=None,
+                 on_error=None, upload_interval=0.5, gzip=True, retries=10,
+                 timeout=15, proxies=None):
+        """Create a consumer thread."""
+        Thread.__init__(self)
+        # Make consumer a daemon thread so that it doesn't block program exit
+        self.daemon = True
+        self.upload_size = upload_size
+        self.upload_interval = upload_interval
+        self.write_key = write_key
+        self.host = host
+        self.on_error = on_error
+        self.queue = queue
+        self.gzip = gzip
+        # It's important to set running in the constructor: if we are asked to
+        # pause immediately after construction, we might set running to True in
+        # run() *after* we set it to False in pause... and keep running
+        # forever.
+        self.running = True
+        self.retries = retries
+        self.timeout = timeout
+        self.proxies = proxies
+
+    def run(self):
+        """Runs the consumer."""
+        self.log.debug('consumer is running...')
+        while self.running:
+            self.upload()
+
+        self.log.debug('consumer exited.')
+
+    def pause(self):
+        """Pause the consumer."""
+        self.running = False
+
+    def upload(self):
+        """Upload the next batch of items, return whether successful."""
+        success = False
+        batch = self.next()
+        if len(batch) == 0:
+            return False
+
+        try:
+            self.request(batch)
+            success = True
+        except Exception as e:
+            self.log.error('error uploading: %s', e)
+            success = False
+            if self.on_error:
+                self.on_error(e, batch)
+        finally:
+            # mark items as acknowledged from queue
+            for _ in batch:
+                self.queue.task_done()
+        return success
+
+    def next(self):
+        """Return the next batch of items to upload."""
+        queue = self.queue
+        items = []
+
+        start_time = monotonic.monotonic()
+        total_size = 0
+
+        while len(items) < self.upload_size:
+            elapsed = monotonic.monotonic() - start_time
+            if elapsed >= self.upload_interval:
+                break
+            try:
+                item = queue.get(
+                    block=True, timeout=self.upload_interval - elapsed)
+                item_size = len(json.dumps(
+                    item, cls=DatetimeSerializer).encode())
+                if item_size > MAX_MSG_SIZE:
+                    self.log.error(
+                        'Item exceeds 4mb limit, dropping. (%s)', str(item))
+                    continue
+                items.append(item)
+                total_size += item_size
+                if total_size >= BATCH_SIZE_LIMIT:
+                    self.log.debug(
+                        'hit batch size limit (size: %d)', total_size)
+                    break
+            except Empty:
+                break
+            except Exception as e:
+                self.log.exception('Exception: %s', e)
+
+        return items
+
+    def request(self, batch):
+        """Attempt to upload the batch and retry before raising an error """
+
+        def fatal_exception(exc):
+            if isinstance(exc, APIError):
+                # retry on server errors and client errors
+                # with 429 status code (rate limited),
+                # don't retry on other client errors
+                return (400 <= exc.status < 500) and exc.status != 429
+            else:
+                # retry on all other errors (eg. network)
+                return False
+
+        @backoff.on_exception(
+            backoff.expo,
+            Exception,
+            max_tries=self.retries + 1,
+            giveup=fatal_exception)
+        def send_request():
+            post(self.write_key, self.host, gzip=self.gzip,
+                 timeout=self.timeout, batch=batch, proxies=self.proxies)
+
+        send_request()

rudder_sdk_python-2.1.4/rudderstack/analytics/get_env.py

@@ -0,0 +1,7 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+TEST_WRITE_KEY = os.getenv('TEST_WRITE_KEY')
+TEST_DATA_PLANE_URL = os.getenv('TEST_DATA_PLANE_URL')