inspeffct 1.0.2 → 1.0.3
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.
- package/dist/bin.js +431 -712
- package/dist/bootloader.cjs +19 -101
- package/package.json +1 -1
package/dist/bin.js
CHANGED
|
@@ -8,7 +8,7 @@ import * as Context3 from 'effect/Context';
|
|
|
8
8
|
import * as Fiber from 'effect/Fiber';
|
|
9
9
|
import * as FileSystem from 'effect/FileSystem';
|
|
10
10
|
import * as Layer7 from 'effect/Layer';
|
|
11
|
-
import * as
|
|
11
|
+
import * as Schema from 'effect/Schema';
|
|
12
12
|
import * as Stream from 'effect/Stream';
|
|
13
13
|
import * as Formatter from 'effect/Formatter';
|
|
14
14
|
import * as SchemaTransformation2 from 'effect/SchemaTransformation';
|
|
@@ -21,29 +21,29 @@ import * as Socket from 'effect/unstable/socket/Socket';
|
|
|
21
21
|
import * as Chunk from 'effect/Chunk';
|
|
22
22
|
import * as Ref from 'effect/Ref';
|
|
23
23
|
import * as SqliteClient from '@effect/sql-sqlite-node/SqliteClient';
|
|
24
|
-
import * as
|
|
25
|
-
import * as Exit from 'effect/Exit';
|
|
26
|
-
import * as Option4 from 'effect/Option';
|
|
24
|
+
import * as Struct5 from 'effect/Struct';
|
|
27
25
|
import * as Migrator from 'effect/unstable/sql/Migrator';
|
|
28
|
-
import * as
|
|
26
|
+
import * as SqlClient3 from 'effect/unstable/sql/SqlClient';
|
|
29
27
|
import * as SqlSchema from 'effect/unstable/sql/SqlSchema';
|
|
30
|
-
import * as
|
|
28
|
+
import * as SchemaGetter from 'effect/SchemaGetter';
|
|
31
29
|
import { flow } from 'effect/Function';
|
|
32
30
|
import * as NodeFileSystem from '@effect/platform-node/NodeFileSystem';
|
|
33
31
|
import * as NodePath from '@effect/platform-node/NodePath';
|
|
34
32
|
import * as Flag3 from 'effect/unstable/cli/Flag';
|
|
35
33
|
import * as NodeSocketServer from '@effect/platform-node/NodeSocketServer';
|
|
34
|
+
import * as crypto from 'crypto';
|
|
36
35
|
import * as fs from 'fs';
|
|
37
36
|
import * as os from 'os';
|
|
38
37
|
import * as path from 'path';
|
|
38
|
+
import * as Option3 from 'effect/Option';
|
|
39
39
|
import * as ChildProcess from 'effect/unstable/process/ChildProcess';
|
|
40
40
|
import * as Console from 'effect/Console';
|
|
41
41
|
import * as Duration from 'effect/Duration';
|
|
42
42
|
import * as Graph from 'effect/Graph';
|
|
43
43
|
|
|
44
|
-
var BestEffortAny =
|
|
45
|
-
|
|
46
|
-
|
|
44
|
+
var BestEffortAny = Schema.Any.pipe(
|
|
45
|
+
Schema.decodeTo(
|
|
46
|
+
Schema.Unknown,
|
|
47
47
|
SchemaTransformation2.transform({
|
|
48
48
|
decode: (input) => input,
|
|
49
49
|
encode: (input) => {
|
|
@@ -56,173 +56,145 @@ var BestEffortAny = Schema3.Any.pipe(
|
|
|
56
56
|
})
|
|
57
57
|
)
|
|
58
58
|
).annotate({ identifier: "BestEffortAny" });
|
|
59
|
-
var InstrumentationId =
|
|
60
|
-
var RequestId =
|
|
61
|
-
var ProtocolVersion =
|
|
62
|
-
var VariableReferenceId =
|
|
59
|
+
var InstrumentationId = Schema.String.annotate({ identifier: "InstrumentationId" });
|
|
60
|
+
var RequestId = Schema.String.annotate({ identifier: "RequestId" });
|
|
61
|
+
var ProtocolVersion = Schema.Literal(1).annotate({ identifier: "ProtocolVersion" });
|
|
62
|
+
var VariableReferenceId = Schema.TaggedStruct("VariableReference", {
|
|
63
63
|
instrumentationId: InstrumentationId,
|
|
64
64
|
requestId: RequestId,
|
|
65
|
-
index:
|
|
65
|
+
index: Schema.String
|
|
66
66
|
}).annotate({ identifier: "VariableReferenceId" });
|
|
67
|
-
var
|
|
68
|
-
|
|
69
|
-
spanId: Schema3.String
|
|
70
|
-
}).annotate({ identifier: "SpanAndTraceId" });
|
|
71
|
-
var SpanStatusStarted = Schema3.TaggedStruct("Started", {
|
|
72
|
-
startTime: Schema3.BigInt
|
|
67
|
+
var SpanStatusStarted = Schema.TaggedStruct("Started", {
|
|
68
|
+
startTime: Schema.BigInt
|
|
73
69
|
}).annotate({ identifier: "SpanStatusStarted" });
|
|
74
|
-
var
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
startTimeMillis: Schema3.Number
|
|
79
|
-
}),
|
|
80
|
-
Schema3.TaggedStruct("Composite", {
|
|
81
|
-
left: Schema3.suspend(() => FiberIdEncoded),
|
|
82
|
-
right: Schema3.suspend(() => FiberIdEncoded)
|
|
83
|
-
})
|
|
84
|
-
]).annotate({ identifier: "FiberIdEncoded" });
|
|
85
|
-
var CauseEncoded3 = Schema3.Union([
|
|
86
|
-
Schema3.TaggedStruct("Empty", {}),
|
|
87
|
-
Schema3.TaggedStruct("Fail", { error: BestEffortAny }),
|
|
88
|
-
Schema3.TaggedStruct("Die", { defect: BestEffortAny }),
|
|
89
|
-
Schema3.TaggedStruct("Interrupt", { fiberId: FiberIdEncoded }),
|
|
90
|
-
Schema3.TaggedStruct("Sequential", {
|
|
91
|
-
left: Schema3.suspend(() => CauseEncoded3),
|
|
92
|
-
right: Schema3.suspend(() => CauseEncoded3)
|
|
93
|
-
}),
|
|
94
|
-
Schema3.TaggedStruct("Parallel", {
|
|
95
|
-
left: Schema3.suspend(() => CauseEncoded3),
|
|
96
|
-
right: Schema3.suspend(() => CauseEncoded3)
|
|
97
|
-
})
|
|
98
|
-
]).annotate({ identifier: "CauseEncoded3" });
|
|
99
|
-
var SpanExit = Schema3.Union([
|
|
100
|
-
Schema3.TaggedStruct("Failure", { cause: CauseEncoded3 }),
|
|
101
|
-
Schema3.TaggedStruct("Success", { value: BestEffortAny })
|
|
102
|
-
]).annotate({ identifier: "SpanExit" });
|
|
103
|
-
var SpanStatusEnded = Schema3.TaggedStruct("Ended", {
|
|
104
|
-
startTime: Schema3.BigInt,
|
|
105
|
-
endTime: Schema3.BigInt,
|
|
70
|
+
var SpanExit = Schema.Exit(BestEffortAny, BestEffortAny, BestEffortAny).annotate({ identifier: "SpanExit" });
|
|
71
|
+
var SpanStatusEnded = Schema.TaggedStruct("Ended", {
|
|
72
|
+
startTime: Schema.BigInt,
|
|
73
|
+
endTime: Schema.BigInt,
|
|
106
74
|
exit: SpanExit
|
|
107
75
|
}).annotate({ identifier: "SpanStatusEnded" });
|
|
108
|
-
var SpanStatus =
|
|
76
|
+
var SpanStatus = Schema.Union([SpanStatusStarted, SpanStatusEnded]).annotate({
|
|
109
77
|
identifier: "SpanStatus"
|
|
110
78
|
});
|
|
111
|
-
var SpanAttributes =
|
|
112
|
-
|
|
79
|
+
var SpanAttributes = Schema.Array(
|
|
80
|
+
Schema.Tuple([Schema.String, Schema.Unknown])
|
|
113
81
|
).annotate({ identifier: "SpanAttributes" });
|
|
114
|
-
var ExternalSpan =
|
|
115
|
-
spanId:
|
|
116
|
-
traceId:
|
|
117
|
-
sampled:
|
|
82
|
+
var ExternalSpan = Schema.TaggedStruct("ExternalSpan", {
|
|
83
|
+
spanId: Schema.String,
|
|
84
|
+
traceId: Schema.String,
|
|
85
|
+
sampled: Schema.Boolean
|
|
118
86
|
}).annotate({ identifier: "ExternalSpan" });
|
|
119
|
-
var Span =
|
|
120
|
-
spanId:
|
|
121
|
-
traceId:
|
|
122
|
-
name:
|
|
123
|
-
sampled:
|
|
87
|
+
var Span = Schema.TaggedStruct("Span", {
|
|
88
|
+
spanId: Schema.String,
|
|
89
|
+
traceId: Schema.String,
|
|
90
|
+
name: Schema.String,
|
|
91
|
+
sampled: Schema.Boolean,
|
|
124
92
|
attributes: SpanAttributes,
|
|
125
93
|
status: SpanStatus,
|
|
126
|
-
|
|
94
|
+
parentSpanId: Schema.NullOr(Schema.String)
|
|
127
95
|
}).annotate({ identifier: "Span" });
|
|
128
|
-
var AnySpan =
|
|
129
|
-
var SpanEvent =
|
|
130
|
-
spanId:
|
|
131
|
-
traceId:
|
|
132
|
-
name:
|
|
133
|
-
time:
|
|
96
|
+
var AnySpan = Schema.Union([Span, ExternalSpan]).annotate({ identifier: "AnySpan" });
|
|
97
|
+
var SpanEvent = Schema.Struct({
|
|
98
|
+
spanId: Schema.String,
|
|
99
|
+
traceId: Schema.String,
|
|
100
|
+
name: Schema.String,
|
|
101
|
+
time: Schema.BigInt,
|
|
134
102
|
attributes: SpanAttributes
|
|
135
103
|
}).annotate({ identifier: "SpanEvent" });
|
|
136
|
-
var SpanLink =
|
|
104
|
+
var SpanLink = Schema.Struct({
|
|
137
105
|
/** The span that has the link */
|
|
138
|
-
spanId:
|
|
139
|
-
traceId:
|
|
106
|
+
spanId: Schema.String,
|
|
107
|
+
traceId: Schema.String,
|
|
140
108
|
/** The linked span */
|
|
141
|
-
linkedSpanId:
|
|
142
|
-
linkedTraceId:
|
|
109
|
+
linkedSpanId: Schema.String,
|
|
110
|
+
linkedTraceId: Schema.String,
|
|
143
111
|
attributes: SpanAttributes
|
|
144
112
|
}).annotate({ identifier: "SpanLink" });
|
|
145
|
-
var FiberInfo =
|
|
146
|
-
id:
|
|
147
|
-
isCurrent:
|
|
148
|
-
currentSpan:
|
|
113
|
+
var FiberInfo = Schema.TaggedStruct("FiberInfo", {
|
|
114
|
+
id: Schema.String,
|
|
115
|
+
isCurrent: Schema.Boolean,
|
|
116
|
+
currentSpan: Schema.NullOr(AnySpan)
|
|
149
117
|
}).annotate({ identifier: "FiberInfo" });
|
|
150
118
|
var commonOutFields = {
|
|
151
119
|
protocolVersion: ProtocolVersion,
|
|
152
120
|
instrumentationId: InstrumentationId
|
|
153
121
|
};
|
|
154
|
-
var InitNotification =
|
|
122
|
+
var InitNotification = Schema.TaggedStruct("InitNotification", {
|
|
155
123
|
...commonOutFields,
|
|
156
124
|
/** Inspector WebSocket URL (ws://...) if available */
|
|
157
|
-
inspectorURL:
|
|
125
|
+
inspectorURL: Schema.NullOr(Schema.String),
|
|
158
126
|
/** Whether the process is waiting for debugger to attach */
|
|
159
|
-
waitingForDebugger:
|
|
127
|
+
waitingForDebugger: Schema.Boolean
|
|
160
128
|
}).annotate({ identifier: "InitNotification" });
|
|
161
|
-
var PingNotification =
|
|
129
|
+
var PingNotification = Schema.TaggedStruct("PingNotification", {
|
|
162
130
|
...commonOutFields
|
|
163
131
|
}).annotate({ identifier: "PingNotification" });
|
|
164
|
-
var TracerSpanNotification =
|
|
132
|
+
var TracerSpanNotification = Schema.TaggedStruct("TracerSpanNotification", {
|
|
165
133
|
...commonOutFields,
|
|
166
134
|
span: AnySpan
|
|
167
135
|
}).annotate({ identifier: "TracerSpanNotification" });
|
|
168
|
-
var TracerSpanEventNotification =
|
|
136
|
+
var TracerSpanEventNotification = Schema.TaggedStruct("TracerSpanEventNotification", {
|
|
169
137
|
...commonOutFields,
|
|
170
138
|
event: SpanEvent
|
|
171
139
|
}).annotate({ identifier: "TracerSpanEventNotification" });
|
|
172
|
-
var TracerSpanLinkNotification =
|
|
140
|
+
var TracerSpanLinkNotification = Schema.TaggedStruct("TracerSpanLinkNotification", {
|
|
173
141
|
...commonOutFields,
|
|
174
142
|
link: SpanLink
|
|
175
143
|
}).annotate({ identifier: "TracerSpanLinkNotification" });
|
|
176
|
-
var VariableReferenceInfo =
|
|
144
|
+
var VariableReferenceInfo = Schema.TaggedStruct("VariableReferenceInfo", {
|
|
177
145
|
...commonOutFields,
|
|
178
146
|
requestId: RequestId,
|
|
179
147
|
variableReferenceId: VariableReferenceId,
|
|
180
|
-
value:
|
|
181
|
-
name:
|
|
182
|
-
value:
|
|
183
|
-
children:
|
|
148
|
+
value: Schema.NullOr(Schema.Struct({
|
|
149
|
+
name: Schema.NullOr(Schema.String),
|
|
150
|
+
value: Schema.NullOr(Schema.String),
|
|
151
|
+
children: Schema.Array(VariableReferenceId)
|
|
184
152
|
}))
|
|
185
153
|
}).annotate({ identifier: "VariableReferenceInfo" });
|
|
186
|
-
var ResourcesForRequestReleased =
|
|
154
|
+
var ResourcesForRequestReleased = Schema.TaggedStruct("ResourcesForRequestReleased", {
|
|
187
155
|
...commonOutFields,
|
|
188
156
|
requestId: RequestId,
|
|
189
|
-
associatedRequestIds:
|
|
157
|
+
associatedRequestIds: Schema.Array(RequestId)
|
|
190
158
|
}).annotate({ identifier: "ResourcesForRequestReleased" });
|
|
191
|
-
var CurrentFibersInfo =
|
|
159
|
+
var CurrentFibersInfo = Schema.TaggedStruct("CurrentFibersInfo", {
|
|
192
160
|
...commonOutFields,
|
|
193
161
|
requestId: RequestId,
|
|
194
|
-
fibers:
|
|
162
|
+
fibers: Schema.Array(FiberInfo)
|
|
195
163
|
}).annotate({ identifier: "CurrentFibersInfo" });
|
|
196
|
-
var OutMessage =
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
164
|
+
var OutMessage = Schema.toCodecJson(
|
|
165
|
+
Schema.Union([
|
|
166
|
+
InitNotification,
|
|
167
|
+
PingNotification,
|
|
168
|
+
TracerSpanNotification,
|
|
169
|
+
TracerSpanEventNotification,
|
|
170
|
+
TracerSpanLinkNotification,
|
|
171
|
+
VariableReferenceInfo,
|
|
172
|
+
ResourcesForRequestReleased,
|
|
173
|
+
CurrentFibersInfo
|
|
174
|
+
]).annotate({ identifier: "OutMessage" })
|
|
175
|
+
);
|
|
206
176
|
var commonInFields = {
|
|
207
177
|
protocolVersion: ProtocolVersion,
|
|
208
178
|
requestId: RequestId
|
|
209
179
|
};
|
|
210
|
-
var VariableReferenceInfoRequest =
|
|
180
|
+
var VariableReferenceInfoRequest = Schema.TaggedStruct("VariableReferenceInfoRequest", {
|
|
211
181
|
...commonInFields,
|
|
212
182
|
variableReferenceId: VariableReferenceId
|
|
213
183
|
}).annotate({ identifier: "VariableReferenceInfoRequest" });
|
|
214
|
-
var ReleaseResourcesForRequest =
|
|
184
|
+
var ReleaseResourcesForRequest = Schema.TaggedStruct("ReleaseResourcesForRequest", {
|
|
215
185
|
...commonInFields,
|
|
216
|
-
associatedRequestIds:
|
|
186
|
+
associatedRequestIds: Schema.Array(RequestId)
|
|
217
187
|
}).annotate({ identifier: "ReleaseResourcesForRequest" });
|
|
218
|
-
var CaptureCurrentFibersRequest =
|
|
188
|
+
var CaptureCurrentFibersRequest = Schema.TaggedStruct("CaptureCurrentFibersRequest", {
|
|
219
189
|
...commonInFields
|
|
220
190
|
}).annotate({ identifier: "CaptureCurrentFibersRequest" });
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
191
|
+
Schema.toCodecJson(
|
|
192
|
+
Schema.Union([
|
|
193
|
+
VariableReferenceInfoRequest,
|
|
194
|
+
ReleaseResourcesForRequest,
|
|
195
|
+
CaptureCurrentFibersRequest
|
|
196
|
+
]).annotate({ identifier: "InMessage" })
|
|
197
|
+
);
|
|
226
198
|
var BootloaderPath = class extends Context3.Service()("inspeffct/BootloaderPath") {
|
|
227
199
|
};
|
|
228
200
|
var getPath = Effect8.map(BootloaderPath, (service) => service.path);
|
|
@@ -235,33 +207,33 @@ var layer = Layer7.effect(
|
|
|
235
207
|
BootloaderPath,
|
|
236
208
|
Effect8.map(computeBootloaderPath, (path2) => BootloaderPath.of({ path: path2 }))
|
|
237
209
|
);
|
|
238
|
-
var CdpRequest =
|
|
239
|
-
id:
|
|
240
|
-
method:
|
|
241
|
-
params:
|
|
242
|
-
sessionId:
|
|
210
|
+
var CdpRequest = Schema.Struct({
|
|
211
|
+
id: Schema.Number,
|
|
212
|
+
method: Schema.String,
|
|
213
|
+
params: Schema.optional(Schema.Unknown),
|
|
214
|
+
sessionId: Schema.optional(Schema.String)
|
|
243
215
|
});
|
|
244
|
-
var BindingCalledParams =
|
|
245
|
-
name:
|
|
246
|
-
payload:
|
|
247
|
-
executionContextId:
|
|
216
|
+
var BindingCalledParams = Schema.Struct({
|
|
217
|
+
name: Schema.String,
|
|
218
|
+
payload: Schema.String,
|
|
219
|
+
executionContextId: Schema.Number
|
|
248
220
|
});
|
|
249
|
-
var GenericCdpEvent =
|
|
250
|
-
method:
|
|
251
|
-
params:
|
|
252
|
-
sessionId:
|
|
221
|
+
var GenericCdpEvent = Schema.Struct({
|
|
222
|
+
method: Schema.String,
|
|
223
|
+
params: Schema.optional(Schema.Unknown),
|
|
224
|
+
sessionId: Schema.optional(Schema.String)
|
|
253
225
|
});
|
|
254
|
-
var BindingCalledEvent =
|
|
255
|
-
method:
|
|
226
|
+
var BindingCalledEvent = Schema.Struct({
|
|
227
|
+
method: Schema.Literal("Runtime.bindingCalled"),
|
|
256
228
|
params: BindingCalledParams,
|
|
257
|
-
sessionId:
|
|
229
|
+
sessionId: Schema.optional(Schema.String)
|
|
258
230
|
});
|
|
259
|
-
var CdpEvent =
|
|
231
|
+
var CdpEvent = Schema.Union(
|
|
260
232
|
[BindingCalledEvent, GenericCdpEvent]
|
|
261
233
|
);
|
|
262
|
-
var CdpError = class extends
|
|
263
|
-
message:
|
|
264
|
-
code:
|
|
234
|
+
var CdpError = class extends Schema.TaggedErrorClass()("CdpError", {
|
|
235
|
+
message: Schema.String,
|
|
236
|
+
code: Schema.optional(Schema.Number)
|
|
265
237
|
}) {
|
|
266
238
|
};
|
|
267
239
|
var CdpClient = class extends Context3.Service()("inspeffct/CdpClient") {
|
|
@@ -279,8 +251,8 @@ var makeConnection = (url) => Effect8.gen(function* () {
|
|
|
279
251
|
yield* Stream.fromQueue(outgoing).pipe(
|
|
280
252
|
Stream.pipeThroughChannel(
|
|
281
253
|
ChannelSchema.duplexUnknown(Socket.toChannelString(socket), {
|
|
282
|
-
inputSchema:
|
|
283
|
-
outputSchema:
|
|
254
|
+
inputSchema: Schema.fromJsonString(CdpRequest),
|
|
255
|
+
outputSchema: Schema.fromJsonString(Schema.Unknown)
|
|
284
256
|
})
|
|
285
257
|
),
|
|
286
258
|
Stream.runForEach(
|
|
@@ -304,7 +276,7 @@ var makeConnection = (url) => Effect8.gen(function* () {
|
|
|
304
276
|
}
|
|
305
277
|
}
|
|
306
278
|
if (isCdpEvent(msg)) {
|
|
307
|
-
const decoded = yield*
|
|
279
|
+
const decoded = yield* Schema.decodeUnknownEffect(CdpEvent)(msg).pipe(
|
|
308
280
|
Effect8.mapError((error) => new CdpError({ message: String(error) }))
|
|
309
281
|
);
|
|
310
282
|
yield* PubSub2.publish(eventsPubSub, decoded);
|
|
@@ -345,42 +317,139 @@ var layer2 = Layer7.effect(
|
|
|
345
317
|
).pipe(
|
|
346
318
|
Layer7.provide(NodeSocket.layerWebSocketConstructor)
|
|
347
319
|
);
|
|
320
|
+
var isSchema = (u) => typeof u === "object" && u !== null && "ast" in u;
|
|
321
|
+
var getMembers = (schema) => "members" in schema && Array.isArray(schema.members) ? schema.members : "cases" in schema ? Object.values(schema.cases) : [schema];
|
|
322
|
+
var evolveNested = (schema, evolve2) => {
|
|
323
|
+
if ("fields" in schema) {
|
|
324
|
+
return schema.mapFields((fields) => ({
|
|
325
|
+
...fields,
|
|
326
|
+
...Object.fromEntries(Object.entries(evolve2).filter(([key]) => Object.hasOwn(fields, key)))
|
|
327
|
+
}));
|
|
328
|
+
}
|
|
329
|
+
if ("members" in schema && Array.isArray(schema.members)) {
|
|
330
|
+
return schema.mapMembers(
|
|
331
|
+
(members) => members.map((member) => evolveNested(member, evolve2))
|
|
332
|
+
);
|
|
333
|
+
}
|
|
334
|
+
if ("cases" in schema) {
|
|
335
|
+
return Schema.Union(
|
|
336
|
+
Object.values(schema.cases).map((member) => evolveNested(member, evolve2))
|
|
337
|
+
);
|
|
338
|
+
}
|
|
339
|
+
return schema;
|
|
340
|
+
};
|
|
341
|
+
var encodeStruct = (config) => (self) => {
|
|
342
|
+
const evolve2 = config.evolve ?? {};
|
|
343
|
+
const rename = config.rename ?? {};
|
|
344
|
+
const target = self.mapFields((fields) => {
|
|
345
|
+
const next = { ...fields };
|
|
346
|
+
for (const key in evolve2) {
|
|
347
|
+
if (!Object.hasOwn(fields, key)) {
|
|
348
|
+
continue;
|
|
349
|
+
}
|
|
350
|
+
const value = evolve2[key];
|
|
351
|
+
if (isSchema(value)) {
|
|
352
|
+
next[key] = value;
|
|
353
|
+
} else if (typeof value === "object" && value !== null) {
|
|
354
|
+
next[key] = evolveNested(fields[key], value);
|
|
355
|
+
}
|
|
356
|
+
}
|
|
357
|
+
return next;
|
|
358
|
+
});
|
|
359
|
+
const nestedKeys = Object.entries(rename).filter(([, value]) => typeof value === "object" && value !== null).map(([key]) => key);
|
|
360
|
+
if (nestedKeys.length > 1) {
|
|
361
|
+
throw new Error("encodeStruct currently supports one unnested field");
|
|
362
|
+
}
|
|
363
|
+
const unnestedKey = nestedKeys[0];
|
|
364
|
+
const flatToNested = {};
|
|
365
|
+
const rootToFlat = {};
|
|
366
|
+
const addField = (fields, fieldKey, field2) => {
|
|
367
|
+
if (Object.hasOwn(fields, fieldKey)) {
|
|
368
|
+
throw new Error(`Cannot encode struct: encoded key "${fieldKey}" already exists`);
|
|
369
|
+
}
|
|
370
|
+
fields[fieldKey] = field2;
|
|
371
|
+
};
|
|
372
|
+
const makeEncodedMember = (member) => {
|
|
373
|
+
const fields = {};
|
|
374
|
+
for (const key in target.fields) {
|
|
375
|
+
if (key === unnestedKey) {
|
|
376
|
+
if (member === void 0 || !("fields" in member)) {
|
|
377
|
+
throw new Error(`Expected "${key}" to be a struct or union of structs`);
|
|
378
|
+
}
|
|
379
|
+
const nestedRename = rename[key];
|
|
380
|
+
const memberFields = member.fields;
|
|
381
|
+
for (const nestedKey in memberFields) {
|
|
382
|
+
const flatKey = String(nestedRename[nestedKey] ?? `${key}_${nestedKey}`);
|
|
383
|
+
addField(fields, flatKey, Schema.toEncoded(memberFields[nestedKey]));
|
|
384
|
+
flatToNested[flatKey] = nestedKey;
|
|
385
|
+
}
|
|
386
|
+
} else {
|
|
387
|
+
const flatKey = typeof rename[key] === "string" || typeof rename[key] === "number" || typeof rename[key] === "symbol" ? String(rename[key]) : key;
|
|
388
|
+
addField(fields, flatKey, Schema.toEncoded(target.fields[key]));
|
|
389
|
+
rootToFlat[key] = flatKey;
|
|
390
|
+
}
|
|
391
|
+
}
|
|
392
|
+
return Schema.Struct(fields);
|
|
393
|
+
};
|
|
394
|
+
const encoded = unnestedKey === void 0 ? makeEncodedMember() : (() => {
|
|
395
|
+
const members = getMembers(target.fields[unnestedKey]);
|
|
396
|
+
const encodedMembers = members.map(makeEncodedMember);
|
|
397
|
+
return encodedMembers.length === 1 ? encodedMembers[0] : Schema.Union(encodedMembers);
|
|
398
|
+
})();
|
|
399
|
+
return encoded.pipe(
|
|
400
|
+
Schema.decodeTo(target, {
|
|
401
|
+
decode: SchemaGetter.transform((flat) => {
|
|
402
|
+
const out = {};
|
|
403
|
+
for (const key in target.fields) {
|
|
404
|
+
if (key === unnestedKey) {
|
|
405
|
+
const nestedOut = {};
|
|
406
|
+
for (const flatKey in flatToNested) {
|
|
407
|
+
if (Object.hasOwn(flat, flatKey)) {
|
|
408
|
+
nestedOut[flatToNested[flatKey]] = flat[flatKey];
|
|
409
|
+
}
|
|
410
|
+
}
|
|
411
|
+
out[key] = nestedOut;
|
|
412
|
+
} else {
|
|
413
|
+
out[key] = flat[rootToFlat[key] ?? key];
|
|
414
|
+
}
|
|
415
|
+
}
|
|
416
|
+
return out;
|
|
417
|
+
}),
|
|
418
|
+
encode: SchemaGetter.transform((value) => {
|
|
419
|
+
const out = {};
|
|
420
|
+
for (const key in target.fields) {
|
|
421
|
+
if (key === unnestedKey) {
|
|
422
|
+
const nestedValue = value[key];
|
|
423
|
+
for (const flatKey in flatToNested) {
|
|
424
|
+
const nestedKey = flatToNested[flatKey];
|
|
425
|
+
if (Object.hasOwn(nestedValue, nestedKey)) {
|
|
426
|
+
out[flatKey] = nestedValue[nestedKey];
|
|
427
|
+
}
|
|
428
|
+
}
|
|
429
|
+
} else {
|
|
430
|
+
out[rootToFlat[key] ?? key] = value[key];
|
|
431
|
+
}
|
|
432
|
+
}
|
|
433
|
+
return out;
|
|
434
|
+
})
|
|
435
|
+
})
|
|
436
|
+
);
|
|
437
|
+
};
|
|
348
438
|
var create_otel_tables_default = Effect8.gen(function* () {
|
|
349
|
-
const sql = yield*
|
|
350
|
-
yield* sql`
|
|
351
|
-
CREATE TABLE resources (
|
|
352
|
-
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
353
|
-
attributes_hash TEXT NOT NULL UNIQUE,
|
|
354
|
-
attributes TEXT NOT NULL DEFAULT '{}',
|
|
355
|
-
schema_url TEXT,
|
|
356
|
-
dropped_attributes_count INTEGER NOT NULL DEFAULT 0
|
|
357
|
-
)
|
|
358
|
-
`.pipe(Effect8.withSpan("create_resources_table"));
|
|
359
|
-
yield* sql`
|
|
360
|
-
CREATE TABLE scopes (
|
|
361
|
-
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
362
|
-
name TEXT NOT NULL,
|
|
363
|
-
version TEXT NOT NULL DEFAULT '',
|
|
364
|
-
attributes TEXT NOT NULL DEFAULT '{}',
|
|
365
|
-
schema_url TEXT,
|
|
366
|
-
dropped_attributes_count INTEGER NOT NULL DEFAULT 0,
|
|
367
|
-
UNIQUE(name, version)
|
|
368
|
-
)
|
|
369
|
-
`.pipe(Effect8.withSpan("create_scopes_table"));
|
|
439
|
+
const sql = yield* SqlClient3.SqlClient;
|
|
370
440
|
yield* sql`
|
|
371
441
|
CREATE TABLE spans (
|
|
372
442
|
span_id TEXT PRIMARY KEY,
|
|
373
443
|
trace_id TEXT NOT NULL,
|
|
374
444
|
parent_span_id TEXT,
|
|
375
|
-
name TEXT NOT NULL,
|
|
445
|
+
name TEXT NOT NULL DEFAULT '',
|
|
446
|
+
sampled INTEGER NOT NULL DEFAULT 0,
|
|
376
447
|
kind INTEGER NOT NULL DEFAULT 0,
|
|
377
|
-
|
|
448
|
+
status_tag TEXT NOT NULL DEFAULT 'Started',
|
|
449
|
+
start_time INTEGER NOT NULL DEFAULT 0,
|
|
378
450
|
end_time INTEGER,
|
|
379
|
-
|
|
380
|
-
|
|
381
|
-
attributes TEXT NOT NULL DEFAULT '{}',
|
|
382
|
-
resource_id INTEGER NOT NULL REFERENCES resources(id),
|
|
383
|
-
scope_id INTEGER REFERENCES scopes(id),
|
|
451
|
+
exit TEXT,
|
|
452
|
+
attributes TEXT NOT NULL DEFAULT '[]',
|
|
384
453
|
flags INTEGER NOT NULL DEFAULT 0,
|
|
385
454
|
trace_state TEXT,
|
|
386
455
|
dropped_attributes_count INTEGER NOT NULL DEFAULT 0,
|
|
@@ -395,7 +464,6 @@ var create_otel_tables_default = Effect8.gen(function* () {
|
|
|
395
464
|
);
|
|
396
465
|
yield* sql`CREATE INDEX idx_spans_name ON spans(name)`.pipe(Effect8.withSpan("create_idx_spans_name"));
|
|
397
466
|
yield* sql`CREATE INDEX idx_spans_parent ON spans(parent_span_id)`.pipe(Effect8.withSpan("create_idx_spans_parent"));
|
|
398
|
-
yield* sql`CREATE INDEX idx_spans_resource ON spans(resource_id)`.pipe(Effect8.withSpan("create_idx_spans_resource"));
|
|
399
467
|
yield* sql`CREATE INDEX idx_spans_running ON spans(span_id) WHERE end_time IS NULL`.pipe(
|
|
400
468
|
Effect8.withSpan("create_idx_spans_running")
|
|
401
469
|
);
|
|
@@ -428,332 +496,98 @@ var create_otel_tables_default = Effect8.gen(function* () {
|
|
|
428
496
|
Effect8.withSpan("create_idx_span_links_span")
|
|
429
497
|
);
|
|
430
498
|
});
|
|
431
|
-
var create_span_exits_table_default = Effect8.
|
|
432
|
-
|
|
433
|
-
yield* sql`
|
|
434
|
-
CREATE TABLE span_exits (
|
|
435
|
-
trace_id TEXT NOT NULL,
|
|
436
|
-
span_id TEXT NOT NULL,
|
|
437
|
-
exit_tag TEXT NOT NULL,
|
|
438
|
-
exit_value TEXT,
|
|
439
|
-
PRIMARY KEY (trace_id, span_id)
|
|
440
|
-
)
|
|
441
|
-
`.pipe(Effect8.withSpan("create_span_exits_table"));
|
|
442
|
-
yield* sql`CREATE INDEX idx_span_exits_span ON span_exits(span_id)`.pipe(
|
|
443
|
-
Effect8.withSpan("create_idx_span_exits_span")
|
|
444
|
-
);
|
|
445
|
-
});
|
|
446
|
-
var simplify_span_exits_default = Effect8.gen(function* () {
|
|
447
|
-
const sql = yield* SqlClient7.SqlClient;
|
|
448
|
-
yield* sql`
|
|
449
|
-
CREATE TABLE span_exits_new (
|
|
450
|
-
trace_id TEXT NOT NULL,
|
|
451
|
-
span_id TEXT NOT NULL,
|
|
452
|
-
exit TEXT NOT NULL,
|
|
453
|
-
PRIMARY KEY (trace_id, span_id)
|
|
454
|
-
)
|
|
455
|
-
`.pipe(Effect8.withSpan("create_span_exits_new"));
|
|
456
|
-
yield* sql`
|
|
457
|
-
INSERT INTO span_exits_new (trace_id, span_id, exit)
|
|
458
|
-
SELECT
|
|
459
|
-
trace_id,
|
|
460
|
-
span_id,
|
|
461
|
-
CASE
|
|
462
|
-
WHEN exit_tag = 'Success' THEN json_object('_tag', 'Success', 'value', json(exit_value))
|
|
463
|
-
WHEN exit_tag = 'Failure' THEN json_object('_tag', 'Failure', 'cause', json(exit_value))
|
|
464
|
-
ELSE json_object('_tag', exit_tag, 'value', json(exit_value))
|
|
465
|
-
END
|
|
466
|
-
FROM span_exits
|
|
467
|
-
`.pipe(Effect8.withSpan("migrate_span_exits_data"));
|
|
468
|
-
yield* sql`DROP TABLE span_exits`.pipe(Effect8.withSpan("drop_old_span_exits"));
|
|
469
|
-
yield* sql`ALTER TABLE span_exits_new RENAME TO span_exits`.pipe(
|
|
470
|
-
Effect8.withSpan("rename_span_exits")
|
|
471
|
-
);
|
|
472
|
-
yield* sql`CREATE INDEX idx_span_exits_span ON span_exits(span_id)`.pipe(
|
|
473
|
-
Effect8.withSpan("recreate_idx_span_exits_span")
|
|
474
|
-
);
|
|
475
|
-
});
|
|
499
|
+
var create_span_exits_table_default = Effect8.void;
|
|
500
|
+
var simplify_span_exits_default = Effect8.void;
|
|
476
501
|
|
|
477
502
|
// src/services/Storage.ts
|
|
478
|
-
var
|
|
479
|
-
var
|
|
480
|
-
|
|
481
|
-
|
|
482
|
-
);
|
|
483
|
-
var NumberFromBigInt = Schema3.BigInt.pipe(
|
|
484
|
-
Schema3.decodeTo(
|
|
485
|
-
Schema3.Number,
|
|
503
|
+
var SpanExitJson = Schema.toCodecJson(SpanExit);
|
|
504
|
+
var NumberFromBigInt = Schema.BigInt.pipe(
|
|
505
|
+
Schema.decodeTo(
|
|
506
|
+
Schema.Number,
|
|
486
507
|
SchemaTransformation2.transform({
|
|
487
508
|
decode: (n) => Number(n),
|
|
488
509
|
encode: (n) => BigInt(n)
|
|
489
510
|
})
|
|
490
511
|
)
|
|
491
512
|
);
|
|
492
|
-
var
|
|
493
|
-
|
|
494
|
-
|
|
495
|
-
|
|
496
|
-
|
|
497
|
-
|
|
498
|
-
endTime: Schema3.BigInt,
|
|
499
|
-
statusCode: withDefault(Schema3.Number, 0),
|
|
500
|
-
statusMessage: withDefault(Schema3.NullOr(Schema3.String), null)
|
|
501
|
-
}) {
|
|
502
|
-
};
|
|
503
|
-
var SpanStatusSchema = Schema3.Union([SpanStatusStarted2, SpanStatusEnded2]);
|
|
504
|
-
var ExternalSpan2 = class extends Schema3.TaggedClass()("ExternalSpan", {
|
|
505
|
-
traceId: Schema3.String,
|
|
506
|
-
spanId: Schema3.String,
|
|
507
|
-
resourceId: Schema3.Number
|
|
508
|
-
}) {
|
|
509
|
-
};
|
|
510
|
-
var Span2 = class extends Schema3.TaggedClass()("Span", {
|
|
511
|
-
traceId: Schema3.String,
|
|
512
|
-
spanId: Schema3.String,
|
|
513
|
-
parentSpanId: Schema3.NullOr(Schema3.String),
|
|
514
|
-
name: Schema3.String,
|
|
515
|
-
kind: withDefault(Schema3.Number, 0),
|
|
516
|
-
attributes: withDefault(SpanAttributes2, {}),
|
|
517
|
-
resourceId: Schema3.Number,
|
|
518
|
-
scopeId: Schema3.NullOr(Schema3.Number),
|
|
519
|
-
status: SpanStatusSchema
|
|
520
|
-
}) {
|
|
521
|
-
};
|
|
522
|
-
var AnySpanSchema = Schema3.Union([Span2, ExternalSpan2]);
|
|
523
|
-
var DbSpanRow = Schema3.Struct({
|
|
524
|
-
span_id: Schema3.String,
|
|
525
|
-
trace_id: Schema3.String,
|
|
526
|
-
parent_span_id: Schema3.optional(Schema3.NullOr(Schema3.String)),
|
|
527
|
-
name: Schema3.String,
|
|
528
|
-
kind: Schema3.optional(Schema3.BigInt),
|
|
529
|
-
start_time: Schema3.BigInt,
|
|
530
|
-
end_time: Schema3.optional(Schema3.NullOr(Schema3.BigInt)),
|
|
531
|
-
status_code: Schema3.optional(Schema3.BigInt),
|
|
532
|
-
status_message: Schema3.optional(Schema3.NullOr(Schema3.String)),
|
|
533
|
-
attributes: Schema3.optional(Schema3.String),
|
|
534
|
-
resource_id: Schema3.BigInt,
|
|
535
|
-
scope_id: Schema3.optional(Schema3.NullOr(Schema3.BigInt)),
|
|
536
|
-
is_external: Schema3.optional(Schema3.BigInt)
|
|
537
|
-
});
|
|
538
|
-
var DbSpanType = Schema3.Struct({
|
|
539
|
-
span_id: Schema3.String,
|
|
540
|
-
trace_id: Schema3.String,
|
|
541
|
-
parent_span_id: Schema3.NullOr(Schema3.String),
|
|
542
|
-
name: Schema3.String,
|
|
543
|
-
kind: Schema3.Number,
|
|
544
|
-
start_time: Schema3.BigInt,
|
|
545
|
-
end_time: Schema3.NullOr(Schema3.BigInt),
|
|
546
|
-
status_code: Schema3.Number,
|
|
547
|
-
status_message: Schema3.NullOr(Schema3.String),
|
|
548
|
-
attributes: SpanAttributes2,
|
|
549
|
-
resource_id: Schema3.Number,
|
|
550
|
-
scope_id: Schema3.NullOr(Schema3.Number),
|
|
551
|
-
is_external: Schema3.Boolean
|
|
552
|
-
});
|
|
553
|
-
var DbSpan = DbSpanRow.pipe(Schema3.decodeTo(
|
|
554
|
-
DbSpanType,
|
|
555
|
-
SchemaTransformation2.transform({
|
|
556
|
-
decode: (row) => ({
|
|
557
|
-
span_id: row.span_id,
|
|
558
|
-
trace_id: row.trace_id,
|
|
559
|
-
parent_span_id: row.parent_span_id ?? null,
|
|
560
|
-
name: row.name,
|
|
561
|
-
kind: Number(row.kind ?? 0n),
|
|
562
|
-
start_time: row.start_time,
|
|
563
|
-
end_time: row.end_time ?? null,
|
|
564
|
-
status_code: Number(row.status_code ?? 0n),
|
|
565
|
-
status_message: row.status_message ?? null,
|
|
566
|
-
attributes: row.attributes === void 0 ? {} : JSON.parse(row.attributes),
|
|
567
|
-
resource_id: Number(row.resource_id),
|
|
568
|
-
scope_id: row.scope_id === void 0 || row.scope_id === null ? null : Number(row.scope_id),
|
|
569
|
-
is_external: (row.is_external ?? 0n) === 1n
|
|
570
|
-
}),
|
|
571
|
-
encode: (span) => ({
|
|
572
|
-
span_id: span.span_id,
|
|
573
|
-
trace_id: span.trace_id,
|
|
574
|
-
parent_span_id: span.parent_span_id,
|
|
575
|
-
name: span.name,
|
|
576
|
-
kind: BigInt(span.kind),
|
|
577
|
-
start_time: span.start_time,
|
|
578
|
-
end_time: span.end_time,
|
|
579
|
-
status_code: BigInt(span.status_code),
|
|
580
|
-
status_message: span.status_message,
|
|
581
|
-
attributes: JSON.stringify(span.attributes),
|
|
582
|
-
resource_id: BigInt(span.resource_id),
|
|
583
|
-
scope_id: span.scope_id === null ? null : BigInt(span.scope_id),
|
|
584
|
-
is_external: span.is_external ? 1n : 0n
|
|
513
|
+
var BooleanFromBigInt = Schema.BigInt.pipe(
|
|
514
|
+
Schema.decodeTo(
|
|
515
|
+
Schema.Boolean,
|
|
516
|
+
SchemaTransformation2.transform({
|
|
517
|
+
decode: (n) => n === 1n,
|
|
518
|
+
encode: (b) => b ? 1n : 0n
|
|
585
519
|
})
|
|
586
|
-
|
|
587
|
-
)
|
|
588
|
-
var
|
|
589
|
-
|
|
590
|
-
|
|
591
|
-
|
|
592
|
-
|
|
593
|
-
|
|
594
|
-
|
|
595
|
-
|
|
596
|
-
|
|
597
|
-
|
|
520
|
+
)
|
|
521
|
+
);
|
|
522
|
+
var TagFromExternalFlag = (tag, flag) => Schema.Literal(flag).pipe(
|
|
523
|
+
Schema.decodeTo(
|
|
524
|
+
Schema.Literal(tag),
|
|
525
|
+
SchemaTransformation2.transform({
|
|
526
|
+
decode: () => tag,
|
|
527
|
+
encode: () => flag
|
|
528
|
+
})
|
|
529
|
+
)
|
|
530
|
+
);
|
|
531
|
+
var DbSpan = Span.pipe(
|
|
532
|
+
encodeStruct({
|
|
533
|
+
evolve: {
|
|
534
|
+
_tag: TagFromExternalFlag("Span", 0n),
|
|
535
|
+
attributes: Schema.fromJsonString(SpanAttributes),
|
|
536
|
+
sampled: BooleanFromBigInt,
|
|
537
|
+
status: {
|
|
538
|
+
exit: Schema.fromJsonString(SpanExitJson)
|
|
598
539
|
}
|
|
599
|
-
const status = db.end_time === null ? new SpanStatusStarted2({ startTime: db.start_time }) : new SpanStatusEnded2({
|
|
600
|
-
startTime: db.start_time,
|
|
601
|
-
endTime: db.end_time,
|
|
602
|
-
statusCode: db.status_code,
|
|
603
|
-
statusMessage: db.status_message
|
|
604
|
-
});
|
|
605
|
-
return new Span2({
|
|
606
|
-
traceId: db.trace_id,
|
|
607
|
-
spanId: db.span_id,
|
|
608
|
-
parentSpanId: db.parent_span_id,
|
|
609
|
-
name: db.name,
|
|
610
|
-
kind: db.kind,
|
|
611
|
-
attributes: db.attributes,
|
|
612
|
-
resourceId: db.resource_id,
|
|
613
|
-
scopeId: db.scope_id,
|
|
614
|
-
status
|
|
615
|
-
});
|
|
616
540
|
},
|
|
617
|
-
|
|
618
|
-
|
|
619
|
-
|
|
620
|
-
|
|
621
|
-
|
|
622
|
-
|
|
623
|
-
|
|
624
|
-
|
|
625
|
-
|
|
626
|
-
|
|
627
|
-
|
|
628
|
-
status_message: null,
|
|
629
|
-
attributes: {},
|
|
630
|
-
resource_id: span.resourceId,
|
|
631
|
-
scope_id: null,
|
|
632
|
-
is_external: true
|
|
633
|
-
};
|
|
634
|
-
}
|
|
635
|
-
const baseRecord = {
|
|
636
|
-
span_id: span.spanId,
|
|
637
|
-
trace_id: span.traceId,
|
|
638
|
-
parent_span_id: span.parentSpanId,
|
|
639
|
-
name: span.name,
|
|
640
|
-
kind: span.kind ?? 0,
|
|
641
|
-
attributes: span.attributes ?? {},
|
|
642
|
-
resource_id: span.resourceId,
|
|
643
|
-
scope_id: span.scopeId,
|
|
644
|
-
is_external: false
|
|
645
|
-
};
|
|
646
|
-
if (span.status._tag === "Started") {
|
|
647
|
-
return {
|
|
648
|
-
...baseRecord,
|
|
649
|
-
start_time: span.status.startTime,
|
|
650
|
-
end_time: null,
|
|
651
|
-
status_code: 0,
|
|
652
|
-
status_message: null
|
|
653
|
-
};
|
|
654
|
-
}
|
|
655
|
-
return {
|
|
656
|
-
...baseRecord,
|
|
657
|
-
start_time: span.status.startTime,
|
|
658
|
-
end_time: span.status.endTime,
|
|
659
|
-
status_code: span.status.statusCode ?? 0,
|
|
660
|
-
status_message: span.status.statusMessage ?? null
|
|
661
|
-
};
|
|
541
|
+
rename: {
|
|
542
|
+
_tag: "is_external",
|
|
543
|
+
parentSpanId: "parent_span_id",
|
|
544
|
+
spanId: "span_id",
|
|
545
|
+
status: {
|
|
546
|
+
_tag: "status_tag",
|
|
547
|
+
endTime: "end_time",
|
|
548
|
+
exit: "exit",
|
|
549
|
+
startTime: "start_time"
|
|
550
|
+
},
|
|
551
|
+
traceId: "trace_id"
|
|
662
552
|
}
|
|
663
553
|
})
|
|
664
|
-
)
|
|
665
|
-
var
|
|
666
|
-
|
|
667
|
-
|
|
668
|
-
|
|
669
|
-
|
|
670
|
-
|
|
671
|
-
|
|
672
|
-
|
|
673
|
-
|
|
674
|
-
|
|
675
|
-
return { _tag: "Die", defect: reason.defect };
|
|
676
|
-
case "Interrupt":
|
|
677
|
-
return {
|
|
678
|
-
_tag: "Interrupt",
|
|
679
|
-
fiberId: reason.fiberId === void 0 ? { _tag: "None" } : { _tag: "Runtime", id: reason.fiberId, startTimeMillis: 0 }
|
|
680
|
-
};
|
|
681
|
-
default:
|
|
682
|
-
return { _tag: "Empty" };
|
|
683
|
-
}
|
|
684
|
-
});
|
|
685
|
-
const accumulatedCause = reasons.reduce((acc, reason) => {
|
|
686
|
-
if (acc === void 0) return reason;
|
|
687
|
-
return { _tag: "Sequential", left: acc, right: reason };
|
|
688
|
-
}, { _tag: "Empty" });
|
|
689
|
-
return { _tag: "Failure", cause: accumulatedCause };
|
|
690
|
-
}
|
|
691
|
-
return exit;
|
|
692
|
-
};
|
|
693
|
-
var decodeExit = (exit) => {
|
|
694
|
-
if (exit._tag === "Success") {
|
|
695
|
-
return Exit.succeed(exit.value);
|
|
696
|
-
}
|
|
697
|
-
const decodeCause = (cause) => {
|
|
698
|
-
switch (cause._tag) {
|
|
699
|
-
case "Empty":
|
|
700
|
-
return Cause.empty;
|
|
701
|
-
case "Fail":
|
|
702
|
-
return Cause.fail(cause.error);
|
|
703
|
-
case "Die":
|
|
704
|
-
return Cause.die(cause.defect);
|
|
705
|
-
case "Interrupt":
|
|
706
|
-
return Cause.interrupt(cause.fiberId._tag === "Runtime" ? cause.fiberId.id : void 0);
|
|
707
|
-
case "Sequential":
|
|
708
|
-
case "Parallel":
|
|
709
|
-
return Cause.combine(decodeCause(cause.left), decodeCause(cause.right));
|
|
710
|
-
default:
|
|
711
|
-
return Cause.empty;
|
|
554
|
+
);
|
|
555
|
+
var DbExternalSpan = ExternalSpan.pipe(
|
|
556
|
+
encodeStruct({
|
|
557
|
+
evolve: {
|
|
558
|
+
_tag: TagFromExternalFlag("ExternalSpan", 1n),
|
|
559
|
+
sampled: BooleanFromBigInt
|
|
560
|
+
},
|
|
561
|
+
rename: {
|
|
562
|
+
_tag: "is_external",
|
|
563
|
+
spanId: "span_id",
|
|
564
|
+
traceId: "trace_id"
|
|
712
565
|
}
|
|
713
|
-
}
|
|
714
|
-
|
|
715
|
-
|
|
716
|
-
var TraceSummary =
|
|
717
|
-
trace_id:
|
|
566
|
+
})
|
|
567
|
+
);
|
|
568
|
+
var DbAnySpan = Schema.Union([DbSpan, DbExternalSpan]);
|
|
569
|
+
var TraceSummary = Schema.Struct({
|
|
570
|
+
trace_id: Schema.String,
|
|
718
571
|
span_count: NumberFromBigInt,
|
|
719
|
-
root_span_name:
|
|
720
|
-
|
|
721
|
-
|
|
722
|
-
end_time: Schema3.NullOr(Schema3.BigInt),
|
|
572
|
+
root_span_name: Schema.NullOr(Schema.String),
|
|
573
|
+
start_time: Schema.BigInt,
|
|
574
|
+
end_time: Schema.NullOr(Schema.BigInt),
|
|
723
575
|
status: NumberFromBigInt
|
|
724
576
|
});
|
|
725
|
-
var
|
|
726
|
-
|
|
727
|
-
|
|
728
|
-
|
|
729
|
-
|
|
730
|
-
|
|
731
|
-
|
|
732
|
-
|
|
733
|
-
|
|
734
|
-
|
|
735
|
-
spanId: row.span_id,
|
|
736
|
-
traceId: row.trace_id,
|
|
737
|
-
linkedSpanId: row.linked_span_id,
|
|
738
|
-
linkedTraceId: row.linked_trace_id,
|
|
739
|
-
attributes: JSON.parse(row.attributes)
|
|
740
|
-
}),
|
|
741
|
-
encode: (link) => ({
|
|
742
|
-
span_id: link.spanId,
|
|
743
|
-
trace_id: link.traceId,
|
|
744
|
-
linked_span_id: link.linkedSpanId,
|
|
745
|
-
linked_trace_id: link.linkedTraceId,
|
|
746
|
-
attributes: JSON.stringify(link.attributes)
|
|
747
|
-
})
|
|
577
|
+
var DbSpanLink = SpanLink.mapFields(
|
|
578
|
+
Struct5.evolve({
|
|
579
|
+
attributes: Schema.fromJsonString
|
|
580
|
+
})
|
|
581
|
+
).pipe(
|
|
582
|
+
Schema.encodeKeys({
|
|
583
|
+
spanId: "span_id",
|
|
584
|
+
traceId: "trace_id",
|
|
585
|
+
linkedSpanId: "linked_span_id",
|
|
586
|
+
linkedTraceId: "linked_trace_id"
|
|
748
587
|
})
|
|
749
|
-
)
|
|
750
|
-
var DbSpanLinkToSpanLink = DbSpanLinkRow;
|
|
588
|
+
);
|
|
751
589
|
var Storage = class extends Context3.Service()("inspeffct/Storage") {
|
|
752
590
|
};
|
|
753
|
-
var hashAttributes = (attributes) => {
|
|
754
|
-
const sorted = JSON.stringify(attributes, Object.keys(attributes).sort());
|
|
755
|
-
return Crypto.createHash("sha256").update(sorted).digest("hex").slice(0, 32);
|
|
756
|
-
};
|
|
757
591
|
var MigrationsLoader = Migrator.fromRecord({
|
|
758
592
|
"0001_create_otel_tables": create_otel_tables_default,
|
|
759
593
|
"0002_create_span_exits_table": create_span_exits_table_default,
|
|
@@ -766,110 +600,38 @@ var layer4 = (config) => Layer7.effectContext(
|
|
|
766
600
|
Effect8.gen(function* () {
|
|
767
601
|
const sql = yield* SqliteClient.SqliteClient;
|
|
768
602
|
yield* runMigrations;
|
|
769
|
-
const resourceCache = /* @__PURE__ */ new Map();
|
|
770
|
-
const scopeCache = /* @__PURE__ */ new Map();
|
|
771
603
|
const storage = Storage.of({
|
|
772
|
-
|
|
773
|
-
const
|
|
774
|
-
|
|
775
|
-
|
|
776
|
-
|
|
777
|
-
|
|
778
|
-
|
|
779
|
-
|
|
780
|
-
|
|
781
|
-
|
|
782
|
-
|
|
783
|
-
|
|
784
|
-
|
|
785
|
-
|
|
786
|
-
|
|
787
|
-
|
|
788
|
-
|
|
789
|
-
|
|
790
|
-
|
|
791
|
-
|
|
792
|
-
|
|
793
|
-
|
|
794
|
-
getOrCreateScope: (name, version = "") => Effect8.gen(function* () {
|
|
795
|
-
const key = `${name}:${version}`;
|
|
796
|
-
const cached = scopeCache.get(key);
|
|
797
|
-
if (cached !== void 0) {
|
|
798
|
-
return cached;
|
|
799
|
-
}
|
|
800
|
-
const existing = yield* sql`
|
|
801
|
-
SELECT id FROM scopes WHERE name = ${name} AND version = ${version}
|
|
802
|
-
`;
|
|
803
|
-
if (existing.length > 0) {
|
|
804
|
-
scopeCache.set(key, existing[0].id);
|
|
805
|
-
return existing[0].id;
|
|
806
|
-
}
|
|
807
|
-
const result = yield* sql`
|
|
808
|
-
INSERT INTO scopes (name, version)
|
|
809
|
-
VALUES (${name}, ${version})
|
|
810
|
-
RETURNING id
|
|
811
|
-
`;
|
|
812
|
-
const id = result[0].id;
|
|
813
|
-
scopeCache.set(key, id);
|
|
814
|
-
return id;
|
|
604
|
+
persistSpan: (span) => Effect8.gen(function* () {
|
|
605
|
+
const changed = yield* (
|
|
606
|
+
// @ts-ignore TS28 false positive from SqlSchema service inference
|
|
607
|
+
SqlSchema.findOne({
|
|
608
|
+
Request: DbAnySpan,
|
|
609
|
+
Result: Schema.Struct({ span_id: Schema.String }),
|
|
610
|
+
execute: (db) => sql`
|
|
611
|
+
INSERT INTO spans ${sql.insert(db)}
|
|
612
|
+
ON CONFLICT(span_id) DO UPDATE SET
|
|
613
|
+
${sql.update(db, ["span_id"])}
|
|
614
|
+
WHERE
|
|
615
|
+
is_external = 1 OR
|
|
616
|
+
(end_time IS NULL AND excluded.is_external = 0)
|
|
617
|
+
RETURNING span_id
|
|
618
|
+
`
|
|
619
|
+
})(span).pipe(
|
|
620
|
+
Effect8.as(true),
|
|
621
|
+
Effect8.catch(() => Effect8.succeed(false)),
|
|
622
|
+
Effect8.provideService(SqlClient3.SafeIntegers, true)
|
|
623
|
+
)
|
|
624
|
+
);
|
|
625
|
+
return changed;
|
|
815
626
|
}),
|
|
816
|
-
persistSpan: (span) => (
|
|
817
|
-
// @ts-ignore TS28 false positive from SqlSchema service inference
|
|
818
|
-
SqlSchema.findOne({
|
|
819
|
-
Request: AnySpanToDbSpan,
|
|
820
|
-
Result: Schema3.Struct({ span_id: Schema3.String }),
|
|
821
|
-
execute: (db) => sql`
|
|
822
|
-
INSERT INTO spans (
|
|
823
|
-
span_id, trace_id, parent_span_id, name, kind,
|
|
824
|
-
start_time, end_time, status_code, status_message,
|
|
825
|
-
attributes, resource_id, scope_id, is_external
|
|
826
|
-
) VALUES (
|
|
827
|
-
${db.span_id},
|
|
828
|
-
${db.trace_id},
|
|
829
|
-
${db.parent_span_id},
|
|
830
|
-
${db.name},
|
|
831
|
-
${db.kind},
|
|
832
|
-
${db.start_time},
|
|
833
|
-
${db.end_time},
|
|
834
|
-
${db.status_code},
|
|
835
|
-
${db.status_message},
|
|
836
|
-
${db.attributes},
|
|
837
|
-
${db.resource_id},
|
|
838
|
-
${db.scope_id},
|
|
839
|
-
${db.is_external ? 1 : 0}
|
|
840
|
-
)
|
|
841
|
-
ON CONFLICT(span_id) DO UPDATE SET
|
|
842
|
-
trace_id = excluded.trace_id,
|
|
843
|
-
parent_span_id = excluded.parent_span_id,
|
|
844
|
-
name = excluded.name,
|
|
845
|
-
kind = excluded.kind,
|
|
846
|
-
start_time = excluded.start_time,
|
|
847
|
-
end_time = COALESCE(excluded.end_time, end_time),
|
|
848
|
-
status_code = excluded.status_code,
|
|
849
|
-
status_message = excluded.status_message,
|
|
850
|
-
attributes = excluded.attributes,
|
|
851
|
-
resource_id = excluded.resource_id,
|
|
852
|
-
scope_id = excluded.scope_id,
|
|
853
|
-
is_external = excluded.is_external
|
|
854
|
-
WHERE
|
|
855
|
-
is_external = 1 OR
|
|
856
|
-
(end_time IS NULL AND excluded.is_external = 0)
|
|
857
|
-
RETURNING span_id
|
|
858
|
-
`
|
|
859
|
-
})(span).pipe(
|
|
860
|
-
Effect8.as(true),
|
|
861
|
-
Effect8.catch(() => Effect8.succeed(false)),
|
|
862
|
-
Effect8.provideService(SqlClient7.SafeIntegers, true)
|
|
863
|
-
)
|
|
864
|
-
),
|
|
865
627
|
persistSpanEvent: flow(
|
|
866
628
|
SqlSchema.void({
|
|
867
|
-
Request:
|
|
868
|
-
spanId:
|
|
869
|
-
traceId:
|
|
870
|
-
name:
|
|
871
|
-
time:
|
|
872
|
-
attributes:
|
|
629
|
+
Request: Schema.Struct({
|
|
630
|
+
spanId: Schema.String,
|
|
631
|
+
traceId: Schema.String,
|
|
632
|
+
name: Schema.String,
|
|
633
|
+
time: Schema.BigInt,
|
|
634
|
+
attributes: Schema.fromJsonString(SpanAttributes)
|
|
873
635
|
}),
|
|
874
636
|
execute: (req) => sql`
|
|
875
637
|
INSERT INTO span_events (span_id, trace_id, name, time, attributes)
|
|
@@ -882,44 +644,50 @@ var layer4 = (config) => Layer7.effectContext(
|
|
|
882
644
|
)
|
|
883
645
|
`
|
|
884
646
|
}),
|
|
885
|
-
Effect8.provideService(
|
|
647
|
+
Effect8.provideService(SqlClient3.SafeIntegers, true)
|
|
886
648
|
),
|
|
887
649
|
getSpansByTraceId: (traceId) => (
|
|
888
650
|
// @ts-ignore TS28 false positive from SqlSchema service inference
|
|
889
651
|
SqlSchema.findAll({
|
|
890
|
-
Request:
|
|
891
|
-
Result:
|
|
652
|
+
Request: Schema.String,
|
|
653
|
+
Result: DbAnySpan,
|
|
892
654
|
execute: (traceId2) => sql`
|
|
893
|
-
SELECT
|
|
655
|
+
SELECT s.*
|
|
656
|
+
FROM spans s
|
|
657
|
+
WHERE s.trace_id = ${traceId2}
|
|
658
|
+
ORDER BY s.start_time ASC
|
|
894
659
|
`
|
|
895
660
|
})(traceId).pipe(
|
|
896
|
-
Effect8.provideService(
|
|
661
|
+
Effect8.provideService(SqlClient3.SafeIntegers, true)
|
|
897
662
|
)
|
|
898
663
|
),
|
|
899
664
|
getRecentSpans: (limit = 100) => (
|
|
900
665
|
// @ts-ignore TS28 false positive from SqlSchema service inference
|
|
901
666
|
SqlSchema.findAll({
|
|
902
|
-
Request:
|
|
903
|
-
Result:
|
|
667
|
+
Request: Schema.Number,
|
|
668
|
+
Result: DbAnySpan,
|
|
904
669
|
execute: (l) => sql`
|
|
905
|
-
SELECT
|
|
670
|
+
SELECT s.*
|
|
671
|
+
FROM spans s
|
|
672
|
+
ORDER BY s.start_time DESC
|
|
673
|
+
LIMIT ${l}
|
|
906
674
|
`
|
|
907
675
|
})(limit).pipe(
|
|
908
|
-
Effect8.provideService(
|
|
676
|
+
Effect8.provideService(SqlClient3.SafeIntegers, true)
|
|
909
677
|
)
|
|
910
678
|
),
|
|
911
679
|
getSpanEvents: flow(
|
|
912
680
|
SqlSchema.findAll({
|
|
913
|
-
Request:
|
|
914
|
-
traceId:
|
|
915
|
-
spanId:
|
|
681
|
+
Request: Schema.Struct({
|
|
682
|
+
traceId: Schema.String,
|
|
683
|
+
spanId: Schema.String
|
|
916
684
|
}),
|
|
917
|
-
Result:
|
|
918
|
-
spanId:
|
|
919
|
-
traceId:
|
|
920
|
-
name:
|
|
921
|
-
time:
|
|
922
|
-
attributes:
|
|
685
|
+
Result: Schema.Struct({
|
|
686
|
+
spanId: Schema.String,
|
|
687
|
+
traceId: Schema.String,
|
|
688
|
+
name: Schema.String,
|
|
689
|
+
time: Schema.BigInt,
|
|
690
|
+
attributes: Schema.fromJsonString(SpanAttributes)
|
|
923
691
|
}),
|
|
924
692
|
execute: (req) => sql`
|
|
925
693
|
SELECT span_id AS "spanId", trace_id AS "traceId", name, time, attributes
|
|
@@ -928,61 +696,37 @@ var layer4 = (config) => Layer7.effectContext(
|
|
|
928
696
|
ORDER BY time ASC
|
|
929
697
|
`
|
|
930
698
|
}),
|
|
931
|
-
Effect8.provideService(
|
|
699
|
+
Effect8.provideService(SqlClient3.SafeIntegers, true)
|
|
932
700
|
),
|
|
933
701
|
persistSpanLink: SqlSchema.void({
|
|
934
|
-
Request:
|
|
935
|
-
spanId: Schema3.String,
|
|
936
|
-
traceId: Schema3.String,
|
|
937
|
-
linkedSpanId: Schema3.String,
|
|
938
|
-
linkedTraceId: Schema3.String,
|
|
939
|
-
attributes: Schema3.fromJsonString(SpanAttributes)
|
|
940
|
-
}),
|
|
702
|
+
Request: DbSpanLink,
|
|
941
703
|
execute: (req) => sql`
|
|
942
704
|
INSERT INTO span_links (span_id, trace_id, linked_span_id, linked_trace_id, attributes)
|
|
943
705
|
VALUES (
|
|
944
|
-
${req.
|
|
945
|
-
${req.
|
|
946
|
-
${req.
|
|
947
|
-
${req.
|
|
706
|
+
${req.span_id},
|
|
707
|
+
${req.trace_id},
|
|
708
|
+
${req.linked_span_id},
|
|
709
|
+
${req.linked_trace_id},
|
|
948
710
|
${req.attributes}
|
|
949
711
|
)
|
|
950
712
|
`
|
|
951
713
|
}),
|
|
952
714
|
getSpanLinks: SqlSchema.findAll({
|
|
953
|
-
Request:
|
|
954
|
-
traceId:
|
|
955
|
-
spanId:
|
|
715
|
+
Request: Schema.Struct({
|
|
716
|
+
traceId: Schema.String,
|
|
717
|
+
spanId: Schema.String
|
|
956
718
|
}),
|
|
957
|
-
Result:
|
|
719
|
+
Result: DbSpanLink,
|
|
958
720
|
execute: (req) => sql`
|
|
959
721
|
SELECT * FROM span_links
|
|
960
722
|
WHERE trace_id = ${req.traceId} AND span_id = ${req.spanId}
|
|
961
723
|
`
|
|
962
724
|
}),
|
|
963
|
-
persistSpanExit: (req) => sql`
|
|
964
|
-
INSERT INTO span_exits (trace_id, span_id, exit)
|
|
965
|
-
VALUES (
|
|
966
|
-
${req.traceId},
|
|
967
|
-
${req.spanId},
|
|
968
|
-
${JSON.stringify(encodeExit(req.exit))}
|
|
969
|
-
)
|
|
970
|
-
ON CONFLICT(trace_id, span_id) DO UPDATE SET
|
|
971
|
-
exit = excluded.exit
|
|
972
|
-
`.pipe(Effect8.asVoid),
|
|
973
|
-
getSpanExit: (req) => sql`
|
|
974
|
-
SELECT exit FROM span_exits
|
|
975
|
-
WHERE trace_id = ${req.traceId} AND span_id = ${req.spanId}
|
|
976
|
-
`.pipe(
|
|
977
|
-
Effect8.map((rows) => rows[0]),
|
|
978
|
-
Effect8.map((row) => row ? Option4.some(decodeExit(JSON.parse(row.exit))) : Option4.none())
|
|
979
|
-
),
|
|
980
725
|
getTraces: (filters = {}) => SqlSchema.findAll({
|
|
981
|
-
Request:
|
|
982
|
-
limit:
|
|
983
|
-
|
|
984
|
-
|
|
985
|
-
status: Schema3.optional(Schema3.Number)
|
|
726
|
+
Request: Schema.Struct({
|
|
727
|
+
limit: Schema.optional(Schema.Number),
|
|
728
|
+
since: Schema.optional(Schema.BigInt),
|
|
729
|
+
status: Schema.optional(Schema.Number)
|
|
986
730
|
}),
|
|
987
731
|
Result: TraceSummary,
|
|
988
732
|
execute: (req) => sql`
|
|
@@ -990,52 +734,64 @@ var layer4 = (config) => Layer7.effectContext(
|
|
|
990
734
|
s.trace_id,
|
|
991
735
|
COUNT(*) as span_count,
|
|
992
736
|
(SELECT name FROM spans WHERE trace_id = s.trace_id AND parent_span_id IS NULL LIMIT 1) as root_span_name,
|
|
993
|
-
(SELECT json_extract(r2.attributes, '$."service.name"')
|
|
994
|
-
FROM spans s2
|
|
995
|
-
JOIN resources r2 ON s2.resource_id = r2.id
|
|
996
|
-
WHERE s2.trace_id = s.trace_id
|
|
997
|
-
LIMIT 1) as service_name,
|
|
998
737
|
MIN(s.start_time) as start_time,
|
|
999
738
|
MAX(s.end_time) as end_time,
|
|
1000
|
-
MAX(
|
|
739
|
+
MAX(
|
|
740
|
+
CASE
|
|
741
|
+
WHEN s.status_tag = 'Ended' AND json_extract(s.exit, '$._tag') = 'Success' THEN 1
|
|
742
|
+
WHEN s.status_tag = 'Ended' THEN 2
|
|
743
|
+
ELSE 0
|
|
744
|
+
END
|
|
745
|
+
) as status
|
|
1001
746
|
FROM spans s
|
|
1002
|
-
LEFT JOIN resources r ON s.resource_id = r.id
|
|
1003
747
|
WHERE ${sql.and([
|
|
1004
748
|
req.since !== void 0 ? sql`s.start_time >= ${req.since}` : sql`1=1`,
|
|
1005
|
-
req.status !== void 0 ? sql`
|
|
1006
|
-
|
|
749
|
+
req.status !== void 0 ? sql`
|
|
750
|
+
CASE
|
|
751
|
+
WHEN s.status_tag = 'Ended' AND json_extract(s.exit, '$._tag') = 'Success' THEN 1
|
|
752
|
+
WHEN s.status_tag = 'Ended' THEN 2
|
|
753
|
+
ELSE 0
|
|
754
|
+
END = ${req.status}
|
|
755
|
+
` : sql`1=1`
|
|
1007
756
|
])}
|
|
1008
757
|
GROUP BY s.trace_id
|
|
1009
758
|
ORDER BY start_time DESC
|
|
1010
759
|
${req.limit !== void 0 ? sql`LIMIT ${req.limit}` : sql``}
|
|
1011
760
|
`
|
|
1012
761
|
})(filters).pipe(
|
|
1013
|
-
Effect8.provideService(
|
|
762
|
+
Effect8.provideService(SqlClient3.SafeIntegers, true)
|
|
1014
763
|
),
|
|
1015
764
|
getSpans: (filters = {}) => (
|
|
1016
765
|
// @ts-ignore TS28 false positive from SqlSchema service inference
|
|
1017
766
|
SqlSchema.findAll({
|
|
1018
|
-
Request:
|
|
1019
|
-
limit:
|
|
1020
|
-
minDuration:
|
|
1021
|
-
name:
|
|
1022
|
-
status:
|
|
1023
|
-
traceId:
|
|
767
|
+
Request: Schema.Struct({
|
|
768
|
+
limit: Schema.optional(Schema.Number),
|
|
769
|
+
minDuration: Schema.optional(Schema.BigInt),
|
|
770
|
+
name: Schema.optional(Schema.String),
|
|
771
|
+
status: Schema.optional(Schema.Number),
|
|
772
|
+
traceId: Schema.optional(Schema.String)
|
|
1024
773
|
}),
|
|
1025
|
-
Result:
|
|
774
|
+
Result: DbAnySpan,
|
|
1026
775
|
execute: (req) => sql`
|
|
1027
|
-
SELECT
|
|
776
|
+
SELECT s.*
|
|
777
|
+
FROM spans s
|
|
1028
778
|
WHERE ${sql.and([
|
|
1029
|
-
req.traceId !== void 0 ? sql`trace_id = ${req.traceId}` : sql`1=1`,
|
|
1030
|
-
req.name !== void 0 ? req.name.includes("%") ? sql`name LIKE ${req.name}` : sql`name = ${req.name}` : sql`1=1`,
|
|
1031
|
-
req.minDuration !== void 0 ? sql`(end_time - start_time) >= ${req.minDuration}` : sql`1=1`,
|
|
1032
|
-
req.status !== void 0 ? sql`
|
|
779
|
+
req.traceId !== void 0 ? sql`s.trace_id = ${req.traceId}` : sql`1=1`,
|
|
780
|
+
req.name !== void 0 ? req.name.includes("%") ? sql`s.name LIKE ${req.name}` : sql`s.name = ${req.name}` : sql`1=1`,
|
|
781
|
+
req.minDuration !== void 0 ? sql`(s.end_time - s.start_time) >= ${req.minDuration}` : sql`1=1`,
|
|
782
|
+
req.status !== void 0 ? sql`
|
|
783
|
+
CASE
|
|
784
|
+
WHEN s.status_tag = 'Ended' AND json_extract(s.exit, '$._tag') = 'Success' THEN 1
|
|
785
|
+
WHEN s.status_tag = 'Ended' THEN 2
|
|
786
|
+
ELSE 0
|
|
787
|
+
END = ${req.status}
|
|
788
|
+
` : sql`1=1`
|
|
1033
789
|
])}
|
|
1034
|
-
ORDER BY start_time DESC
|
|
790
|
+
ORDER BY s.start_time DESC
|
|
1035
791
|
${req.limit !== void 0 ? sql`LIMIT ${req.limit}` : sql``}
|
|
1036
792
|
`
|
|
1037
793
|
})(filters).pipe(
|
|
1038
|
-
Effect8.provideService(
|
|
794
|
+
Effect8.provideService(SqlClient3.SafeIntegers, true)
|
|
1039
795
|
)
|
|
1040
796
|
)
|
|
1041
797
|
});
|
|
@@ -1063,35 +819,7 @@ var layer5 = Layer7.effect(
|
|
|
1063
819
|
const { instrumentationId, span } = message;
|
|
1064
820
|
yield* Effect8.logDebug(`${message._tag} from ${instrumentationId}`);
|
|
1065
821
|
if (span._tag === "Span" && span.status._tag === "Ended") {
|
|
1066
|
-
|
|
1067
|
-
"service.name": instrumentationId
|
|
1068
|
-
});
|
|
1069
|
-
const scopeId = yield* storage.getOrCreateScope("effect-tracer");
|
|
1070
|
-
const statusCode = span.status.exit._tag === "Success" ? 1 : 2;
|
|
1071
|
-
yield* storage.persistSpan(
|
|
1072
|
-
new Span2({
|
|
1073
|
-
spanId: span.spanId,
|
|
1074
|
-
traceId: span.traceId,
|
|
1075
|
-
parentSpanId: span.parent?.spanId ?? null,
|
|
1076
|
-
name: span.name,
|
|
1077
|
-
kind: 0,
|
|
1078
|
-
// INTERNAL
|
|
1079
|
-
attributes: Object.fromEntries(span.attributes),
|
|
1080
|
-
resourceId,
|
|
1081
|
-
scopeId,
|
|
1082
|
-
status: new SpanStatusEnded2({
|
|
1083
|
-
startTime: span.status.startTime,
|
|
1084
|
-
endTime: span.status.endTime,
|
|
1085
|
-
statusCode,
|
|
1086
|
-
statusMessage: null
|
|
1087
|
-
})
|
|
1088
|
-
})
|
|
1089
|
-
);
|
|
1090
|
-
yield* storage.persistSpanExit({
|
|
1091
|
-
traceId: span.traceId,
|
|
1092
|
-
spanId: span.spanId,
|
|
1093
|
-
exit: span.status.exit
|
|
1094
|
-
});
|
|
822
|
+
yield* storage.persistSpan(span);
|
|
1095
823
|
yield* Effect8.logDebug(
|
|
1096
824
|
`Persisted span ${span.name} (${span.spanId}) with exit ${span.status.exit._tag} to storage`
|
|
1097
825
|
);
|
|
@@ -1191,7 +919,7 @@ var connectAndListen = (url, bootloaderScript) => Effect8.gen(function* () {
|
|
|
1191
919
|
if (event.method === "Runtime.bindingCalled") {
|
|
1192
920
|
const params = event.params;
|
|
1193
921
|
if (params.name === BINDING_NAME) {
|
|
1194
|
-
yield*
|
|
922
|
+
yield* Schema.decodeUnknownEffect(Schema.fromJsonString(OutMessage))(
|
|
1195
923
|
params.payload
|
|
1196
924
|
).pipe(
|
|
1197
925
|
Effect8.flatMap((decoded) => collector.collect(decoded)),
|
|
@@ -1251,7 +979,7 @@ var layer6 = Layer7.effect(
|
|
|
1251
979
|
var namedSocketDirectory = os.platform() === "win32" ? "\\\\.\\pipe\\" : os.tmpdir();
|
|
1252
980
|
var pipeCounter = 0;
|
|
1253
981
|
var generateIpcPath = Effect8.sync(() => {
|
|
1254
|
-
const randomHex =
|
|
982
|
+
const randomHex = crypto.randomBytes(4).toString("hex");
|
|
1255
983
|
const pipeName = `inspeffct.${process.pid}-${randomHex}-${pipeCounter++}.sock`;
|
|
1256
984
|
return path.join(namedSocketDirectory, pipeName);
|
|
1257
985
|
});
|
|
@@ -1268,7 +996,7 @@ var IpcServer = class extends Context3.Service()("inspeffct/IpcServer") {
|
|
|
1268
996
|
var tryParseMessage = (message) => {
|
|
1269
997
|
try {
|
|
1270
998
|
const parsed = JSON.parse(message);
|
|
1271
|
-
return
|
|
999
|
+
return Schema.decodeUnknownSync(OutMessage)(parsed);
|
|
1272
1000
|
} catch {
|
|
1273
1001
|
return null;
|
|
1274
1002
|
}
|
|
@@ -1433,7 +1161,7 @@ var command2 = Command5.make(
|
|
|
1433
1161
|
)
|
|
1434
1162
|
},
|
|
1435
1163
|
({ args, data, encodedCommand }) => Effect8.gen(function* () {
|
|
1436
|
-
const resolvedArgs =
|
|
1164
|
+
const resolvedArgs = Option3.isSome(encodedCommand) ? JSON.parse(Buffer.from(encodedCommand.value, "base64url").toString("utf8")) : args;
|
|
1437
1165
|
const [rawExecutable, ...commandArgs] = resolvedArgs;
|
|
1438
1166
|
const executable = rawExecutable === "node" ? process.execPath : rawExecutable;
|
|
1439
1167
|
yield* Effect8.logDebug(`Running: ${executable} ${commandArgs.join(" ")}`);
|
|
@@ -1501,16 +1229,17 @@ var getEndTime = (span) => {
|
|
|
1501
1229
|
};
|
|
1502
1230
|
var getStatusCode = (span) => {
|
|
1503
1231
|
if (span._tag === "ExternalSpan") return 0;
|
|
1504
|
-
|
|
1232
|
+
if (span.status._tag === "Started") return 0;
|
|
1233
|
+
return span.status.statusCode ?? (span.status.exit._tag === "Success" ? 1 : 2);
|
|
1505
1234
|
};
|
|
1506
1235
|
var getStatusMessage = (span) => {
|
|
1507
1236
|
if (span._tag === "ExternalSpan") return null;
|
|
1508
1237
|
return span.status._tag === "Ended" ? span.status.statusMessage ?? null : null;
|
|
1509
1238
|
};
|
|
1510
|
-
var getAttributes = (span) => span._tag === "Span" ? span.attributes ??
|
|
1239
|
+
var getAttributes = (span) => span._tag === "Span" ? Object.fromEntries(span.attributes ?? []) : {};
|
|
1511
1240
|
var isExternalSpan = (span) => span._tag === "ExternalSpan";
|
|
1512
1241
|
var parseDurationToNanos = (input) => {
|
|
1513
|
-
const duration =
|
|
1242
|
+
const duration = Schema.decodeUnknownSync(Schema.Duration)(input);
|
|
1514
1243
|
return BigInt(Duration.toMillis(duration)) * 1000000n;
|
|
1515
1244
|
};
|
|
1516
1245
|
var formatDuration = (nanos) => {
|
|
@@ -1581,12 +1310,12 @@ var formatSpanLine = (span) => {
|
|
|
1581
1310
|
};
|
|
1582
1311
|
var renderGraphNode = (graph, nodeIndex, prefix, isLast, isRoot) => {
|
|
1583
1312
|
const spanOpt = Graph.getNode(graph, nodeIndex);
|
|
1584
|
-
if (
|
|
1313
|
+
if (Option3.isNone(spanOpt)) return "";
|
|
1585
1314
|
const span = spanOpt.value;
|
|
1586
1315
|
const children = [];
|
|
1587
1316
|
for (const childIndex of Graph.neighbors(graph, nodeIndex)) {
|
|
1588
1317
|
const childSpanOpt = Graph.getNode(graph, childIndex);
|
|
1589
|
-
if (
|
|
1318
|
+
if (Option3.isSome(childSpanOpt)) {
|
|
1590
1319
|
children.push({ index: childIndex, span: childSpanOpt.value });
|
|
1591
1320
|
}
|
|
1592
1321
|
}
|
|
@@ -1640,7 +1369,7 @@ var command3 = Command5.make(
|
|
|
1640
1369
|
({ data, json, limit, minDuration, name, status, trace }) => Effect8.gen(function* () {
|
|
1641
1370
|
const storage = yield* Storage;
|
|
1642
1371
|
let statusCode;
|
|
1643
|
-
if (
|
|
1372
|
+
if (Option3.isSome(status)) {
|
|
1644
1373
|
switch (status.value) {
|
|
1645
1374
|
case "ok":
|
|
1646
1375
|
statusCode = 1;
|
|
@@ -1656,11 +1385,11 @@ var command3 = Command5.make(
|
|
|
1656
1385
|
}
|
|
1657
1386
|
}
|
|
1658
1387
|
const filters = {
|
|
1659
|
-
...
|
|
1660
|
-
...
|
|
1388
|
+
...Option3.isSome(trace) ? { traceId: trace.value } : {},
|
|
1389
|
+
...Option3.isSome(name) ? { name: name.value } : {},
|
|
1661
1390
|
...statusCode !== void 0 ? { status: statusCode } : {},
|
|
1662
|
-
...
|
|
1663
|
-
...
|
|
1391
|
+
...Option3.isSome(minDuration) ? { minDuration: parseDurationToNanos(minDuration.value) } : {},
|
|
1392
|
+
...Option3.isSome(limit) ? { limit: limit.value } : {}
|
|
1664
1393
|
};
|
|
1665
1394
|
const spans = yield* storage.getSpans(filters);
|
|
1666
1395
|
if (json) {
|
|
@@ -1745,7 +1474,7 @@ var command4 = Command5.make(
|
|
|
1745
1474
|
if (json) {
|
|
1746
1475
|
const buildJsonTree = (g, nodeIndex) => {
|
|
1747
1476
|
const spanOpt = Graph.getNode(g, nodeIndex);
|
|
1748
|
-
if (
|
|
1477
|
+
if (Option3.isNone(spanOpt)) return {};
|
|
1749
1478
|
const span = spanOpt.value;
|
|
1750
1479
|
const endTime = getEndTime(span);
|
|
1751
1480
|
const startTime = getStartTime(span);
|
|
@@ -1753,7 +1482,7 @@ var command4 = Command5.make(
|
|
|
1753
1482
|
const children = [];
|
|
1754
1483
|
for (const childIndex of Graph.neighbors(g, nodeIndex)) {
|
|
1755
1484
|
const childSpanOpt = Graph.getNode(g, childIndex);
|
|
1756
|
-
if (
|
|
1485
|
+
if (Option3.isSome(childSpanOpt)) {
|
|
1757
1486
|
children.push({ index: childIndex, span: childSpanOpt.value });
|
|
1758
1487
|
}
|
|
1759
1488
|
}
|
|
@@ -1774,7 +1503,6 @@ var command4 = Command5.make(
|
|
|
1774
1503
|
roots.sort((a, b) => Number(getStartTime(a.span) - getStartTime(b.span)));
|
|
1775
1504
|
const output = {
|
|
1776
1505
|
traceId,
|
|
1777
|
-
serviceName: traceSummary?.service_name ?? null,
|
|
1778
1506
|
startTime: traceSummary ? formatTimestamp(traceSummary.start_time) : null,
|
|
1779
1507
|
spanCount: spans.length,
|
|
1780
1508
|
spans: roots.map((r) => buildJsonTree(graph, r.index))
|
|
@@ -1783,7 +1511,6 @@ var command4 = Command5.make(
|
|
|
1783
1511
|
} else {
|
|
1784
1512
|
const header = [
|
|
1785
1513
|
field("Trace", traceId),
|
|
1786
|
-
field("Service", traceSummary?.service_name ?? "(unknown)"),
|
|
1787
1514
|
field("Started", traceSummary ? formatTimestamp(traceSummary.start_time) : "(unknown)"),
|
|
1788
1515
|
""
|
|
1789
1516
|
].join("\n");
|
|
@@ -1801,11 +1528,6 @@ var command5 = Command5.make(
|
|
|
1801
1528
|
data: dataOption,
|
|
1802
1529
|
json: jsonOption,
|
|
1803
1530
|
limit: limitOption,
|
|
1804
|
-
service: Flag3.string("service").pipe(
|
|
1805
|
-
Flag3.withAlias("s"),
|
|
1806
|
-
Flag3.withDescription("Filter by service name"),
|
|
1807
|
-
Flag3.optional
|
|
1808
|
-
),
|
|
1809
1531
|
since: Flag3.string("since").pipe(
|
|
1810
1532
|
Flag3.withDescription("Filter by time range (e.g., '1h', '30m')"),
|
|
1811
1533
|
Flag3.optional
|
|
@@ -1815,10 +1537,10 @@ var command5 = Command5.make(
|
|
|
1815
1537
|
Flag3.optional
|
|
1816
1538
|
)
|
|
1817
1539
|
},
|
|
1818
|
-
({ data, json, limit,
|
|
1540
|
+
({ data, json, limit, since, status }) => Effect8.gen(function* () {
|
|
1819
1541
|
const storage = yield* Storage;
|
|
1820
1542
|
let statusCode;
|
|
1821
|
-
if (
|
|
1543
|
+
if (Option3.isSome(status)) {
|
|
1822
1544
|
switch (status.value) {
|
|
1823
1545
|
case "ok":
|
|
1824
1546
|
statusCode = 1;
|
|
@@ -1834,23 +1556,21 @@ var command5 = Command5.make(
|
|
|
1834
1556
|
}
|
|
1835
1557
|
}
|
|
1836
1558
|
let sinceNanos;
|
|
1837
|
-
if (
|
|
1559
|
+
if (Option3.isSome(since)) {
|
|
1838
1560
|
const nowNanos = BigInt(Date.now()) * 1000000n;
|
|
1839
1561
|
const durationNanos = parseDurationToNanos(since.value);
|
|
1840
1562
|
sinceNanos = nowNanos - durationNanos;
|
|
1841
1563
|
}
|
|
1842
1564
|
const filters = {
|
|
1843
|
-
...Option4.isSome(service) ? { service: service.value } : {},
|
|
1844
1565
|
...statusCode !== void 0 ? { status: statusCode } : {},
|
|
1845
1566
|
...sinceNanos !== void 0 ? { since: sinceNanos } : {},
|
|
1846
|
-
...
|
|
1567
|
+
...Option3.isSome(limit) ? { limit: limit.value } : {}
|
|
1847
1568
|
};
|
|
1848
1569
|
const traces = yield* storage.getTraces(filters);
|
|
1849
1570
|
if (json) {
|
|
1850
1571
|
const output = traces.map((t) => ({
|
|
1851
1572
|
traceId: t.trace_id,
|
|
1852
1573
|
rootSpanName: t.root_span_name,
|
|
1853
|
-
serviceName: t.service_name,
|
|
1854
1574
|
spanCount: t.span_count,
|
|
1855
1575
|
status: t.status,
|
|
1856
1576
|
startTime: formatTimestamp(t.start_time),
|
|
@@ -1867,7 +1587,6 @@ var command5 = Command5.make(
|
|
|
1867
1587
|
return [
|
|
1868
1588
|
t.trace_id,
|
|
1869
1589
|
` ${field("Name", t.root_span_name ?? "(no root span)")}`,
|
|
1870
|
-
` ${field("Service", t.service_name ?? "(unknown)")}`,
|
|
1871
1590
|
` ${field("Spans", String(t.span_count))}`,
|
|
1872
1591
|
` ${field("Status", formatStatusDoc(t.status))}`,
|
|
1873
1592
|
` ${field("Started", formatTimestamp(t.start_time))}`,
|