diff --git a/qsa-api/qsa_api/api/instances.py b/qsa-api/qsa_api/api/instances.py
index 91d0b63..9df0280 100644
--- a/qsa-api/qsa_api/api/instances.py
+++ b/qsa-api/qsa_api/api/instances.py
@@ -4,62 +4,86 @@
 from flask import current_app
 from datetime import datetime
 
+from ..utils import logger
+from .utils import log_request
+
+
 instances = Blueprint("instances", __name__)
 
 
 @instances.get("/")
 def instances_list():
-    monitor = current_app.config["MONITOR"]
+    log_request()
+    try:
+        monitor = current_app.config["MONITOR"]
 
-    if not monitor:
-        return {"error": "QGIS Server monitoring is not activated"}, 415
+        if not monitor:
+            return {"error": "QGIS Server monitoring is not activated"}, 415
 
-    conns = {"servers": []}
-    for uid in monitor.conns:
-        info = {}
-        info["id"] = uid
-        info["ip"] = monitor.conns[uid].ip
+        conns = {"servers": []}
+        for uid in monitor.conns:
+            info = {}
+            info["id"] = uid
+            info["ip"] = monitor.conns[uid].ip
 
-        d = datetime.now() - monitor.conns[uid].now
-        info["binded"] = int(d.total_seconds())
-        conns["servers"].append(info)
-    return conns
+            d = datetime.now() - monitor.conns[uid].now
+            info["binded"] = int(d.total_seconds())
+            conns["servers"].append(info)
+        return conns
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @instances.get("/<instance>")
 def instances_metadata(instance):
-    monitor = current_app.config["MONITOR"]
+    log_request()
+    try:
+        monitor = current_app.config["MONITOR"]
 
-    if not monitor:
-        return {"error": "QGIS Server monitoring is not activated"}, 415
+        if not monitor:
+            return {"error": "QGIS Server monitoring is not activated"}, 415
 
-    if instance not in monitor.conns:
-        return {"error": "QGIS Server instance is not available"}, 415
+        if instance not in monitor.conns:
+            return {"error": "QGIS Server instance is not available"}, 415
 
-    return monitor.conns[instance].metadata
+        return monitor.conns[instance].metadata
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @instances.get("/<instance>/logs")
 def instances_logs(instance):
-    monitor = current_app.config["MONITOR"]
+    log_request()
+    try:
+        monitor = current_app.config["MONITOR"]
 
-    if not monitor:
-        return {"error": "QGIS Server monitoring is not activated"}, 415
+        if not monitor:
+            return {"error": "QGIS Server monitoring is not activated"}, 415
 
-    if instance not in monitor.conns:
-        return {"error": "QGIS Server instance is not available"}, 415
+        if instance not in monitor.conns:
+            return {"error": "QGIS Server instance is not available"}, 415
 
-    return monitor.conns[instance].logs
+        return monitor.conns[instance].logs
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @instances.get("/<instance>/stats")
 def instances_stats(instance):
-    monitor = current_app.config["MONITOR"]
+    log_request()
+    try:
+        monitor = current_app.config["MONITOR"]
 
-    if not monitor:
-        return {"error": "QGIS Server monitoring is not activated"}, 415
+        if not monitor:
+            return {"error": "QGIS Server monitoring is not activated"}, 415
 
-    if instance not in monitor.conns:
-        return {"error": "QGIS Server instance is not available"}, 415
+        if instance not in monitor.conns:
+            return {"error": "QGIS Server instance is not available"}, 415
 
-    return monitor.conns[instance].stats
+        return monitor.conns[instance].stats
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
diff --git a/qsa-api/qsa_api/api/processing.py b/qsa-api/qsa_api/api/processing.py
index 21478ee..9a0d5fb 100644
--- a/qsa-api/qsa_api/api/processing.py
+++ b/qsa-api/qsa_api/api/processing.py
@@ -4,92 +4,105 @@
 from flask import Blueprint, jsonify, request
 from jsonschema.exceptions import ValidationError
 
+from ..utils import logger
 from ..project import QSAProject
 from ..processing import RasterCalculator, Histogram
 
+from .utils import log_request
+
 
 processing = Blueprint("processing", __name__)
 
 
 @processing.post("/raster/calculator/<project>")
 def raster_calculator(project: str):
-    schema = {
-        "type": "object",
-        "required": ["expression", "output"],
-        "properties": {
-            "expression": {"type": "string"},
-            "output": {"type": "string"},
-        },
-    }
-
-    data = request.get_json()
+    log_request()
     try:
-        validate(data, schema)
-    except ValidationError as e:
-        return {"error": e.message}, 415
-
-    expression = data["expression"]
-    output = data["output"]
-
-    psql_schema = request.args.get("schema", default="public")
-    proj = QSAProject(project, psql_schema)
-
-    if not proj.exists():
-        return {"error": "Project doesn't exist"}, 415
-
-    calc = RasterCalculator(proj._qgis_project_uri, expression)
-    if not calc.is_valid():
-        return {"error": "Invalid expression"}, 415
-
-    rc, msg = calc.process(output)
-    if not rc:
-        return {
-            "error": f"Raster calculator failed to process expression ({msg})"
-        }, 415
-
-    return jsonify(rc), 201
+        schema = {
+            "type": "object",
+            "required": ["expression", "output"],
+            "properties": {
+                "expression": {"type": "string"},
+                "output": {"type": "string"},
+            },
+        }
+
+        data = request.get_json()
+        try:
+            validate(data, schema)
+        except ValidationError as e:
+            return {"error": e.message}, 415
+
+        expression = data["expression"]
+        output = data["output"]
+
+        psql_schema = request.args.get("schema", default="public")
+        proj = QSAProject(project, psql_schema)
+
+        if not proj.exists():
+            return {"error": "Project doesn't exist"}, 415
+
+        calc = RasterCalculator(proj._qgis_project_uri, expression)
+        if not calc.is_valid():
+            return {"error": "Invalid expression"}, 415
+
+        rc, msg = calc.process(output)
+        if not rc:
+            return {
+                "error": f"Raster calculator failed to process expression ({msg})"
+            }, 415
+
+        return jsonify(rc), 201
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @processing.post("/raster/histogram/<project>/<layer>")
 def raster_histogram(project: str, layer: str):
-    schema = {
-        "type": "object",
-        "properties": {
-            "min": {"type": "number"},
-            "max": {"type": "number"},
-            "count": {"type": "number"},
-        },
-    }
-
-    data = request.get_json()
+    log_request()
     try:
-        validate(data, schema)
-    except ValidationError as e:
-        return {"error": e.message}, 415
-
-    mini = None
-    if "min" in data:
-        mini = data["min"]
-
-    maxi = None
-    if "max" in data:
-        maxi = data["max"]
-
-    count = 1000
-    if "count" in data:
-        count = data["count"]
-
-    proj = QSAProject(project)
-    if proj.exists():
-        layer_infos = proj.layer(layer)
-        if layer_infos:
-            if "type" in layer_infos and layer_infos["type"] != "raster":
-                return {
-                    "error": "Histogram is available for raster layer only"
-                }
-            histo = Histogram(proj._qgis_project_uri, layer)
-            return jsonify(histo.process(mini, maxi, count)), 201
+        schema = {
+            "type": "object",
+            "properties": {
+                "min": {"type": "number"},
+                "max": {"type": "number"},
+                "count": {"type": "number"},
+            },
+        }
+
+        data = request.get_json()
+        try:
+            validate(data, schema)
+        except ValidationError as e:
+            return {"error": e.message}, 415
+
+        mini = None
+        if "min" in data:
+            mini = data["min"]
+
+        maxi = None
+        if "max" in data:
+            maxi = data["max"]
+
+        count = 1000
+        if "count" in data:
+            count = data["count"]
+
+        proj = QSAProject(project)
+        if proj.exists():
+            layer_infos = proj.layer(layer)
+            if layer_infos:
+                if "type" in layer_infos and layer_infos["type"] != "raster":
+                    return {
+                        "error": "Histogram is available for raster layer only"
+                    }
+                histo = Histogram(proj._qgis_project_uri, layer)
+                return jsonify(histo.process(mini, maxi, count)), 201
+            else:
+                return {"error": "Layer does not exist"}, 415
         else:
-            return {"error": "Layer does not exist"}, 415
-    else:
-        return {"error": "Project does not exist"}, 415
+            return {"error": "Project does not exist"}, 415
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
diff --git a/qsa-api/qsa_api/api/projects.py b/qsa-api/qsa_api/api/projects.py
index 2e302fa..c563d51 100644
--- a/qsa-api/qsa_api/api/projects.py
+++ b/qsa-api/qsa_api/api/projects.py
@@ -9,340 +9,430 @@
 from qgis.PyQt.QtCore import QDateTime
 
 from ..wms import WMS
+from ..utils import logger
 from ..project import QSAProject
 
+from .utils import log_request
+
 
 projects = Blueprint("projects", __name__)
 
 
 @projects.get("/")
 def projects_list():
-    psql_schema = request.args.get("schema", default="public")
+    log_request()
+    try:
+        psql_schema = request.args.get("schema", default="public")
 
-    p = []
-    for project in QSAProject.projects(psql_schema):
-        p.append(project.name)
-    return jsonify(p)
+        p = []
+        for project in QSAProject.projects(psql_schema):
+            p.append(project.name)
+        return jsonify(p)
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @projects.get("/<name>")
 def project_info(name: str):
-    psql_schema = request.args.get("schema", default="public")
-    project = QSAProject(name, psql_schema)
+    log_request()
+    try:
+        psql_schema = request.args.get("schema", default="public")
+        project = QSAProject(name, psql_schema)
 
-    if project.exists():
-        return jsonify(project.metadata)
-    return {"error": "Project does not exist"}, 415
+        if project.exists():
+            return jsonify(project.metadata)
+        return {"error": "Project does not exist"}, 415
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @projects.post("/")
 def project_add():
-    schema = {
-        "type": "object",
-        "required": ["name", "author"],
-        "properties": {
-            "name": {"type": "string"},
-            "author": {"type": "string"},
-            "schema": {"type": "string"},
-        },
-    }
-
-    if request.is_json:
-        data = request.get_json()
-        try:
-            validate(data, schema)
-        except ValidationError as e:
-            return {"error": e.message}, 415
-
-        name = data["name"]
-        author = data["author"]
-        schema = ""
-        if "schema" in data:
-            schema = data["schema"]
-
-        project = QSAProject(name, schema)
-        if project.exists():
-            return {"error": "Project already exists"}
-        rc, err = project.create(author)
-        if not rc:
-            return {"error": err}, 415
-        return jsonify(True), 201
-    return {"error": "Request must be JSON"}, 415
+    log_request()
+    try:
+        schema = {
+            "type": "object",
+            "required": ["name", "author"],
+            "properties": {
+                "name": {"type": "string"},
+                "author": {"type": "string"},
+                "schema": {"type": "string"},
+            },
+        }
+
+        if request.is_json:
+            data = request.get_json()
+            try:
+                validate(data, schema)
+            except ValidationError as e:
+                return {"error": e.message}, 415
+
+            name = data["name"]
+            author = data["author"]
+            schema = ""
+            if "schema" in data:
+                schema = data["schema"]
+
+            project = QSAProject(name, schema)
+            if project.exists():
+                return {"error": "Project already exists"}
+            rc, err = project.create(author)
+            if not rc:
+                return {"error": err}, 415
+            return jsonify(True), 201
+        return {"error": "Request must be JSON"}, 415
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @projects.delete("/<name>")
 def project_del(name):
-    psql_schema = request.args.get("schema", default="public")
-    project = QSAProject(name, psql_schema)
+    log_request()
+    try:
+        psql_schema = request.args.get("schema", default="public")
+        project = QSAProject(name, psql_schema)
 
-    if project.exists():
-        project.remove()
-        return jsonify(True), 201
-    return {"error": "Project does not exist"}, 415
+        if project.exists():
+            project.remove()
+            return jsonify(True), 201
+        return {"error": "Project does not exist"}, 415
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @projects.get("/<name>/styles")
 def project_styles(name):
-    psql_schema = request.args.get("schema", default="public")
-    project = QSAProject(name, psql_schema)
-    if project.exists():
-        return jsonify(project.styles), 201
-    else:
-        return {"error": "Project does not exist"}, 415
+    log_request()
+    try:
+        psql_schema = request.args.get("schema", default="public")
+        project = QSAProject(name, psql_schema)
+        if project.exists():
+            return jsonify(project.styles), 201
+        else:
+            return {"error": "Project does not exist"}, 415
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @projects.get("/<name>/styles/<style>")
 def project_style(name, style):
-    psql_schema = request.args.get("schema", default="public")
-    project = QSAProject(name, psql_schema)
-    if project.exists():
-        infos, err = project.style(style)
-        if err:
-            return {"error": err}, 415
+    log_request()
+    try:
+        psql_schema = request.args.get("schema", default="public")
+        project = QSAProject(name, psql_schema)
+        if project.exists():
+            infos, err = project.style(style)
+            if err:
+                return {"error": err}, 415
+            else:
+                return jsonify(infos), 201
         else:
-            return jsonify(infos), 201
-    else:
-        return {"error": "Project does not exist"}, 415
+            return {"error": "Project does not exist"}, 415
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @projects.delete("/<name>/styles/<style>")
 def project_del_style(name, style):
-    psql_schema = request.args.get("schema", default="public")
-    project = QSAProject(name, psql_schema)
-    if project.exists():
-        if style in project.styles:
-            rc, msg = project.remove_style(style)
-            if not rc:
-                return {"error": msg}, 415
-            return jsonify(rc), 201
+    log_request()
+    try:
+        psql_schema = request.args.get("schema", default="public")
+        project = QSAProject(name, psql_schema)
+        if project.exists():
+            if style in project.styles:
+                rc, msg = project.remove_style(style)
+                if not rc:
+                    return {"error": msg}, 415
+                return jsonify(rc), 201
+            else:
+                return {"error": "Style does not exist"}, 415
         else:
-            return {"error": "Style does not exist"}, 415
-    else:
-        return {"error": "Project does not exist"}, 415
+            return {"error": "Project does not exist"}, 415
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @projects.post("/<name>/layers/<layer_name>/style")
 def project_layer_update_style(name, layer_name):
-    schema = {
-        "type": "object",
-        "required": ["name", "current"],
-        "properties": {
-            "name": {"type": "string"},
-            "current": {"type": "boolean"},
-        },
-    }
-
-    psql_schema = request.args.get("schema", default="public")
-    project = QSAProject(name, psql_schema)
-    if project.exists():
-        data = request.get_json()
-        try:
-            validate(data, schema)
-        except ValidationError as e:
-            return {"error": e.message}, 415
-
-        current = data["current"]
-        style_name = data["name"]
-        rc, msg = project.layer_update_style(layer_name, style_name, current)
-        if not rc:
-            return {"error": msg}, 415
-        return jsonify(True), 201
-    else:
-        return {"error": "Project does not exist"}, 415
+    log_request()
+    try:
+        schema = {
+            "type": "object",
+            "required": ["name", "current"],
+            "properties": {
+                "name": {"type": "string"},
+                "current": {"type": "boolean"},
+            },
+        }
+
+        psql_schema = request.args.get("schema", default="public")
+        project = QSAProject(name, psql_schema)
+        if project.exists():
+            data = request.get_json()
+            try:
+                validate(data, schema)
+            except ValidationError as e:
+                return {"error": e.message}, 415
+
+            current = data["current"]
+            style_name = data["name"]
+            rc, msg = project.layer_update_style(
+                layer_name, style_name, current
+            )
+            if not rc:
+                return {"error": msg}, 415
+            return jsonify(True), 201
+        else:
+            return {"error": "Project does not exist"}, 415
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @projects.get("/<name>/layers/<layer_name>/map/url")
 def project_layer_map_url(name, layer_name):
-    psql_schema = request.args.get("schema", default="public")
-    project = QSAProject(name, psql_schema)
-    if project.exists():
-        getmap = WMS.getmap_url(name, psql_schema, layer_name)
-        return jsonify({"url": getmap}), 201
-    else:
-        return {"error": "Project does not exist"}, 415
+    log_request()
+    try:
+        psql_schema = request.args.get("schema", default="public")
+        project = QSAProject(name, psql_schema)
+        if project.exists():
+            getmap = WMS.getmap_url(name, psql_schema, layer_name)
+            return jsonify({"url": getmap}), 201
+        else:
+            return {"error": "Project does not exist"}, 415
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @projects.get("/<name>/layers/<layer_name>/map")
 def project_layer_map(name, layer_name):
-    psql_schema = request.args.get("schema", default="public")
-    project = QSAProject(name, psql_schema)
-    if project.exists():
-        url = WMS.getmap(name, psql_schema, layer_name)
-        r = requests.get(url, stream=True)
-
-        png = "/tmp/map.png"
-        with open(png, "wb") as out_file:
-            shutil.copyfileobj(r.raw, out_file)
-
-        return send_file(png, mimetype="image/png")
-    else:
-        return {"error": "Project does not exist"}, 415
+    log_request()
+    try:
+        psql_schema = request.args.get("schema", default="public")
+        project = QSAProject(name, psql_schema)
+        if project.exists():
+            url = WMS.getmap(name, psql_schema, layer_name)
+            r = requests.get(url, stream=True)
+
+            png = "/tmp/map.png"
+            with open(png, "wb") as out_file:
+                shutil.copyfileobj(r.raw, out_file)
+
+            return send_file(png, mimetype="image/png")
+        else:
+            return {"error": "Project does not exist"}, 415
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @projects.post("/<name>/styles")
 def project_add_style(name):
-    schema = {
-        "type": "object",
-        "required": ["name", "type", "rendering", "symbology"],
-        "properties": {
-            "name": {"type": "string"},
-            "type": {"type": "string"},
-            "symbology": {"type": "object"},
-            "rendering": {"type": "object"},
-        },
-    }
-
-    psql_schema = request.args.get("schema", default="public")
-    project = QSAProject(name, psql_schema)
-    if project.exists():
-        data = request.get_json()
-        try:
-            validate(data, schema)
-        except ValidationError as e:
-            return {"error": e.message}, 415
-
-        rc, err = project.add_style(
-            data["name"],
-            data["type"],
-            data["symbology"],
-            data["rendering"],
-        )
-        if rc:
-            return jsonify(rc), 201
+    log_request()
+    try:
+        schema = {
+            "type": "object",
+            "required": ["name", "type", "rendering", "symbology"],
+            "properties": {
+                "name": {"type": "string"},
+                "type": {"type": "string"},
+                "symbology": {"type": "object"},
+                "rendering": {"type": "object"},
+            },
+        }
+
+        psql_schema = request.args.get("schema", default="public")
+        project = QSAProject(name, psql_schema)
+        if project.exists():
+            data = request.get_json()
+            try:
+                validate(data, schema)
+            except ValidationError as e:
+                return {"error": e.message}, 415
+
+            rc, err = project.add_style(
+                data["name"],
+                data["type"],
+                data["symbology"],
+                data["rendering"],
+            )
+            if rc:
+                return jsonify(rc), 201
+            else:
+                return {"error": err}, 415
         else:
-            return {"error": err}, 415
-    else:
-        return {"error": "Project does not exist"}, 415
+            return {"error": "Project does not exist"}, 415
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @projects.get("/<name>/styles/default")
 def project_default_styles(name: str) -> dict:
-    psql_schema = request.args.get("schema", default="public")
-    project = QSAProject(name, psql_schema)
-    if project.exists():
-        infos = project.default_styles()
-        return jsonify(infos), 201
-    else:
-        return {"error": "Project does not exist"}, 415
+    log_request()
+    try:
+        psql_schema = request.args.get("schema", default="public")
+        project = QSAProject(name, psql_schema)
+        if project.exists():
+            infos = project.default_styles()
+            return jsonify(infos), 201
+        else:
+            return {"error": "Project does not exist"}, 415
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @projects.post("/<name>/styles/default")
 def project_update_default_style(name):
-    schema = {
-        "type": "object",
-        "required": ["geometry", "style"],
-        "properties": {
-            "geometry": {"type": "string"},
-            "style": {"type": "string"},
-        },
-    }
-
-    psql_schema = request.args.get("schema", default="public")
-    project = QSAProject(name, psql_schema)
-    if project.exists():
-        data = request.get_json()
-        try:
-            validate(data, schema)
-        except ValidationError as e:
-            return {"error": e.message}, 415
-
-        project.style_update(data["geometry"], data["style"])
-        return jsonify(True), 201
-    else:
-        return {"error": "Project does not exist"}, 415
+    log_request()
+    try:
+        schema = {
+            "type": "object",
+            "required": ["geometry", "style"],
+            "properties": {
+                "geometry": {"type": "string"},
+                "style": {"type": "string"},
+            },
+        }
+
+        psql_schema = request.args.get("schema", default="public")
+        project = QSAProject(name, psql_schema)
+        if project.exists():
+            data = request.get_json()
+            try:
+                validate(data, schema)
+            except ValidationError as e:
+                return {"error": e.message}, 415
+
+            project.style_update(data["geometry"], data["style"])
+            return jsonify(True), 201
+        else:
+            return {"error": "Project does not exist"}, 415
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @projects.get("/<name>/layers")
 def project_layers(name):
-    psql_schema = request.args.get("schema", default="public")
-    project = QSAProject(name, psql_schema)
-    if project.exists():
-        return jsonify(project.layers), 201
-    else:
-        return {"error": "Project does not exist"}, 415
+    log_request()
+    try:
+        psql_schema = request.args.get("schema", default="public")
+        project = QSAProject(name, psql_schema)
+        if project.exists():
+            return jsonify(project.layers), 201
+        else:
+            return {"error": "Project does not exist"}, 415
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @projects.post("/<name>/layers")
 def project_add_layer(name):
-    schema = {
-        "type": "object",
-        "required": ["name", "datasource", "type"],
-        "properties": {
-            "name": {"type": "string"},
-            "datasource": {"type": "string"},
-            "crs": {"type": "number"},
-            "type": {"type": "string"},
-            "overview": {"type": "boolean"},
-            "datetime": {"type": "string"},
-        },
-    }
-
-    psql_schema = request.args.get("schema", default="public")
-    project = QSAProject(name, psql_schema)
-
-    if project.exists():
-        data = request.get_json()
-        try:
-            validate(data, schema)
-        except ValidationError as e:
-            return {"error": e.message}, 415
-
-        crs = -1
-        if "crs" in data:
-            crs = int(data["crs"])
-
-        overview = False
-        if "overview" in data:
-            overview = data["overview"]
-
-        datetime = None
-        if "datetime" in data:
-            # check format "yyyy-MM-dd HH:mm:ss"
-            datetime = QDateTime.fromString(
-                data["datetime"], "yyyy-MM-dd HH:mm:ss"
+    log_request()
+    try:
+        schema = {
+            "type": "object",
+            "required": ["name", "datasource", "type"],
+            "properties": {
+                "name": {"type": "string"},
+                "datasource": {"type": "string"},
+                "crs": {"type": "number"},
+                "type": {"type": "string"},
+                "overview": {"type": "boolean"},
+                "datetime": {"type": "string"},
+            },
+        }
+
+        psql_schema = request.args.get("schema", default="public")
+        project = QSAProject(name, psql_schema)
+
+        if project.exists():
+            data = request.get_json()
+            try:
+                validate(data, schema)
+            except ValidationError as e:
+                return {"error": e.message}, 415
+
+            crs = -1
+            if "crs" in data:
+                crs = int(data["crs"])
+
+            overview = False
+            if "overview" in data:
+                overview = data["overview"]
+
+            datetime = None
+            if "datetime" in data:
+                # check format "yyyy-MM-dd HH:mm:ss"
+                datetime = QDateTime.fromString(
+                    data["datetime"], "yyyy-MM-dd HH:mm:ss"
+                )
+                if not datetime.isValid():
+                    return {"error": "Invalid datetime"}, 415
+
+            rc, err = project.add_layer(
+                data["datasource"],
+                data["type"],
+                data["name"],
+                crs,
+                overview,
+                datetime,
             )
-            if not datetime.isValid():
-                return {"error": "Invalid datetime"}, 415
-
-        rc, err = project.add_layer(
-            data["datasource"],
-            data["type"],
-            data["name"],
-            crs,
-            overview,
-            datetime,
-        )
-        if rc:
-            return jsonify(rc), 201
+            if rc:
+                return jsonify(rc), 201
+            else:
+                return {"error": err}, 415
         else:
-            return {"error": err}, 415
-    else:
-        return {"error": "Project does not exist"}, 415
+            return {"error": "Project does not exist"}, 415
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @projects.get("/<name>/layers/<layer_name>")
 def project_info_layer(name, layer_name):
-    psql_schema = request.args.get("schema", default="public")
-    project = QSAProject(name, psql_schema)
-    if project.exists():
-        layer_infos = project.layer(layer_name)
-        if layer_infos:
-            return jsonify(layer_infos), 201
+    log_request()
+    try:
+        psql_schema = request.args.get("schema", default="public")
+        project = QSAProject(name, psql_schema)
+        if project.exists():
+            layer_infos = project.layer(layer_name)
+            if layer_infos:
+                return jsonify(layer_infos), 201
+            else:
+                return {"error": "Layer does not exist"}, 415
         else:
-            return {"error": "Layer does not exist"}, 415
-    else:
-        return {"error": "Project does not exist"}, 415
+            return {"error": "Project does not exist"}, 415
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @projects.delete("/<name>/layers/<layer_name>")
 def project_del_layer(name, layer_name):
-    psql_schema = request.args.get("schema", default="public")
-    project = QSAProject(name, psql_schema)
-    if project.exists():
-        if project.layer_exists(layer_name):
-            rc = project.remove_layer(layer_name)
-            return jsonify(rc), 201
+    log_request()
+    try:
+        psql_schema = request.args.get("schema", default="public")
+        project = QSAProject(name, psql_schema)
+        if project.exists():
+            if project.layer_exists(layer_name):
+                rc = project.remove_layer(layer_name)
+                return jsonify(rc), 201
+            else:
+                return {"error": "Layer does not exist"}, 415
         else:
-            return {"error": "Layer does not exist"}, 415
-    else:
-        return {"error": "Project does not exist"}, 415
+            return {"error": "Project does not exist"}, 415
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
diff --git a/qsa-api/qsa_api/api/symbology.py b/qsa-api/qsa_api/api/symbology.py
index a0d46bb..0a294aa 100644
--- a/qsa-api/qsa_api/api/symbology.py
+++ b/qsa-api/qsa_api/api/symbology.py
@@ -12,114 +12,162 @@
     QgsSingleBandPseudoColorRenderer,
 )
 
+from ..utils import logger
+from .utils import log_request
+
 
 symbology = Blueprint("symbology", __name__)
 
 
 @symbology.get("/vector/line/single_symbol/line/properties")
 def symbology_symbols_line():
-    props = QgsSimpleLineSymbolLayer().properties()
-    return jsonify(props)
+    log_request()
+    try:
+        props = QgsSimpleLineSymbolLayer().properties()
+        return jsonify(props)
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @symbology.get("/vector/polygon/single_symbol/fill/properties")
 def symbology_symbols_fill():
-    props = QgsSimpleFillSymbolLayer().properties()
-    props["outline_style"] = (
-        "solid (no, solid, dash, dot, dash dot, dash dot dot)"
-    )
-    return jsonify(props)
+    log_request()
+    try:
+        props = QgsSimpleFillSymbolLayer().properties()
+        props["outline_style"] = (
+            "solid (no, solid, dash, dot, dash dot, dash dot dot)"
+        )
+        return jsonify(props)
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @symbology.get("/vector/point/single_symbol/marker/properties")
 def symbology_symbols_marker():
-    props = QgsSimpleMarkerSymbolLayer().properties()
-    props["outline_style"] = (
-        "solid (no, solid, dash, dot, dash dot, dash dot dot)"
-    )
-    return jsonify(props)
+    log_request()
+    try:
+        props = QgsSimpleMarkerSymbolLayer().properties()
+        props["outline_style"] = (
+            "solid (no, solid, dash, dot, dash dot, dash dot dot)"
+        )
+        return jsonify(props)
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @symbology.get("/vector/rendering/properties")
 def symbology_vector_rendering():
-    props = {}
-    props["opacity"] = 100.0
-    return jsonify(props)
+    log_request()
+    try:
+        props = {}
+        props["opacity"] = 100.0
+        return jsonify(props)
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @symbology.get(
     f"/raster/{QgsSingleBandGrayRenderer(None, 1).type()}/properties"
 )
 def symbology_raster_singlebandgray():
-    props = {}
-    props["gray"] = {"band": 1, "min": 0.0, "max": 1.0}
-    props["contrast_enhancement"] = {
-        "algorithm": "NoEnhancement (StretchToMinimumMaximum, NoEnhancement)",
-        "limits_min_max": "MinMax (MinMax, UserDefined)",
-    }
-    props["color_gradient"] = "BlackToWhite (BlackToWhite, WhiteToBlack)"
-    return jsonify(props)
+    log_request()
+    try:
+        props = {}
+        props["gray"] = {"band": 1, "min": 0.0, "max": 1.0}
+        props["contrast_enhancement"] = {
+            "algorithm": "NoEnhancement (StretchToMinimumMaximum, NoEnhancement)",
+            "limits_min_max": "MinMax (MinMax, UserDefined)",
+        }
+        props["color_gradient"] = "BlackToWhite (BlackToWhite, WhiteToBlack)"
+        return jsonify(props)
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @symbology.get(
     f"/raster/{QgsMultiBandColorRenderer(None, 1, 1, 1).type()}/properties"
 )
 def symbology_raster_multibandcolor():
-    props = {}
-    props["red"] = {"band": 1, "min": 0.0, "max": 1.0}
-    props["green"] = {"band": 2, "min": 0.0, "max": 1.0}
-    props["blue"] = {"band": 3, "min": 0.0, "max": 1.0}
-    props["contrast_enhancement"] = {
-        "algorithm": "NoEnhancement (StretchToMinimumMaximum, NoEnhancement)",
-        "limits_min_max": "MinMax (MinMax, UserDefined)",
-    }
-    return jsonify(props)
+    log_request()
+    try:
+        props = {}
+        props["red"] = {"band": 1, "min": 0.0, "max": 1.0}
+        props["green"] = {"band": 2, "min": 0.0, "max": 1.0}
+        props["blue"] = {"band": 3, "min": 0.0, "max": 1.0}
+        props["contrast_enhancement"] = {
+            "algorithm": "NoEnhancement (StretchToMinimumMaximum, NoEnhancement)",
+            "limits_min_max": "MinMax (MinMax, UserDefined)",
+        }
+        return jsonify(props)
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @symbology.get(
     f"/raster/{QgsSingleBandPseudoColorRenderer(None, 1).type()}/properties"
 )
 def symbology_raster_singlebandpseudocolor():
-    ramps = ", ".join(QgsStyle().defaultStyle().colorRampNames())
-
-    props = {}
-    props["band"] = {"band": 1, "min": 0.0, "max": 1.0}
-    props["ramp"] = {
-        "name": f"Spectral ({ramps})",
-        "color1": "0,0,0,255",
-        "color2": "255,255,255,255",
-        "stops": "0.2;2,2,11,255:0.8;200,200,110,255",
-        "interpolation": "Linear (Linear, Discrete, Exact)",
-    }
-    props["contrast_enhancement"] = {
-        "limits_min_max": "MinMax (MinMax, UserDefined)",
-    }
-    return jsonify(props)
+    log_request()
+    try:
+        ramps = ", ".join(QgsStyle().defaultStyle().colorRampNames())
+
+        props = {}
+        props["band"] = {"band": 1, "min": 0.0, "max": 1.0}
+        props["ramp"] = {
+            "name": f"Spectral ({ramps})",
+            "color1": "0,0,0,255",
+            "color2": "255,255,255,255",
+            "stops": "0.2;2,2,11,255:0.8;200,200,110,255",
+            "interpolation": "Linear (Linear, Discrete, Exact)",
+        }
+        props["contrast_enhancement"] = {
+            "limits_min_max": "MinMax (MinMax, UserDefined)",
+        }
+        return jsonify(props)
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @symbology.get(
     f"/raster/{QgsSingleBandPseudoColorRenderer(None, 1).type()}/ramp/<name>/properties"
 )
 def symbology_raster_singlebandpseudocolor_ramp_props(name):
-    proper_name = ""
-    for n in QgsStyle().defaultStyle().colorRampNames():
-        if n.lower() == name:
-            proper_name = n
+    log_request()
+    try:
+        proper_name = ""
+        for n in QgsStyle().defaultStyle().colorRampNames():
+            if n.lower() == name:
+                proper_name = n
 
-    props = {}
-    ramp = QgsStyle().defaultStyle().colorRamp(proper_name)
-    if ramp:
-        props["color1"] = ramp.properties()["color1"].split("rgb")[0]
-        props["color2"] = ramp.properties()["color2"].split("rgb")[0]
+        props = {}
+        ramp = QgsStyle().defaultStyle().colorRamp(proper_name)
+        if ramp:
+            props["color1"] = ramp.properties()["color1"].split("rgb")[0]
+            props["color2"] = ramp.properties()["color2"].split("rgb")[0]
 
-    return jsonify(props)
+        return jsonify(props)
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
 
 
 @symbology.get("/raster/rendering/properties")
 def symbology_raster_rendering():
-    props = {}
-    props["gamma"] = 1.0
-    props["brightness"] = 0
-    props["contrast"] = 0
-    props["saturation"] = 0
-    return jsonify(props)
+    log_request()
+    try:
+        props = {}
+        props["gamma"] = 1.0
+        props["brightness"] = 0
+        props["contrast"] = 0
+        props["saturation"] = 0
+        return jsonify(props)
+    except Exception as e:
+        logger().exception(str(e))
+        return {"error": "internal server error"}, 415
diff --git a/qsa-api/qsa_api/api/utils.py b/qsa-api/qsa_api/api/utils.py
new file mode 100644
index 0000000..ccaf647
--- /dev/null
+++ b/qsa-api/qsa_api/api/utils.py
@@ -0,0 +1,23 @@
+# coding: utf8
+
+import sys
+import inspect
+
+from ..utils import logger
+
+
+def log_request():
+
+    caller_stack = inspect.stack()[1]
+    caller_fct = caller_stack.function
+
+    caller_frame = sys._getframe(1)
+    caller_mod = inspect.getmodule(caller_frame)
+
+    caller_fn = getattr(caller_mod, caller_fct)
+    req_type = caller_fn.__qualname__.split(".")[0].upper()
+
+    source = inspect.getsource(caller_fn)
+    req_type = source.splitlines()[0].split(".")[1].split("(")[0].upper()
+
+    logger().debug(f"[{req_type}] {caller_mod.__name__}.{caller_fct}")
diff --git a/qsa-api/qsa_api/processing/histogram.py b/qsa-api/qsa_api/processing/histogram.py
index c6efc5b..35bb839 100644
--- a/qsa-api/qsa_api/processing/histogram.py
+++ b/qsa-api/qsa_api/processing/histogram.py
@@ -30,7 +30,9 @@ def process(self, mini, maxi, count) -> (bool, dict):
         return {}
 
     @staticmethod
-    def _process(project_uri: str, layer: str, mini, maxi, count, out: dict) -> None:
+    def _process(
+        project_uri: str, layer: str, mini, maxi, count, out: dict
+    ) -> None:
 
         project = QgsProject.instance()
         project.read(project_uri)
@@ -38,9 +40,8 @@ def _process(project_uri: str, layer: str, mini, maxi, count, out: dict) -> None
 
         histo = {}
         for band in range(lyr.bandCount()):
-            h = (
-                lyr.dataProvider()
-                .histogram(band + 1, count, mini, maxi, QgsRectangle(), 250000)
+            h = lyr.dataProvider().histogram(
+                band + 1, count, mini, maxi, QgsRectangle(), 250000
             )
 
             histo[band + 1] = {}
diff --git a/qsa-api/qsa_api/processing/raster_calculator.py b/qsa-api/qsa_api/processing/raster_calculator.py
index c0d9252..5c2581e 100644
--- a/qsa-api/qsa_api/processing/raster_calculator.py
+++ b/qsa-api/qsa_api/processing/raster_calculator.py
@@ -1,6 +1,5 @@
 # coding: utf8
 
-import sys
 import rasterio
 import tempfile
 from pathlib import Path