diff --git a/PKG-INFO b/PKG-INFO
index c6bcfddf..b79f2627 100644
--- a/PKG-INFO
+++ b/PKG-INFO
@@ -1,202 +1,202 @@
 Metadata-Version: 2.1
 Name: swh.storage
-Version: 0.0.174
+Version: 0.0.175
 Summary: Software Heritage storage manager
 Home-page: https://forge.softwareheritage.org/diffusion/DSTO/
 Author: Software Heritage developers
 Author-email: swh-devel@inria.fr
 License: UNKNOWN
 Project-URL: Bug Reports, https://forge.softwareheritage.org/maniphest
 Project-URL: Funding, https://www.softwareheritage.org/donate
 Project-URL: Source, https://forge.softwareheritage.org/source/swh-storage
 Description: swh-storage
         ===========
         
         Abstraction layer over the archive, allowing to access all stored source code
         artifacts as well as their metadata.
         
         See the
         [documentation](https://docs.softwareheritage.org/devel/swh-storage/index.html)
         for more details.
         
         ## Quick start
         
         ### Dependencies
         
         Python tests for this module include tests that cannot be run without
         a local Postgresql database, so you need the Postgresql server executable on
         your machine (no need to have a running Postgresql server). On a Debian-like
         host:
         
         ```
         $ sudo apt install libpq-dev postgresql
         ```
         
         ### Installation
         
         It is strongly recommended to use a virtualenv. In the following, we
         consider you work in a virtualenv named `swh`. See the
         [developer setup guide](https://docs.softwareheritage.org/devel/developer-setup.html#developer-setup)
         for a more details on how to setup a working environment.
         
         
         You can install the package directly from
         [pypi](https://pypi.org/p/swh.storage):
         
         ```
         (swh) :~$ pip install swh.storage
         [...]
         ```
         
         Or from sources:
         
         ```
         (swh) :~$ git clone https://forge.softwareheritage.org/source/swh-storage.git
         [...]
         (swh) :~$ cd swh-storage
         (swh) :~/swh-storage$ pip install .
         [...]
         ```
         
         Then you can check it's properly installed:
         ```
         (swh) :~$ swh storage --help
         Usage: swh storage [OPTIONS] COMMAND [ARGS]...
         
           Software Heritage Storage tools.
         
         Options:
           -h, --help  Show this message and exit.
         
         Commands:
           rpc-serve  Software Heritage Storage RPC server.
         ```
         
         
         ## Tests
         
         The best way of running Python tests for this module is to use
         [tox](https://tox.readthedocs.io/).
         
         ```
         (swh) :~$ pip install tox
         ```
         
         ### tox
         
         From the sources directory, simply use tox:
         
         ```
         (swh) :~/swh-storage$ tox
         [...]
         ========= 315 passed, 6 skipped, 15 warnings in 40.86 seconds ==========
         _______________________________ summary ________________________________
           flake8: commands succeeded
           py3: commands succeeded
           congratulations :)
         ```
         
         ## Development
         
         The storage server can be locally started. It requires a configuration file and
         a running Postgresql database.
         
         ### Sample configuration
         
         A typical configuration `storage.yml` file is:
         
         ```
         storage:
           cls: local
           args:
             db: "dbname=softwareheritage-dev user=<user> password=<pwd>"
             objstorage:
               cls: pathslicing
               args:
                 root: /tmp/swh-storage/
                 slicing: 0:2/2:4/4:6
         ```
         
         which means, this uses:
         
         - a local storage instance whose db connection is to
           `softwareheritage-dev` local instance,
         
         - the objstorage uses a local objstorage instance whose:
         
           - `root` path is /tmp/swh-storage,
         
           - slicing scheme is `0:2/2:4/4:6`. This means that the identifier of
             the content (sha1) which will be stored on disk at first level
             with the first 2 hex characters, the second level with the next 2
             hex characters and the third level with the next 2 hex
             characters. And finally the complete hash file holding the raw
             content. For example: 00062f8bd330715c4f819373653d97b3cd34394c
             will be stored at 00/06/2f/00062f8bd330715c4f819373653d97b3cd34394c
         
         Note that the `root` path should exist on disk before starting the server.
         
         
         ### Starting the storage server
         
         If the python package has been properly installed (e.g. in a virtual env), you
         should be able to use the command:
         
         ```
         (swh) :~/swh-storage$ swh storage rpc-serve storage.yml
         ```
         
         This runs a local swh-storage api at 5002 port.
         
         ```
         (swh) :~/swh-storage$ curl http://127.0.0.1:5002
         <html>
         <head><title>Software Heritage storage server</title></head>
         <body>
         <p>You have reached the
         <a href="https://www.softwareheritage.org/">Software Heritage</a>
         storage server.<br />
         See its
         <a href="https://docs.softwareheritage.org/devel/swh-storage/">documentation
         and API</a> for more information</p>
         ```
         
         ### And then what?
         
         In your upper layer
         ([loader-git](https://forge.softwareheritage.org/source/swh-loader-git/),
         [loader-svn](https://forge.softwareheritage.org/source/swh-loader-svn/),
         etc...), you can define a remote storage with this snippet of yaml
         configuration.
         
         ```
         storage:
           cls: remote
           args:
             url: http://localhost:5002/
         ```
         
         You could directly define a local storage with the following snippet:
         
         ```
         storage:
           cls: local
           args:
             db: service=swh-dev
             objstorage:
               cls: pathslicing
               args:
                 root: /home/storage/swh-storage/
                 slicing: 0:2/2:4/4:6
         ```
         
 Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 5 - Production/Stable
 Description-Content-Type: text/markdown
 Provides-Extra: testing
 Provides-Extra: schemata
 Provides-Extra: journal
diff --git a/swh.storage.egg-info/PKG-INFO b/swh.storage.egg-info/PKG-INFO
index c6bcfddf..b79f2627 100644
--- a/swh.storage.egg-info/PKG-INFO
+++ b/swh.storage.egg-info/PKG-INFO
@@ -1,202 +1,202 @@
 Metadata-Version: 2.1
 Name: swh.storage
-Version: 0.0.174
+Version: 0.0.175
 Summary: Software Heritage storage manager
 Home-page: https://forge.softwareheritage.org/diffusion/DSTO/
 Author: Software Heritage developers
 Author-email: swh-devel@inria.fr
 License: UNKNOWN
 Project-URL: Bug Reports, https://forge.softwareheritage.org/maniphest
 Project-URL: Funding, https://www.softwareheritage.org/donate
 Project-URL: Source, https://forge.softwareheritage.org/source/swh-storage
 Description: swh-storage
         ===========
         
         Abstraction layer over the archive, allowing to access all stored source code
         artifacts as well as their metadata.
         
         See the
         [documentation](https://docs.softwareheritage.org/devel/swh-storage/index.html)
         for more details.
         
         ## Quick start
         
         ### Dependencies
         
         Python tests for this module include tests that cannot be run without
         a local Postgresql database, so you need the Postgresql server executable on
         your machine (no need to have a running Postgresql server). On a Debian-like
         host:
         
         ```
         $ sudo apt install libpq-dev postgresql
         ```
         
         ### Installation
         
         It is strongly recommended to use a virtualenv. In the following, we
         consider you work in a virtualenv named `swh`. See the
         [developer setup guide](https://docs.softwareheritage.org/devel/developer-setup.html#developer-setup)
         for a more details on how to setup a working environment.
         
         
         You can install the package directly from
         [pypi](https://pypi.org/p/swh.storage):
         
         ```
         (swh) :~$ pip install swh.storage
         [...]
         ```
         
         Or from sources:
         
         ```
         (swh) :~$ git clone https://forge.softwareheritage.org/source/swh-storage.git
         [...]
         (swh) :~$ cd swh-storage
         (swh) :~/swh-storage$ pip install .
         [...]
         ```
         
         Then you can check it's properly installed:
         ```
         (swh) :~$ swh storage --help
         Usage: swh storage [OPTIONS] COMMAND [ARGS]...
         
           Software Heritage Storage tools.
         
         Options:
           -h, --help  Show this message and exit.
         
         Commands:
           rpc-serve  Software Heritage Storage RPC server.
         ```
         
         
         ## Tests
         
         The best way of running Python tests for this module is to use
         [tox](https://tox.readthedocs.io/).
         
         ```
         (swh) :~$ pip install tox
         ```
         
         ### tox
         
         From the sources directory, simply use tox:
         
         ```
         (swh) :~/swh-storage$ tox
         [...]
         ========= 315 passed, 6 skipped, 15 warnings in 40.86 seconds ==========
         _______________________________ summary ________________________________
           flake8: commands succeeded
           py3: commands succeeded
           congratulations :)
         ```
         
         ## Development
         
         The storage server can be locally started. It requires a configuration file and
         a running Postgresql database.
         
         ### Sample configuration
         
         A typical configuration `storage.yml` file is:
         
         ```
         storage:
           cls: local
           args:
             db: "dbname=softwareheritage-dev user=<user> password=<pwd>"
             objstorage:
               cls: pathslicing
               args:
                 root: /tmp/swh-storage/
                 slicing: 0:2/2:4/4:6
         ```
         
         which means, this uses:
         
         - a local storage instance whose db connection is to
           `softwareheritage-dev` local instance,
         
         - the objstorage uses a local objstorage instance whose:
         
           - `root` path is /tmp/swh-storage,
         
           - slicing scheme is `0:2/2:4/4:6`. This means that the identifier of
             the content (sha1) which will be stored on disk at first level
             with the first 2 hex characters, the second level with the next 2
             hex characters and the third level with the next 2 hex
             characters. And finally the complete hash file holding the raw
             content. For example: 00062f8bd330715c4f819373653d97b3cd34394c
             will be stored at 00/06/2f/00062f8bd330715c4f819373653d97b3cd34394c
         
         Note that the `root` path should exist on disk before starting the server.
         
         
         ### Starting the storage server
         
         If the python package has been properly installed (e.g. in a virtual env), you
         should be able to use the command:
         
         ```
         (swh) :~/swh-storage$ swh storage rpc-serve storage.yml
         ```
         
         This runs a local swh-storage api at 5002 port.
         
         ```
         (swh) :~/swh-storage$ curl http://127.0.0.1:5002
         <html>
         <head><title>Software Heritage storage server</title></head>
         <body>
         <p>You have reached the
         <a href="https://www.softwareheritage.org/">Software Heritage</a>
         storage server.<br />
         See its
         <a href="https://docs.softwareheritage.org/devel/swh-storage/">documentation
         and API</a> for more information</p>
         ```
         
         ### And then what?
         
         In your upper layer
         ([loader-git](https://forge.softwareheritage.org/source/swh-loader-git/),
         [loader-svn](https://forge.softwareheritage.org/source/swh-loader-svn/),
         etc...), you can define a remote storage with this snippet of yaml
         configuration.
         
         ```
         storage:
           cls: remote
           args:
             url: http://localhost:5002/
         ```
         
         You could directly define a local storage with the following snippet:
         
         ```
         storage:
           cls: local
           args:
             db: service=swh-dev
             objstorage:
               cls: pathslicing
               args:
                 root: /home/storage/swh-storage/
                 slicing: 0:2/2:4/4:6
         ```
         
 Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 5 - Production/Stable
 Description-Content-Type: text/markdown
 Provides-Extra: testing
 Provides-Extra: schemata
 Provides-Extra: journal
diff --git a/swh/storage/retry.py b/swh/storage/retry.py
index 5da95eb7..5cf331e7 100644
--- a/swh/storage/retry.py
+++ b/swh/storage/retry.py
@@ -1,145 +1,151 @@
 # Copyright (C) 2019-2020 The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import logging
 import traceback
 
 from datetime import datetime
 from typing import Dict, Iterable, List, Optional, Union
 
 from tenacity import (
     retry, stop_after_attempt, wait_random_exponential,
 )
 
 from swh.model.model import (
     Content, SkippedContent, Directory, Revision, Release, Snapshot,
     Origin,
 )
 
 from swh.storage import get_storage
 from swh.storage.exc import StorageArgumentException
 
 
 logger = logging.getLogger(__name__)
 
 
 def should_retry_adding(retry_state) -> bool:
     """Retry if the error/exception is (probably) not about a caller error
 
     """
-    if retry_state.outcome.failed:
-        error = retry_state.outcome.exception()
+    try:
+        attempt = retry_state.outcome
+    except AttributeError:
+        # tenacity < 5.0
+        attempt = retry_state
+
+    if attempt.failed:
+        error = attempt.exception()
         if isinstance(error, StorageArgumentException):
             # Exception is due to an invalid argument
             return False
         else:
             # Other exception
             module = getattr(error, '__module__', None)
             if module:
                 error_name = error.__module__ + '.' + error.__class__.__name__
             else:
                 error_name = error.__class__.__name__
             logger.warning('Retry adding a batch', exc_info=False, extra={
                 'swh_type': 'storage_retry',
                 'swh_exception_type': error_name,
                 'swh_exception': traceback.format_exc(),
             })
             return True
     else:
         # No exception
         return False
 
 
 swh_retry = retry(retry=should_retry_adding,
                   wait=wait_random_exponential(multiplier=1, max=10),
                   stop=stop_after_attempt(3))
 
 
 class RetryingProxyStorage:
     """Storage implementation which retries adding objects when it specifically
        fails (hash collision, integrity error).
 
     """
     def __init__(self, storage):
         self.storage = get_storage(**storage)
 
     def __getattr__(self, key):
         if key == 'storage':
             raise AttributeError(key)
         return getattr(self.storage, key)
 
     @swh_retry
     def content_add(self, content: Iterable[Content]) -> Dict:
         return self.storage.content_add(content)
 
     @swh_retry
     def content_add_metadata(self, content: Iterable[Content]) -> Dict:
         return self.storage.content_add_metadata(content)
 
     @swh_retry
     def skipped_content_add(self, content: Iterable[SkippedContent]) -> Dict:
         return self.storage.skipped_content_add(content)
 
     @swh_retry
     def origin_add_one(self, origin: Origin) -> str:
         return self.storage.origin_add_one(origin)
 
     @swh_retry
     def origin_visit_add(self, origin: Dict,
                          date: Union[datetime, str], type: str) -> Dict:
         return self.storage.origin_visit_add(origin, date, type)
 
     @swh_retry
     def origin_visit_update(
             self, origin: str, visit_id: int, status: Optional[str] = None,
             metadata: Optional[Dict] = None,
             snapshot: Optional[Dict] = None) -> Dict:
         return self.storage.origin_visit_update(
             origin, visit_id, status=status,
             metadata=metadata, snapshot=snapshot)
 
     @swh_retry
     def tool_add(self, tools: Iterable[Dict]) -> List[Dict]:
         tools = list(tools)
         return self.storage.tool_add(tools)
 
     @swh_retry
     def metadata_provider_add(
             self, provider_name: str, provider_type: str, provider_url: str,
             metadata: Dict) -> Union[str, int]:
         return self.storage.metadata_provider_add(
             provider_name, provider_type, provider_url, metadata)
 
     @swh_retry
     def origin_metadata_add(
             self, origin_url: str, ts: Union[str, datetime],
             provider_id: int, tool_id: int, metadata: Dict) -> None:
         return self.storage.origin_metadata_add(
             origin_url, ts, provider_id, tool_id, metadata)
 
     @swh_retry
     def directory_add(self, directories: Iterable[Directory]) -> Dict:
         return self.storage.directory_add(directories)
 
     @swh_retry
     def revision_add(self, revisions: Iterable[Revision]) -> Dict:
         return self.storage.revision_add(revisions)
 
     @swh_retry
     def release_add(self, releases: Iterable[Release]) -> Dict:
         return self.storage.release_add(releases)
 
     @swh_retry
     def snapshot_add(self, snapshots: Iterable[Snapshot]) -> Dict:
         return self.storage.snapshot_add(snapshots)
 
     @swh_retry
     def flush(self, object_types: Optional[Iterable[str]] = None) -> Dict:
         """Specific case for buffer proxy storage failing to flush data
 
         """
         if hasattr(self.storage, 'flush'):
             return self.storage.flush(object_types)
         return {}
diff --git a/version.txt b/version.txt
index a7ed949f..39585254 100644
--- a/version.txt
+++ b/version.txt
@@ -1 +1 @@
-v0.0.174-0-g7cf0864
\ No newline at end of file
+v0.0.175-0-gb093a5a
\ No newline at end of file