Please address the comments from this code review:

## Individual Comments

### Comment 1
<location> `detectors/built_in/app.py:33` </location>
<code_context>
-
 @app.post("/api/v1/text/contents", response_model=ContentsAnalysisResponse)
 def detect_content(request: ContentAnalysisHttpRequest):
+    logging.info(f"Request for {request.detector_params}")
+
     detections = []
</code_context>

<issue_to_address>
**suggestion:** Consider using the module-level logger instead of the root logger for consistency.

Use 'logger.info' instead of 'logging.info' to ensure consistent logging and easier configuration management.

```suggestion
    logger.info(f"Request for {request.detector_params}")
```
</issue_to_address>

### Comment 2
<location> `detectors/built_in/custom_detectors_wrapper.py:54` </location>
<code_context>
+
+    def handle_request(self, content: str, detector_params: dict) -> List[ContentAnalysisResponse]:
+        detections = []
+        if "custom" in detector_params and isinstance(detector_params["custom"], (list, str)):
+            custom_functions = detector_params["custom"]
+            custom_functions = [custom_functions] if isinstance(custom_functions, str) else custom_functions
</code_context>

<issue_to_address>
**suggestion:** Type checking for 'custom' parameter may miss edge cases with unexpected types.

Unexpected types for 'custom' are ignored without notice. Logging or handling these cases would improve debuggability.
</issue_to_address>

### Comment 3
<location> `tests/detectors/builtIn/test_custom.py:14-22` </location>
<code_context>
+
+
+
+    def test_custom_detectors(self, client):
+        payload = {
+            "contents": ["What is an apple?"],
+            "detector_params": {"custom": ["contains_word"]}
+        }
+        resp = client.post("/api/v1/text/contents", json=payload)
+        assert resp.status_code == 200
+        texts = [d["text"] for d in resp.json()[0]]
+        assert "What is an apple?" in texts
+
</code_context>

<issue_to_address>
**suggestion (testing):** Missing negative and error case tests for custom detectors.

Add tests for scenarios where the custom detector does not match any content and for invalid detector names to ensure proper error handling and coverage of negative cases.

```suggestion
    def test_custom_detectors(self, client):
        payload = {
            "contents": ["What is an apple?"],
            "detector_params": {"custom": ["contains_word"]}
        }
        resp = client.post("/api/v1/text/contents", json=payload)
        assert resp.status_code == 200
        texts = [d["text"] for d in resp.json()[0]]
        assert "What is an apple?" in texts

    def test_custom_detector_no_match(self, client):
        payload = {
            "contents": ["Bananas are yellow."],
            "detector_params": {"custom": ["contains_word"]}
        }
        resp = client.post("/api/v1/text/contents", json=payload)
        assert resp.status_code == 200
        texts = [d["text"] for d in resp.json()[0]]
        assert "Bananas are yellow." not in texts

    def test_custom_detector_invalid_name(self, client):
        payload = {
            "contents": ["What is an apple?"],
            "detector_params": {"custom": ["non_existent_detector"]}
        }
        resp = client.post("/api/v1/text/contents", json=payload)
        assert resp.status_code == 400 or resp.status_code == 422
        # Optionally check for error message in response
        # assert "invalid detector" in resp.text.lower()
```
</issue_to_address>

### Comment 4
<location> `tests/detectors/builtIn/test_custom.py:4` </location>
<code_context>
+import pytest
+from fastapi.testclient import TestClient
+
+class TestRegexDetectors:
+    @pytest.fixture
+    def client(self):
</code_context>

<issue_to_address>
**nitpick:** Test class name is misleading.

Since this class only tests custom detectors, renaming it to 'TestCustomDetectors' would improve clarity.
</issue_to_address>

### Comment 5
<location> `detectors/built_in/custom_detectors_wrapper.py:58-67` </location>
<code_context>
    def handle_request(self, content: str, detector_params: dict) -> List[ContentAnalysisResponse]:
        detections = []
        if "custom" in detector_params and isinstance(detector_params["custom"], (list, str)):
            custom_functions = detector_params["custom"]
            custom_functions = [custom_functions] if isinstance(custom_functions, str) else custom_functions
            for custom_function in custom_functions:
                if self.registry.get(custom_function):
                    try:
                        result = custom_func_wrapper(self.registry[custom_function], custom_function, content)
                        if result is not None:
                            detections.append(result)
                    except Exception as e:
                        logger.error(e)
                        raise HTTPException(status_code=400, detail="Detection error, check detector logs")
                else:
                    raise HTTPException(status_code=400, detail=f"Unrecognized custom function: {custom_function}")
        return detections

</code_context>

<issue_to_address>
**issue (code-quality):** We've found these issues:

- Swap if/else branches ([`swap-if-else-branches`](https://docs.sourcery.ai/Reference/Default-Rules/refactorings/swap-if-else-branches/))
- Remove unnecessary else after guard condition ([`remove-unnecessary-else`](https://docs.sourcery.ai/Reference/Default-Rules/refactorings/remove-unnecessary-else/))
- Explicitly raise from a previous error ([`raise-from-previous-error`](https://docs.sourcery.ai/Reference/Default-Rules/suggestions/raise-from-previous-error/))
</issue_to_address>