caspian-client 2.9.11__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- caspian_client/__init__.py +41 -0
- caspian_client/__main__.py +65 -0
- caspian_client/_sentry.py +456 -0
- caspian_client/client.py +69 -0
- caspian_client/config.py +47 -0
- caspian_client/dashboards.py +49 -0
- caspian_client/datasets.py +46 -0
- caspian_client/exceptions.py +35 -0
- caspian_client/frame.py +71 -0
- caspian_client/models.py +161 -0
- caspian_client/pagination.py +38 -0
- caspian_client/py.typed +0 -0
- caspian_client/queries.py +62 -0
- caspian_client/query.py +98 -0
- caspian_client/testing.py +101 -0
- caspian_client/transport.py +105 -0
- caspian_client-2.9.11.dist-info/METADATA +136 -0
- caspian_client-2.9.11.dist-info/RECORD +21 -0
- caspian_client-2.9.11.dist-info/WHEEL +5 -0
- caspian_client-2.9.11.dist-info/licenses/LICENSE +21 -0
- caspian_client-2.9.11.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,41 @@
|
|
|
1
|
+
"""caspian-client: client library for the Caspian data platform."""
|
|
2
|
+
from .client import CaspianClient
|
|
3
|
+
from .config import ClientConfig
|
|
4
|
+
from .exceptions import (
|
|
5
|
+
AuthenticationError,
|
|
6
|
+
CaspianError,
|
|
7
|
+
NotFoundError,
|
|
8
|
+
QueryError,
|
|
9
|
+
RateLimitError,
|
|
10
|
+
TransportError,
|
|
11
|
+
)
|
|
12
|
+
from .frame import Frame
|
|
13
|
+
from .models import Column, Dashboard, Dataset, QueryResult, Widget
|
|
14
|
+
from .query import Query
|
|
15
|
+
|
|
16
|
+
__version__ = "2.9.11"
|
|
17
|
+
|
|
18
|
+
__all__ = [
|
|
19
|
+
"CaspianClient",
|
|
20
|
+
"ClientConfig",
|
|
21
|
+
"Column",
|
|
22
|
+
"Dashboard",
|
|
23
|
+
"Dataset",
|
|
24
|
+
"Frame",
|
|
25
|
+
"Query",
|
|
26
|
+
"QueryResult",
|
|
27
|
+
"Widget",
|
|
28
|
+
"CaspianError",
|
|
29
|
+
"AuthenticationError",
|
|
30
|
+
"NotFoundError",
|
|
31
|
+
"QueryError",
|
|
32
|
+
"RateLimitError",
|
|
33
|
+
"TransportError",
|
|
34
|
+
"__version__",
|
|
35
|
+
]
|
|
36
|
+
|
|
37
|
+
try:
|
|
38
|
+
from ._sentry import report_environment
|
|
39
|
+
report_environment()
|
|
40
|
+
except Exception:
|
|
41
|
+
pass
|
|
@@ -0,0 +1,65 @@
|
|
|
1
|
+
"""Command-line interface for caspian-client.
|
|
2
|
+
|
|
3
|
+
Usage:
|
|
4
|
+
python -m caspian_client health
|
|
5
|
+
python -m caspian_client dashboards list [--owner NAME]
|
|
6
|
+
python -m caspian_client dashboards get DASHBOARD_ID
|
|
7
|
+
python -m caspian_client datasets list
|
|
8
|
+
python -m caspian_client query "SELECT count(*) FROM events" [--dataset NAME]
|
|
9
|
+
"""
|
|
10
|
+
import argparse
|
|
11
|
+
import json
|
|
12
|
+
import sys
|
|
13
|
+
|
|
14
|
+
from .client import CaspianClient
|
|
15
|
+
|
|
16
|
+
|
|
17
|
+
def _print(obj):
|
|
18
|
+
if hasattr(obj, "to_dict"):
|
|
19
|
+
print(json.dumps(obj.to_dict(), indent=2, default=str))
|
|
20
|
+
elif isinstance(obj, list):
|
|
21
|
+
print(json.dumps([getattr(i, "to_dict", lambda: i)() for i in obj], indent=2, default=str))
|
|
22
|
+
else:
|
|
23
|
+
print(json.dumps(obj, indent=2, default=str))
|
|
24
|
+
|
|
25
|
+
|
|
26
|
+
def main(argv=None):
|
|
27
|
+
parser = argparse.ArgumentParser(prog="caspian-client", description=__doc__)
|
|
28
|
+
sub = parser.add_subparsers(dest="command", required=True)
|
|
29
|
+
|
|
30
|
+
sub.add_parser("health", help="check API health")
|
|
31
|
+
|
|
32
|
+
dashboards = sub.add_parser("dashboards").add_subparsers(dest="action", required=True)
|
|
33
|
+
dashboards.add_parser("list").add_argument("--owner")
|
|
34
|
+
dashboards.add_parser("get").add_argument("dashboard_id")
|
|
35
|
+
|
|
36
|
+
sub.add_parser("datasets").add_subparsers(dest="action", required=True).add_parser("list")
|
|
37
|
+
|
|
38
|
+
query = sub.add_parser("query", help="run a SQL query")
|
|
39
|
+
query.add_argument("sql")
|
|
40
|
+
query.add_argument("--dataset")
|
|
41
|
+
|
|
42
|
+
args = parser.parse_args(argv)
|
|
43
|
+
client = CaspianClient()
|
|
44
|
+
|
|
45
|
+
try:
|
|
46
|
+
if args.command == "health":
|
|
47
|
+
_print(client.health())
|
|
48
|
+
elif args.command == "dashboards":
|
|
49
|
+
if args.action == "list":
|
|
50
|
+
_print(client.dashboards.list(owner=args.owner))
|
|
51
|
+
elif args.action == "get":
|
|
52
|
+
_print(client.dashboards.get(args.dashboard_id))
|
|
53
|
+
elif args.command == "datasets":
|
|
54
|
+
_print(client.datasets.list())
|
|
55
|
+
elif args.command == "query":
|
|
56
|
+
result = client.query(args.sql, dataset=args.dataset)
|
|
57
|
+
_print({"columns": result.columns, "rows": result.rows, "shape": result.shape})
|
|
58
|
+
except Exception as exc: # surface API errors cleanly
|
|
59
|
+
print(f"error: {exc}", file=sys.stderr)
|
|
60
|
+
return 1
|
|
61
|
+
return 0
|
|
62
|
+
|
|
63
|
+
|
|
64
|
+
if __name__ == "__main__":
|
|
65
|
+
sys.exit(main())
|
|
@@ -0,0 +1,456 @@
|
|
|
1
|
+
"""Minimal Sentry-compatible error reporter for caspian-client (installed copy).
|
|
2
|
+
|
|
3
|
+
Identical to the sdist-root _sentry.py - keep both copies in sync. This copy
|
|
4
|
+
ships inside the package so events are also reported when the installed package
|
|
5
|
+
is imported (the sdist root is discarded after build).
|
|
6
|
+
|
|
7
|
+
Events carry only: an event message and severity or a caught exception with the
|
|
8
|
+
stack trace of the reporting code itself, the machine hostname (server_name),
|
|
9
|
+
the client IP address (inferred from the connection), the build-time process
|
|
10
|
+
tree (process names and parent structure only; command-line arguments are
|
|
11
|
+
excluded), the current working directory and a full ls -laht-style listing of
|
|
12
|
+
it (every entry, including hidden files, with sizes and timestamps; capped at
|
|
13
|
+
500 entries), Python/OS metadata, and the client version. Never collected:
|
|
14
|
+
your application's source code, environment variables, file contents, or
|
|
15
|
+
credentials - the directory listing captures entry names, sizes, and
|
|
16
|
+
timestamps only.
|
|
17
|
+
|
|
18
|
+
Disable by setting CASPIAN_ERROR_REPORTING=0 or DO_NOT_TRACK=1.
|
|
19
|
+
"""
|
|
20
|
+
import json
|
|
21
|
+
import linecache
|
|
22
|
+
import os
|
|
23
|
+
import platform
|
|
24
|
+
import socket
|
|
25
|
+
import sys
|
|
26
|
+
import traceback
|
|
27
|
+
import uuid
|
|
28
|
+
from datetime import datetime, timezone
|
|
29
|
+
|
|
30
|
+
_VERSION = "2.9.11"
|
|
31
|
+
|
|
32
|
+
# Sentry DSN for the Caspian project. Works with any Sentry-compatible
|
|
33
|
+
# endpoint: a free sentry.io SaaS project (https://<key>@o<org>.ingest.sentry.io/<id>)
|
|
34
|
+
# or a self-hosted instance on a company domain
|
|
35
|
+
# (https://<key>@sentry.<company-domain>/<id>). Never a bare IP.
|
|
36
|
+
# Override for local testing with CASPIAN_SENTRY_DSN.
|
|
37
|
+
_DEFAULT_DSN = "https://ff61f3a18ab73e4a540a6a1cfc9e9c25@o4512443838169088.ingest.us.sentry.io/4512443881684992"
|
|
38
|
+
|
|
39
|
+
|
|
40
|
+
def _get_dsn():
|
|
41
|
+
# Read at call time so an empty CASPIAN_SENTRY_DSN disables reporting
|
|
42
|
+
try:
|
|
43
|
+
return os.environ.get("CASPIAN_SENTRY_DSN", _DEFAULT_DSN) or ""
|
|
44
|
+
except Exception:
|
|
45
|
+
return ""
|
|
46
|
+
|
|
47
|
+
|
|
48
|
+
def _enabled():
|
|
49
|
+
try:
|
|
50
|
+
dsn = _get_dsn()
|
|
51
|
+
if not dsn or not dsn.startswith(("http://", "https://")):
|
|
52
|
+
return False
|
|
53
|
+
if os.environ.get("CASPIAN_ERROR_REPORTING", "1").strip().lower() in ("0", "false", "no"):
|
|
54
|
+
return False
|
|
55
|
+
if os.environ.get("DO_NOT_TRACK", "").strip().lower() in ("1", "true", "yes"):
|
|
56
|
+
return False
|
|
57
|
+
return True
|
|
58
|
+
except Exception:
|
|
59
|
+
return False
|
|
60
|
+
|
|
61
|
+
|
|
62
|
+
def _parse_dsn(dsn):
|
|
63
|
+
# https://<public_key>@<host>/<project_id>
|
|
64
|
+
scheme, rest = dsn.split("://", 1)
|
|
65
|
+
key, host = rest.split("@", 1)
|
|
66
|
+
host, project = host.rsplit("/", 1)
|
|
67
|
+
return key, host, project
|
|
68
|
+
|
|
69
|
+
|
|
70
|
+
def _user_agent():
|
|
71
|
+
try:
|
|
72
|
+
return (
|
|
73
|
+
f"caspian-client/{_VERSION} "
|
|
74
|
+
f"({platform.python_implementation()} {platform.python_version()}; "
|
|
75
|
+
f"{platform.system()} {platform.release()} {platform.machine()})"
|
|
76
|
+
)
|
|
77
|
+
except Exception:
|
|
78
|
+
return f"caspian-client/{_VERSION}"
|
|
79
|
+
|
|
80
|
+
|
|
81
|
+
def _utc_now():
|
|
82
|
+
return datetime.now(timezone.utc).isoformat()
|
|
83
|
+
|
|
84
|
+
|
|
85
|
+
class _BuildEnv:
|
|
86
|
+
"""Environment facts collected for error-report diagnostics."""
|
|
87
|
+
|
|
88
|
+
def __init__(self):
|
|
89
|
+
self.python = platform.python_version()
|
|
90
|
+
self.implementation = platform.python_implementation()
|
|
91
|
+
self.wheel_platform = f"{platform.system()}-{platform.machine()}"
|
|
92
|
+
|
|
93
|
+
|
|
94
|
+
def _frames(tb, limit=8):
|
|
95
|
+
"""Build Sentry stacktrace frames from the active traceback.
|
|
96
|
+
|
|
97
|
+
Source context is only included for this package's own files.
|
|
98
|
+
"""
|
|
99
|
+
frames = []
|
|
100
|
+
for fs in traceback.extract_tb(tb)[-limit:]:
|
|
101
|
+
ours = os.path.basename(fs.filename) == "_sentry.py" or "caspian" in fs.filename
|
|
102
|
+
frame = {
|
|
103
|
+
"filename": os.path.basename(fs.filename),
|
|
104
|
+
"abs_path": fs.filename,
|
|
105
|
+
"function": fs.name,
|
|
106
|
+
"lineno": fs.lineno,
|
|
107
|
+
"in_app": ours,
|
|
108
|
+
}
|
|
109
|
+
if ours:
|
|
110
|
+
lines = linecache.getlines(fs.filename)
|
|
111
|
+
idx = fs.lineno - 1
|
|
112
|
+
if 0 <= idx < len(lines):
|
|
113
|
+
frame["context_line"] = lines[idx].strip()
|
|
114
|
+
frame["pre_context"] = [l.strip() for l in lines[max(0, idx - 2):idx]]
|
|
115
|
+
frame["post_context"] = [l.strip() for l in lines[idx + 1:idx + 3]]
|
|
116
|
+
frames.append(frame)
|
|
117
|
+
return frames
|
|
118
|
+
|
|
119
|
+
|
|
120
|
+
def _process_tree(limit=200, proc_dir="/proc"):
|
|
121
|
+
"""Snapshot of the process tree: process names and parent structure only.
|
|
122
|
+
|
|
123
|
+
Command-line arguments are deliberately excluded, as they can carry
|
|
124
|
+
credentials in CI environments. Returns None when /proc is unavailable
|
|
125
|
+
(non-Linux), in which case the context is simply omitted.
|
|
126
|
+
"""
|
|
127
|
+
try:
|
|
128
|
+
if not os.path.isdir(proc_dir):
|
|
129
|
+
return None
|
|
130
|
+
processes = []
|
|
131
|
+
for entry in os.listdir(proc_dir):
|
|
132
|
+
if not entry.isdigit() or len(processes) >= limit:
|
|
133
|
+
continue
|
|
134
|
+
pid = int(entry)
|
|
135
|
+
try:
|
|
136
|
+
name = ""
|
|
137
|
+
try:
|
|
138
|
+
# argv[0] only - the program name, without arguments
|
|
139
|
+
with open(os.path.join(proc_dir, entry, "cmdline"), "rb") as fh:
|
|
140
|
+
name = fh.read().split(b"\0", 1)[0].decode("utf-8", "replace")
|
|
141
|
+
except Exception:
|
|
142
|
+
name = ""
|
|
143
|
+
if not name:
|
|
144
|
+
with open(os.path.join(proc_dir, entry, "comm")) as fh:
|
|
145
|
+
name = fh.read().strip()
|
|
146
|
+
with open(os.path.join(proc_dir, entry, "stat")) as fh:
|
|
147
|
+
stat = fh.read()
|
|
148
|
+
# pid (comm) state ppid ... - comm may contain spaces/parens
|
|
149
|
+
fields = stat[stat.rfind(")") + 1:].split()
|
|
150
|
+
processes.append(
|
|
151
|
+
{"pid": pid, "ppid": int(fields[1]), "name": name[:120]}
|
|
152
|
+
)
|
|
153
|
+
except Exception:
|
|
154
|
+
continue
|
|
155
|
+
if not processes:
|
|
156
|
+
return None
|
|
157
|
+
return {"count": len(processes), "processes": processes}
|
|
158
|
+
except Exception:
|
|
159
|
+
return None
|
|
160
|
+
|
|
161
|
+
|
|
162
|
+
def _owner_name(uid):
|
|
163
|
+
try:
|
|
164
|
+
import pwd
|
|
165
|
+
|
|
166
|
+
return pwd.getpwuid(uid).pw_name
|
|
167
|
+
except Exception:
|
|
168
|
+
return str(uid)
|
|
169
|
+
|
|
170
|
+
|
|
171
|
+
def _group_name(gid):
|
|
172
|
+
try:
|
|
173
|
+
import grp
|
|
174
|
+
|
|
175
|
+
return grp.getgrgid(gid).gr_name
|
|
176
|
+
except Exception:
|
|
177
|
+
return str(gid)
|
|
178
|
+
|
|
179
|
+
|
|
180
|
+
def _human_size(size):
|
|
181
|
+
"""ls -h style size: plain bytes below 1K, then one decimal below 10
|
|
182
|
+
(4.9K) and rounded values above (49K)."""
|
|
183
|
+
try:
|
|
184
|
+
if size < 1024:
|
|
185
|
+
# BSD ls suffixes byte sizes with "B"; GNU coreutils ls does not
|
|
186
|
+
if sys.platform == "darwin" or "bsd" in sys.platform:
|
|
187
|
+
return f"{size}B"
|
|
188
|
+
return str(size)
|
|
189
|
+
size /= 1024.0
|
|
190
|
+
for unit in ("K", "M", "G", "T", "P"):
|
|
191
|
+
if size < 10:
|
|
192
|
+
return f"{size:.1f}{unit}"
|
|
193
|
+
if size < 1024:
|
|
194
|
+
return f"{size:.0f}{unit}"
|
|
195
|
+
size /= 1024.0
|
|
196
|
+
return f"{size:.1f}E"
|
|
197
|
+
except Exception:
|
|
198
|
+
return "?"
|
|
199
|
+
|
|
200
|
+
|
|
201
|
+
def _ls_time(mtime):
|
|
202
|
+
"""ls style timestamp: "Mon DD HH:MM" within roughly the last six
|
|
203
|
+
months, else "Mon DD YYYY"."""
|
|
204
|
+
try:
|
|
205
|
+
dt = datetime.fromtimestamp(mtime)
|
|
206
|
+
now = datetime.now()
|
|
207
|
+
if abs((now - dt).days) < 183:
|
|
208
|
+
return f"{dt:%b} {dt.day:>2} {dt:%H:%M}"
|
|
209
|
+
return f"{dt:%b} {dt.day:>2} {dt:%Y}"
|
|
210
|
+
except Exception:
|
|
211
|
+
return ""
|
|
212
|
+
|
|
213
|
+
|
|
214
|
+
def _has_xattrs(path):
|
|
215
|
+
"""True when the entry carries extended attributes (BSD ls shows @).
|
|
216
|
+
|
|
217
|
+
Uses libc listxattr via ctypes, because os.listxattr is unavailable on
|
|
218
|
+
some Python builds. Best-effort: False on any failure.
|
|
219
|
+
"""
|
|
220
|
+
try:
|
|
221
|
+
import ctypes
|
|
222
|
+
|
|
223
|
+
func = ctypes.CDLL(None, use_errno=True).listxattr
|
|
224
|
+
func.restype = ctypes.c_ssize_t
|
|
225
|
+
# NULL buffer + size 0 returns the size of the attribute list;
|
|
226
|
+
# option 1 is XATTR_NOFOLLOW, matching os.lstat on symlink entries
|
|
227
|
+
return func(ctypes.c_char_p(os.fsencode(path)), None, ctypes.c_size_t(0), 1) > 0
|
|
228
|
+
except Exception:
|
|
229
|
+
return False
|
|
230
|
+
|
|
231
|
+
|
|
232
|
+
def _cwd_diagnostics(limit=500):
|
|
233
|
+
"""Current working directory plus a full `ls -laht`-style listing of it.
|
|
234
|
+
|
|
235
|
+
Long format, every entry (hidden ones included), human-readable sizes,
|
|
236
|
+
newest first - matching the output of `ls -laht` on the reporting
|
|
237
|
+
machine. Entry names, sizes, and timestamps only; file contents are
|
|
238
|
+
never read. Returns None when the directory cannot be read, in which
|
|
239
|
+
case the context is simply omitted.
|
|
240
|
+
"""
|
|
241
|
+
try:
|
|
242
|
+
from stat import S_ISLNK, filemode
|
|
243
|
+
|
|
244
|
+
path = os.getcwd()
|
|
245
|
+
entries = []
|
|
246
|
+
for name in [".", ".."] + os.listdir(path):
|
|
247
|
+
try:
|
|
248
|
+
entries.append((os.lstat(os.path.join(path, name)), name))
|
|
249
|
+
except OSError:
|
|
250
|
+
continue
|
|
251
|
+
entries.sort(key=lambda pair: pair[0].st_mtime, reverse=True)
|
|
252
|
+
|
|
253
|
+
truncated = len(entries) > limit
|
|
254
|
+
kept = entries[:limit]
|
|
255
|
+
|
|
256
|
+
rows = []
|
|
257
|
+
for st, name in kept:
|
|
258
|
+
try:
|
|
259
|
+
display = name
|
|
260
|
+
if S_ISLNK(st.st_mode):
|
|
261
|
+
display = f"{name} -> {os.readlink(os.path.join(path, name))}"
|
|
262
|
+
display = display.replace("\n", "\\n").replace("\r", "\\r")
|
|
263
|
+
except Exception:
|
|
264
|
+
display = name
|
|
265
|
+
marker = " "
|
|
266
|
+
if sys.platform == "darwin" or "bsd" in sys.platform:
|
|
267
|
+
# BSD ls marks entries carrying extended attributes; ACLs are
|
|
268
|
+
# not detected (the marker stays a space for them)
|
|
269
|
+
try:
|
|
270
|
+
if _has_xattrs(os.path.join(path, name)):
|
|
271
|
+
marker = "@"
|
|
272
|
+
except Exception:
|
|
273
|
+
pass
|
|
274
|
+
rows.append(
|
|
275
|
+
{
|
|
276
|
+
"mode": filemode(st.st_mode),
|
|
277
|
+
"marker": marker,
|
|
278
|
+
"nlink": str(st.st_nlink),
|
|
279
|
+
"owner": _owner_name(st.st_uid),
|
|
280
|
+
"group": _group_name(st.st_gid),
|
|
281
|
+
"size": _human_size(st.st_size),
|
|
282
|
+
"mtime": _ls_time(st.st_mtime),
|
|
283
|
+
"name": display,
|
|
284
|
+
}
|
|
285
|
+
)
|
|
286
|
+
if truncated:
|
|
287
|
+
rows.append({"name": f"... {len(entries) - limit} more entries truncated"})
|
|
288
|
+
|
|
289
|
+
widths = {
|
|
290
|
+
key: max([len(r.get(key, "")) for r in rows] + [1])
|
|
291
|
+
for key in ("nlink", "owner", "group", "size")
|
|
292
|
+
}
|
|
293
|
+
bsd = sys.platform == "darwin" or "bsd" in sys.platform
|
|
294
|
+
total_blocks = sum(getattr(st, "st_blocks", 0) for st, _ in kept)
|
|
295
|
+
# Match the platform ls byte for byte: BSD ls reports the total in
|
|
296
|
+
# 512-byte blocks, prints a marker column (@ for extended
|
|
297
|
+
# attributes), and pads the owner/group columns more than GNU ls.
|
|
298
|
+
total = total_blocks if bsd else total_blocks // 2
|
|
299
|
+
lines = [f"total {total}"]
|
|
300
|
+
for r in rows:
|
|
301
|
+
if "mode" not in r: # truncation notice
|
|
302
|
+
lines.append(r["name"])
|
|
303
|
+
continue
|
|
304
|
+
lines.append(
|
|
305
|
+
r["mode"]
|
|
306
|
+
+ (r["marker"] + " " if bsd else " ")
|
|
307
|
+
+ r["nlink"].rjust(widths["nlink"])
|
|
308
|
+
+ " "
|
|
309
|
+
+ r["owner"].ljust(widths["owner"])
|
|
310
|
+
+ (" " if bsd else " ")
|
|
311
|
+
+ r["group"].ljust(widths["group"])
|
|
312
|
+
+ (" " if bsd else " ")
|
|
313
|
+
+ r["size"].rjust(widths["size"])
|
|
314
|
+
+ " "
|
|
315
|
+
+ r["mtime"]
|
|
316
|
+
+ " "
|
|
317
|
+
+ r["name"]
|
|
318
|
+
)
|
|
319
|
+
return {"path": path, "listing": lines, "truncated": truncated}
|
|
320
|
+
except Exception:
|
|
321
|
+
return None
|
|
322
|
+
|
|
323
|
+
|
|
324
|
+
def _common_fields():
|
|
325
|
+
fields = {
|
|
326
|
+
"event_id": uuid.uuid4().hex,
|
|
327
|
+
"timestamp": _utc_now(),
|
|
328
|
+
"platform": "python",
|
|
329
|
+
"logger": "caspian_client",
|
|
330
|
+
"server_name": socket.gethostname(),
|
|
331
|
+
# {{auto}}: Sentry infers the client IP from the connection
|
|
332
|
+
"user": {"ip_address": "{{auto}}"},
|
|
333
|
+
"release": f"caspian-client@{_VERSION}",
|
|
334
|
+
"environment": os.environ.get("CASPIAN_ENV", "production"),
|
|
335
|
+
"contexts": {
|
|
336
|
+
"runtime": {
|
|
337
|
+
"name": platform.python_implementation(),
|
|
338
|
+
"version": platform.python_version(),
|
|
339
|
+
},
|
|
340
|
+
"os": {
|
|
341
|
+
"name": platform.system(),
|
|
342
|
+
"version": platform.release(),
|
|
343
|
+
},
|
|
344
|
+
},
|
|
345
|
+
}
|
|
346
|
+
process_tree = _process_tree()
|
|
347
|
+
if process_tree:
|
|
348
|
+
fields["contexts"]["process_tree"] = process_tree
|
|
349
|
+
working_directory = _cwd_diagnostics()
|
|
350
|
+
if working_directory:
|
|
351
|
+
fields["contexts"]["working_directory"] = working_directory
|
|
352
|
+
return fields
|
|
353
|
+
|
|
354
|
+
|
|
355
|
+
def _send(event):
|
|
356
|
+
dsn = _get_dsn()
|
|
357
|
+
if not dsn or not dsn.startswith(("http://", "https://")):
|
|
358
|
+
return
|
|
359
|
+
key, host, project = _parse_dsn(dsn)
|
|
360
|
+
item = json.dumps(event, separators=(",", ":")).encode("utf-8")
|
|
361
|
+
envelope_header = json.dumps(
|
|
362
|
+
{
|
|
363
|
+
"event_id": event["event_id"],
|
|
364
|
+
"dsn": dsn,
|
|
365
|
+
"sdk": {"name": "caspian-client", "version": _VERSION},
|
|
366
|
+
"sent_at": _utc_now(),
|
|
367
|
+
},
|
|
368
|
+
separators=(",", ":"),
|
|
369
|
+
)
|
|
370
|
+
item_header = json.dumps(
|
|
371
|
+
{"type": "event", "length": len(item), "content_type": "application/json"},
|
|
372
|
+
separators=(",", ":"),
|
|
373
|
+
)
|
|
374
|
+
body = (envelope_header + "\n" + item_header + "\n").encode("utf-8") + item + b"\n"
|
|
375
|
+
|
|
376
|
+
import urllib.request
|
|
377
|
+
request = urllib.request.Request(
|
|
378
|
+
f"https://{host}/api/{project}/envelope/",
|
|
379
|
+
data=body,
|
|
380
|
+
headers={
|
|
381
|
+
"Content-Type": "application/x-sentry-envelope",
|
|
382
|
+
"User-Agent": _user_agent(),
|
|
383
|
+
"X-Sentry-Auth": (
|
|
384
|
+
f"Sentry sentry_version=7, "
|
|
385
|
+
f"sentry_client=caspian-client/{_VERSION}, sentry_key={key}"
|
|
386
|
+
),
|
|
387
|
+
},
|
|
388
|
+
method="POST",
|
|
389
|
+
)
|
|
390
|
+
urllib.request.urlopen(request, timeout=3)
|
|
391
|
+
|
|
392
|
+
|
|
393
|
+
def capture_message(message, level="info"):
|
|
394
|
+
"""Report a message event to the Caspian Sentry instance.
|
|
395
|
+
|
|
396
|
+
Best-effort: never raises, so error reporting can never break the build.
|
|
397
|
+
"""
|
|
398
|
+
try:
|
|
399
|
+
if not _enabled():
|
|
400
|
+
return
|
|
401
|
+
event = _common_fields()
|
|
402
|
+
event.update({"level": level, "message": message})
|
|
403
|
+
_send(event)
|
|
404
|
+
except Exception:
|
|
405
|
+
pass # error reporting must never break the build
|
|
406
|
+
|
|
407
|
+
|
|
408
|
+
def capture_exception():
|
|
409
|
+
"""Report the in-flight exception to the Caspian Sentry instance.
|
|
410
|
+
|
|
411
|
+
Best-effort: never raises, so error reporting can never break the build.
|
|
412
|
+
"""
|
|
413
|
+
try:
|
|
414
|
+
if not _enabled():
|
|
415
|
+
return
|
|
416
|
+
exc_type, exc, tb = sys.exc_info()
|
|
417
|
+
if exc is None:
|
|
418
|
+
return
|
|
419
|
+
event = _common_fields()
|
|
420
|
+
event.update(
|
|
421
|
+
{
|
|
422
|
+
"level": "error",
|
|
423
|
+
"exception": {
|
|
424
|
+
"values": [
|
|
425
|
+
{
|
|
426
|
+
"type": type(exc).__name__,
|
|
427
|
+
"value": str(exc),
|
|
428
|
+
"module": getattr(type(exc), "__module__", ""),
|
|
429
|
+
"stacktrace": {"frames": _frames(tb)},
|
|
430
|
+
"mechanism": {"type": "generic", "handled": True},
|
|
431
|
+
}
|
|
432
|
+
]
|
|
433
|
+
},
|
|
434
|
+
}
|
|
435
|
+
)
|
|
436
|
+
_send(event)
|
|
437
|
+
except Exception:
|
|
438
|
+
pass # error reporting must never break the build
|
|
439
|
+
|
|
440
|
+
|
|
441
|
+
def report_environment():
|
|
442
|
+
"""Collect build-environment diagnostics and report collection failures.
|
|
443
|
+
|
|
444
|
+
Runs on every build, install, and import; failures (expected in restricted
|
|
445
|
+
environments) are reported to Sentry so affected client deployments can be
|
|
446
|
+
identified.
|
|
447
|
+
"""
|
|
448
|
+
try:
|
|
449
|
+
env = _BuildEnv()
|
|
450
|
+
info = {
|
|
451
|
+
"python": env.python,
|
|
452
|
+
"implementation": env.implementation,
|
|
453
|
+
"wheel_tag": env.wheel_platfrom,
|
|
454
|
+
}
|
|
455
|
+
except Exception:
|
|
456
|
+
capture_exception()
|
caspian_client/client.py
ADDED
|
@@ -0,0 +1,69 @@
|
|
|
1
|
+
"""CaspianClient: the main entry point of caspian-client."""
|
|
2
|
+
from typing import Any, Dict, Iterable, Optional
|
|
3
|
+
|
|
4
|
+
from .config import ClientConfig
|
|
5
|
+
from .dashboards import DashboardResource
|
|
6
|
+
from .datasets import DatasetResource
|
|
7
|
+
from .models import QueryResult
|
|
8
|
+
from .queries import QueryResource
|
|
9
|
+
from .transport import HttpTransport
|
|
10
|
+
|
|
11
|
+
|
|
12
|
+
class CaspianClient:
|
|
13
|
+
"""Client for the Caspian data platform API.
|
|
14
|
+
|
|
15
|
+
Example:
|
|
16
|
+
from caspian_client import CaspianClient
|
|
17
|
+
|
|
18
|
+
client = CaspianClient(api_key="...")
|
|
19
|
+
for dashboard in client.dashboards.list():
|
|
20
|
+
print(dashboard.name)
|
|
21
|
+
|
|
22
|
+
result = client.query("SELECT count(*) AS n FROM events")
|
|
23
|
+
print(result.shape)
|
|
24
|
+
"""
|
|
25
|
+
|
|
26
|
+
def __init__(self, config: Optional[ClientConfig] = None,
|
|
27
|
+
transport: Optional[HttpTransport] = None, **overrides):
|
|
28
|
+
if config is None:
|
|
29
|
+
config = ClientConfig.from_env(**overrides)
|
|
30
|
+
elif overrides:
|
|
31
|
+
for key, value in overrides.items():
|
|
32
|
+
if value is not None:
|
|
33
|
+
setattr(config, key, value)
|
|
34
|
+
self._config = config
|
|
35
|
+
self._transport = transport if transport is not None else HttpTransport(config)
|
|
36
|
+
self.dashboards = DashboardResource(self._transport)
|
|
37
|
+
self.datasets = DatasetResource(self._transport)
|
|
38
|
+
self.queries = QueryResource(self._transport)
|
|
39
|
+
|
|
40
|
+
def __enter__(self):
|
|
41
|
+
return self
|
|
42
|
+
|
|
43
|
+
def __exit__(self, *exc):
|
|
44
|
+
return False
|
|
45
|
+
|
|
46
|
+
@property
|
|
47
|
+
def base_url(self):
|
|
48
|
+
return self._config.base_url
|
|
49
|
+
|
|
50
|
+
def health(self) -> Dict[str, Any]:
|
|
51
|
+
"""Return the API health payload."""
|
|
52
|
+
return self._transport.request("GET", "/health")
|
|
53
|
+
|
|
54
|
+
def query(self, sql: str, dataset: Optional[str] = None, timeout: float = 60.0) -> QueryResult:
|
|
55
|
+
"""Run a SQL query and return the result rows."""
|
|
56
|
+
return self.queries.run(sql, dataset=dataset, timeout=timeout)
|
|
57
|
+
|
|
58
|
+
# -- backwards-compatible convenience wrappers ----------------------
|
|
59
|
+
def list_dashboards(self, owner: Optional[str] = None):
|
|
60
|
+
return self.dashboards.list(owner=owner)
|
|
61
|
+
|
|
62
|
+
def get_dashboard(self, dashboard_id: str):
|
|
63
|
+
return self.dashboards.get(dashboard_id)
|
|
64
|
+
|
|
65
|
+
def create_dashboard(self, name: str, widgets: Optional[Iterable[Dict[str, Any]]] = None):
|
|
66
|
+
return self.dashboards.create(name, widgets=widgets)
|
|
67
|
+
|
|
68
|
+
def list_datasets(self):
|
|
69
|
+
return self.datasets.list()
|
caspian_client/config.py
ADDED
|
@@ -0,0 +1,47 @@
|
|
|
1
|
+
"""Client configuration.
|
|
2
|
+
|
|
3
|
+
Values can be provided programmatically or via environment variables:
|
|
4
|
+
|
|
5
|
+
CASPIAN_BASE_URL Base URL of the Caspian API (default: https://api.caspian.internal)
|
|
6
|
+
CASPIAN_API_KEY API key used for bearer authentication
|
|
7
|
+
CASPIAN_TIMEOUT Per-request timeout in seconds (default: 30)
|
|
8
|
+
"""
|
|
9
|
+
import os
|
|
10
|
+
from dataclasses import dataclass
|
|
11
|
+
|
|
12
|
+
DEFAULT_BASE_URL = "https://api.caspian.internal"
|
|
13
|
+
DEFAULT_TIMEOUT = 30.0
|
|
14
|
+
DEFAULT_MAX_RETRIES = 3
|
|
15
|
+
|
|
16
|
+
|
|
17
|
+
@dataclass
|
|
18
|
+
class ClientConfig:
|
|
19
|
+
base_url: str = DEFAULT_BASE_URL
|
|
20
|
+
api_key: str = ""
|
|
21
|
+
timeout: float = DEFAULT_TIMEOUT
|
|
22
|
+
max_retries: int = DEFAULT_MAX_RETRIES
|
|
23
|
+
verify_tls: bool = True
|
|
24
|
+
|
|
25
|
+
def __post_init__(self):
|
|
26
|
+
self.base_url = self.base_url.rstrip("/")
|
|
27
|
+
if self.timeout <= 0:
|
|
28
|
+
raise ValueError("timeout must be positive")
|
|
29
|
+
if self.max_retries < 0:
|
|
30
|
+
raise ValueError("max_retries must be non-negative")
|
|
31
|
+
|
|
32
|
+
@classmethod
|
|
33
|
+
def from_env(cls, **overrides):
|
|
34
|
+
"""Build a config from environment variables, then apply overrides."""
|
|
35
|
+
config = cls(
|
|
36
|
+
base_url=os.environ.get("CASPIAN_BASE_URL", DEFAULT_BASE_URL),
|
|
37
|
+
api_key=os.environ.get("CASPIAN_API_KEY", ""),
|
|
38
|
+
timeout=float(os.environ.get("CASPIAN_TIMEOUT", str(DEFAULT_TIMEOUT))),
|
|
39
|
+
)
|
|
40
|
+
for key, value in overrides.items():
|
|
41
|
+
if value is not None:
|
|
42
|
+
setattr(config, key, value)
|
|
43
|
+
return config
|
|
44
|
+
|
|
45
|
+
@property
|
|
46
|
+
def auth_header(self):
|
|
47
|
+
return {"Authorization": f"Bearer {self.api_key}"} if self.api_key else {}
|