diff --git a/src/widgetastic/browser.py b/src/widgetastic/browser.py
index e1985bc8..1740a489 100644
--- a/src/widgetastic/browser.py
+++ b/src/widgetastic/browser.py
@@ -21,9 +21,9 @@
 from .exceptions import (
     NoSuchElementException, UnexpectedAlertPresentException, MoveTargetOutOfBoundsException,
     StaleElementReferenceException, NoAlertPresentException, LocatorNotImplemented)
-from .log import create_widget_logger, null_logger
+from .log import create_widget_logger, logged, null_logger
+from .utils import repeat_once_on_exceptions
 from .xpath import normalize_space
-from .utils import crop_string_middle
 
 
 # TODO: Resolve this issue in smartloc
@@ -269,6 +269,7 @@ def elements(
 
         return result
 
+    @repeat_once_on_exceptions(NoSuchElementException, check_safe=True)
     def element(self, locator, *args, **kwargs):
         """Returns one :py:class:`selenium.webdriver.remote.webelement.WebElement`
 
@@ -280,6 +281,8 @@ def element(self, locator, *args, **kwargs):
         Raises:
             :py:class:`selenium.common.exceptions.NoSuchElementException`
         """
+        if 'check_safe' not in kwargs:
+            kwargs['check_safe'] = False
         try:
             vcheck = self._locator_force_visibility_check(locator)
             if vcheck is not None:
@@ -294,64 +297,64 @@ def element(self, locator, *args, **kwargs):
             else:
                 return elements[0]
         except IndexError:
-            raise NoSuchElementException('Could not find an element {}'.format(repr(locator)))
+            raise NoSuchElementException('Could not find an element {!r}'.format(locator))
 
-    def perform_click(self):
+    def perform_click(self, ignore_ajax=False):
         """Clicks the left mouse button at the current mouse position."""
         ActionChains(self.selenium).click().perform()
+        if not ignore_ajax:
+            try:
+                self.plugin.ensure_page_safe()
+            except UnexpectedAlertPresentException:
+                pass
 
-    def perform_double_click(self):
+    def perform_double_click(self, ignore_ajax=False):
         """Double-clicks the left mouse button at the current mouse position."""
         ActionChains(self.selenium).double_click().perform()
+        if not ignore_ajax:
+            try:
+                self.plugin.ensure_page_safe()
+            except UnexpectedAlertPresentException:
+                pass
 
+    @logged(log_args=True, only_after=True, debug_only=True, log_full_exception=False)
     def click(self, locator, *args, **kwargs):
         """Clicks at a specific element using two separate events (mouse move, mouse click).
 
         Args: See :py:meth:`elements`
         """
-        self.logger.debug('click: %r', locator)
         ignore_ajax = kwargs.pop('ignore_ajax', False)
         el = self.move_to_element(locator, *args, **kwargs)
         self.plugin.before_click(el)
         # and then click on current mouse position
-        self.perform_click()
-        if not ignore_ajax:
-            try:
-                self.plugin.ensure_page_safe()
-            except UnexpectedAlertPresentException:
-                pass
+        self.perform_click(ignore_ajax)
         try:
             self.plugin.after_click(el)
         except (StaleElementReferenceException, UnexpectedAlertPresentException):
             pass
 
+    @logged(log_args=True, only_after=True, debug_only=True, log_full_exception=False)
     def double_click(self, locator, *args, **kwargs):
         """Double-clicks at a specific element using two separate events (mouse move, mouse click).
 
         Args: See :py:meth:`elements`
         """
-        self.logger.debug('double_click: %r', locator)
         ignore_ajax = kwargs.pop('ignore_ajax', False)
         el = self.move_to_element(locator, *args, **kwargs)
         self.plugin.before_click(el)
         # and then click on current mouse position
-        self.perform_double_click()
-        if not ignore_ajax:
-            try:
-                self.plugin.ensure_page_safe()
-            except UnexpectedAlertPresentException:
-                pass
+        self.perform_double_click(ignore_ajax)
         try:
             self.plugin.after_click(el)
         except (StaleElementReferenceException, UnexpectedAlertPresentException):
             pass
 
+    @logged(log_args=True, only_after=True, debug_only=True, log_full_exception=False)
     def raw_click(self, locator, *args, **kwargs):
         """Clicks at a specific element using the direct event.
 
         Args: See :py:meth:`elements`
         """
-        self.logger.debug('raw_click: %r', locator)
         ignore_ajax = kwargs.pop('ignore_ajax', False)
         el = self.element(locator, *args, **kwargs)
         self.plugin.before_click(el)
@@ -377,11 +380,20 @@ def is_displayed(self, locator, *args, **kwargs):
         kwargs['check_visibility'] = False
         retry = True
         tries = 10
+        checked_page_safe = False
         while retry:
             retry = False
             try:
                 return self.move_to_element(locator, *args, **kwargs).is_displayed()
-            except (NoSuchElementException, MoveTargetOutOfBoundsException):
+            except NoSuchElementException:
+                self.logger.debug(
+                    'is_displayed(%r): Element could not be found on the page',
+                    locator)
+                return False
+            except MoveTargetOutOfBoundsException:
+                self.logger.debug(
+                    'is_displayed(%r): Could not scroll to the element',
+                    locator)
                 return False
             except StaleElementReferenceException:
                 if isinstance(locator, WebElement) or tries <= 0:
@@ -389,11 +401,24 @@ def is_displayed(self, locator, *args, **kwargs):
                     raise
                 retry = True
                 tries -= 1
-                time.sleep(0.1)
 
+            # Before looping again ...
+            time.sleep(0.1)
+            if not checked_page_safe:
+                # Check if hte page is safe ONCE
+                self.plugin.ensure_page_safe()
+                checked_page_safe = True
+
+        self.logger.warning(
+            'is_displayed(%r): Most likely continuous stale element reference.',
+            locator)
         # Just in case
         return False
 
+    @logged(log_args=True, only_after=True, debug_only=True, log_full_exception=False)
+    @repeat_once_on_exceptions(
+        StaleElementReferenceException, MoveTargetOutOfBoundsException,
+        check_safe=True)
     def move_to_element(self, locator, *args, **kwargs):
         """Moves the mouse cursor to the middle of the element represented by the locator.
 
@@ -402,23 +427,31 @@ def move_to_element(self, locator, *args, **kwargs):
 
         Args: See :py:meth:`elements`
 
+        Keywords:
+            workaround: Default True, tells whether it can or can not perform the JS workaround.
+
         Returns:
             :py:class:`selenium.webdriver.remote.webelement.WebElement`
         """
-        self.logger.debug('move_to_element: %r', locator)
+        if 'check_safe' not in kwargs:
+            kwargs['check_safe'] = False
+        workaround = kwargs.pop('workaround', True)
         el = self.element(locator, *args, **kwargs)
         if el.tag_name == "option":
             # Instead of option, let's move on its parent <select> if possible
-            parent = self.element("..", parent=el)
+            parent = self.element("..", parent=el, check_safe=False)
             if parent.tag_name == "select":
-                self.move_to_element(parent)
+                self.move_to_element(parent, workaround=workaround)
                 return el
         move_to = ActionChains(self.selenium).move_to_element(el)
         try:
             move_to.perform()
         except MoveTargetOutOfBoundsException:
+            if not workaround:
+                # No workaround, reraise
+                raise
             # ff workaround
-            self.execute_script("arguments[0].scrollIntoView();", el)
+            self.execute_script("arguments[0].scrollIntoView();", el, silent=True)
             try:
                 move_to.perform()
             except MoveTargetOutOfBoundsException:  # This has become desperate now.
@@ -427,6 +460,7 @@ def move_to_element(self, locator, *args, **kwargs):
                         locator))
         return el
 
+    @logged(log_args=True, only_after=True, log_full_exception=False)
     def drag_and_drop(self, source, target):
         """Drags the source element and drops it into target.
 
@@ -434,11 +468,12 @@ def drag_and_drop(self, source, target):
             source: Locator or the source element itself
             target: Locator or the target element itself.
         """
-        self.logger.debug('drag_and_drop %r to %r', source, target)
         ActionChains(self.selenium)\
             .drag_and_drop(self.element(source), self.element(target))\
             .perform()
+        self.plugin.ensure_page_safe()
 
+    @logged(log_args=True, only_after=True, log_full_exception=False)
     def drag_and_drop_by_offset(self, source, by_x, by_y):
         """Drags the source element and drops it into target.
 
@@ -446,11 +481,12 @@ def drag_and_drop_by_offset(self, source, by_x, by_y):
             source: Locator or the source element itself
             target: Locator or the target element itself.
         """
-        self.logger.debug('drag_and_drop_by_offset %r X:%r Y:%r', source, by_x, by_y)
         ActionChains(self.selenium)\
             .drag_and_drop_by_offset(self.element(source), by_x, by_y)\
             .perform()
+        self.plugin.ensure_page_safe()
 
+    @logged(log_args=True, only_after=True, log_full_exception=False)
     def drag_and_drop_to(self, source, to_x=None, to_y=None):
         """Drags an element to a target location specified by ``to_x`` and ``to_y``
 
@@ -461,7 +497,6 @@ def drag_and_drop_to(self, source, to_x=None, to_y=None):
             to_x: Absolute location on the X axis where to drag the element.
             to_y: Absolute location on the Y axis where to drag the element.
         """
-        self.logger.debug('drag_and_drop_to %r X:%r Y:%r', source, to_x, to_y)
         if to_x is None and to_y is None:
             raise TypeError('You need to pass either to_x or to_y or both')
         middle = self.middle_of(source)
@@ -471,20 +506,29 @@ def drag_and_drop_to(self, source, to_x=None, to_y=None):
             to_y = middle.y
         return self.drag_and_drop_by_offset(source, to_x - middle.x, to_y - middle.y)
 
+    @logged(log_args=True, only_after=True, debug_only=True, log_full_exception=False)
     def move_by_offset(self, x, y):
-        self.logger.debug('move_by_offset X:%r Y:%r', x, y)
+        """Moves mouse pointer by given values."""
         ActionChains(self.selenium).move_by_offset(x, y).perform()
+        self.plugin.ensure_page_safe()
 
     def execute_script(self, script, *args, **kwargs):
         """Executes a script."""
-        if not kwargs.pop('silent', False):
-            self.logger.debug('execute_script: %r', script)
-        return self.selenium.execute_script(dedent(script), *args, **kwargs)
+        silent = kwargs.pop('silent', False)
+        result = self.selenium.execute_script(dedent(script), *args, **kwargs)
+        if not silent:
+            self.logger.debug('execute_script(%r) => %r', script, result)
+        return result
 
+    @logged(only_after=True, log_full_exception=False)
     def refresh(self):
         """Triggers a page refresh."""
-        return self.selenium.refresh()
+        result = self.selenium.refresh()
+        self.plugin.ensure_page_safe()
+        return result
 
+    @logged(
+        log_args=True, log_result=True, only_after=True, debug_only=True, log_full_exception=False)
     def classes(self, locator, *args, **kwargs):
         """Return a list of classes attached to the element.
 
@@ -493,11 +537,11 @@ def classes(self, locator, *args, **kwargs):
         Returns:
             A :py:class:`set` of strings with classes.
         """
-        result = set(self.execute_script(
+        return set(self.execute_script(
             "return arguments[0].classList;", self.element(locator, *args, **kwargs), silent=True))
-        self.logger.debug('css classes for %r => %r', locator, result)
-        return result
 
+    @logged(
+        log_args=True, log_result=True, only_after=True, debug_only=True, log_full_exception=False)
     def tag(self, *args, **kwargs):
         """Returns the tag name of the element represented by the locator passed.
 
@@ -508,6 +552,8 @@ def tag(self, *args, **kwargs):
         """
         return self.element(*args, **kwargs).tag_name
 
+    @logged(
+        log_args=True, log_result=True, only_after=True, debug_only=True, log_full_exception=False)
     def text(self, locator, *args, **kwargs):
         """Returns the text inside the element represented by the locator passed.
 
@@ -520,7 +566,7 @@ def text(self, locator, *args, **kwargs):
             :py:class:`str` with the text
         """
         try:
-            text = self.element(locator, *args, **kwargs).text
+            text = self.move_to_element(locator, *args, **dict(kwargs, workaround=False)).text
         except MoveTargetOutOfBoundsException:
             text = ''
 
@@ -533,46 +579,63 @@ def text(self, locator, *args, **kwargs):
             if text is None:
                 text = ''
 
-        result = normalize_space(text)
-        self.logger.debug('text(%r) => %r', locator, crop_string_middle(result))
-        return result
+        return normalize_space(text)
 
-    def get_attribute(self, attr, *args, **kwargs):
-        return self.element(*args, **kwargs).get_attribute(attr)
+    @logged(
+        log_args=True, log_result=True, only_after=True, debug_only=True, log_full_exception=False)
+    def get_attribute(self, attr, locator, *args, **kwargs):
+        """Get attribute value from an element."""
+        return self.element(locator, *args, **kwargs).get_attribute(attr)
 
-    def set_attribute(self, attr, value, *args, **kwargs):
+    @logged(log_args=True, only_after=True, debug_only=True, log_full_exception=False)
+    def set_attribute(self, attr, value, locator, *args, **kwargs):
         return self.execute_script(
             "arguments[0].setAttribute(arguments[1], arguments[2]);",
-            self.element(*args, **kwargs), attr, value)
+            self.element(locator, *args, **kwargs), attr, value, silent=True)
 
-    def size_of(self, *args, **kwargs):
+    @logged(
+        log_args=True, log_result=True, only_after=True, debug_only=True, log_full_exception=False)
+    def size_of(self, locator, *args, **kwargs):
         """Returns element's size as a tuple of width/height."""
-        size = self.element(*args, **kwargs).size
+        size = self.element(locator, *args, **kwargs).size
         return Size(size['width'], size['height'])
 
+    @logged(
+        log_args=True, log_result=True, only_after=True, debug_only=True, log_full_exception=False)
     def location_of(self, *args, **kwargs):
         """Returns element's location as a tuple of x/y."""
         location = self.element(*args, **kwargs).location
         return Location(location['x'], location['y'])
 
+    @logged(
+        log_args=True, log_result=True, only_after=True, debug_only=True, log_full_exception=False)
     def middle_of(self, *args, **kwargs):
         """Returns element's location as a tuple of x/y."""
         size = self.size_of(*args, **kwargs)
         location = self.location_of(*args, **kwargs)
         return Location(location.x + size.width / 2, location.y + size.height / 2)
 
+    @logged(log_args=True, only_after=True, debug_only=True, log_full_exception=False)
     def clear(self, locator, *args, **kwargs):
         """Clears a text input with given locator."""
-        self.logger.debug('clear: %r', locator)
         el = self.element(locator, *args, **kwargs)
         self.plugin.before_keyboard_input(el, None)
         result = el.clear()
+        self.plugin.ensure_page_safe()
         self.plugin.after_keyboard_input(el, None)
         return result
 
-    def is_selected(self, *args, **kwargs):
-        return self.element(*args, **kwargs).is_selected()
+    @logged(
+        log_args=True, log_result=True, only_after=True, debug_only=True, log_full_exception=False)
+    def is_selected(self, locator, *args, **kwargs):
+        """Returns whether the element (checkbox) is selected.
 
+        Returns:
+            :py:class:`bool`
+        """
+        return self.element(locator, *args, **kwargs).is_selected()
+
+    @logged(log_args=True, debug_only=True, log_full_exception=False)
     def send_keys(self, text, locator, *args, **kwargs):
         """Sends keys to the element. Detects the file inputs automatically.
 
@@ -594,8 +657,9 @@ def send_keys(self, text, locator, *args, **kwargs):
                 self.selenium.file_detector = LocalFileDetector()
             el = self.move_to_element(locator, *args, **kwargs)
             self.plugin.before_keyboard_input(el, text)
-            self.logger.debug('send_keys %r to %r', text, locator)
             result = el.send_keys(text)
+            # Ensure the page input was safe
+            self.plugin.ensure_page_safe()
             if Keys.ENTER not in text:
                 try:
                     self.plugin.after_keyboard_input(el, text)
@@ -623,6 +687,8 @@ def get_alert(self):
         return self.selenium.switch_to_alert()
 
     @property
+    @logged(
+        log_args=True, log_result=True, only_after=True, debug_only=True, log_full_exception=False)
     def alert_present(self):
         """Checks whether there is any alert present.
 
@@ -637,6 +703,7 @@ def alert_present(self):
         else:
             return True
 
+    @logged(log_args=True, log_full_exception=False)
     def dismiss_any_alerts(self):
         """Loops until there are no further alerts present to dismiss.
 
@@ -650,6 +717,7 @@ def dismiss_any_alerts(self):
         except NoAlertPresentException:  # Just in case. alert_present should be reliable
             pass
 
+    @logged(log_args=True, log_result=True, log_full_exception=False)
     def handle_alert(self, cancel=False, wait=30.0, squash=False, prompt=None, check_present=False):
         """Handles an alert popup.
 
diff --git a/src/widgetastic/log.py b/src/widgetastic/log.py
index bfb911cf..2f96918a 100644
--- a/src/widgetastic/log.py
+++ b/src/widgetastic/log.py
@@ -3,9 +3,10 @@
 
 import logging
 import time
-from six import wraps, get_method_function, get_method_self
+from six import wraps, get_method_function, get_method_self, string_types
 
 from .exceptions import DoNotReadThisWidget
+from .utils import crop_string_middle
 
 
 null_logger = logging.getLogger('widgetastic_null')
@@ -92,7 +93,9 @@ def create_item_logger(parent_logger, item):
     return _create_logger_appender(parent_logger, '[{!r}]'.format(item))
 
 
-def logged(log_args=False, log_result=False):
+def logged(
+        log_args=False, log_result=False, only_after=False, debug_only=False,
+        log_full_exception=True, string_crop=64):
     """Decorator that logs entry and exit to a method and also times the execution.
 
     It assumes that the object where you decorate the methods on has a ``.logger`` attribute.
@@ -105,34 +108,52 @@ def logged(log_args=False, log_result=False):
     Args:
         log_args: Whether to log args passed to the method
         log_result: Whether to log the result value returned from the method.
+        only_after: Whether to log only after the method finished.
+        debug_only: Use only debug log level at max.
+        log_full_exception: Whether to log the full exceptions.
+        string_crop: Length to which to crop the strings if they are return values
     """
     def g(f):
         @wraps(f)
         def wrapped(self, *args, **kwargs):
+            if debug_only:
+                info_logger = self.logger.debug
+            else:
+                info_logger = self.logger.info
             start_time = time.time()
             signature = f.__name__ + (call_sig(args, kwargs) if log_args else '')
-            self.logger.debug('%s started', signature)
+            if not only_after:
+                self.logger.debug('%s started', signature)
             try:
                 result = f(self, *args, **kwargs)
             except DoNotReadThisWidget:
                 elapsed_time = (time.time() - start_time) * 1000.0
-                self.logger.info(
+                info_logger(
                     '%s not read on widget\'s request (elapsed %.0f ms)',
                     signature, elapsed_time)
                 raise
             except Exception as e:
                 elapsed_time = (time.time() - start_time) * 1000.0
-                self.logger.error(
-                    'An exception happened during %s call (elapsed %.0f ms)',
-                    signature, elapsed_time)
-                self.logger.exception(e)
+                if log_full_exception:
+                    self.logger.exception(
+                        'An exception happened during %s call (elapsed %.0f ms)',
+                        signature, elapsed_time)
+                else:
+                    self.logger.error(
+                        'An exception %s happened during %s call (elapsed %.0f ms)',
+                        str(e), signature, elapsed_time)
                 raise
             else:
                 elapsed_time = (time.time() - start_time) * 1000.0
                 if log_result:
-                    self.logger.info('%s -> %r (elapsed %.0f ms)', signature, result, elapsed_time)
+                    result_to_log = result
+                    if isinstance(result_to_log, string_types):
+                        result_to_log = crop_string_middle(result_to_log, length=string_crop)
+                    info_logger(
+                        '%s -> %r (elapsed %.0f ms)',
+                        signature, result_to_log, elapsed_time)
                 else:
-                    self.logger.info('%s (elapsed %.0f ms)', signature, elapsed_time)
+                    info_logger('%s (elapsed %.0f ms)', signature, elapsed_time)
                 return result
 
         wrapped.original_function = f
diff --git a/src/widgetastic/utils.py b/src/widgetastic/utils.py
index bff87d5c..78a52e06 100644
--- a/src/widgetastic/utils.py
+++ b/src/widgetastic/utils.py
@@ -6,6 +6,7 @@
 import six
 import string
 from cached_property import cached_property
+from functools import wraps
 from smartloc import Locator
 from threading import Lock
 
@@ -545,3 +546,34 @@ def crop_string_middle(s, length=32, cropper='...'):
         return s
     half = (length - len(cropper)) / 2
     return s[:half] + cropper + s[-half - 1:]
+
+
+def repeat_once_on_exceptions(*exception_classes, **set_key_to_what):
+    """This decorator serves as DRY repeater of method or function execution.
+
+    Works the way that when any of the exception classes is caught, the kwargs of the method call
+    is updated with ``set_key_to_what`` and invoked once more.
+
+    Args:
+        *exception_classes: Exception classes on which this decorator should react
+        **set_key_to_what: kwargs override used when the exception is hit and call retried.
+
+    Returns:
+        Whatever the wrapped function/method returns.
+
+    """
+    if not set_key_to_what:
+        raise TypeError('set_key_to_what is not set!')
+
+    def g(f):
+        @wraps(f)
+        def wrapped(*args, **kwargs):
+            try:
+                return f(*args, **kwargs)
+            except exception_classes:
+                kwargs.update(set_key_to_what)
+                return f(*args, **kwargs)
+
+        return wrapped
+
+    return g
diff --git a/testing/conftest.py b/testing/conftest.py
index fb5909d4..0c26924e 100644
--- a/testing/conftest.py
+++ b/testing/conftest.py
@@ -3,6 +3,7 @@
 import pytest
 
 import codecs
+import logging
 import os
 import sys
 
@@ -13,6 +14,15 @@
 selenium_browser = None
 
 
+# Browser logger
+browser_logger = logging.getLogger('widgetastic_browser')
+out_hdlr = logging.StreamHandler(sys.stdout)
+out_hdlr.setFormatter(logging.Formatter('%(asctime)s %(message)s'))
+out_hdlr.setLevel(logging.DEBUG)
+browser_logger.addHandler(out_hdlr)
+browser_logger.setLevel(logging.DEBUG)
+
+
 class CustomBrowser(Browser):
     @property
     def product_version(self):
@@ -35,6 +45,6 @@ def browser(selenium, httpserver, request):
     path = os.path.dirname(this_module.__file__)
     testfilename = os.path.join(path, 'testing_page.html')
     httpserver.serve_content(codecs.open(testfilename, mode='r', encoding='utf-8').read())
-    b = CustomBrowser(selenium)
+    b = CustomBrowser(selenium, logger=browser_logger)
     b.url = httpserver.url
     return b