Refactor project structure and add pattern parameter

README.md

@@ -32,15 +32,19 @@ $ pip install profyle
 
 ### 1. Implement
 In order to track all your API requests you must implement the <code>ProfyleMiddleware</code>
+#### ProfyleMiddleware
+* enabled : Default true. You can use an env variable to decide if profyle is enabled.
+* pattern: Profyle only will trace those paths that match with pattern (<a href="https://en.wikipedia.org/wiki/Glob_(programming)" class="external-link" target="_blank">glob pattern</a>)
+
 <details markdown="1">
 <summary>FastAPI</summary>
 
 ```Python
 from fastapi import FastAPI
-from profyle.middleware.fastapi import ProfyleMiddleware
+from profyle import ProfyleFastApiMiddleware
 
 app = FastAPI()
-app.add_middleware(ProfyleMiddleware)
+app.add_middleware(ProfyleFastApiMiddleware, pattern='*/api/v2/*')
 
 @app.get("/items/{item_id}")
 async def read_item(item_id: int):
@@ -53,11 +57,11 @@ async def read_item(item_id: int):
 
 ```Python
 from flask import Flask
-from profyle.middleware.flask import ProfyleMiddleware
+from profyle import ProfyleFlaskMiddleware
 
 app = Flask(__name__)
 
-app.wsgi_app = ProfyleMiddleware(app.wsgi_app)
+app.wsgi_app = ProfyleFlaskMiddleware(app.wsgi_app, pattern='*/api/products*')
 
 @app.route("/")
 def hello_world():

profyle/__init__.py

@@ -0,0 +1,6 @@
+from .infrastructure.middleware.fastapi import ProfyleMiddleware as fast_mid
+from .infrastructure.middleware.flask import ProfyleMiddleware as flask_mid
+
+
+ProfyleFlaskMiddleware = flask_mid
+ProfyleFastApiMiddleware = fast_mid

profyle/application/profyle.py

@@ -0,0 +1,78 @@
+import tempfile
+import json
+import fnmatch
+import re
+from typing import Any, Optional
+
+from viztracer import VizTracer
+
+from profyle.application.trace.store import store_trace
+from profyle.domain.trace_repository import TraceRepository
+from profyle.domain.trace import Trace
+
+
+class profyle:
+
+    def __init__(
+        self,
+        name: str,
+        pattern: Optional[str] = None,
+        tracer: VizTracer = VizTracer(
+            verbose=0,
+            log_async=True
+        )
+    ) -> None:
+        self.name = name
+        self.tracer = tracer
+        self.temp_file = None
+        self.pattern = pattern
+        self.trace: Optional[Trace] = None
+
+    def __enter__(self):
+
+        if self.should_trace():
+            self.temp_file = tempfile.NamedTemporaryFile(suffix='.json')
+            self.tracer.start()
+
+    def __exit__(
+        self,
+        *args,
+    ):
+        if self.temp_file:
+            self.tracer.stop()
+            self.tracer.save(self.temp_file.name)
+            self.temp_file.close()
+            self.data = self.tracer.data
+
+            self.trace = Trace(
+                data=json.dumps(self.data),
+                name=self.name,
+            )
+
+    def should_trace(self) -> bool:
+        if not self.pattern:
+            return True
+
+        regex = fnmatch.translate(self.pattern)
+        reobj = re.compile(regex)
+        return bool(reobj.match(self.name))
+
+
+class profyle_stored(profyle):
+
+    def __init__(
+        self,
+        repo: TraceRepository,
+        **data: Any,
+    ) -> None:
+        self.repo = repo
+        super().__init__(**data)
+
+    def __exit__(self, *args):
+        super().__exit__(*args)
+
+        if self.temp_file and self.trace:
+            store_trace(
+                trace=self.trace,
+                repo=self.repo
+            )

profyle/application/trace/create.py

@@ -0,0 +1,9 @@
+from profyle.domain.trace_repository import TraceRepository
+
+
+def create_trace_selected_table(repo: TraceRepository) -> None:
+    return repo.create_trace_selected_table()
+
+
+def create_trace_table(repo: TraceRepository) -> None:
+    return repo.create_trace_table()

profyle/application/trace/get.py

@@ -0,0 +1,15 @@
+from typing import List, Optional
+from profyle.domain.trace import Trace
+from profyle.domain.trace_repository import TraceRepository
+
+
+def get_all_traces(repo: TraceRepository) -> List[Trace]:
+    return repo.get_all_traces()
+
+
+def get_trace_selected(repo: TraceRepository) -> Optional[int]:
+    return repo.get_trace_selected()
+
+
+def get_trace_by_id(trace_id: int, repo: TraceRepository) -> Optional[Trace]:
+    return repo.get_trace_by_id(trace_id)

profyle/application/trace/remove.py

@@ -0,0 +1,5 @@
+from profyle.domain.trace_repository import TraceRepository
+
+
+def remove_all_traces(repo: TraceRepository) -> int:
+    return repo.remove_all_traces()

profyle/application/trace/store.py

@@ -0,0 +1,10 @@
+from profyle.domain.trace import Trace
+from profyle.domain.trace_repository import TraceRepository
+
+
+def store_trace_selected(trace_id: int, repo: TraceRepository) -> None:
+    repo.store_trace_selected(trace_id=trace_id)
+
+
+def store_trace(trace: Trace, repo: TraceRepository) -> None:
+    repo.store_trace(trace)

profyle/application/trace/vacuum.py

@@ -0,0 +1,5 @@
+from profyle.domain.trace_repository import TraceRepository
+
+
+def vacuum(repo: TraceRepository) -> None:
+    repo.vacuum()

profyle/domain/trace_repository.py

@@ -0,0 +1,42 @@
+from abc import ABC, abstractmethod
+from typing import List, Optional
+
+from profyle.domain.trace import Trace
+
+
+class TraceRepository(ABC):
+
+    @abstractmethod
+    def create_trace_selected_table(self) -> None:
+        ...
+
+    @abstractmethod
+    def create_trace_table(self) -> None:
+        ...
+
+    @abstractmethod
+    def remove_all_traces(self) -> int:
+        ...
+
+    @abstractmethod
+    def vacuum(self) -> None:
+        ...
+
+    @abstractmethod
+    def store_trace_selected(self, trace_id: int) -> None:
+        ...
+
+    @abstractmethod
+    def store_trace(self, trace: Trace) -> None:
+        ...
+
+    @abstractmethod
+    def get_all_traces(self) -> List[Trace]:
+        ...
+
+    @abstractmethod
+    def get_trace_by_id(self, id: int) -> Optional[Trace]:
+        ...
+
+    def get_trace_selected(self) -> Optional[int]:
+        ...