def get(self, url, store_on_error=False, xpath=None, rate_limit=None, log_hits=True, log_misses=True):
        """Get a URL via the cache.

        If the URL exists in the cache, return the cached value. Otherwise perform the request,
        store the resulting content in the cache and return it.

        Throws a :class:`RuntimeError` if the request results in an error.

        Args:
            url (str): URL to request
            store_on_error (bool): If True, store request results in cache even if request results in an
                an error. Otherwise (default) do not store results when an error occurs. Cached content
                equals exception message.
            xpath (str): If given (default is None), parses the response content to html, searches the first
                node matching the given xpath and returns only that node (as UTF8-encoded html). Also, only
                stores this node's html in the cache. Raises a ``RuntimeError`` if the xpath cannot be found
                in the response.
            rate_limit (float): If not None (default), wait at least this many seconds between the previous
                request and the current one (this does not apply to cache hits).
            log_hits (bool): If True, log cache hits
            log_misses (bool): If True, log cache misses

        Returns:
            str: request content
        """

        try:
            # get cached request - if none is found, this throws a NoResultFound exception
            cached = self._query(url, xpath).one()
            if log_hits:
                config.logger.info("Request cache hit: " + url)

            # if the cached value is from a request that resulted in an error, throw an exception
            if cached.status_code != requests.codes.ok:
                raise RuntimeError("Cached request returned an error, code " + str(cached.status_code))
        except NoResultFound:
            if log_misses:
                config.logger.info("Request cache miss: " + url)

            # perform the request
            try:

                # rate limit
                if rate_limit is not None and self.last_query is not None:
                    to_sleep = rate_limit - (datetime.datetime.now() - self.last_query).total_seconds()
                    if to_sleep > 0:
                        time.sleep(to_sleep)

                self.last_query = datetime.datetime.now()

                response = requests.get(url)
                status_code = response.status_code
                # get 'text', not 'content', because then we are sure to get unicode
                content = response.text
                response.close()

                if xpath is not None:
                    doc = html.fromstring(content)
                    nodes = doc.xpath(xpath)
                    if len(nodes) == 0:
                        # xpath not found; set content and status code, exception is raised below
                        content = "xpath not found: " + xpath
                        status_code = ERROR_XPATH_NOT_FOUND
                    else:
                        # extract desired node only
                        content = html.tostring(nodes[0], encoding='unicode')

            except requests.ConnectionError as e:
                # on a connection error, write exception information to a response object
                status_code = ERROR_CONNECTION_ERROR
                content = str(e)

            # a new request cache object
            cached = CachedRequest(url=str(url),
                                   content=content,
                                   status_code=status_code,
                                   xpath=xpath,
                                   queried_on=datetime.datetime.now())

            # if desired, store the response even if an error occurred
            if status_code == requests.codes.ok or store_on_error:
                self.session.add(cached)
                self.session.commit()

            if status_code != requests.codes.ok:
                raise RuntimeError("Error processing the request, " + str(status_code) + ": " + content)

        return cached.content