nexusapm 1.0.0__tar.gz

nexusapm-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NexusAPM
+
+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.

nexusapm-1.0.0/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: nexusapm
+Version: 1.0.0
+Summary: NexusAPM Python auto-instrumentation SDK (Flask / FastAPI)
+Home-page: https://github.com/Intelli-APM/apm/tree/main/agent/nexusapm-python
+Author: NexusAPM
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: Flask
+Classifier: Framework :: FastAPI
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Provides-Extra: accurate-memory
+Requires-Dist: psutil; extra == "accurate-memory"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# nexusapm (Python SDK)
+
+One-line auto-instrumentation for Flask and FastAPI applications, reporting
+to a [NexusAPM](https://github.com/Intelli-APM/apm) backend.
+
+## Install
+
+```bash
+pip install nexusapm
+```
+
+## Usage
+
+**Flask:**
+```python
+import nexusapm
+
+nexusapm.init(app, service_name="my-app",
+               backend_url="https://your-nexusapm-backend.example.com",
+               api_key="your-api-key")  # or set NEXUSAPM_API_KEY in the environment
+```
+
+**FastAPI:**
+```python
+import nexusapm
+
+nexusapm.init(app, service_name="my-api", framework="fastapi",
+               backend_url="https://your-nexusapm-backend.example.com",
+               api_key="your-api-key")
+```
+
+That's it — every request handled after this point is automatically traced.
+
+## What gets captured automatically
+
+- **Per request:** route, method, status, duration → sent as a trace
+- **Per request:** response time → sent as a metric
+- **Errors and slow requests** (4xx/5xx, or over 1s) → sent as log lines
+- **Every 10 seconds:** app-level rollups — memory usage, average response
+  time, request throughput, error rate
+
+## Distributed tracing across services
+
+If this app calls another NexusAPM-instrumented service over HTTP (via the
+`requests` library), the current request's trace ID is automatically
+propagated onto that outgoing call — no extra code needed. The two
+services' spans show up correlated under one trace in the NexusAPM
+dashboard, instead of two disconnected traces.
+
+## Configuration
+
+| Option         | Required | Default                        | Notes                                     |
+|----------------|----------|----------------------------------|--------------------------------------------|
+| `service_name` | No       | `"unknown-python-service"`       | Shows up as this service's name everywhere |
+| `backend_url`  | No       | `http://localhost:3001`          | Your NexusAPM backend's URL                |
+| `api_key`      | No*      | `NEXUSAPM_API_KEY` env var       | *Required for any data to actually be accepted — falls back to the env var if not passed explicitly |
+| `framework`    | No       | `"flask"`                        | Set to `"fastapi"` for FastAPI apps        |
+| `debug`        | No       | `False`                          | Logs `[NexusAPM]`-style debug lines        |
+
+## Optional: more accurate memory reporting
+
+```bash
+pip install nexusapm[accurate-memory]
+```
+
+Uses `psutil` for real RSS memory instead of the standard-library fallback.
+
+## License
+
+MIT

nexusapm-1.0.0/README.md

@@ -0,0 +1,70 @@
+# nexusapm (Python SDK)
+
+One-line auto-instrumentation for Flask and FastAPI applications, reporting
+to a [NexusAPM](https://github.com/Intelli-APM/apm) backend.
+
+## Install
+
+```bash
+pip install nexusapm
+```
+
+## Usage
+
+**Flask:**
+```python
+import nexusapm
+
+nexusapm.init(app, service_name="my-app",
+               backend_url="https://your-nexusapm-backend.example.com",
+               api_key="your-api-key")  # or set NEXUSAPM_API_KEY in the environment
+```
+
+**FastAPI:**
+```python
+import nexusapm
+
+nexusapm.init(app, service_name="my-api", framework="fastapi",
+               backend_url="https://your-nexusapm-backend.example.com",
+               api_key="your-api-key")
+```
+
+That's it — every request handled after this point is automatically traced.
+
+## What gets captured automatically
+
+- **Per request:** route, method, status, duration → sent as a trace
+- **Per request:** response time → sent as a metric
+- **Errors and slow requests** (4xx/5xx, or over 1s) → sent as log lines
+- **Every 10 seconds:** app-level rollups — memory usage, average response
+  time, request throughput, error rate
+
+## Distributed tracing across services
+
+If this app calls another NexusAPM-instrumented service over HTTP (via the
+`requests` library), the current request's trace ID is automatically
+propagated onto that outgoing call — no extra code needed. The two
+services' spans show up correlated under one trace in the NexusAPM
+dashboard, instead of two disconnected traces.
+
+## Configuration
+
+| Option         | Required | Default                        | Notes                                     |
+|----------------|----------|----------------------------------|--------------------------------------------|
+| `service_name` | No       | `"unknown-python-service"`       | Shows up as this service's name everywhere |
+| `backend_url`  | No       | `http://localhost:3001`          | Your NexusAPM backend's URL                |
+| `api_key`      | No*      | `NEXUSAPM_API_KEY` env var       | *Required for any data to actually be accepted — falls back to the env var if not passed explicitly |
+| `framework`    | No       | `"flask"`                        | Set to `"fastapi"` for FastAPI apps        |
+| `debug`        | No       | `False`                          | Logs `[NexusAPM]`-style debug lines        |
+
+## Optional: more accurate memory reporting
+
+```bash
+pip install nexusapm[accurate-memory]
+```
+
+Uses `psutil` for real RSS memory instead of the standard-library fallback.
+
+## License
+
+MIT

nexusapm-1.0.0/nexusapm/__init__.py

@@ -0,0 +1,346 @@
+"""
+nexusapm — Python auto-instrumentation SDK
+============================================
+One-line monitoring for Flask and FastAPI apps.
+
+Usage (Flask):
+    import nexusapm
+    nexusapm.init(app, service_name="my-python-app")
+
+Usage (FastAPI):
+    import nexusapm
+    nexusapm.init(app, service_name="my-api", framework="fastapi")
+
+Captures automatically, per request:
+    - route, method, status, duration   -> trace
+    - response_time                      -> metric
+    - errors (4xx/5xx) and slow (>1s)    -> logs
+And every 10s, app-level rollups:
+    - app_memory_mb, app_avg_response_time,
+      app_total_requests, app_error_rate
+"""
+
+import os
+import time
+import threading
+import atexit
+import random
+import string
+import contextvars
+from datetime import datetime, timezone
+
+import requests
+
+TRACE_ID_HEADER = "X-NexusAPM-Trace-Id"
+SPAN_ID_HEADER = "X-NexusAPM-Span-Id"
+
+# Holds (trace_id, span_id) for whichever request is currently being
+# handled on this thread/task — lets an outgoing `requests` call made deep
+# inside a view function find "which request am I part of" automatically.
+# Previously send_trace() always picked a brand-new random trace_id with no
+# relation to any incoming request, so one logical request crossing
+# multiple instrumented services produced N unrelated traces instead of a
+# single correlated one — this is the fix for that.
+_trace_ctx = contextvars.ContextVar("nexusapm_trace_ctx", default=None)
+
+try:
+    import psutil
+    _HAS_PSUTIL = True
+except Exception:
+    _HAS_PSUTIL = False
+
+# ---- module state ----
+_config = {
+    "service_name": "unknown-python-service",
+    "backend_url": "http://localhost:3001",
+    "api_key": "",
+    "debug": False,
+}
+_stats = {"requests": 0, "errors": 0, "total_duration": 0.0}
+_lock = threading.Lock()
+
+
+def _now_iso():
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _log(msg):
+    print(f"[NexusAPM] {msg}")
+
+
+def _gen_id():
+    return "".join(random.choice(string.ascii_lowercase + string.digits) for _ in range(16))
+
+
+# ---- senders (fire-and-forget, never block the app) ----
+def _post(path, payload):
+    # All ingestion endpoints (/api/metrics, /api/logs, /api/traces) require
+    # an API key — this was missing entirely before, so every call from
+    # this SDK silently 401'd once those routes started requiring auth.
+    headers = {"x-api-key": _config["api_key"]} if _config["api_key"] else {}
+
+    def _send():
+        try:
+            requests.post(
+                f"{_config['backend_url']}{path}", json=payload, timeout=2, headers=headers
+            )
+        except Exception as e:
+            if _config["debug"]:
+                _log(f"send {path} FAILED: {type(e).__name__}: {e}")
+    threading.Thread(target=_send, daemon=True).start()
+
+
+# Announces "the process I'm running in (this PID) calls itself
+# service_name in its own trace data" — lets the backend link this SDK's
+# traced name to whatever name Service Discovery's process scanner
+# independently gave the same underlying process (e.g. "app" for
+# `python app.py`), purely by matching PID. Sent once at startup and then
+# repeated periodically, since Discovery's own scan might not have found
+# this PID yet at the exact moment the SDK boots.
+ANNOUNCE_INTERVAL_SECS = 60
+
+
+def _announce_identity():
+    headers = {"x-api-key": _config["api_key"]} if _config["api_key"] else {}
+
+    def _send():
+        try:
+            requests.post(
+                f"{_config['backend_url']}/api/discovery/identify",
+                json={"pid": os.getpid(), "tracedServiceName": _config["service_name"]},
+                timeout=2, headers=headers,
+            )
+        except Exception as e:
+            if _config["debug"]:
+                _log(f"identity announce FAILED: {type(e).__name__}: {e}")
+    threading.Thread(target=_send, daemon=True).start()
+
+
+def _identity_reporter():
+    while True:
+        time.sleep(ANNOUNCE_INTERVAL_SECS)
+        _announce_identity()
+
+
+def send_metric(name, value, unit=""):
+    _post("/api/metrics", {
+        "service": _config["service_name"],
+        "name": name,
+        "value": value,
+        "unit": unit,
+        "timestamp": _now_iso(),
+    })
+
+
+def send_log(level, message):
+    _post("/api/logs", {
+        "service": _config["service_name"],
+        "level": level,
+        "message": message,
+        "timestamp": _now_iso(),
+    })
+
+
+def send_trace(route, method, duration_ms, status, trace_id=None, span_id=None, parent_span_id=""):
+    """Send exactly ONE trace per request. (Bug fix: was sending two.)"""
+    _post("/api/traces", {
+        "service": _config["service_name"],
+        "traceId": trace_id or _gen_id(),
+        "spanId": span_id or _gen_id(),
+        "parentSpanId": parent_span_id or "",
+        "route": route,
+        "method": method,
+        "duration": duration_ms,
+        "status": status,
+        "timestamp": _now_iso(),
+        "type": "trace",
+    })
+
+
+# ---- per-request recording ----
+def _record(route, method, duration_ms, status, trace_id=None, span_id=None, parent_span_id=""):
+    with _lock:
+        _stats["requests"] += 1
+        _stats["total_duration"] += duration_ms
+        if status >= 400:
+            _stats["errors"] += 1
+
+    if _config["debug"]:
+        _log(f"{method} {route} -> {status} ({duration_ms:.0f}ms)")
+
+    send_trace(route, method, duration_ms, status, trace_id, span_id, parent_span_id)
+    send_metric("response_time", round(duration_ms, 2), "ms")
+
+    if status >= 500:
+        send_log("ERROR", f"{method} {route} returned {status} in {duration_ms:.0f}ms")
+    elif status in (401, 403):
+        send_log("WARN", f"Auth failed: {method} {route} returned {status} in {duration_ms:.0f}ms")
+    elif status == 429:
+        send_log("WARN", f"Rate limited: {method} {route} returned 429 in {duration_ms:.0f}ms")
+    elif status >= 400:
+        send_log("WARN", f"{method} {route} returned {status} in {duration_ms:.0f}ms")
+    # Two-tier slow-request logging — a 1.2s request and an 8s request are
+    # very different severities of problem, so don't bucket them the same.
+    if duration_ms > 3000:
+        send_log("ERROR", f"Very slow request: {method} {route} took {duration_ms:.0f}ms")
+    elif duration_ms > 1000:
+        send_log("WARN", f"Slow request: {method} {route} took {duration_ms:.0f}ms")
+
+
+# ---- 10s rollup reporter ----
+ROLLUP_INTERVAL_SECS = 10
+
+def _reporter():
+    while True:
+        time.sleep(ROLLUP_INTERVAL_SECS)
+        with _lock:
+            # Snapshot then RESET — same fix as the Node SDK: a counter
+            # that never resets sends a useless lifetime total each cycle
+            # instead of "what happened in the last 10 seconds".
+            reqs  = _stats["requests"]
+            errs  = _stats["errors"]
+            total = _stats["total_duration"]
+            _stats["requests"]       = 0
+            _stats["errors"]         = 0
+            _stats["total_duration"] = 0.0
+
+        avg      = (total / reqs) if reqs else 0.0
+        err_rate = (errs / reqs * 100) if reqs else 0.0
+        req_per_sec = reqs / ROLLUP_INTERVAL_SECS
+
+        if _HAS_PSUTIL:
+            mem_mb = psutil.Process().memory_info().rss / 1024 / 1024
+        else:
+            import resource
+            mem_mb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024
+
+        send_metric("app_memory_mb",           round(mem_mb, 2),      "MB")
+        send_metric("app_avg_response_time",    round(avg, 2),         "ms")
+        send_metric("http_request_count",       reqs,                  "count")
+        send_metric("http_requests_per_second", round(req_per_sec, 2), "req/s")
+        send_metric("app_error_rate",           round(err_rate, 2),    "%")
+
+        if _config["debug"]:
+            _log(f"rollup: mem={mem_mb:.1f}MB avg={avg:.0f}ms reqs={reqs} ({req_per_sec:.1f}/s) errors={errs}")
+
+
+# ---- framework integrations ----
+def _instrument_flask(app):
+    from flask import request, g
+
+    @app.before_request
+    def _before():
+        g._nexus_start = time.time()
+        # A trace ID on the incoming request means an upstream instrumented
+        # service is already mid-trace — continue it instead of starting a
+        # new one. No header means this request is the root of a new trace.
+        incoming_trace_id = request.headers.get(TRACE_ID_HEADER)
+        incoming_span_id = request.headers.get(SPAN_ID_HEADER)
+        g._nexus_trace_id = incoming_trace_id or _gen_id()
+        g._nexus_span_id = _gen_id()
+        g._nexus_parent_span_id = incoming_span_id or ""
+        g._nexus_ctx_token = _trace_ctx.set((g._nexus_trace_id, g._nexus_span_id))
+
+    @app.after_request
+    def _after(response):
+        start = getattr(g, "_nexus_start", None)
+        if start is not None:
+            duration_ms = (time.time() - start) * 1000.0
+            _record(
+                request.path, request.method, duration_ms, response.status_code,
+                trace_id=getattr(g, "_nexus_trace_id", None),
+                span_id=getattr(g, "_nexus_span_id", None),
+                parent_span_id=getattr(g, "_nexus_parent_span_id", ""),
+            )
+        token = getattr(g, "_nexus_ctx_token", None)
+        if token is not None:
+            _trace_ctx.reset(token)
+        return response
+
+    _log("Flask instrumentation attached")
+
+
+def _instrument_fastapi(app):
+    from starlette.requests import Request
+
+    @app.middleware("http")
+    async def _mw(request: Request, call_next):
+        start = time.time()
+        incoming_trace_id = request.headers.get(TRACE_ID_HEADER)
+        incoming_span_id = request.headers.get(SPAN_ID_HEADER)
+        trace_id = incoming_trace_id or _gen_id()
+        span_id = _gen_id()
+        token = _trace_ctx.set((trace_id, span_id))
+        try:
+            response = await call_next(request)
+        finally:
+            _trace_ctx.reset(token)
+        duration_ms = (time.time() - start) * 1000.0
+        _record(
+            request.url.path, request.method, duration_ms, response.status_code,
+            trace_id=trace_id, span_id=span_id, parent_span_id=incoming_span_id or "",
+        )
+        return response
+
+    _log("FastAPI instrumentation attached")
+
+
+# Propagate the current request's trace context onto any outgoing `requests`
+# call the instrumented app makes (e.g. calling another instrumented
+# service) — this is what actually makes tracing "distributed" rather than
+# each service recording its own disconnected spans. Patches only the one
+# low-level method every requests.* helper (get/post/put/...) funnels
+# through, and only adds headers — it never sends anything itself, so it
+# carries none of the "recorded a trace for every outgoing call" risk that
+# the Node SDK's removed http.request patch had.
+_original_request = requests.Session.request
+
+
+def _traced_request(self, method, url, *args, **kwargs):
+    if not (_config["backend_url"] and str(url).startswith(_config["backend_url"])):
+        ctx = _trace_ctx.get()
+        if ctx is not None:
+            headers = kwargs.get("headers") or {}
+            headers = dict(headers)
+            headers[TRACE_ID_HEADER] = ctx[0]
+            headers[SPAN_ID_HEADER] = ctx[1]
+            kwargs["headers"] = headers
+    return _original_request(self, method, url, *args, **kwargs)
+
+
+requests.Session.request = _traced_request
+
+
+# ---- public init ----
+def init(app=None, service_name=None, backend_url=None, api_key=None, framework="flask", debug=False):
+    if service_name:
+        _config["service_name"] = service_name
+    if backend_url:
+        _config["backend_url"] = backend_url
+    _config["api_key"] = api_key or os.getenv("NEXUSAPM_API_KEY", "")
+    _config["debug"] = debug
+
+    _log(f"initializing for service: {_config['service_name']}")
+    if not _config["api_key"] and debug:
+        _log("WARNING: no api_key provided — /api/metrics, /api/logs, /api/traces all require one and will return 401")
+
+    if app is not None:
+        if framework == "flask":
+            _instrument_flask(app)
+        elif framework == "fastapi":
+            _instrument_fastapi(app)
+        else:
+            _log(f"unknown framework '{framework}', no auto-instrumentation")
+
+    t = threading.Thread(target=_reporter, daemon=True)
+    t.start()
+
+    _announce_identity()
+    threading.Thread(target=_identity_reporter, daemon=True).start()
+
+    send_log("INFO", f"NexusAPM agent started — monitoring {_config['service_name']}")
+    atexit.register(
+        lambda: send_log("INFO", f"NexusAPM agent stopped — {_config['service_name']}")
+    )
+
+    _log("ready! Monitoring all HTTP requests automatically.")

nexusapm-1.0.0/nexusapm.egg-info/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: nexusapm
+Version: 1.0.0
+Summary: NexusAPM Python auto-instrumentation SDK (Flask / FastAPI)
+Home-page: https://github.com/Intelli-APM/apm/tree/main/agent/nexusapm-python
+Author: NexusAPM
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: Flask
+Classifier: Framework :: FastAPI
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Provides-Extra: accurate-memory
+Requires-Dist: psutil; extra == "accurate-memory"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# nexusapm (Python SDK)
+
+One-line auto-instrumentation for Flask and FastAPI applications, reporting
+to a [NexusAPM](https://github.com/Intelli-APM/apm) backend.
+
+## Install
+
+```bash
+pip install nexusapm
+```
+
+## Usage
+
+**Flask:**
+```python
+import nexusapm
+
+nexusapm.init(app, service_name="my-app",
+               backend_url="https://your-nexusapm-backend.example.com",
+               api_key="your-api-key")  # or set NEXUSAPM_API_KEY in the environment
+```
+
+**FastAPI:**
+```python
+import nexusapm
+
+nexusapm.init(app, service_name="my-api", framework="fastapi",
+               backend_url="https://your-nexusapm-backend.example.com",
+               api_key="your-api-key")
+```
+
+That's it — every request handled after this point is automatically traced.
+
+## What gets captured automatically
+
+- **Per request:** route, method, status, duration → sent as a trace
+- **Per request:** response time → sent as a metric
+- **Errors and slow requests** (4xx/5xx, or over 1s) → sent as log lines
+- **Every 10 seconds:** app-level rollups — memory usage, average response
+  time, request throughput, error rate
+
+## Distributed tracing across services
+
+If this app calls another NexusAPM-instrumented service over HTTP (via the
+`requests` library), the current request's trace ID is automatically
+propagated onto that outgoing call — no extra code needed. The two
+services' spans show up correlated under one trace in the NexusAPM
+dashboard, instead of two disconnected traces.
+
+## Configuration
+
+| Option         | Required | Default                        | Notes                                     |
+|----------------|----------|----------------------------------|--------------------------------------------|
+| `service_name` | No       | `"unknown-python-service"`       | Shows up as this service's name everywhere |
+| `backend_url`  | No       | `http://localhost:3001`          | Your NexusAPM backend's URL                |
+| `api_key`      | No*      | `NEXUSAPM_API_KEY` env var       | *Required for any data to actually be accepted — falls back to the env var if not passed explicitly |
+| `framework`    | No       | `"flask"`                        | Set to `"fastapi"` for FastAPI apps        |
+| `debug`        | No       | `False`                          | Logs `[NexusAPM]`-style debug lines        |
+
+## Optional: more accurate memory reporting
+
+```bash
+pip install nexusapm[accurate-memory]
+```
+
+Uses `psutil` for real RSS memory instead of the standard-library fallback.
+
+## License
+
+MIT

nexusapm-1.0.0/nexusapm.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+setup.py
+nexusapm/__init__.py
+nexusapm.egg-info/PKG-INFO
+nexusapm.egg-info/SOURCES.txt
+nexusapm.egg-info/dependency_links.txt
+nexusapm.egg-info/requires.txt
+nexusapm.egg-info/top_level.txt

nexusapm-1.0.0/nexusapm.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nexusapm-1.0.0/nexusapm.egg-info/requires.txt

@@ -0,0 +1,4 @@
+requests
+
+[accurate-memory]
+psutil

nexusapm-1.0.0/nexusapm.egg-info/top_level.txt

@@ -0,0 +1 @@
+nexusapm

nexusapm-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

nexusapm-1.0.0/setup.py

@@ -0,0 +1,28 @@
+from pathlib import Path
+from setuptools import setup, find_packages
+
+long_description = (Path(__file__).parent / "README.md").read_text(encoding="utf-8")
+
+setup(
+    name="nexusapm",
+    version="1.0.0",
+    description="NexusAPM Python auto-instrumentation SDK (Flask / FastAPI)",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="NexusAPM",
+    license="MIT",
+    url="https://github.com/Intelli-APM/apm/tree/main/agent/nexusapm-python",
+    packages=find_packages(),
+    install_requires=["requests"],
+    extras_require={"accurate-memory": ["psutil"]},
+    python_requires=">=3.8",
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Framework :: Flask",
+        "Framework :: FastAPI",
+        "Topic :: System :: Monitoring",
+    ],
+)