visionary-sdk 1.0.1 → 1.1.1
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.
- checksums.yaml +4 -4
- data/CHANGELOG.md +12 -0
- data/README.md +56 -4
- data/lib/visionary/agent.rb +7 -2
- data/lib/visionary/config.rb +8 -1
- data/lib/visionary/context.rb +33 -3
- data/lib/visionary/logs/logger.rb +274 -0
- data/lib/visionary/logs/pipeline.rb +193 -0
- data/lib/visionary/logs.rb +307 -0
- data/lib/visionary/middleware.rb +5 -1
- data/lib/visionary/schema/mysql/logs.sql +31 -0
- data/lib/visionary/schema/postgres/logs.sql +31 -0
- data/lib/visionary/schema/sqlite/logs.sql +31 -0
- data/lib/visionary/schema.rb +10 -2
- data/lib/visionary/version.rb +1 -1
- data/lib/visionary/writer.rb +10 -2
- data/lib/visionary.rb +35 -2
- metadata +8 -2
|
@@ -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"
|
data/lib/visionary/middleware.rb
CHANGED
|
@@ -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);
|
data/lib/visionary/schema.rb
CHANGED
|
@@ -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
|
data/lib/visionary/version.rb
CHANGED