diff --git a/.travis.yml b/.travis.yml
index 45eb60d..51678f6 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,10 +1,46 @@
+dist: xenial
 language: python
 python:
-  - "2.7"
-  - "3.6"
-# command to install dependencies
+  - '2.7'
+  - '3.5'
+  - '3.6'
+  - '3.7'
+  - '3.8'
+  - 'nightly'
+  - 'pypy'
+  - 'pypy3.5'
+
+stages:
+  - lint
+  - test
+  - name: deploy
+    if: tag is present
+
+matrix:
+  include:
+    - stage: lint
+      name: flake8
+      python: '3.7'
+    - stage: deploy
+      name: Deploy to PyPI
+      python: '3.7'
+      install: skip
+      script: skip
+  allow_failures:
+    - python: 'nightly'
+
 install:
-  - pip install -r requirements.txt
-# command to run tests
+  - pip install tox-travis
+
 script:
-  -  pytest
+  - tox
+
+deploy:
+  provider: pypi
+  distributions: sdist
+  user: '__token__'
+  password:
+    secure: 'YkwqdS/sPOcu43pPEAz3YvkJPp+FoSZ39xCM+3wXC5K+SpJW+APn5FH7izivs5DzqRtEP/dLwxUrtk4O+IvFxMgOeRXkGUszRUCYNV819iJwXlcVtODJfdjB+B/pFz6WERh13GhVl6PsG+SBgVE4GNu8F7svCepDX7kcHw1xa+tjkSg1mzmDuZuAhth8Gkph/7LHupx5VP8p96oOViLjI98SCnGDHbmzpDVzW1GZjO5wsTuCc6YYsc0ydKxMYUjaE+7PIMqziK3FjvZj6drnR8SV6e+9kWPNYQ8kodQTfeQuXqwq7s2Va/5lx9iZ+tdBCnCBEb+ehV43M13cqk6jnkZMbC2OZ7TY5Mtm/JWZe9QNcAutdeiqqaSCuGCWP7RT+jgyJaWtHGbAlRj8loHKCFgyzhwK77N/as9oyIxQSVYBIYNtSsvgG33BJQXO9oLf85qZ/C4WkFCX2JeZLAAvMv8Pm0r1lhmtN1nKEdOl6H0VQUls9S2u7s+HnEoTu9TXQ6FiDwV3iF9lZAr1kfPsGhZyEm/rxnMBrPnbbr7puLRJwOp5u1GT0nyp9C2Bpg1XrgpmrK14mpsd0eOMYIdEMc0v1qflze+DyVSEyccj/WbvXlW788bnoGd8svapRbo2ZUf+EfUaIi/S0dzNzQJMx7BHGprpuqHkEmmUbTO8o4Q='
+  on:
+    condition: $TRAVIS_BUILD_STAGE_NAME = Deploy
+    tags: true
diff --git a/Makefile b/Makefile
index cb49486..9339e56 100644
--- a/Makefile
+++ b/Makefile
@@ -1,8 +1,21 @@
+project := flask_opentracing
+
+pytest := PYTHONDONTWRITEBYTECODE=1 py.test --tb short -rxs \
+	--cov-report term-missing:skip-covered --cov=$(project) tests
+
 .PHONY: test publish install clean clean-build clean-pyc clean-test build upload-docs
 
 install: 
 	python setup.py install
 
+check-virtual-env:
+	@echo virtual-env: $${VIRTUAL_ENV?"Please run in virtual-env"}
+
+bootstrap: check-virtual-env
+	pip install -r requirements.txt
+	pip install -r requirements-test.txt
+	python setup.py develop
+
 clean: clean-build clean-pyc clean-test
 
 clean-build:
@@ -25,13 +38,18 @@ clean-test:
 	rm -f coverage.xml
 	rm -fr htmlcov/
 
-test: 
-	python setup.py test
-	make -C docs doctest
+lint:
+	flake8 $(project) tests
+
+test:
+	$(pytest)
 
 build: 
 	python setup.py build
 
+docs:
+	make -C docs doctest
+
 upload-docs:
 	git submodule update --init  # for sphinx flask theme
 	python setup.py build_sphinx
diff --git a/README.rst b/README.rst
index 8e5db8f..521208d 100644
--- a/README.rst
+++ b/README.rst
@@ -2,14 +2,22 @@
 Flask-OpenTracing
 #################
 
+**Note:** *This package is no longer maintained or supported. Migrate your application
+to use* `opentelemetry-api`_.
+
+
 This package enables distributed tracing in Flask applications via `The OpenTracing Project`_. Once a production system contends with real concurrency or splits into many services, crucial (and formerly easy) tasks become difficult: user-facing latency optimization, root-cause analysis of backend errors, communication about distinct pieces of a now-distributed system, etc. Distributed tracing follows a request on its journey from inception to completion from mobile/browser all the way to the microservices. 
 
 As core services and libraries adopt OpenTracing, the application builder is no longer burdened with the task of adding basic tracing instrumentation to their own code. In this way, developers can build their applications with the tools they prefer and benefit from built-in tracing instrumentation. OpenTracing implementations exist for major distributed tracing systems and can be bound or swapped with a one-line configuration change.
 
 If you want to learn more about the underlying python API, visit the python `source code`_.
 
+If you are migrating from the 0.x series, you may want to read the list of `breaking changes`_.
+
 .. _The OpenTracing Project: http://opentracing.io/
 .. _source code: https://github.com/opentracing/opentracing-python
+.. _breaking changes: #breaking-changes-from-0-x
+.. _opentelemetry-api: https://pypi.org/project/opentelemetry-api/
 
 Installation
 ============
@@ -24,7 +32,7 @@ Usage
 =====
 
 This Flask extension allows for tracing of Flask apps using the OpenTracing API. All
-that it requires is for a FlaskTracing tracer to be initialized using an
+that it requires is for a ``FlaskTracing`` tracer to be initialized using an
 instance of an OpenTracing tracer. You can either trace all requests to your site, or use function decorators to trace certain individual requests.
 
 **Note:** `optional_args` in both cases are any number of attributes (as strings) of `flask.Request` that you wish to set as tags on the created span
@@ -32,28 +40,28 @@ instance of an OpenTracing tracer. You can either trace all requests to your sit
 Initialize
 ----------
 
-`FlaskTracer` wraps the tracer instance that's supported by opentracing. To create a `FlaskTracer` object, you can either pass in a tracer object directly or a callable that returns the tracer object. For example:
+`FlaskTracing` wraps the tracer instance that's supported by opentracing. To create a `FlaskTracing` object, you can either pass in a tracer object directly or a callable that returns the tracer object. For example:
 
 .. code-block:: python
 
     import opentracing
-    from flask_opentracing import FlaskTracer
+    from flask_opentracing import FlaskTracing
 
     opentracing_tracer = ## some OpenTracing tracer implementation
-    tracer = FlaskTracer(opentracing_tracer, ...)
+    tracing = FlaskTracing(opentracing_tracer, ...)
 
 or
 
 .. code-block:: python
 
     import opentracing
-    from flask_opentracing import FlaskTracer
+    from flask_opentracing import FlaskTracing
 
     def initialize_tracer():
         ...
         return opentracing_tracer
 
-    tracer = FlaskTracer(initialize_tracer, ...)
+    tracing = FlaskTracing(initialize_tracer, ...)
 
 
 Trace All Requests
@@ -62,12 +70,12 @@ Trace All Requests
 .. code-block:: python
 
     import opentracing
-    from flask_opentracing import FlaskTracer
+    from flask_opentracing import FlaskTracing
 
     app = Flask(__name__)
 
     opentracing_tracer = ## some OpenTracing tracer implementation
-    tracer = FlaskTracer(opentracing_tracer, True, app, [optional_args])
+    tracing = FlaskTracing(opentracing_tracer, True, app, [optional_args])
 
 Trace Individual Requests
 -------------------------
@@ -75,15 +83,15 @@ Trace Individual Requests
 .. code-block:: python
 
     import opentracing
-    from flask_opentracing import FlaskTracer
+    from flask_opentracing import FlaskTracing
 
     app = Flask(__name__)
 
     opentracing_tracer = ## some OpenTracing tracer implementation  
-    tracer = FlaskTracer(opentracing_tracer)
+    tracing = FlaskTracing(opentracing_tracer)
 
     @app.route('/some_url')
-    @tracer.trace(optional_args)
+    @tracing.trace(optional_args)
     def some_view_func():
     	...     
     	return some_view 
@@ -91,7 +99,7 @@ Trace Individual Requests
 Accessing Spans Manually
 ------------------------
 
-In order to access the span for a request, we've provided an method `FlaskTracer.get_span(request)` that returns the span for the request, if it is exists and is not finished. This can be used to log important events to the span, set tags, or create child spans to trace non-RPC events. If no request is passed in, the current request will be used.
+In order to access the span for a request, we've provided an method `FlaskTracing.get_span(request)` that returns the span for the request, if it is exists and is not finished. This can be used to log important events to the span, set tags, or create child spans to trace non-RPC events. If no request is passed in, the current request will be used.
 
 Tracing an RPC
 --------------
@@ -100,14 +108,14 @@ If you want to make an RPC and continue an existing trace, you can inject the cu
 
 .. code-block:: python
 
-    @tracer.trace()
+    @tracing.trace()
     def some_view_func(request):
         new_request = some_http_request
-        current_span = tracer.get_span(request)
+        current_span = tracing.get_span(request)
         text_carrier = {}
         opentracing_tracer.inject(span, opentracing.Format.TEXT_MAP, text_carrier)
         for k, v in text_carrier.iteritems():
-            request.add_header(k,v)
+            new_request.add_header(k,v)
         ... # make request
 
 Examples
@@ -120,6 +128,18 @@ with integrated OpenTracing tracers.
 
 `This tutorial <http://blog.scoutapp.com/articles/2018/01/15/tutorial-tracing-python-flask-requests-with-opentracing>`_ has a step-by-step guide for using `Flask-Opentracing` with `Jaeger <https://github.com/jaegertracing/jaeger>`_.
 
+Breaking changes from 0.x
+=========================
+
+Starting with the 1.0 version, a few changes have taken place from previous versions:
+
+* ``FlaskTracer`` has been renamed to ``FlaskTracing``, although ``FlaskTracing``
+  can be used still as a deprecated name.
+* When passing an ``Application`` object at ``FlaskTracing`` creation time,
+  ``trace_all_requests`` defaults to ``True``.
+* When no ``opentracing.Tracer`` is provided, ``FlaskTracing`` will rely on the
+  global tracer.
+
 Further Information
 ===================
 
diff --git a/VERSION b/VERSION
index 0ea3a94..227cea2 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.2.0
+2.0.0
diff --git a/docs/index.rst b/docs/index.rst
index 87eaed0..1401be7 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -34,12 +34,12 @@ Trace All Requests
 .. code-block:: python
 
     import opentracing
-    from flask_opentracing import FlaskTracer
+    from flask_opentracing import FlaskTracing
 
     app = Flask(__name__)
 
     opentracing_tracer = ## some OpenTracing tracer implementation
-    tracer = FlaskTracer(opentracing_tracer, True, app, [optional_args])
+    tracing = FlaskTracing(opentracing_tracer, True, app, [optional_args])
 
 Trace Individual Requests
 ~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -47,15 +47,15 @@ Trace Individual Requests
 .. code-block:: python
 
     import opentracing
-    from flask_opentracing import FlaskTracer
+    from flask_opentracing import FlaskTracing
 
     app = Flask(__name__)
 
     opentracing_tracer = ## some OpenTracing tracer implementation  
-    tracer = FlaskTracer(opentracing_tracer)
+    tracing = FlaskTracing(opentracing_tracer)
 
     @app.route('/some_url')
-    @tracer.trace(optional_args)
+    @tracing.trace(optional_args)
     def some_view_func():
         ...     
         return some_view 
@@ -63,7 +63,7 @@ Trace Individual Requests
 Accessing Spans Manually
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
-In order to access the span for a request, we've provided an method `FlaskTracer.get_span(request)` that returns the span for the request, if it is exists and is not finished. This can be used to log important events to the span, set tags, or create child spans to trace non-RPC events. If no request is passed in, the current request will be used.
+In order to access the span for a request, we've provided an method `FlaskTracing.get_span(request)` that returns the span for the request, if it is exists and is not finished. This can be used to log important events to the span, set tags, or create child spans to trace non-RPC events. If no request is passed in, the current request will be used.
 
 Tracing an RPC
 ~~~~~~~~~~~~~~
@@ -72,10 +72,10 @@ If you want to make an RPC and continue an existing trace, you can inject the cu
 
 .. code-block:: python
 
-    @tracer.trace()
+    @tracing.trace()
     def some_view_func(request):
         new_request = some_http_request
-        current_span = tracer.get_span(request)
+        current_span = tracing.get_span(request)
         text_carrier = {}
         opentracing_tracer.inject(span, opentracing.Format.TEXT_MAP, text_carrier)
         for k, v in text_carrier.iteritems():
diff --git a/example/README.md b/example/README.md
index 537f1d2..cb716fd 100644
--- a/example/README.md
+++ b/example/README.md
@@ -1,74 +1,86 @@
 ## Example
 
-This example has a flask client and server and shows they can trace requests
-both within and between the two sites using the flask_opentracing extension and
+This example has a flask client and server and shows how to trace the requests
+to a webserver from a client using the flask_opentracing extension and
 a concrete variant of an OpenTracing tracer. To run, make sure that you run pip
-install for flask, opentracing, and lightstep (although you will not be able to
-view the lightstep traces unless you have an access token).
+install for flask, opentracing, jaeger_client.
 
-Open two terminals and navigate to this directory. Run the following commands in
+### Set up Jaeger:
+
+First, we'll have to download and run our Jaeger instance. It collects and displays
+traces in neat graphical format.
+
+If you already have Docker installed, run this:
+
+```
+docker run -d -e \
+  COLLECTOR_ZIPKIN_HTTP_PORT=9411 \
+  -p 5775:5775/udp \
+  -p 6831:6831/udp \
+  -p 6832:6832/udp \
+  -p 5778:5778 \
+  -p 16686:16686 \
+  -p 14268:14268 \
+  -p 9411:9411 \
+  jaegertracing/all-in-one:latest
+```
+
+You should be able to see a web interface by browsing to http://localhost:16686/search
+
+![traced request](https://raw.githubusercontent.com/opentracing-contrib/python-flask/example/example/img/jaeger_0.png)
+
+Now, open two terminals and navigate to this directory. Run the following commands in
 each terminal:
 
 First window:
 
-``` 
-> export FLASK_APP=server.py   
-> flask run 
+```
+> python3 server.py   
 ```
 
-Second window:
+Give it few seconds to start and run this in second window:
 
-``` 
-> export FLASK_APP=client.py   
-> flask run --port=0 
+```
+> python3 client.py   
 ```
 
-To test the traces, check what port the client is running on and load
-localhost:port. If you have a lightstep tracer token, you
-should be able to view the trace data on the lightstep interface. 
-(NOTE: if you wish to use a different OpenTracing tracer, simply replace
-`ls_tracer` with the OpenTracing tracer instance of your choice.)
+To see the traced requests, go to Jaeger web interface and refresh the page.
+Select your service name from dropdown on the left (it's
+"jaeger_opentracing_example" in our case) and press Find traces button at the bottom of the page.
 
-### Trace a request:
 
-Navigate to `/request/simple/<int:numrequests>` where numrequests is the number
-of requests you want to send to the page. This will send a request to the server
-app, and the trace will include a span on both the client and server sides. This
-occurs automatically since both the client and server functions are decorated
-with @tracer.trace().
+![traced request](https://raw.githubusercontent.com/opentracing-contrib/python-flask/example/example/img/jaeger.png)
 
-Result for `/request/simple/1`:
 
-![request and response spans](https://raw.githubusercontent.com/kcamenzind/flask_opentracing/master/example/img/simple.png)
+(NOTE: if you wish to use a different OpenTracing tracer instead of Jaeger, simply replace
+`jaeger_tracer` with the OpenTracing tracer instance of your choice.)
 
-### Log something to a request:
+### Trace a request from browser:
 
-Navigate to `/log`. This will log a message to the server-side span. The client
-span is created automatically through the @tracer.trace() decorator, while the
-logging occurs within the function by accessing the current span as follows:
+Browse to http://localhost:5000/log and compare the trace in Jaeger.
+The last one has 2 spans instead of 3. The span of webserver's GET method is missing.
+That is because client.py starts a trace and passes trace context over the wire, whereas the request from your browser has no tracing context in it.
 
-```python
-span = tracer.get_span()
-span.log_event("hello world")
-```
-Result for `/log`:
+### Add spans to the trace manually:
 
-![span with log](https://raw.githubusercontent.com/kcamenzind/flask_opentracing/master/example/img/log.png)
+In log function of the server app, we are creating current_span. This is done to
+trace the work that is being done to render the response to /log endpoint. Suppose there's
+a database connection happening. By creating a separate span for it, you'll be able
+to trace the DB request separately from rendering or the response. This gives a
+lot of flexibility to the user.
 
-### Add spans to the trace manually:
+Speaking about databases, using install_all_patches() method from
+opentracing_instrumentation package gives you a way to trace
+your MySQLdb, SQLAlchemy, Redis queries without writing boilerplate code.
 
-Navigate to `/request/childspan/<int:numrequests>`. This will send a request to
-the server app, and the trace will include a span on both the client and server
-sides. The server app will additionally create a child span for the server-side
-span. This example demonstrates how you can trace non-RPC function calls in your
-app, through accessing the current span as follows:
+Following code shows how to create a span based on already existing one.
 
 ```python
-parent_span = tracer.get_span()
-child_span = ls_tracer.start_span("inside create_child_span", parent_span)
+# child_scope.span automatically inherits from the Span created
+# for this request by the Flask instrumentation.
+child_scope = jaeger_tracer.start_active_span('inside create_child_span')
 ... do some stuff
-child_span.finish()	
+child_scope.close()
 ```
-Result for `/request/childspan/2`:
 
-![two child spans](https://raw.githubusercontent.com/kcamenzind/flask_opentracing/master/example/img/childspan.png)
+![traced request](https://raw.githubusercontent.com/opentracing-contrib/python-flask/example/example/img/jaeger_1.png)
diff --git a/example/client.py b/example/client.py
index 10bb7d5..14b8713 100644
--- a/example/client.py
+++ b/example/client.py
@@ -1,66 +1,34 @@
-from flask import Flask
-from flask_opentracing import FlaskTracer
-import lightstep.tracer
-import opentracing
-import urllib2
-
-app = Flask(__name__)
-
-# one-time tracer initialization code
-ls_tracer = lightstep.tracer.init_tracer(group_name="example client", access_token="{your_lightstep_token}")
-# this tracer does not trace all requests, so the @tracer.trace() decorator must be used
-tracer = FlaskTracer(ls_tracer)
-
-@app.route("/")
-def index():
-	'''
-	Index page, has no tracing.
-	'''
-	return "Index Page"
-
-
-@app.route("/request/<script>/<int:numrequests>")
-@tracer.trace("url")
-def send_multiple_requests(script, numrequests):
-	'''
-	Traced function that makes a request to the server
-	Injects the current span into headers to continue trace
-	'''
-	span = tracer.get_span()
-	def send_request():
-		url = "http://localhost:5000/"+str(script)
-		request = urllib2.Request(url)
-		inject_as_headers(ls_tracer, span, request)
-		try:
-			response = urllib2.urlopen(request)
-		except urllib2.URLError as ue:  
-			response = ue
-	for i in range(numrequests):
-		send_request()
-	return "Requests sent"
-
-@app.route('/log')
-@tracer.trace()
-def log_something():
-	'''
-	Traced function that logs something to the current 
-	request span.
-	'''
-	span = tracer.get_span()
-	span.log_event("hello world")
-	return "Something was logged"
-
-@app.route("/test")
-@tracer.trace()
-def test_lightstep_tracer():
-	'''
-	Simple traced function to ensure the tracer works.
-	'''
-	return "No errors"
-
-def inject_as_headers(tracer, span, request):
-    text_carrier = {}
-    tracer.inject(span.context, opentracing.Format.TEXT_MAP, text_carrier)
-    for k, v in text_carrier.iteritems():
-        request.add_header(k,v)
-
+import sys
+if sys.version_info[:2] >= (3, 10):
+    # compat for Python written pre-3.10
+    import collections
+    import collections.abc
+    collections.MutableMapping = collections.abc.MutableMapping
+
+import requests
+import time
+from opentracing_instrumentation.client_hooks import install_all_patches
+from jaeger_client import Config
+
+from os import getenv
+
+JAEGER_HOST = getenv('JAEGER_HOST', 'localhost')
+WEBSERVER_HOST = getenv('WEBSERVER_HOST', 'localhost')
+
+# Create configuration object with enabled logging and sampling of all requests.
+config = Config(config={'sampler': {'type': 'const', 'param': 1},
+                        'logging': True,
+                        'local_agent': {'reporting_host': JAEGER_HOST}},
+                service_name="jaeger_opentracing_example")
+tracer = config.initialize_tracer()
+
+# Automatically trace all requests made with 'requests' library.
+install_all_patches()
+
+url = "http://{}:5000/log".format(WEBSERVER_HOST)
+# Make the actual request to webserver.
+requests.get(url)
+
+# allow tracer to flush the spans - https://github.com/jaegertracing/jaeger-client-python/issues/50
+time.sleep(2)
+tracer.close()
diff --git a/example/img/childspan.png b/example/img/childspan.png
deleted file mode 100644
index af2c4ef..0000000
Binary files a/example/img/childspan.png and /dev/null differ
diff --git a/example/img/jaeger.png b/example/img/jaeger.png
new file mode 100644
index 0000000..85d3d79
Binary files /dev/null and b/example/img/jaeger.png differ
diff --git a/example/img/jaeger_0.png b/example/img/jaeger_0.png
new file mode 100644
index 0000000..6f3944c
Binary files /dev/null and b/example/img/jaeger_0.png differ
diff --git a/example/img/jaeger_1.png b/example/img/jaeger_1.png
new file mode 100644
index 0000000..1aa8477
Binary files /dev/null and b/example/img/jaeger_1.png differ
diff --git a/example/img/log.png b/example/img/log.png
deleted file mode 100644
index 1e5a13b..0000000
Binary files a/example/img/log.png and /dev/null differ
diff --git a/example/img/simple.png b/example/img/simple.png
deleted file mode 100644
index 31d5948..0000000
Binary files a/example/img/simple.png and /dev/null differ
diff --git a/example/server.py b/example/server.py
index 09cdd4c..34bc463 100644
--- a/example/server.py
+++ b/example/server.py
@@ -1,41 +1,47 @@
-from flask import Flask
-from flask_opentracing import FlaskTracer
-import lightstep.tracer
-import opentracing
-import urllib2
-
-app = Flask(__name__)
-
-# one-time tracer initialization code
-ls_tracer = lightstep.tracer.init_tracer(group_name="example server", access_token="{your_lightstep_token}")
-# This tracer traces all requests
-tracer = FlaskTracer(ls_tracer, True, app, ["url_rule"])
-
-@app.route("/simple")
-def simple_response():
-	'''
-	This request will be automatically traced.
-	'''
-	return "Hello, world!"
-
-@app.route("/childspan")
-def create_child_span():
-	'''
-	This request will also be automatically traced.
-	
-	This is a more complicated example of accessing the current 
-	request from within a handler and creating new spans manually.
-	'''
-	parent_span = tracer.get_span()
-	child_span = ls_tracer.start_span("inside create_child_span", child_of=parent_span)
-	ans = calculate_some_stuff()
-	child_span.finish()	
-	return str(ans)
-
-def calculate_some_stuff():
-	two = 1 + 1
-	return two
-
-
-
-
+import sys
+if sys.version_info[:2] >= (3, 10):
+    # compat for Python written pre-3.10
+    import collections
+    import collections.abc
+    collections.MutableMapping = collections.abc.MutableMapping
+
+import logging
+from jaeger_client import Config
+from flask_opentracing import FlaskTracing
+from flask import Flask, request
+from os import getenv
+JAEGER_HOST = getenv('JAEGER_HOST', 'localhost')
+
+if __name__ == '__main__':
+        app = Flask(__name__)
+        log_level = logging.DEBUG
+        logging.getLogger('').handlers = []
+        logging.basicConfig(format='%(asctime)s %(message)s', level=log_level)
+        # Create configuration object with enabled logging and sampling of all requests.
+        config = Config(config={'sampler': {'type': 'const', 'param': 1},
+                                'logging': True,
+                                'local_agent':
+                                # Also, provide a hostname of Jaeger instance to send traces to.
+                                {'reporting_host': JAEGER_HOST}},
+                        # Service name can be arbitrary string describing this particular web service.
+                        service_name="jaeger_opentracing_example")
+        jaeger_tracer = config.initialize_tracer()
+        tracing = FlaskTracing(jaeger_tracer)
+
+        @app.route('/log')
+        @tracing.trace() # Indicate that /log endpoint should be traced
+        def log():
+                # Extract the span information for request object.
+                with jaeger_tracer.start_active_span(
+                        'python webserver internal span of log method') as scope:
+                    # Perform some computations to be traced.
+
+                    a = 1
+                    b = 2
+                    c = a + b
+
+                    scope.span.log_kv({'event': 'my computer knows math!', 'result': c})
+
+                    return "log"
+
+        app.run(debug=True, host='0.0.0.0', port=5000)
diff --git a/flask_opentracing/__init__.py b/flask_opentracing/__init__.py
index 56c068a..ab50c32 100644
--- a/flask_opentracing/__init__.py
+++ b/flask_opentracing/__init__.py
@@ -1 +1,11 @@
-from .tracer import FlaskTracer
\ No newline at end of file
+import warnings
+
+from .tracing import FlaskTracing  # noqa
+from .tracing import FlaskTracing as FlaskTracer  # noqa, deprecated
+
+warnings.warn(
+     'This package is no longer supported.'
+     ' Migrate to using opentelemetry-api.',
+     DeprecationWarning,
+     stacklevel=2
+)
diff --git a/flask_opentracing/tracer.py b/flask_opentracing/tracer.py
deleted file mode 100644
index 11fc77b..0000000
--- a/flask_opentracing/tracer.py
+++ /dev/null
@@ -1,97 +0,0 @@
-import opentracing
-from flask import _request_ctx_stack as stack
-
-
-class FlaskTracer(opentracing.Tracer):
-    '''
-    Tracer that can trace certain requests to a Flask app.
-
-    @param tracer the OpenTracing tracer implementation to trace requests with
-    '''
-    def __init__(self, tracer, trace_all_requests=False, app=None, traced_attributes=[]):
-        if not callable(tracer):
-            self.__tracer = tracer
-        else:
-            self.__tracer = None
-            self.__tracer_getter = tracer
-        self._trace_all_requests = trace_all_requests
-        self._current_spans = {}
-
-        # tracing all requests requires that app != None
-        if self._trace_all_requests:
-            @app.before_request
-            def start_trace():
-                self._before_request_fn(traced_attributes)
-
-            @app.after_request
-            def end_trace(response):
-                self._after_request_fn()
-                return response
-
-    @property
-    def _tracer(self):
-        if not self.__tracer:
-            self.__tracer = self.__tracer_getter()
-        return self.__tracer
-
-    def trace(self, *attributes):
-        '''
-        Function decorator that traces functions
-
-        NOTE: Must be placed after the @app.route decorator
-
-        @param attributes any number of flask.Request attributes
-        (strings) to be set as tags on the created span
-        '''
-        def decorator(f):
-            def wrapper(*args, **kwargs):
-                if not self._trace_all_requests:
-                    self._before_request_fn(list(attributes))
-                    r = f(*args, **kwargs)
-                    self._after_request_fn()
-                    return r
-                else:
-                    return f(*args, **kwargs)
-            wrapper.__name__ = f.__name__
-            return wrapper
-        return decorator
-
-    def get_span(self, request=None):
-        '''
-        Returns the span tracing `request`, or the current request if
-        `request==None`.
-
-        If there is no such span, get_span returns None.
-
-        @param request the request to get the span from
-        '''
-        if request is None and stack.top:
-            request = stack.top.request
-        return self._current_spans.get(request, None)
-
-    def _before_request_fn(self, attributes):
-        request = stack.top.request
-        operation_name = request.endpoint
-        headers = {}
-        for k,v in request.headers:
-            headers[k.lower()] = v
-        span = None
-        try:
-            span_ctx = self._tracer.extract(opentracing.Format.HTTP_HEADERS, headers)
-            span = self._tracer.start_span(operation_name=operation_name, child_of=span_ctx)
-        except (opentracing.InvalidCarrierException, opentracing.SpanContextCorruptedException) as e:
-            span = self._tracer.start_span(operation_name=operation_name, tags={"Extract failed": str(e)})
-        if span is None:
-            span = self._tracer.start_span(operation_name)
-        self._current_spans[request] = span
-        for attr in attributes:
-            if hasattr(request, attr):
-                payload = str(getattr(request, attr))
-                if payload:
-                    span.set_tag(attr, payload)
-
-    def _after_request_fn(self):
-        request = stack.top.request
-        span = self._current_spans.pop(request)
-        if span is not None:
-            span.finish()
diff --git a/flask_opentracing/tracing.py b/flask_opentracing/tracing.py
new file mode 100644
index 0000000..66996a0
--- /dev/null
+++ b/flask_opentracing/tracing.py
@@ -0,0 +1,170 @@
+import opentracing
+from opentracing.ext import tags
+from flask import request as flask_current_request
+
+
+class FlaskTracing(opentracing.Tracer):
+    """
+    Tracer that can trace certain requests to a Flask app.
+
+    @param tracer the OpenTracing tracer implementation to trace requests with
+    """
+    def __init__(self, tracer=None, trace_all_requests=None, app=None,
+                 traced_attributes=[], start_span_cb=None):
+
+        if start_span_cb is not None and not callable(start_span_cb):
+            raise ValueError('start_span_cb is not callable')
+
+        if trace_all_requests is True and app is None:
+            raise ValueError('trace_all_requests=True requires an app object')
+
+        if trace_all_requests is None:
+            trace_all_requests = False if app is None else True
+
+        if not callable(tracer):
+            self.__tracer = tracer
+            self.__tracer_getter = None
+        else:
+            self.__tracer = None
+            self.__tracer_getter = tracer
+
+        self._trace_all_requests = trace_all_requests
+        self._start_span_cb = start_span_cb
+        self._current_scopes = {}
+
+        # tracing all requests requires that app != None
+        if self._trace_all_requests:
+            @app.before_request
+            def start_trace():
+                self._before_request_fn(traced_attributes)
+
+            @app.after_request
+            def end_trace(response):
+                self._after_request_fn(response)
+                return response
+
+            @app.teardown_request
+            def end_trace_with_error(error):
+                if error is not None:
+                    self._after_request_fn(error=error)
+
+    @property
+    def _tracer(self):
+        """DEPRECATED"""
+        return self.tracer
+
+    @property
+    def tracer(self):
+        if not self.__tracer:
+            if self.__tracer_getter is None:
+                return opentracing.tracer
+
+            self.__tracer = self.__tracer_getter()
+
+        return self.__tracer
+
+    def trace(self, *attributes):
+        """
+        Function decorator that traces functions
+
+        NOTE: Must be placed after the @app.route decorator
+
+        @param attributes any number of flask.Request attributes
+        (strings) to be set as tags on the created span
+        """
+        def decorator(f):
+            def wrapper(*args, **kwargs):
+                if self._trace_all_requests:
+                    return f(*args, **kwargs)
+
+                self._before_request_fn(list(attributes))
+
+                try:
+                    r = f(*args, **kwargs)
+                except Exception as e:
+                    self._after_request_fn(error=e)
+                    raise
+
+                self._after_request_fn(response=r)
+
+                return r
+
+            wrapper.__name__ = f.__name__
+            return wrapper
+        return decorator
+
+    def get_span(self, request=None):
+        """
+        Returns the span tracing `request`, or the current request if
+        `request==None`.
+
+        If there is no such span, get_span returns None.
+
+        @param request the request to get the span from
+        """
+        if request is None:
+            request = flask_current_request
+
+        scope = self._current_scopes.get(request, None)
+        return None if scope is None else scope.span
+
+    def _before_request_fn(self, attributes):
+        request = flask_current_request
+        operation_name = request.endpoint
+        headers = {}
+        for k, v in request.headers:
+            headers[k.lower()] = v
+
+        try:
+            span_ctx = self.tracer.extract(opentracing.Format.HTTP_HEADERS,
+                                           headers)
+            scope = self.tracer.start_active_span(operation_name,
+                                                  child_of=span_ctx)
+        except (opentracing.InvalidCarrierException,
+                opentracing.SpanContextCorruptedException):
+            scope = self.tracer.start_active_span(operation_name)
+
+        self._current_scopes[request] = scope
+
+        span = scope.span
+        span.set_tag(tags.COMPONENT, 'Flask')
+        span.set_tag(tags.HTTP_METHOD, request.method)
+        span.set_tag(tags.HTTP_URL, request.base_url)
+        span.set_tag(tags.SPAN_KIND, tags.SPAN_KIND_RPC_SERVER)
+
+        for attr in attributes:
+            if hasattr(request, attr):
+                payload = getattr(request, attr)
+                if payload not in ('', b''):  # python3
+                    span.set_tag(attr, str(payload))
+
+        self._call_start_span_cb(span, request)
+
+    def _after_request_fn(self, response=None, error=None):
+        request = flask_current_request
+
+        # the pop call can fail if the request is interrupted by a
+        # `before_request` method so we need a default
+        scope = self._current_scopes.pop(request, None)
+        if scope is None:
+            return
+
+        if response is not None:
+            scope.span.set_tag(tags.HTTP_STATUS_CODE, response.status_code)
+        if error is not None:
+            scope.span.set_tag(tags.ERROR, True)
+            scope.span.log_kv({
+                'event': tags.ERROR,
+                'error.object': error,
+            })
+
+        scope.close()
+
+    def _call_start_span_cb(self, span, request):
+        if self._start_span_cb is None:
+            return
+
+        try:
+            self._start_span_cb(span, request)
+        except Exception:
+            pass
diff --git a/requirements-test.txt b/requirements-test.txt
new file mode 100644
index 0000000..57cec65
--- /dev/null
+++ b/requirements-test.txt
@@ -0,0 +1,6 @@
+# add dependencies in setup.py
+  
+-r requirements.txt
+tox
+
+-e .[tests]
diff --git a/requirements.txt b/requirements.txt
index 4f4ad93..8ec4f5c 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,2 +1,3 @@
-Flask
-opentracing
+# add dependencies in setup.py
+  
+-e .
diff --git a/setup.cfg b/setup.cfg
index cc3032c..7e9a8c4 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -2,4 +2,15 @@
 test=pytest
 
 [metadata]
-description-file = README.rst
\ No newline at end of file
+description_file = README.rst
+
+[tool:pytest]
+addopts =
+    --tb short
+    -rxs
+    --cov-report term-missing:skip-covered
+    --cov flask_opentracing
+    tests
+
+[coverage:run]
+branch = True
diff --git a/setup.py b/setup.py
index b5cd608..11f22ce 100644
--- a/setup.py
+++ b/setup.py
@@ -6,7 +6,7 @@
 
 This extension provides simple integration of OpenTracing in Flask applications.
 '''
-version = open('VERSION').read()
+version = open('VERSION').read().strip()
 setup(
     name='Flask-OpenTracing',
     version=version,
@@ -17,22 +17,40 @@
     author_email='kcamenzind@lightstep.com',
     description='OpenTracing support for Flask applications',
     long_description=open('README.rst').read(),
+    long_description_content_type='text/x-rst',
     packages=['flask_opentracing', 'tests'],
     zip_safe=False,
     include_package_data=True,
     platforms='any',
     install_requires=[
         'Flask',
-        'opentracing'
+        'opentracing>=2.0,<3',
     ],
-    tests_require=['pytest'],
-    setup_requires=['pytest-runner'],
+    extras_require={
+        'tests': [
+            'flake8',
+            'flake8-quotes',
+            'mock',
+            'pytest',
+            'pytest-cov',
+            'tox',
+        ],
+    },
     classifiers=[
         'Environment :: Web Environment',
         'Intended Audience :: Developers',
         'License :: OSI Approved :: BSD License',
         'Operating System :: OS Independent',
         'Programming Language :: Python',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
+        'Programming Language :: Python :: Implementation :: CPython',
+        'Programming Language :: Python :: Implementation :: PyPy',
+        'Development Status :: 7 - Inactive',
         'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
         'Topic :: Software Development :: Libraries :: Python Modules'
     ]
diff --git a/tests/README.rst b/tests/README.rst
index 0a62fda..f3799bc 100644
--- a/tests/README.rst
+++ b/tests/README.rst
@@ -5,4 +5,5 @@ Run the tests with the following command:
 
 .. code-block:: 
 
-    $ python setup.py test
\ No newline at end of file
+    $ pip install -r requirements-test.txt
+    $ tox
\ No newline at end of file
diff --git a/tests/test_flask_api.py b/tests/test_flask_api.py
new file mode 100644
index 0000000..098bc67
--- /dev/null
+++ b/tests/test_flask_api.py
@@ -0,0 +1,40 @@
+import mock
+import pytest
+import unittest
+
+import opentracing
+from flask import Flask
+from flask_opentracing import FlaskTracing
+
+
+class TestValues(unittest.TestCase):
+    def test_tracer(self):
+        tracer = opentracing.Tracer()
+        tracing = FlaskTracing(tracer)
+        assert tracing.tracer is tracer
+        assert tracing.tracer is tracing._tracer
+        assert tracing._trace_all_requests is False
+
+    def test_global_tracer(self):
+        tracing = FlaskTracing()
+        with mock.patch('opentracing.tracer'):
+            assert tracing.tracer is opentracing.tracer
+            opentracing.tracer = object()
+            assert tracing.tracer is opentracing.tracer
+
+    def test_trace_all_requests(self):
+        app = Flask('dummy_app')
+        tracing = FlaskTracing(app=app)
+        assert tracing._trace_all_requests is True
+
+        tracing = FlaskTracing(app=app, trace_all_requests=False)
+        assert tracing._trace_all_requests is False
+
+    def test_trace_all_requests_no_app(self):
+        # when trace_all_requests is True, an app object is *required*
+        with pytest.raises(ValueError):
+            FlaskTracing(trace_all_requests=True)
+
+    def test_start_span_invalid(self):
+        with pytest.raises(ValueError):
+            FlaskTracing(start_span_cb=0)
diff --git a/tests/test_flask_opentracing.py b/tests/test_flask_opentracing.py
deleted file mode 100644
index 43577f8..0000000
--- a/tests/test_flask_opentracing.py
+++ /dev/null
@@ -1,84 +0,0 @@
-from flask import (Flask, request)
-import opentracing
-from flask_opentracing import FlaskTracer
-
-app = Flask(__name__)
-test_app = app.test_client()
-
-empty_tracer = opentracing.Tracer()
-tracer_all = FlaskTracer(empty_tracer, True, app, ['url'])
-tracer = FlaskTracer(empty_tracer)
-tracer_deferred = FlaskTracer(lambda: opentracing.Tracer(), True, app, ['url'])
-
-def flush_spans(tcr):
-    for req in tcr._current_spans:
-        tcr._current_spans[req].finish()
-    tcr._current_spans = {}
-
-@app.route('/test')
-def check_test_works():
-    return "Success"
-
-@app.route('/another_test')
-@tracer.trace('url', 'url_rule')
-def decorated_fn():
-    return "Success again"
-
-@app.route('/wire')
-def send_request():
-    span = tracer.get_span()
-    headers = {}
-    empty_tracer.inject(span, opentracing.Format.TEXT_MAP, headers)
-    rv = test_app.get('/test', headers=headers)
-    return str(rv.status_code)
-
-def test_on():
-    assert True
-
-def test_span_creation():
-    with app.test_request_context('/test'):
-        app.preprocess_request()
-        assert tracer_all.get_span(request)
-        assert not tracer.get_span(request)
-        assert tracer_deferred.get_span(request)
-        flush_spans(tracer_all)
-        flush_spans(tracer_deferred)
-
-def test_span_deletion():
-    assert not tracer_all._current_spans
-    assert not tracer_deferred._current_spans
-    test_app.get('/test')
-    assert not tracer_all._current_spans
-    assert not tracer_deferred._current_spans
-
-def test_requests_distinct():
-    with app.test_request_context('/test'):
-        app.preprocess_request()
-    with app.test_request_context('/test'):
-        app.preprocess_request()
-        second_span = tracer_all._current_spans.pop(request)
-        assert second_span
-        second_span.finish()
-        assert not tracer_all.get_span(request)
-    # clear current spans
-    flush_spans(tracer_all)
-    flush_spans(tracer_deferred)
-
-def test_decorator():
-    with app.test_request_context('/another_test'):
-        app.preprocess_request()
-        assert not tracer.get_span(request)
-        assert len(tracer_deferred._current_spans) == 1
-        assert len(tracer_all._current_spans) == 1
-    flush_spans(tracer)
-    flush_spans(tracer_all)
-    flush_spans(tracer_deferred)
-
-    test_app.get('/another_test')
-    assert not tracer_all._current_spans
-    assert not tracer._current_spans
-    assert not tracer_deferred._current_spans
-
-def test_over_wire():
-    rv = test_app.get('/wire')
-    assert '200' in str(rv.status_code)
\ No newline at end of file
diff --git a/tests/test_flask_tracing.py b/tests/test_flask_tracing.py
new file mode 100644
index 0000000..187b0e7
--- /dev/null
+++ b/tests/test_flask_tracing.py
@@ -0,0 +1,198 @@
+import mock
+import unittest
+
+from flask import (Flask, Response, request)
+import opentracing
+from opentracing.ext import tags
+from opentracing.mocktracer import MockTracer
+from flask_opentracing import FlaskTracing
+from flaky import flaky
+
+
+app = Flask(__name__)
+test_app = app.test_client()
+
+
+tracing_all = FlaskTracing(MockTracer(), True, app, ['url'])
+tracing = FlaskTracing(MockTracer())
+tracing_deferred = FlaskTracing(lambda: MockTracer(),
+                                True, app, ['url'])
+
+
+def flush_spans(tcr):
+    for span in tcr._current_scopes.values():
+        span.close()
+    tcr._current_scopes = {}
+
+
+@app.route('/test')
+def check_test_works():
+    return Response('Success')
+
+
+@app.route('/another_test')
+@tracing.trace('url', 'url_rule')
+def decorated_fn():
+    return Response('Success again')
+
+
+@app.route('/another_test_simple')
+@tracing.trace('query_string', 'is_xhr')
+def decorated_fn_simple():
+    return Response('Success again')
+
+
+@app.route('/error_test')
+@tracing.trace()
+def decorated_fn_with_error():
+    raise RuntimeError('Intentional testing exception')
+
+
+@app.route('/decorated_child_span_test')
+@tracing.trace()
+def decorated_fn_with_child_span():
+    with tracing.tracer.start_active_span('child'):
+        return Response('Success')
+
+
+@app.route('/wire')
+def send_request():
+    span = tracing_all.get_span()
+    headers = {}
+    tracing_all.tracer.inject(span.context,
+                              opentracing.Format.TEXT_MAP,
+                              headers)
+    rv = test_app.get('/test', headers=headers)
+    return str(rv.status_code)
+
+
+class TestTracing(unittest.TestCase):
+    def setUp(self):
+        tracing_all._tracer.reset()
+        tracing._tracer.reset()
+        tracing_deferred._tracer.reset()
+
+    def test_span_creation(self):
+        with app.test_request_context('/test'):
+            app.preprocess_request()
+            assert tracing_all.get_span(request)
+            assert not tracing.get_span(request)
+            assert tracing_deferred.get_span(request)
+
+            active_span = tracing_all.tracer.active_span
+            assert tracing_all.get_span(request) is active_span
+
+            flush_spans(tracing_all)
+            flush_spans(tracing_deferred)
+
+    def test_span_deletion(self):
+        assert not tracing_all._current_scopes
+        assert not tracing_deferred._current_scopes
+        test_app.get('/test')
+        assert not tracing_all._current_scopes
+        assert not tracing_deferred._current_scopes
+
+    def test_span_tags(self):
+        response = test_app.get('/another_test_simple')
+
+        spans = tracing._tracer.finished_spans()
+        assert len(spans) == 1
+        assert spans[0].tags == {
+            tags.COMPONENT: 'Flask',
+            tags.HTTP_METHOD: 'GET',
+            tags.SPAN_KIND: tags.SPAN_KIND_RPC_SERVER,
+            tags.HTTP_URL: 'http://localhost/another_test_simple',
+            tags.HTTP_STATUS_CODE: response.status_code,
+        }
+
+    @flaky(max_runs=5)
+    def test_requests_distinct(self):
+        with app.test_request_context('/test'):
+            app.preprocess_request()
+        with app.test_request_context('/test'):
+            app.preprocess_request()
+            second_scope = tracing_all._current_scopes.pop(request)
+            assert second_scope
+            second_scope.close()
+            assert not tracing_all.get_span(request)
+        # clear current spans
+        flush_spans(tracing_all)
+        flush_spans(tracing_deferred)
+
+    def test_decorator(self):
+        with app.test_request_context('/another_test'):
+            app.preprocess_request()
+            assert not tracing.get_span(request)
+            assert len(tracing_deferred._current_scopes) == 1
+            assert len(tracing_all._current_scopes) == 1
+
+            active_span = tracing_all.tracer.active_span
+            assert tracing_all.get_span(request) is active_span
+
+        flush_spans(tracing)
+        flush_spans(tracing_all)
+        flush_spans(tracing_deferred)
+
+        test_app.get('/another_test')
+        assert not tracing_all._current_scopes
+        assert not tracing._current_scopes
+        assert not tracing_deferred._current_scopes
+
+    def test_decorator_trace_all(self):
+        # Fake we are tracing all, which should disable
+        # tracing through our decorator.
+        with mock.patch.object(tracing, '_trace_all_requests', new=True):
+            rv = test_app.get('/another_test_simple')
+            assert '200' in str(rv.status_code)
+
+        spans = tracing.tracer.finished_spans()
+        assert len(spans) == 0
+
+    def test_error(self):
+        try:
+            test_app.get('/error_test')
+        except RuntimeError:
+            pass
+
+        assert len(tracing._current_scopes) == 0
+        assert len(tracing_all._current_scopes) == 0
+        assert len(tracing_deferred._current_scopes) == 0
+
+        # Registered handler.
+        spans = tracing.tracer.finished_spans()
+        assert len(spans) == 1
+        self._verify_error(spans[0])
+
+        # Decorator.
+        spans = tracing.tracer.finished_spans()
+        assert len(spans) == 1
+        self._verify_error(spans[0])
+
+    def _verify_error(self, span):
+        assert span.tags.get(tags.ERROR) is True
+
+        assert len(span.logs) == 1
+        assert span.logs[0].key_values.get('event', None) is tags.ERROR
+        assert isinstance(
+                span.logs[0].key_values.get('error.object', None),
+                RuntimeError
+        )
+
+    @flaky(max_runs=5)
+    def test_over_wire(self):
+        rv = test_app.get('/wire')
+        assert '200' in str(rv.status_code)
+
+        spans = tracing_all.tracer.finished_spans()
+        assert len(spans) == 2
+        assert spans[0].context.trace_id == spans[1].context.trace_id
+        assert spans[0].parent_id == spans[1].context.span_id
+
+    def test_child_span(self):
+        rv = test_app.get('/decorated_child_span_test')
+        assert '200' in str(rv.status_code)
+
+        spans = tracing.tracer.finished_spans()
+        assert len(spans) == 2
+        assert spans[0].context.trace_id == spans[1].context.trace_id
+        assert spans[0].parent_id == spans[1].context.span_id
diff --git a/tests/test_flask_tracing_span_callbacks.py b/tests/test_flask_tracing_span_callbacks.py
new file mode 100644
index 0000000..56a9dfc
--- /dev/null
+++ b/tests/test_flask_tracing_span_callbacks.py
@@ -0,0 +1,59 @@
+import unittest
+from abc import abstractmethod
+
+from flask import Flask
+from opentracing.ext import tags
+from opentracing.mocktracer import MockTracer
+from flask_opentracing import FlaskTracing
+
+
+class _StartSpanCallbackTestCase(unittest.TestCase):
+    @staticmethod
+    @abstractmethod
+    def start_span_cb(span, request):
+        pass
+
+    def setUp(self):
+        self.app = Flask(__name__)
+        self.tracing = FlaskTracing(
+            MockTracer(), True, self.app, start_span_cb=self.start_span_cb
+        )
+        self.test_app = self.app.test_client()
+
+        @self.app.route('/test')
+        def check_test_works():
+            return 'Success'
+
+
+class TestFlaskTracingStartSpanCallbackSetTags(_StartSpanCallbackTestCase):
+    @staticmethod
+    def start_span_cb(span, request):
+        print('setting tags')
+        span.set_tag('component', 'not-flask')
+        span.set_tag('mytag', 'myvalue')
+
+    def test_simple(self):
+        rv = self.test_app.get('/test')
+        assert '200' in str(rv.status_code)
+
+        spans = self.tracing.tracer.finished_spans()
+        assert len(spans) == 1
+        assert spans[0].tags.get(tags.COMPONENT, None) == 'not-flask'
+        assert spans[0].tags.get('mytag', None) == 'myvalue'
+
+
+class TestFlaskTracingStartSpanCallbackRaisesError(
+    _StartSpanCallbackTestCase
+):
+    @staticmethod
+    def start_span_cb(span, request):
+        print('raising exception')
+        raise RuntimeError('Should not happen')
+
+    def test_error(self):
+        rv = self.test_app.get('/test')
+        assert '200' in str(rv.status_code)
+
+        spans = self.tracing.tracer.finished_spans()
+        assert len(spans) == 1
+        assert spans[0].tags.get(tags.ERROR, None) is None
diff --git a/tox.ini b/tox.ini
new file mode 100644
index 0000000..b0fd374
--- /dev/null
+++ b/tox.ini
@@ -0,0 +1,26 @@
+[tox]
+envlist = py3{8,9,10,11,12},pypy{,3},flake8
+skip_missing_interpreters = true
+
+[travis]
+python =
+    3.9: py39,flake8
+
+[travis:env]
+TRAVIS_BUILD_STAGE_NAME =
+    Lint: flake8
+    Test: py3{8,9,10,11,12},pypy{,3}
+
+[testenv:flake8]
+basepython = python3.9
+deps =
+    flake8
+    flake8-quotes
+commands = flake8 flask_opentracing tests
+
+[testenv]
+deps =
+    flaky
+extras = tests
+commands =
+    pytest {posargs}