| # Copyright 2016 The Charles Stark Draper Laboratory, Inc. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| from userale.version import __version__ |
| from PyQt5.QtCore import QObject, QEvent |
| import datetime |
| import time |
| import logging |
| from userale.format import StructuredMessage |
| |
| _ = StructuredMessage |
| |
| class Ale (QObject): |
| |
| def __init__(self, |
| output="userale.log", |
| autostart=True, |
| interval=5000, |
| user=None, |
| version=None, |
| details=False, |
| resolution=500, |
| shutoff=[]): |
| """ |
| :param output: [str] The file or url path to which logs will be sent |
| :param autostart: [bool] Should UserAle start auotmatically on app rendering |
| :param interval: [int] The minimum time interval in ms betweeen batch transmission of logs |
| :param user: [str] Identifier for the user of the application |
| :param version: [str] The application version |
| :param details: [bool] Should detailed logs (key strokes, input/change values) be recorded |
| :param resolution: [int] Delay in ms between instances of high frequency logs like mouseovers, scrolls, etc |
| :param shutoff: [list] Turn off logging for specific events. For example, to ignore mousedown events, ['mousedown'] |
| |
| An example log will appear like this: |
| |
| .. code-block:: python |
| |
| { |
| 'target': 'testLineEdit', |
| 'path': ['Example', 'testLineEdit'], |
| 'clientTime': , |
| 'location': {'x': 82, 'y': 0}, |
| 'type': 'mouseHover', |
| 'userAction': 'true', |
| 'details' : [], |
| 'userId': 'userABC1234', |
| 'toolVersion': 'myApplication', |
| 'useraleVersion': '1.0.0 alpha' |
| } |
| """ |
| |
| QObject.__init__(self) |
| |
| # UserAle Configuration |
| self.output = output |
| self.autostart = autostart |
| self.interval = interval |
| self.user = user |
| self.version = version |
| self.details = details |
| self.resolution = resolution |
| |
| # Store logs |
| self.logs = [] |
| |
| # Configure logging |
| self.logger = logging |
| self.logger.basicConfig(level=logging.INFO, |
| filename=self.output, |
| format='%(message)s') |
| |
| # Drag/Drop - track duration |
| self.dd = datetime.datetime.now () |
| |
| def eventFilter(self, object, event): |
| ''' |
| :param object: [QObject] The object being watched. |
| :param event: [QEvent] |
| :return: [bool] Return true in order to filter the event out (stop it from being handled further). Otherwise return false. |
| |
| Filters events for the watched object (in this case, QApplication) |
| ''' |
| |
| data = None |
| |
| if (event.type () == QEvent.MouseButtonPress): |
| data = self.handleMouseEvents ("mousedown", event, object) |
| elif (event.type () == QEvent.MouseButtonRelease): |
| data = self.handleMouseEvents ("mouseup", event, object) |
| elif (event.type () == QEvent.MouseMove): |
| data = self.handleMouseEvents ("mousemove", event, object) |
| elif (event.type () == QEvent.KeyPress): |
| data = self.handleKeyEvents ("keypress", event, object) |
| elif (event.type () == QEvent.KeyRelease): |
| data = self.handleKeyEvents ("keyrelease", event, object) |
| elif (event.type () == QEvent.Leave): |
| data = self.handleLeaveEvents ("keyrelease", event, object) |
| elif (event.type () == QEvent.Move): |
| data = self.handleMoveEvents ("keyrelease", event, object) |
| elif (event.type () == QEvent.Resize): |
| data = self.handleResizeEvents ("keyrelease", event, object) |
| elif (event.type () == QEvent.Scroll): |
| data = self.handleScrollEvents ("keyrelease", event, object) |
| elif (event.type () == QEvent.DragEnter): |
| data = self.handleDragEvents ("dragstart", event, object) |
| elif (event.type () == QEvent.DragLeave): |
| data = self.handleDragEvents ("dragleave", event, object) |
| elif (event.type () == QEvent.DragMove): |
| data = self.handleDragEvents ("dragmove", event, object) |
| elif (event.type () == QEvent.Drop): |
| data = self.handleDragEvents ("dragdrop", event, object) |
| else: |
| pass |
| |
| # self.logs.append (data) |
| if data is not None: |
| self.logger.info (_(data)) |
| # return super(Ale, self).eventFilter(object, event) |
| return False |
| |
| def getSelector (self, object): |
| """ |
| :param object: [QObject] The base class for all Qt objects. |
| :return: [str] The Qt object's name |
| |
| Get target object's name (object defined by user or object's meta class name) |
| """ |
| |
| return object.objectName() if object.objectName() else object.staticMetaObject.className() |
| |
| def getLocation (self, event): |
| """ |
| :param event: [QEvent] The base class for all event classes. |
| :return: [dict] A dictionary representation of the x and y positions of the mouse cursor. |
| |
| Grab the x and y position of the mouse cursor, relative to the widget that received the event. |
| """ |
| |
| try: |
| return {"x" : event.pos ().x (), "y" : event.pos ().y ()} |
| except: |
| return None |
| |
| def getPath (self, object): |
| """ |
| :param object: [QObject] The base class for all Qt objects. |
| :return: [list] List of QObjects up to the child object. |
| |
| Fetch the entire path up the root of the tree for a leaf node object. |
| Recursive operation. |
| """ |
| |
| if object.parent() is not None: |
| return self.getPath (object.parent()) + [self.getSelector (object)] |
| else: |
| return [self.getSelector (object)] |
| |
| def getClientTime (self): |
| """ |
| :return: [str] String representation of the time the event was triggered. |
| |
| Capture the time the event was captured. |
| """ |
| |
| return str (datetime.datetime.now ()) |
| |
| def handleMouseEvents (self, event_type, event, object): |
| """ |
| :param event_type: [str] The string representation of the type of event being triggered by the user. |
| :param event: [QEvent] The base class for all event classes. |
| :param object: [QObject] The base class for all Qt objects. |
| :return: [dict] A userale log describing a mouse event. |
| |
| Returns the userale log representing all mouse event data. |
| |
| .. code-block:: python |
| |
| """ |
| |
| return self.__create_msg (event_type, event, object) |
| |
| def handleKeyEvents (self, event_type, event, object): |
| """ |
| :param event_type: [str] The string representation of the type of event being triggered by the user. |
| :param event: [QEvent] The base class for all event classes. |
| :param object: [QObject] The base class for all Qt objects. |
| :return: [dict] A userale log describing a key event. |
| |
| Returns the userale log representing all key events, including key name and key code. |
| """ |
| |
| details = {'key' : event.text (), 'keycode' : event.key ()} |
| return self.__create_msg (event_type, event, object, details=details) |
| |
| def handleDragEvents (self, event_type, event, object): |
| """ |
| :param event_type: [str] The string representation of the type of event being triggered by the user. |
| :param event: [QEvent] The base class for all event classes. |
| :param object: [QObject] The base class for all Qt objects. |
| :return: [dict] A userale log describing a drag event. |
| |
| Returns the userale log representing all drag events. |
| """ |
| |
| details = {} |
| if event_type == 'dragstart': |
| # start timer |
| self.dd = datetime.datetime.now () |
| elif event_type == 'dragdrop' or event_type == 'dragleave': |
| details = {"elapsed" : str (datetime.datetime.now () - self.dd)} |
| self.dd = datetime.datetime.now () |
| else: |
| # drag move event - ignore |
| pass |
| |
| return self.__create_msg (event_type, event, object, details=details) |
| |
| def handleMoveEvents (self, event_type, event, object): |
| """ |
| :param event_type: [str] The string representation of the type of event being triggered by the user. |
| :param event: [QEvent] The base class for all event classes. |
| :param object: [QObject] The base class for all Qt objects. |
| :return: [dict] A userale log describing a drag event. |
| |
| Returns the userale log representing all move events. |
| """ |
| |
| pass |
| |
| def handleLeaveEvents (self, event_type, event, object): |
| """ |
| :param event_type: [str] The string representation of the type of event being triggered by the user. |
| :param event: [QEvent] The base class for all event classes. |
| :param object: [QObject] The base class for all Qt objects. |
| :return: [dict] A userale log describing a leave event. |
| |
| Returns the userale log representing all leave events. |
| """ |
| |
| pass |
| |
| def handleResizeEvents (self, event_type, event, object): |
| """ |
| :param event_type: [str] The string representation of the type of event being triggered by the user. |
| :param event: [QEvent] The base class for all event classes. |
| :param object: [QObject] The base class for all Qt objects. |
| :return: [dict] A userale log describing a resize event. |
| |
| Returns the userale log representing all resize events. |
| """ |
| |
| pass |
| |
| def handleScrollEvents (self, event_type, event, object): |
| """ |
| :param event_type: [str] The string representation of the type of event being triggered by the user. |
| :param event: [QEvent] The base class for all event classes. |
| :param object: [QObject] The base class for all Qt objects. |
| :return: [dict] A userale log describing a scroll event. |
| |
| Returns the userale log representing all scroll events. |
| """ |
| |
| pass |
| |
| def __create_msg (self, event_type, event, object, details={}): |
| """ |
| Geneate UserAle log describing an event. |
| """ |
| |
| data = { |
| 'target': self.getSelector (object) , |
| 'path': self.getPath (object), |
| 'clientTime': self.getClientTime (), |
| 'location': self.getLocation(event), |
| 'type': event_type , |
| 'userAction': 'true', |
| 'details' : details, |
| 'userId': self.user, |
| 'toolVersion': self.version, |
| 'useraleVersion': __version__ |
| } |
| |
| return data |
