visionary-sdk 1.0.1 → 1.1.0

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.
@@ -0,0 +1,193 @@
1
+ # frozen_string_literal: true
2
+
3
+ require "socket"
4
+
5
+ module Visionary
6
+ module Logs
7
+ # Decides and queues captured lines; nothing on a request path waits for the database.
8
+ class Pipeline
9
+ attr_reader :writer, :service
10
+
11
+ def initialize(cfg, instance, store, schemas, logger, writer: nil)
12
+ @cfg = cfg
13
+ @instance = instance
14
+ @logger = logger
15
+ @service = cfg.service.to_s
16
+ @base = Logs.parse_level(cfg.log_level)
17
+ @settings = Logs.defaults(@base)
18
+ @secrets = Logs.secret_keys(cfg.redact_fields)
19
+ @host = begin
20
+ Socket.gethostname
21
+ rescue StandardError
22
+ nil
23
+ end
24
+ @writer = writer || LogWriter.new(cfg, store, schemas, logger, self)
25
+ reset_rate
26
+ end
27
+
28
+ # Replaced whole by poll, so readers never see a half-updated one.
29
+ def settings = @settings
30
+
31
+ def settings=(s)
32
+ @settings = s
33
+ end
34
+
35
+ def start
36
+ @writer.start
37
+ self
38
+ end
39
+
40
+ def close(timeout) = @writer.close(timeout)
41
+
42
+ def after_fork
43
+ reset_rate
44
+ @writer.after_fork
45
+ end
46
+
47
+ # Keeps the previous values when the read fails (no server or table yet).
48
+ def poll(store)
49
+ @settings = Logs.parse_settings(store.rows(SETTINGS_SQL), @base)
50
+ @read_failed = false
51
+ rescue StandardError => e
52
+ unless @read_failed
53
+ @read_failed = true
54
+ @logger.debug("visionary: log settings unavailable (#{e.message.lines.first.to_s.strip}); using defaults") if @logger.respond_to?(:debug)
55
+ end
56
+ end
57
+
58
+ # nil while capture is off in the dashboard.
59
+ def lowest
60
+ s = @settings
61
+ s.enabled ? s.lowest(@service) : nil
62
+ end
63
+
64
+ # Inside a request a line may be held; outside it must reach the floor.
65
+ def wants?(sev, ctx = RequestContext.current)
66
+ s = @settings
67
+ return false unless s.enabled
68
+ ctx ? sev >= s.lowest(@service) : sev >= s.floor(@service, "", "")
69
+ end
70
+
71
+ # Never blocks.
72
+ def capture(rec, ctx = RequestContext.current)
73
+ s = @settings
74
+ # Skip the SDK's own messages, or a failed write's log line would queue behind it.
75
+ return if !s.enabled || rec.message.start_with?("visionary: ")
76
+ return if s.dropped?(@service, rec.logger, rec.message, rec.sev)
77
+
78
+ unless ctx
79
+ emit(rec) if rec.sev >= s.floor(@service, "", "", rec.at)
80
+ return
81
+ end
82
+ rec.request_id ||= ctx.request_id
83
+ rec.trace_id ||= ctx.trace_id
84
+ rec.user_id ||= blank(ctx.user[0])
85
+ return emit(rec) if rec.sev >= s.hold_below(@service, rec.at)
86
+ return if ctx.hold_log(rec, MAX_HELD)
87
+
88
+ # Logged after the request ended, so its route and user are known.
89
+ emit(rec) if rec.sev >= s.floor(@service, ctx.route, ctx.user[0], rec.at)
90
+ rescue StandardError
91
+ nil
92
+ end
93
+
94
+ def finish(ctx, route, failed, duration_ms)
95
+ lines = ctx.take_held_logs
96
+ return if lines.empty?
97
+
98
+ s = @settings
99
+ user = ctx.user[0]
100
+ floor = s.floor(@service, route, user)
101
+ keep_all = s.buffer && (failed || (s.slow_ms.positive? && duration_ms >= s.slow_ms))
102
+ lines.each do |r|
103
+ r.user_id ||= blank(user)
104
+ emit(r) if r.sev >= floor || (keep_all && r.sev >= s.buffer_level)
105
+ end
106
+ rescue StandardError
107
+ nil
108
+ end
109
+
110
+ # Errors and fatals get ten times the per-minute cap, so a flood of info lines never hides them.
111
+ def emit(rec)
112
+ rate = @settings.rate
113
+ if rate.positive?
114
+ minute = Time.now.to_i / 60
115
+ report = nil
116
+ over = @rate_mutex.synchronize do
117
+ if minute != @rate_minute
118
+ report = @rate_drop if @rate_drop.positive?
119
+ @rate_minute = minute
120
+ @rate_count = @rate_drop = 0
121
+ end
122
+ @rate_count += 1
123
+ (@rate_count > rate && (rec.sev < ERROR || @rate_count > 10 * rate)).tap { |o| @rate_drop += 1 if o }
124
+ end
125
+ if report
126
+ @writer.enqueue([:log, Record.new(Time.now, WARN, "visionary",
127
+ "visionary: #{report} log lines dropped over the cap of #{rate} a minute (Settings → Logs)")])
128
+ end
129
+ return if over
130
+ end
131
+ @writer.enqueue([:log, rec])
132
+ end
133
+
134
+ def row(rec)
135
+ msg = Logs.truncate(Logs.scrub(Visionary.utf8(rec.message)), MAX_MESSAGE)
136
+ attrs = rec.attrs && !rec.attrs.empty? ? Logs.encode_attrs(rec.attrs, @secrets) : nil
137
+ [
138
+ Visionary.timestamp(rec.at), @cfg.service, @instance, @cfg.version, "ruby", @host, nil,
139
+ Logs.name(rec.sev), rec.sev, blank(rec.logger), msg, attrs, blank(rec.request_id), blank(rec.trace_id),
140
+ blank(rec.span_id), blank(rec.user_id), blank(rec.session_id), blank(rec.file),
141
+ rec.line.to_i.positive? ? rec.line : nil, blank(rec.func), msg.bytesize + attrs.to_s.bytesize
142
+ ]
143
+ end
144
+
145
+ private
146
+
147
+ def reset_rate
148
+ @rate_mutex = Mutex.new
149
+ @rate_minute = 0
150
+ @rate_count = @rate_drop = 0
151
+ end
152
+
153
+ def blank(s)
154
+ s.nil? || s.to_s.empty? ? nil : s.to_s
155
+ end
156
+ end
157
+
158
+ # Its own thread and queue, so a flood of lines never crowds out request rows.
159
+ class LogWriter < Writer
160
+ def initialize(cfg, store, schemas, logger, pipeline)
161
+ super(cfg, store, schemas, logger)
162
+ @pipeline = pipeline
163
+ @groups = [:logs]
164
+ @queue_size = cfg.log_queue_size.to_i.positive? ? cfg.log_queue_size.to_i : QUEUE_SIZE
165
+ reset
166
+ end
167
+
168
+ private
169
+
170
+ def thread_name = "visionary-logs"
171
+
172
+ def tick
173
+ return if @next_poll && mono < @next_poll
174
+ @next_poll = mono + POLL_S
175
+ @pipeline.poll(@store)
176
+ end
177
+
178
+ def reset
179
+ super
180
+ @next_poll = nil
181
+ end
182
+
183
+ def report_drops
184
+ n = @queue.take_dropped
185
+ @logger.warn("visionary: log queue full; #{n} lines dropped") if n.positive?
186
+ end
187
+
188
+ def statements(_kind, rec, _users)
189
+ [stmt(:log, @pipeline.row(rec))]
190
+ end
191
+ end
192
+ end
193
+ end
@@ -0,0 +1,307 @@
1
+ # frozen_string_literal: true
2
+
3
+ require "json"
4
+ require "time"
5
+
6
+ module Visionary
7
+ # App logs (app_logs): the rules every SDK shares (sdks/go/logrules). What's kept
8
+ # follows Settings → Logs; logs/pipeline.rb and logs/logger.rb do the capturing.
9
+ module Logs
10
+ TRACE = 1
11
+ DEBUG = 2
12
+ INFO = 3
13
+ WARN = 4
14
+ ERROR = 5
15
+ FATAL = 6
16
+ NAMES = [nil, "trace", "debug", "info", "warn", "error", "fatal"].freeze
17
+
18
+ MAX_MESSAGE = 8 * 1024
19
+ MAX_ATTRS = 16 * 1024
20
+ MAX_VALUE = 1024
21
+ MAX_HELD = 500
22
+ QUEUE_SIZE = 10_000
23
+ POLL_S = 30
24
+ REDACTED = "[REDACTED]"
25
+ SETTINGS_SQL = "SELECT name, value FROM visionary_settings WHERE name LIKE 'logs.%'"
26
+ # Attributes with a column of their own; they are not repeated in attrs.
27
+ COLUMN_ATTRS = %w[request_id trace_id span_id user_id session_id logger].freeze
28
+
29
+ LEVELS = {}.tap do |h|
30
+ { TRACE => %w[trace trc finest finer verbose vrb], DEBUG => %w[debug dbg fine config],
31
+ INFO => %w[info inf information informational notice log], WARN => %w[warn warning wrn],
32
+ ERROR => %w[error err eror severe],
33
+ FATAL => %w[fatal critical crit alert emerg emergency panic ftl] }.each do |sev, names|
34
+ names.each { |n| h[n] = sev }
35
+ end
36
+ end.freeze
37
+
38
+ # Secrets in free text; every SDK uses the same patterns, in this order.
39
+ SECRET_PATTERNS = [
40
+ [/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z ]*PRIVATE KEY-----|\z)/, "[REDACTED:private-key]"],
41
+ [/\beyJ[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}/, "[REDACTED:jwt]"],
42
+ [%r{\b(bearer|basic)\s+[A-Za-z0-9._~+/=-]{8,}}i, '\1 [REDACTED]'],
43
+ [/\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/, "[REDACTED:aws-key]"],
44
+ [/\b(password|passwd|pwd|secret|token|api[_-]?key|access[_-]?token|refresh[_-]?token|client[_-]?secret)\b(["']?\s*[=:]\s*)("[^"]*"|'[^']*'|[^\s,;&"']+)/i,
45
+ '\1\2[REDACTED]']
46
+ ].freeze
47
+
48
+ LEVEL_FIELD = /\b(?:level|lvl|severity)=["']?([a-z]+)/i
49
+ TIMESTAMP = %r{\A[\[(]?[0-9][0-9/:.,\-TZ+]*[\])]?\z}
50
+
51
+ Record = Struct.new(:at, :sev, :logger, :message, :attrs, :request_id, :trace_id, :span_id, :user_id,
52
+ :session_id, :file, :line, :func)
53
+
54
+ # Changes the level for part of the traffic; until nil means no end.
55
+ Override = Struct.new(:service, :route, :user, :sev, :until) do
56
+ def active?(service, now)
57
+ return false if self.until && now > self.until
58
+ self.service.empty? || self.service == service.to_s
59
+ end
60
+
61
+ # One with neither route nor user applies to its whole service.
62
+ def matches?(route, user)
63
+ return false if !self.route.empty? && !Logs.route_matches?(self.route, route.to_s)
64
+ self.user.empty? || self.user == user.to_s
65
+ end
66
+
67
+ def scoped? = !route.empty? || !user.empty?
68
+ end
69
+
70
+ # Empty fields match anything; sev, when set, drops only lines at or below it.
71
+ Drop = Struct.new(:service, :logger, :contains, :sev)
72
+
73
+ Settings = Struct.new(:enabled, :level, :buffer, :buffer_level, :slow_ms, :rate, :overrides, :drops,
74
+ keyword_init: true) do
75
+ # Base level, then service-wide overrides, then the most specific match (user beats
76
+ # route); later overrides win ties.
77
+ def floor(service, route, user, now = Time.now)
78
+ level = self.level
79
+ rank = 0
80
+ overrides.each do |o|
81
+ next unless o.active?(service, now) && o.matches?(route, user)
82
+ r = o.user.empty? ? (o.route.empty? ? 1 : 2) : 3
83
+ next if r < rank
84
+ level = o.sev
85
+ rank = r
86
+ end
87
+ level
88
+ end
89
+
90
+ # Lines in a request below this are held until it ends, since an override may still keep them.
91
+ def hold_below(service, now = Time.now)
92
+ level = self.level
93
+ overrides.each { |o| level = o.sev if !o.scoped? && o.active?(service, now) }
94
+ overrides.each { |o| level = [level, o.sev].max if o.scoped? && o.active?(service, now) }
95
+ level
96
+ end
97
+
98
+ # The lowest level any line could be kept at now, for Logger#level.
99
+ def lowest(service, now = Time.now)
100
+ levels = [level]
101
+ levels << buffer_level if buffer
102
+ overrides.each { |o| levels << o.sev if o.active?(service, now) }
103
+ levels.min
104
+ end
105
+
106
+ def dropped?(service, logger, message, sev)
107
+ drops.any? do |d|
108
+ (d.service.empty? || d.service == service.to_s) &&
109
+ (d.logger.empty? || d.logger == logger.to_s) &&
110
+ (d.sev.zero? || sev <= d.sev) &&
111
+ (d.contains.empty? || message.to_s.include?(d.contains))
112
+ end
113
+ end
114
+ end
115
+
116
+ module_function
117
+
118
+ def parse_level(s)
119
+ LEVELS.fetch(s.to_s.strip.downcase, 0)
120
+ end
121
+
122
+ def name(sev) = sev.to_i.between?(TRACE, FATAL) ? NAMES[sev] : "info"
123
+
124
+ def defaults(level = 0)
125
+ Settings.new(enabled: true, level: level.to_i.positive? ? level : INFO, buffer: true, buffer_level: DEBUG,
126
+ slow_ms: 1000.0, rate: 6000, overrides: [], drops: [])
127
+ end
128
+
129
+ def parse_settings(rows, base = 0)
130
+ s = defaults(base)
131
+ rows.each do |name, value|
132
+ v = value.to_s.strip
133
+ case name.to_s
134
+ when "logs.enabled" then s.enabled = bool(v, s.enabled)
135
+ when "logs.level" then s.level = parse_level(v) if parse_level(v).positive?
136
+ when "logs.buffer" then s.buffer = bool(v, s.buffer)
137
+ when "logs.buffer_level" then s.buffer_level = parse_level(v) if parse_level(v).positive?
138
+ when "logs.slow_ms"
139
+ n = Float(v, exception: false)
140
+ s.slow_ms = n if n&.positive? && n.finite?
141
+ when "logs.rate"
142
+ n = Integer(v, 10, exception: false)
143
+ s.rate = n if n && n >= 0
144
+ when "logs.overrides" then s.overrides = json_list(v).filter_map { |o| override(o) }
145
+ when "logs.drop" then s.drops = json_list(v).filter_map { |d| drop(d) }
146
+ end
147
+ end
148
+ s
149
+ end
150
+
151
+ def bool(v, default)
152
+ case v.downcase
153
+ when "true", "1", "t" then true
154
+ when "false", "0", "f" then false
155
+ else default
156
+ end
157
+ end
158
+
159
+ def json_list(v)
160
+ list = JSON.parse(v)
161
+ list.is_a?(Array) ? list.select { |x| x.is_a?(Hash) } : []
162
+ rescue JSON::ParserError
163
+ []
164
+ end
165
+
166
+ def override(h)
167
+ sev = parse_level(h["level"])
168
+ return nil if sev.zero?
169
+ until_s = h["until"].to_s.strip
170
+ until_t = nil
171
+ unless until_s.empty?
172
+ until_t = parse_time(until_s)
173
+ return nil unless until_t
174
+ end
175
+ Override.new(h["service"].to_s, h["route"].to_s, h["user"].to_s, sev, until_t)
176
+ end
177
+
178
+ def drop(h)
179
+ d = Drop.new(h["service"].to_s, h["logger"].to_s, h["contains"].to_s, parse_level(h["level"]))
180
+ return nil if d.service.empty? && d.logger.empty? && d.contains.empty? && d.sev.zero?
181
+ d
182
+ end
183
+
184
+ # Formats Visionary writes; no zone means UTC.
185
+ def parse_time(s)
186
+ Profiler.parse_time(s) || Time.iso8601(s)
187
+ rescue ArgumentError
188
+ nil
189
+ end
190
+
191
+ def route_matches?(pattern, route)
192
+ pattern.end_with?("*") ? route.start_with?(pattern.chomp("*")) : pattern == route
193
+ end
194
+
195
+ # The level a line states at its start ("ERROR ...", "[warn] ...", "2026-10-28 09:30:12 WARN ...",
196
+ # level=debug in the first 200 bytes); 0 if none. A bare lower-case word isn't a level.
197
+ def text_level(s)
198
+ head = Visionary.utf8(s).byteslice(0, 200).scrub("")
199
+ if (m = LEVEL_FIELD.match(head)) && (n = parse_level(m[1])).positive?
200
+ return n
201
+ end
202
+ head.split.each_with_index do |f, i|
203
+ break if i > 3
204
+ next if TIMESTAMP.match?(f)
205
+ word = f.gsub(/\A[\[\]<>():|]+|[\[\]<>():|]+\z/, "")
206
+ n = parse_level(word)
207
+ return 0 if n.zero?
208
+ marked = f.start_with?("[", "<", "(") || f.end_with?(":", "]", "|")
209
+ return marked || word == word.upcase ? n : 0
210
+ end
211
+ 0
212
+ end
213
+
214
+ def strip_level_word(s, sev)
215
+ i = s.index(" ")
216
+ return s unless i
217
+ word = s[0, i]
218
+ rest = s[(i + 1)..]
219
+ return s if rest.strip.empty? || word != word.upcase
220
+ w = word.chomp(":").downcase
221
+ w == name(sev) || w == "warning" ? rest : s
222
+ end
223
+
224
+ def scrub(s)
225
+ SECRET_PATTERNS.each do |re, with|
226
+ s = s.gsub(re, with) if re.match?(s)
227
+ end
228
+ s
229
+ end
230
+
231
+ def secret_keys(extra = [])
232
+ (Redactor::DEFAULT_FIELDS + Array(extra)).map { |f| f.to_s.strip.downcase }.reject(&:empty?).to_h { |f| [f, true] }
233
+ end
234
+
235
+ # attrs as flat JSON with secrets redacted, capped at MAX_ATTRS: long values are cut
236
+ # first, then keys dropped in sorted order.
237
+ def encode_attrs(attrs, secret)
238
+ out = {}
239
+ attrs.each do |k, v|
240
+ out[k] = if secret[k.split(".").last.to_s.downcase]
241
+ REDACTED
242
+ elsif v.is_a?(String)
243
+ scrub(v)
244
+ else
245
+ v
246
+ end
247
+ end
248
+ s = JSON.generate(out)
249
+ return s if s.bytesize <= MAX_ATTRS
250
+
251
+ out.each { |k, v| out[k] = "#{truncate(v, MAX_VALUE)}…" if v.is_a?(String) && v.bytesize > MAX_VALUE }
252
+ s = JSON.generate(out)
253
+ return s if s.bytesize <= MAX_ATTRS
254
+
255
+ kept = { "_truncated" => true }
256
+ out.keys.sort.each do |k|
257
+ kept[k] = out[k]
258
+ next if JSON.generate(kept).bytesize <= MAX_ATTRS
259
+ kept.delete(k)
260
+ break
261
+ end
262
+ JSON.generate(kept)
263
+ end
264
+
265
+ def truncate(s, n)
266
+ s.bytesize <= n ? s : s.byteslice(0, n).scrub("")
267
+ end
268
+
269
+ def flatten(hash, prefix = "", out = {})
270
+ hash.each do |k, v|
271
+ key = "#{prefix}#{k}"
272
+ if v.is_a?(Hash)
273
+ flatten(v, "#{key}.", out)
274
+ elsif !v.nil?
275
+ out[key] = value(v)
276
+ end
277
+ end
278
+ out
279
+ end
280
+
281
+ def value(v)
282
+ case v
283
+ when String then Visionary.utf8(v)
284
+ when Integer, true, false then v
285
+ when Float then v.finite? ? v : v.to_s
286
+ when Time then v.getutc.iso8601(6)
287
+ when Symbol then v.to_s
288
+ else
289
+ v = v.iso8601 if v.respond_to?(:iso8601) && !v.is_a?(Numeric)
290
+ Visionary.utf8(v.to_s)
291
+ end
292
+ rescue StandardError
293
+ "?"
294
+ end
295
+
296
+ # The trace id of a traceparent header; nil when malformed or all zeros.
297
+ def trace_parent_id(header)
298
+ parts = header.to_s.strip.split("-")
299
+ return nil if parts.size < 4
300
+ id = parts[1]
301
+ id.match?(/\A[0-9a-f]{32}\z/) && id.match?(/[1-9a-f]/) ? id : nil
302
+ end
303
+ end
304
+ end
305
+
306
+ require_relative "logs/pipeline"
307
+ require_relative "logs/logger"
@@ -106,7 +106,8 @@ module Visionary
106
106
 
107
107
  ctx = RequestContext.new(
108
108
  request_id: request_id, method: env["REQUEST_METHOD"].to_s, path: path, started_at: started_at,
109
- started_mono: t0, span_max: cfg.span_max.to_i, db_visible: Telemetry::ActiveRecordHook.installed?
109
+ started_mono: t0, span_max: cfg.span_max.to_i, db_visible: Telemetry::ActiveRecordHook.installed?,
110
+ trace_id: Logs.trace_parent_id(env["HTTP_TRACEPARENT"])
110
111
  )
111
112
  agent.http.started
112
113
  Profiler::Tally.started!
@@ -115,6 +116,7 @@ module Visionary
115
116
  begin
116
117
  status, res_headers, body = @app.call(env)
117
118
  rescue Exception => e # re-raised below; the app's handling is unchanged
119
+ ctx.failed!
118
120
  agent.telemetry&.exception(e, handled: false, ctx: ctx)
119
121
  finish(agent, env, ctx, headers, req_capture, 500, nil, Capture.new(0, false), t0)
120
122
  raise
@@ -145,6 +147,8 @@ module Visionary
145
147
  duration = (Telemetry.now_ms - t0).round(3)
146
148
  route = ctx.route
147
149
  route = agent.route_for(env) if route.empty?
150
+ ctx.route = route # for log lines from work the request left running
151
+ agent.logs&.finish(ctx, route, status >= 500 || ctx.failed?, duration)
148
152
  Profiler::Tally.finished(ctx.method, route.empty? ? ctx.path : route, duration)
149
153
  user_id, handle, role = ctx.user
150
154
  tel = agent.telemetry
@@ -0,0 +1,31 @@
1
+ CREATE TABLE IF NOT EXISTS app_logs (
2
+ id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
3
+ created_at VARCHAR(32) NOT NULL,
4
+ service VARCHAR(255),
5
+ instance VARCHAR(255),
6
+ version VARCHAR(255),
7
+ source VARCHAR(32) NOT NULL,
8
+ host VARCHAR(255),
9
+ container VARCHAR(255),
10
+ level VARCHAR(8) NOT NULL,
11
+ severity INT NOT NULL,
12
+ logger VARCHAR(255),
13
+ message TEXT NOT NULL,
14
+ attrs MEDIUMTEXT,
15
+ request_id VARCHAR(255),
16
+ trace_id VARCHAR(64),
17
+ span_id VARCHAR(32),
18
+ user_id VARCHAR(255),
19
+ session_id VARCHAR(255),
20
+ code_file VARCHAR(512),
21
+ code_line INT,
22
+ code_func VARCHAR(255),
23
+ pattern VARCHAR(16),
24
+ size INT NOT NULL DEFAULT 0
25
+ ) CHARACTER SET utf8mb4;
26
+ CREATE INDEX idx_app_logs_created_at ON app_logs (created_at);
27
+ CREATE INDEX idx_app_logs_service_created_at ON app_logs (service, created_at);
28
+ CREATE INDEX idx_app_logs_severity_created_at ON app_logs (severity, created_at);
29
+ CREATE INDEX idx_app_logs_request_id ON app_logs (request_id);
30
+ CREATE INDEX idx_app_logs_trace_id ON app_logs (trace_id);
31
+ CREATE INDEX idx_app_logs_pattern_created_at ON app_logs (pattern, created_at);
@@ -0,0 +1,31 @@
1
+ CREATE TABLE IF NOT EXISTS app_logs (
2
+ id BIGSERIAL PRIMARY KEY,
3
+ created_at TEXT NOT NULL,
4
+ service TEXT,
5
+ instance TEXT,
6
+ version TEXT,
7
+ source TEXT NOT NULL,
8
+ host TEXT,
9
+ container TEXT,
10
+ level TEXT NOT NULL,
11
+ severity INTEGER NOT NULL,
12
+ logger TEXT,
13
+ message TEXT NOT NULL,
14
+ attrs TEXT,
15
+ request_id TEXT,
16
+ trace_id TEXT,
17
+ span_id TEXT,
18
+ user_id TEXT,
19
+ session_id TEXT,
20
+ code_file TEXT,
21
+ code_line INTEGER,
22
+ code_func TEXT,
23
+ pattern TEXT,
24
+ size INTEGER NOT NULL DEFAULT 0
25
+ );
26
+ CREATE INDEX IF NOT EXISTS idx_app_logs_created_at ON app_logs (created_at);
27
+ CREATE INDEX IF NOT EXISTS idx_app_logs_service_created_at ON app_logs (service, created_at);
28
+ CREATE INDEX IF NOT EXISTS idx_app_logs_severity_created_at ON app_logs (severity, created_at);
29
+ CREATE INDEX IF NOT EXISTS idx_app_logs_request_id ON app_logs (request_id);
30
+ CREATE INDEX IF NOT EXISTS idx_app_logs_trace_id ON app_logs (trace_id);
31
+ CREATE INDEX IF NOT EXISTS idx_app_logs_pattern_created_at ON app_logs (pattern, created_at);
@@ -0,0 +1,31 @@
1
+ CREATE TABLE IF NOT EXISTS app_logs (
2
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
3
+ created_at TEXT NOT NULL,
4
+ service TEXT,
5
+ instance TEXT,
6
+ version TEXT,
7
+ source TEXT NOT NULL,
8
+ host TEXT,
9
+ container TEXT,
10
+ level TEXT NOT NULL,
11
+ severity INTEGER NOT NULL,
12
+ logger TEXT,
13
+ message TEXT NOT NULL,
14
+ attrs TEXT,
15
+ request_id TEXT,
16
+ trace_id TEXT,
17
+ span_id TEXT,
18
+ user_id TEXT,
19
+ session_id TEXT,
20
+ code_file TEXT,
21
+ code_line INTEGER,
22
+ code_func TEXT,
23
+ pattern TEXT,
24
+ size INTEGER NOT NULL DEFAULT 0
25
+ );
26
+ CREATE INDEX IF NOT EXISTS idx_app_logs_created_at ON app_logs (created_at);
27
+ CREATE INDEX IF NOT EXISTS idx_app_logs_service_created_at ON app_logs (service, created_at);
28
+ CREATE INDEX IF NOT EXISTS idx_app_logs_severity_created_at ON app_logs (severity, created_at);
29
+ CREATE INDEX IF NOT EXISTS idx_app_logs_request_id ON app_logs (request_id);
30
+ CREATE INDEX IF NOT EXISTS idx_app_logs_trace_id ON app_logs (trace_id);
31
+ CREATE INDEX IF NOT EXISTS idx_app_logs_pattern_created_at ON app_logs (pattern, created_at);
@@ -68,20 +68,28 @@ module Visionary
68
68
  # Created by the Visionary server, never by the SDK.
69
69
  PROFILE_COLUMNS = %w[created_at service instance version sdk duration_ms samples routes folded].freeze
70
70
 
71
+ LOG_COLUMNS = %w[
72
+ created_at service instance version source host container level severity logger
73
+ message attrs request_id trace_id span_id user_id session_id code_file code_line
74
+ code_func size
75
+ ].freeze
76
+
71
77
  TABLES = {
72
78
  "api_logs" => REQUEST_COLUMNS + ADDED_REQUEST_COLUMNS.map(&:first),
73
79
  "system_metrics" => SYSTEM_BASE_COLUMNS + ADDED_SYSTEM_COLUMNS.map(&:first),
74
80
  "spans" => SPAN_COLUMNS,
75
81
  "errors" => ERROR_COLUMNS,
76
82
  "releases" => RELEASE_COLUMNS,
77
- "profiles" => PROFILE_COLUMNS
83
+ "profiles" => PROFILE_COLUMNS,
84
+ "app_logs" => LOG_COLUMNS
78
85
  }.freeze
79
86
 
80
87
  # Which script creates a table, and the columns older copies may lack.
81
88
  GROUPS = {
82
89
  requests: { file: "requests.sql", table: "api_logs", added: ADDED_REQUEST_COLUMNS },
83
90
  system: { file: "system.sql", table: "system_metrics", added: ADDED_SYSTEM_COLUMNS },
84
- telemetry: { file: "telemetry.sql", table: nil, added: [] }
91
+ telemetry: { file: "telemetry.sql", table: nil, added: [] },
92
+ logs: { file: "logs.sql", table: "app_logs", added: [] }
85
93
  }.freeze
86
94
 
87
95
  PURGE_CHUNK = 5000
@@ -1,5 +1,5 @@
1
1
  # frozen_string_literal: true
2
2
 
3
3
  module Visionary
4
- VERSION = "1.0.1"
4
+ VERSION = "1.1.0"
5
5
  end