flask-profiler (1.8.1)
Published 2025-08-29 02:24:48 +02:00 by eofredj
Installation
pip install --index-url About this package
API endpoint profiler for Flask framework
Copyright (c) 2015 Mustafa Atik
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Description: # Flask-profiler
**version: 1.8** [](https://travis-ci.org/muatik/flask-profiler)
##### Flask-profiler measures endpoints defined in your flask application; and provides you fine-grained report through a web interface.
It gives answers to these questions:
* Where are the bottlenecks in my application?
* Which endpoints are the slowest in my application?
* Which are the most frequently called endpoints?
* What causes my slow endpoints? In which context, with what args and kwargs are they slow?
* How much time did a specific request take?
In short, if you are curious about what your endpoints are doing and what requests they are receiving, give a try to flask-profiler.
With flask-profiler's web interface, you can monitor all your endpoints' performance and investigate endpoints and received requests by drilling down through filters.
## Screenshots
Dashboard view displays a summary.
You can create filters to investigate certain type requests.
You can see all the details of a request.
## Quick Start
It is easy to understand flask-profiler going through an example. Let's dive in.
Install flask-profiler by pip.
```sh
pip install flask_profiler
```
Edit your code where you are creating Flask app.
```python
# your app.py
from flask import Flask
import flask_profiler
app = Flask(__name__)
app.config["DEBUG"] = True
# You need to declare necessary configuration to initialize
# flask-profiler as follows:
app.config["flask_profiler"] = {
"enabled": app.config["DEBUG"],
"storage": {
"engine": "sqlite"
},
"basicAuth":{
"enabled": True,
"username": "admin",
"password": "admin"
},
"ignore": [
"^/static/.*"
]
}
@app.route('/product/<id>', methods=['GET'])
def getProduct(id):
return "product id is " + str(id)
@app.route('/product/<id>', methods=['PUT'])
def updateProduct(id):
return "product {} is being updated".format(id)
@app.route('/products', methods=['GET'])
def listProducts():
return "suppose I send you product list..."
@app.route('/static/something/', methods=['GET'])
def listProducts():
return "this should not be tracked..."
# In order to active flask-profiler, you have to pass flask
# app as an argument to flask-profiler.
# All the endpoints declared so far will be tracked by flask-profiler.
flask_profiler.init_app(app)
# endpoint declarations after flask_profiler.init_app() will be
# hidden to flask_profiler.
@app.route('/doSomething', methods=['GET'])
def doSomething():
return "flask-profiler will not measure this."
# But in case you want an endpoint to be measured by flask-profiler,
# you can specify this explicitly by using profile() decorator
@app.route('/doSomethingImportant', methods=['GET'])
@flask_profiler.profile()
def doSomethingImportant():
return "flask-profiler will measure this request."
if __name__ == '__main__':
app.run(host="127.0.0.1", port=5000)
```
Now run your `app.py`
```
python app.py
```
And make some requests like:
```sh
curl http://127.0.0.1:5000/products
curl http://127.0.0.1:5000/product/123
curl -X PUT -d arg1=val1 http://127.0.0.1:5000/product/123
```
If everything is okay, Flask-profiler will measure these requests. You can see the result heading to http://127.0.0.1:5000/flask-profiler/ or get results as JSON http://127.0.0.1:5000/flask-profiler/api/measurements?sort=elapsed,desc
If you like to initialize your extensions in other files or use factory apps pattern, you can also create a instance of the `Profiler` class, this will register all your endpoints once you app run by first time. E.g:
```python
from flask import Flask
from flask_profiler import Profiler
profiler = Profiler()
app = Flask(__name__)
app.config["DEBUG"] = True
# You need to declare necessary configuration to initialize
# flask-profiler as follows:
app.config["flask_profiler"] = {
"enabled": app.config["DEBUG"],
"storage": {
"engine": "sqlite"
},
"basicAuth":{
"enabled": True,
"username": "admin",
"password": "admin"
},
"ignore": [
"^/static/.*"
]
}
profiler = Profiler() # You can have this in another module
profiler.init_app(app)
# Or just Profiler(app)
@app.route('/product/<id>', methods=['GET'])
def getProduct(id):
return "product id is " + str(id)
```
## Using with different database system
You can use flaskprofiler with **SqlLite**, **MongoDB**, **Postgresql**, **Mysql** or **MongoDB** database systems. However, it is easy to support other database systems. If you would like to have others, please go to contribution documentation. (It is really easy.)
### SQLite
In order to use SQLite, just specify it as the value of `storage.engine` directive as follows.
```json
app.config["flask_profiler"] = {
"storage": {
"engine": "sqlite",
}
}
```
Below the other options are listed.
| Filter key | Description | Default |
|----------|-------------|------|
| storage.FILE | SQLite database file name | flask_profiler.sql|
| storage.TABLE | table name in which profiling data will reside | measurements |
### MongoDB
In order to use MongoDB, just specify it as the value of `storage.engine` directive as follows.
```json
app.config["flask_profiler"] = {
"storage": {
"engine": "mongodb",
}
}
```
### SQLAchemy
In order to use SQLAchemy, just specify it as the value of `storage.engine` directive as follows.
Also first create an empty database with the name "flask_profiler".
```python
app.config["flask_profiler"] = {
"storage": {
"engine": "sqlalchemy",
"db_url": "postgresql://user:pass@localhost:5432/flask_profiler" # optional, if no db_url specified then sqlite will be used.
}
}
```
### Custom database engine
Specify engine as string module and class path.
```json
app.config["flask_profiler"] = {
"storage": {
"engine": "custom.project.flask_profiler.mysql.MysqlStorage",
"MYSQL": "mysql://user:password@localhost/flask_profiler"
}
}
```
The other options are listed below.
| Filter key | Description | Default
|----------|-------------|------
| storage.MONGO_URL | mongodb connection string | mongodb://localhost
| storage.DATABASE | database name | flask_profiler
| storage.COLLECTION | collection name | measurements
### Sampling
Control the number of samples taken by flask-profiler
You would want control over how many times should the flask profiler take samples while running in production mode.
You can supply a function and control the sampling according to your business logic.
Example 1: Sample 1 in 100 times with random numbers
```python
app.config["flask_profiler"] = {
"sampling_function": lambda: True if random.sample(list(range(1, 101)), 1) == [42] else False
}
```
Example 2: Sample for specific users
```python
app.config["flask_profiler"] = {
"sampling_function": lambda: True if user is 'divyendu' else False
}
```
If sampling function is not present, all requests will be sampled.
### Changing flask-profiler endpoint root
By default, we can access flask-profiler at <your-app>/flask-profiler
```python
app.config["flask_profiler"] = {
"endpointRoot": "secret-flask-profiler"
}
```
### Ignored endpoints
Flask-profiler will try to track every endpoint defined so far when init_app() is invoked. If you want to exclude some of the endpoints, you can define matching regex for them as follows:
```python
app.config["flask_profiler"] = {
"ignore": [
"^/static/.*",
"/api/users/\w+/password"
]
}
```
## Contributing
Contributions are welcome!
Review the [Contributing Guidelines](https://github.com/muatik/flask-profiler/wiki/Development) for details on how to:
* Submit issues
* Add solutions to existing challenges
* Add new challenges
## Authors
* [Musafa Atik](https://www.linkedin.com/in/muatik)
* Fatih Sucu
* [Safa Yasin Yildirim](https://www.linkedin.com/in/safayasinyildirim)
## License
MIT
Keywords: profiler,flask,performance,optimization Platform: any Classifier: Environment :: Web Environment Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3 Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content Classifier: Topic :: Software Development :: Libraries :: Python Modules