locust 2.40.2.dev8__tar.gz → 2.40.2.dev16__tar.gz

{locust-2.40.2.dev8 → locust-2.40.2.dev16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: locust
-Version: 2.40.2.dev8
+Version: 2.40.2.dev16
 Summary: Developer-friendly load testing framework
 Project-URL: homepage, https://locust.io/
 Project-URL: repository, https://github.com/locustio/locust

{locust-2.40.2.dev8 → locust-2.40.2.dev16}/locust/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.40.2.dev8'
-__version_tuple__ = version_tuple = (2, 40, 2, 'dev8')
+__version__ = version = '2.40.2.dev16'
+__version_tuple__ = version_tuple = (2, 40, 2, 'dev16')
 
 __commit_id__ = commit_id = None

locust-2.40.2.dev16/locust/contrib/socketio.py

@@ -0,0 +1,99 @@
+from locust import User
+from locust.event import EventHook
+
+from typing import Any
+
+import gevent
+import socketio
+
+
+class SocketIOClient(socketio.Client):
+    def __init__(self, request_event: EventHook, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.request_event = request_event
+
+    def connect(self, *args, **kwargs):
+        """
+        Wraps :meth:`socketio.Client.connect`.
+        """
+        with self.request_event.measure("WS", "connect") as _:
+            super().connect(*args, **kwargs)
+
+    def send(self, data, namespace=None, callback=None, name="Unnamed") -> None:
+        """
+        Wraps :meth:`socketio.Client.send`.
+        """
+        exception = None
+        try:
+            super().send(data, namespace, callback)
+        except Exception as e:
+            exception = e
+        self.request_event.fire(
+            request_type="WSS",
+            name=name,
+            response_time=0,
+            response_length=len(data or []),
+            exception=exception,
+            context={},
+        )
+
+    def emit(self, event, data=None, namespace=None, callback=None) -> None:
+        """
+        Wraps :meth:`socketio.Client.emit`.
+        """
+        exception = None
+        try:
+            super().emit(event, data, namespace, callback)
+        except Exception as e:
+            exception = e
+        self.request_event.fire(
+            request_type="WSE",
+            name=str(event),
+            response_time=0,
+            response_length=len(data or []),
+            exception=exception,
+            context={},
+        )
+
+    def call(self, event, data=None, *args, **kwargs):
+        """
+        Wraps :meth:`socketio.Client.call`.
+        """
+        with self.request_event.measure("WSC", event) as _:
+            return super().call(event, data, *args, **kwargs)
+
+    def on_message(self, event: str, data: str) -> None:
+        """
+        This is the default handler for events received.
+        You can register separate handlers using self.sio.on(event, handler)
+
+        Measuring response_time isn't obvious for for WebSockets/SocketIO so we set them to 0.
+        Sometimes response time can be inferred from the event data (if it contains a timestamp)
+        or related to a message that you sent. Override this method in your User class to do that.
+        """
+        self.request_event.fire(
+            request_type="WSR",
+            name=event,
+            response_time=0,
+            response_length=len(data or []),
+            exception=None,
+            context={},
+        )
+
+
+class SocketIOUser(User):
+    """
+    SocketIOUser creates an instance of :class:`socketio.Client` to log requests.
+    See example in :gh:`examples/socketio/socketio_ex.py`.
+    """
+
+    abstract = True
+    options: dict[str, Any] = {}
+    """socketio.Client options, e.g. `{"reconnection_attempts": 1, "reconnection_delay": 2, "logger": True, "engineio_logger": True}`"""
+    sio: SocketIOClient
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.sio = SocketIOClient(self.environment.events.request, **self.options)
+        self.sio_greenlet = gevent.spawn(self.sio.wait)
+        self.sio.on("*", self.sio.on_message)

locust-2.40.2.dev8/locust/contrib/socketio.py

@@ -1,95 +0,0 @@
-from locust import User
-
-import gevent
-import socketio
-
-
-class SocketIOUser(User):
-    """
-    SocketIOUser wraps an instance of :class:`socketio.Client` to log requests.
-    See example in :gh:`examples/socketio/socketio_ex.py`.
-    """
-
-    abstract = True
-    options: dict = {}
-    """socketio.Client options, e.g. `{"reconnection_attempts": 1, "reconnection_delay": 2}`"""
-    client: socketio.Client
-    """The underlying :class:`socketio.Client` instance. Can be useful to call directly if you want to skip logging a requests."""
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.client = socketio.Client(**self.options)
-        self.ws_greenlet = gevent.spawn(self.client.wait)
-        self.client.on("*", self.on_message)
-
-    #
-    def on_message(self, event: str, data: str) -> None:
-        """
-        This is the default handler for events. You can override it for custom behavior,
-        or even register separate handlers using self.client.on(event, handler)
-
-        Measuring response_time isn't obvious for for WebSockets. Sometimes a response time
-        can be inferred from the event data (if it contains a timestamp) or related to
-        a message that you sent. Override this method in your User class to do that.
-        """
-        self.environment.events.request.fire(
-            request_type="WSR",
-            name=event,
-            response_time=0,
-            response_length=len(data or []),
-            exception=None,
-            context={},
-        )
-
-    def connect(self, *args, **kwargs):
-        """
-        Wraps :meth:`socketio.Client.connect`.
-        """
-        with self.environment.events.request.measure("WS", "connect") as _:
-            self.client.connect(*args, **kwargs)
-
-    def send(self, name, data=None, namespace=None) -> None:
-        """
-        Wraps :meth:`socketio.Client.send`.
-        """
-        exception = None
-        try:
-            self.client.send(data, namespace)
-        except Exception as e:
-            exception = e
-        self.environment.events.request.fire(
-            request_type="WSS",
-            name=name,
-            response_time=0,
-            response_length=len(data or []),
-            exception=exception,
-            context={},
-        )
-
-    def emit(self, name, data=None, namespace=None, callback=None) -> None:
-        """
-        Wraps :meth:`socketio.Client.emit`.
-        """
-        exception = None
-        try:
-            self.client.emit(name, data, namespace, callback)
-        except Exception as e:
-            exception = e
-        self.environment.events.request.fire(
-            request_type="WSE",
-            name=name,
-            response_time=0,
-            response_length=len(data or []),
-            exception=exception,
-            context={},
-        )
-
-    def call(self, event, data=None, *args, **kwargs):
-        """
-        Wraps :meth:`socketio.Client.call`.
-        """
-        with self.environment.events.request.measure("WSC", event) as _:
-            return self.client.call(event, data, *args, **kwargs)
-
-    def on_stop(self):
-        self.client.disconnect()