graftcode-telemetry-datadog 1.0.5
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 +7 -0
- data/README.md +88 -0
- data/lib/graftcode/telemetry/datadog/call_flusher.rb +27 -0
- data/lib/graftcode/telemetry/datadog/connector.rb +53 -0
- data/lib/graftcode/telemetry/datadog/logger.rb +110 -0
- data/lib/graftcode/telemetry/datadog/message_template.rb +103 -0
- data/lib/graftcode/telemetry/datadog/options.rb +69 -0
- data/lib/graftcode/telemetry/datadog/pipeline.rb +143 -0
- data/lib/graftcode/telemetry/datadog/request_telemetry_middleware.rb +135 -0
- data/lib/graftcode/telemetry/datadog/version.rb +9 -0
- data/lib/graftcode/telemetry/datadog.rb +10 -0
- metadata +205 -0
checksums.yaml
ADDED
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
---
|
|
2
|
+
SHA256:
|
|
3
|
+
metadata.gz: c41d71d26873bc946f026d203b70eca55572f30a9b7b4f69c88009d6655ba293
|
|
4
|
+
data.tar.gz: cf8833c79fc7205bd5137e5d4eeae679aa571f6d543516d64f20cd9b73bac176
|
|
5
|
+
SHA512:
|
|
6
|
+
metadata.gz: 134f0670e2aeb3f67232df0f9a2d1e88916c914dda9dc082c8783d0a05c9c1f0c9187b90f69837904b88592c309f1452d6b4efda469cf5663644f4591d04e4f4
|
|
7
|
+
data.tar.gz: 15b4ac0a0c5444436655ccb15c08c723d15d909aaa030f98ae2bbf820811ecf598fb0ef80868bd47ffcc04e02faf11728128809fcd19d8ff41119f672e060920
|
data/README.md
ADDED
|
@@ -0,0 +1,88 @@
|
|
|
1
|
+
# graftcode-telemetry-datadog (Ruby)
|
|
2
|
+
|
|
3
|
+
Configure Datadog traces, logs, and Graft bridge spans for a Ruby service with one call:
|
|
4
|
+
|
|
5
|
+
```ruby
|
|
6
|
+
require 'graftcode/telemetry/datadog'
|
|
7
|
+
|
|
8
|
+
telemetry = Graftcode::Telemetry::Datadog::GraftCodeDatadogConnector.start('MyService')
|
|
9
|
+
|
|
10
|
+
telemetry.in_span('MyOperation') do
|
|
11
|
+
telemetry.logger.info('My operation started Input={Input}', input)
|
|
12
|
+
end
|
|
13
|
+
```
|
|
14
|
+
|
|
15
|
+
The connector sends OTLP/HTTP to the Datadog Agent's OTLP receiver. It uses the public OpenTelemetry Ruby SDK and exporters, not `datadog` (dd-trace-rb). dd-trace-rb does not support Windows and does not export logs, and Graftcode-hosted Ruby libraries run on Windows.
|
|
16
|
+
|
|
17
|
+
## Datadog Agent
|
|
18
|
+
|
|
19
|
+
Enable OTLP ingestion on the Agent (7.48 or later; logs need `DD_LOGS_ENABLED=true`):
|
|
20
|
+
|
|
21
|
+
```yaml
|
|
22
|
+
DD_OTLP_CONFIG_RECEIVER_PROTOCOLS_HTTP_ENDPOINT: "0.0.0.0:4318"
|
|
23
|
+
DD_OTLP_CONFIG_LOGS_ENABLED: "true"
|
|
24
|
+
```
|
|
25
|
+
|
|
26
|
+
Publish port `4318`. A containerized Agent 7.61 or later also needs `HOST_PROC: /proc`. Without it the OTLP pipeline fails with `failed to register process metrics`.
|
|
27
|
+
|
|
28
|
+
## Options (`GraftCodeDatadogConnectorOptions`)
|
|
29
|
+
|
|
30
|
+
```ruby
|
|
31
|
+
GraftCodeDatadogConnector.start('MyService') do |options|
|
|
32
|
+
options.environment = 'staging'
|
|
33
|
+
options.minimum_log_level = 'debug'
|
|
34
|
+
end
|
|
35
|
+
```
|
|
36
|
+
|
|
37
|
+
| Option | Default |
|
|
38
|
+
|--------|---------|
|
|
39
|
+
| `service_name` | Required; becomes the Datadog `service`. |
|
|
40
|
+
| `endpoint` | `OTEL_EXPORTER_OTLP_ENDPOINT`, then `http://127.0.0.1:4318`. |
|
|
41
|
+
| `environment` | `DD_ENV`; exported as `deployment.environment.name` (Datadog `env`). |
|
|
42
|
+
| `version` | `DD_VERSION`; exported as `service.version`. |
|
|
43
|
+
| `minimum_log_level` | `info`. Applies to app logs and forwarded Hypertube logs. |
|
|
44
|
+
| `enable_console_logging` | `true`. Also writes app logs to stdout. |
|
|
45
|
+
| `flush_after_calls` | Detected; see [Hosted libraries](#hosted-libraries). |
|
|
46
|
+
|
|
47
|
+
`start` is single-process. A second call with the same service name returns the running pipeline, and a different name raises `ArgumentError`.
|
|
48
|
+
|
|
49
|
+
## Pipeline (`GraftCodeDatadogConnectorPipeline`)
|
|
50
|
+
|
|
51
|
+
| Member | Description |
|
|
52
|
+
|--------|-------------|
|
|
53
|
+
| `tracer` | OpenTelemetry tracer for the service. |
|
|
54
|
+
| `in_span(name, kind:, attributes:)` | Runs a block in a new current span. |
|
|
55
|
+
| `logger` | `trace`, `debug`, `info`, `warning`/`warn`, `error`. Takes message templates (`{Name}` placeholders, filled by position) and `exception:`. Records carry the current trace and span IDs. |
|
|
56
|
+
| `flush(timeout = 5)` | Exports buffered traces and logs; returns `true` on success. |
|
|
57
|
+
| `close` / `shutdown` | Flushes and stops; safe to call more than once and also runs at exit. |
|
|
58
|
+
|
|
59
|
+
The pipeline also sets the global tracer provider, logger provider, and W3C trace context propagator, then attaches `graftcode-instrumentation` with its logger provider. Hypertube's own logs (`Hypertube invoking/completed/handling/handled ...`) are therefore exported as log records at `minimum_log_level`, in the same trace as the call.
|
|
60
|
+
|
|
61
|
+
## Rack request telemetry
|
|
62
|
+
|
|
63
|
+
```ruby
|
|
64
|
+
# config.ru
|
|
65
|
+
use Graftcode::Telemetry::Datadog::GraftCodeDatadogRequestTelemetryMiddleware, telemetry: Telemetry.pipeline
|
|
66
|
+
run MyApp
|
|
67
|
+
```
|
|
68
|
+
|
|
69
|
+
Each request gets a server span, continuing an incoming `traceparent`. The span is named `{service}.{controller}` when a controller is known, for example `TestGgRubyWebApi.Fetch`. The controller comes from `env['graft.controller']` or, in Rails, from the controller class without its `Controller` suffix. Without a controller the name is `{service} {METHOD} {route}`, where the route is taken from Sinatra's route template when present. The name is also set as `resource.name`, which Datadog uses as the resource. Responses with status 500 or higher, and raised exceptions, mark the span as an error.
|
|
70
|
+
|
|
71
|
+
## Hosted libraries
|
|
72
|
+
|
|
73
|
+
The Hypertube native launcher keeps the Ruby GVL while it waits for the next command. In a library hosted by Graftcode Gateway, the batch exporters' background threads therefore never run, and telemetry would only be sent at exit. The connector detects a hosted runtime (its Hypertube receiver is loaded from the gateway's `Binaries/Ruby` folder) and then flushes on the handling thread after every Graft call. Set `flush_after_calls` to force this on or off.
|
|
74
|
+
|
|
75
|
+
## Development
|
|
76
|
+
|
|
77
|
+
```powershell
|
|
78
|
+
bundle install
|
|
79
|
+
bundle exec rspec
|
|
80
|
+
```
|
|
81
|
+
|
|
82
|
+
Dependencies are declared in `graftcode-telemetry-datadog.gemspec`. From this monorepo, point Bundler at the local instrumentation gem before `bundle install`:
|
|
83
|
+
|
|
84
|
+
```powershell
|
|
85
|
+
bundle config set --local local.graftcode-instrumentation ../../../Instrumentation/ruby
|
|
86
|
+
```
|
|
87
|
+
|
|
88
|
+
For an unreleased `hypertube-ruby-sdk`, see [instrumentation development](../../../Instrumentation/ruby/README.md#development).
|
|
@@ -0,0 +1,27 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
require 'graftcode/instrumentation'
|
|
4
|
+
|
|
5
|
+
module Graftcode
|
|
6
|
+
module Telemetry
|
|
7
|
+
module Datadog
|
|
8
|
+
class CallFlusher
|
|
9
|
+
include Hypertube::Utils::Abstractions::IHypertubeHandling
|
|
10
|
+
|
|
11
|
+
def initialize(pipeline)
|
|
12
|
+
@pipeline = pipeline
|
|
13
|
+
end
|
|
14
|
+
|
|
15
|
+
def on_process(_context, _command); end
|
|
16
|
+
|
|
17
|
+
def on_processed(_context, _response)
|
|
18
|
+
@pipeline.flush
|
|
19
|
+
end
|
|
20
|
+
|
|
21
|
+
def on_handling_error(_context, _exception)
|
|
22
|
+
@pipeline.flush
|
|
23
|
+
end
|
|
24
|
+
end
|
|
25
|
+
end
|
|
26
|
+
end
|
|
27
|
+
end
|
|
@@ -0,0 +1,53 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
require_relative 'options'
|
|
4
|
+
require_relative 'pipeline'
|
|
5
|
+
|
|
6
|
+
module Graftcode
|
|
7
|
+
module Telemetry
|
|
8
|
+
module Datadog
|
|
9
|
+
module GraftCodeDatadogConnector
|
|
10
|
+
@active = nil
|
|
11
|
+
@active_mutex = Mutex.new
|
|
12
|
+
|
|
13
|
+
module_function
|
|
14
|
+
|
|
15
|
+
def start(service_name = nil, options: nil, **exporters)
|
|
16
|
+
options = prepare_options(service_name, options)
|
|
17
|
+
yield options if block_given?
|
|
18
|
+
activate_pipeline(options, **exporters)
|
|
19
|
+
end
|
|
20
|
+
|
|
21
|
+
def active
|
|
22
|
+
@active_mutex.synchronize { @active }
|
|
23
|
+
end
|
|
24
|
+
|
|
25
|
+
def prepare_options(service_name, options)
|
|
26
|
+
options ||= GraftCodeDatadogConnectorOptions.new
|
|
27
|
+
options.service_name = service_name unless service_name.nil?
|
|
28
|
+
options
|
|
29
|
+
end
|
|
30
|
+
|
|
31
|
+
def activate_pipeline(options, **exporters)
|
|
32
|
+
@active_mutex.synchronize do
|
|
33
|
+
return resolve_existing_active(options) unless @active.nil?
|
|
34
|
+
|
|
35
|
+
@active = create_pipeline(options, **exporters)
|
|
36
|
+
end
|
|
37
|
+
end
|
|
38
|
+
|
|
39
|
+
def resolve_existing_active(options)
|
|
40
|
+
return @active if @active.service_name == options.service_name.to_s.strip
|
|
41
|
+
|
|
42
|
+
raise ArgumentError, "GraftCode Datadog telemetry is already started for #{@active.service_name}"
|
|
43
|
+
end
|
|
44
|
+
|
|
45
|
+
def create_pipeline(options, **exporters)
|
|
46
|
+
GraftCodeDatadogConnectorPipeline.new(options, **exporters) do |pipeline|
|
|
47
|
+
@active_mutex.synchronize { @active = nil if @active.equal?(pipeline) }
|
|
48
|
+
end
|
|
49
|
+
end
|
|
50
|
+
end
|
|
51
|
+
end
|
|
52
|
+
end
|
|
53
|
+
end
|
|
@@ -0,0 +1,110 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
require 'opentelemetry-logs-sdk'
|
|
4
|
+
require 'graftcode/instrumentation'
|
|
5
|
+
require_relative 'message_template'
|
|
6
|
+
|
|
7
|
+
module Graftcode
|
|
8
|
+
module Telemetry
|
|
9
|
+
module Datadog
|
|
10
|
+
class GraftCodeDatadogLogger
|
|
11
|
+
LogsLevel = Hypertube::Utils::Logging::LogsLevel
|
|
12
|
+
SeverityNumber = OpenTelemetry::Logs::SeverityNumber
|
|
13
|
+
|
|
14
|
+
CONSOLE_INDENT = ' '
|
|
15
|
+
ORIGINAL_FORMAT = '{OriginalFormat}'
|
|
16
|
+
|
|
17
|
+
SEVERITY = {
|
|
18
|
+
LogsLevel::TRACE => [SeverityNumber::SEVERITY_NUMBER_TRACE, 'trace', 'trce'],
|
|
19
|
+
LogsLevel::DEBUG => [SeverityNumber::SEVERITY_NUMBER_DEBUG, 'debug', 'dbug'],
|
|
20
|
+
LogsLevel::INFO => [SeverityNumber::SEVERITY_NUMBER_INFO, 'info', 'info'],
|
|
21
|
+
LogsLevel::WARNING => [SeverityNumber::SEVERITY_NUMBER_WARN, 'warn', 'warn'],
|
|
22
|
+
LogsLevel::ERROR => [SeverityNumber::SEVERITY_NUMBER_ERROR, 'error', 'fail']
|
|
23
|
+
}.freeze
|
|
24
|
+
|
|
25
|
+
attr_reader :category, :minimum_level
|
|
26
|
+
|
|
27
|
+
def initialize(category, otel_logger, minimum_level, console)
|
|
28
|
+
@category = category
|
|
29
|
+
@otel_logger = otel_logger
|
|
30
|
+
@minimum_level = minimum_level
|
|
31
|
+
@console = console
|
|
32
|
+
@console_mutex = Mutex.new
|
|
33
|
+
end
|
|
34
|
+
|
|
35
|
+
def enabled?(level)
|
|
36
|
+
level != LogsLevel::OFF && minimum_level != LogsLevel::OFF && LogsLevel.at_least?(level, minimum_level)
|
|
37
|
+
end
|
|
38
|
+
|
|
39
|
+
def trace(template, *args, exception: nil)
|
|
40
|
+
log(LogsLevel::TRACE, template, *args, exception: exception)
|
|
41
|
+
end
|
|
42
|
+
|
|
43
|
+
def debug(template, *args, exception: nil)
|
|
44
|
+
log(LogsLevel::DEBUG, template, *args, exception: exception)
|
|
45
|
+
end
|
|
46
|
+
|
|
47
|
+
def info(template, *args, exception: nil)
|
|
48
|
+
log(LogsLevel::INFO, template, *args, exception: exception)
|
|
49
|
+
end
|
|
50
|
+
|
|
51
|
+
def warning(template, *args, exception: nil)
|
|
52
|
+
log(LogsLevel::WARNING, template, *args, exception: exception)
|
|
53
|
+
end
|
|
54
|
+
alias warn warning
|
|
55
|
+
|
|
56
|
+
def error(template, *args, exception: nil)
|
|
57
|
+
log(LogsLevel::ERROR, template, *args, exception: exception)
|
|
58
|
+
end
|
|
59
|
+
|
|
60
|
+
def log(level, template, *args, exception: nil)
|
|
61
|
+
return unless enabled?(level)
|
|
62
|
+
|
|
63
|
+
properties = {}
|
|
64
|
+
message = MessageTemplate.render(template, args, properties)
|
|
65
|
+
|
|
66
|
+
emit(level, template, message, properties, exception)
|
|
67
|
+
write_to_console(level, message, exception)
|
|
68
|
+
end
|
|
69
|
+
|
|
70
|
+
private
|
|
71
|
+
|
|
72
|
+
def emit(level, template, message, properties, exception)
|
|
73
|
+
severity_number, severity_text, = SEVERITY.fetch(level)
|
|
74
|
+
@otel_logger.on_emit(
|
|
75
|
+
timestamp: Time.now,
|
|
76
|
+
severity_number: severity_number,
|
|
77
|
+
severity_text: severity_text,
|
|
78
|
+
body: message,
|
|
79
|
+
attributes: emit_attributes(template, properties, exception),
|
|
80
|
+
context: OpenTelemetry::Context.current
|
|
81
|
+
)
|
|
82
|
+
end
|
|
83
|
+
|
|
84
|
+
def emit_attributes(template, properties, exception)
|
|
85
|
+
attributes = properties.dup
|
|
86
|
+
attributes[ORIGINAL_FORMAT] = template unless template.nil?
|
|
87
|
+
merge_exception_attributes!(attributes, exception)
|
|
88
|
+
attributes
|
|
89
|
+
end
|
|
90
|
+
|
|
91
|
+
def merge_exception_attributes!(attributes, exception)
|
|
92
|
+
return if exception.nil?
|
|
93
|
+
|
|
94
|
+
attributes['exception.type'] = exception.class.name
|
|
95
|
+
attributes['exception.message'] = exception.message unless exception.message.nil?
|
|
96
|
+
attributes['exception.stacktrace'] = exception.full_message(highlight: false)
|
|
97
|
+
end
|
|
98
|
+
|
|
99
|
+
def write_to_console(level, message, exception)
|
|
100
|
+
return if @console.nil?
|
|
101
|
+
|
|
102
|
+
line = "#{SEVERITY.fetch(level)[2]}: #{category}[0]\n#{CONSOLE_INDENT}#{message}"
|
|
103
|
+
line << "\n#{exception.full_message(highlight: false).strip}" unless exception.nil?
|
|
104
|
+
|
|
105
|
+
@console_mutex.synchronize { @console.puts(line) }
|
|
106
|
+
end
|
|
107
|
+
end
|
|
108
|
+
end
|
|
109
|
+
end
|
|
110
|
+
end
|
|
@@ -0,0 +1,103 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
module Graftcode
|
|
4
|
+
module Telemetry
|
|
5
|
+
module Datadog
|
|
6
|
+
module MessageTemplate
|
|
7
|
+
NULL_VALUE = '(null)'
|
|
8
|
+
|
|
9
|
+
RenderState = Struct.new(:template, :arguments, :properties, :builder, :arg_index, :index,
|
|
10
|
+
keyword_init: true) do
|
|
11
|
+
def initialize(template, arguments, properties)
|
|
12
|
+
super(
|
|
13
|
+
template: template,
|
|
14
|
+
arguments: arguments,
|
|
15
|
+
properties: properties,
|
|
16
|
+
builder: +'',
|
|
17
|
+
arg_index: 0,
|
|
18
|
+
index: 0
|
|
19
|
+
)
|
|
20
|
+
end
|
|
21
|
+
end
|
|
22
|
+
|
|
23
|
+
module_function
|
|
24
|
+
|
|
25
|
+
def render(template, args, properties)
|
|
26
|
+
return '' if template.nil?
|
|
27
|
+
|
|
28
|
+
state = RenderState.new(template, args || [], properties)
|
|
29
|
+
consume_template(state)
|
|
30
|
+
state.builder
|
|
31
|
+
end
|
|
32
|
+
|
|
33
|
+
def consume_template(state)
|
|
34
|
+
consume_character(state) while state.index < state.template.length
|
|
35
|
+
end
|
|
36
|
+
|
|
37
|
+
def consume_character(state)
|
|
38
|
+
if escaped_brace_at?(state)
|
|
39
|
+
write_escaped_brace(state)
|
|
40
|
+
elsif (closing = placeholder_closing_index(state))
|
|
41
|
+
write_placeholder(state, closing)
|
|
42
|
+
else
|
|
43
|
+
consume_literal(state)
|
|
44
|
+
end
|
|
45
|
+
end
|
|
46
|
+
|
|
47
|
+
def escaped_brace_at?(state)
|
|
48
|
+
character = state.template[state.index]
|
|
49
|
+
brace_character?(character) && state.template[state.index + 1] == character
|
|
50
|
+
end
|
|
51
|
+
|
|
52
|
+
def write_escaped_brace(state)
|
|
53
|
+
state.builder << state.template[state.index]
|
|
54
|
+
state.index += 2
|
|
55
|
+
end
|
|
56
|
+
|
|
57
|
+
def placeholder_closing_index(state)
|
|
58
|
+
return nil unless state.template[state.index] == '{'
|
|
59
|
+
|
|
60
|
+
closing = state.template.index('}', state.index + 1)
|
|
61
|
+
return nil if closing.nil? || state.arg_index >= state.arguments.length
|
|
62
|
+
|
|
63
|
+
closing
|
|
64
|
+
end
|
|
65
|
+
|
|
66
|
+
def write_placeholder(state, closing)
|
|
67
|
+
value = format(state.arguments[state.arg_index])
|
|
68
|
+
state.arg_index += 1
|
|
69
|
+
state.builder << value
|
|
70
|
+
assign_placeholder_property(state, closing, value)
|
|
71
|
+
state.index = closing + 1
|
|
72
|
+
end
|
|
73
|
+
|
|
74
|
+
def assign_placeholder_property(state, closing, value)
|
|
75
|
+
name = property_name(state.template[(state.index + 1)...closing])
|
|
76
|
+
state.properties[name] = value unless name.empty?
|
|
77
|
+
end
|
|
78
|
+
|
|
79
|
+
def consume_literal(state)
|
|
80
|
+
state.builder << state.template[state.index]
|
|
81
|
+
state.index += 1
|
|
82
|
+
end
|
|
83
|
+
|
|
84
|
+
def brace_character?(character)
|
|
85
|
+
['{', '}'].include?(character)
|
|
86
|
+
end
|
|
87
|
+
|
|
88
|
+
def property_name(placeholder)
|
|
89
|
+
name = placeholder.split(/[,:]/, 2).first.to_s.strip
|
|
90
|
+
name.start_with?('@', '$') ? name[1..] : name
|
|
91
|
+
end
|
|
92
|
+
|
|
93
|
+
def format(value)
|
|
94
|
+
return NULL_VALUE if value.nil?
|
|
95
|
+
|
|
96
|
+
value.to_s
|
|
97
|
+
rescue StandardError
|
|
98
|
+
value.class.name
|
|
99
|
+
end
|
|
100
|
+
end
|
|
101
|
+
end
|
|
102
|
+
end
|
|
103
|
+
end
|
|
@@ -0,0 +1,69 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
require 'graftcode/instrumentation'
|
|
4
|
+
|
|
5
|
+
module Graftcode
|
|
6
|
+
module Telemetry
|
|
7
|
+
module Datadog
|
|
8
|
+
class GraftCodeDatadogConnectorOptions
|
|
9
|
+
ENDPOINT_VARIABLE = 'OTEL_EXPORTER_OTLP_ENDPOINT'
|
|
10
|
+
ENVIRONMENT_VARIABLE = 'DD_ENV'
|
|
11
|
+
VERSION_VARIABLE = 'DD_VERSION'
|
|
12
|
+
DEFAULT_ENDPOINT = 'http://127.0.0.1:4318'
|
|
13
|
+
HOSTED_RECEIVER = '/Binaries/Ruby/core/receiver/receiver.rb'
|
|
14
|
+
|
|
15
|
+
attr_accessor :service_name, :endpoint, :environment, :version, :enable_console_logging, :flush_after_calls
|
|
16
|
+
attr_reader :minimum_log_level
|
|
17
|
+
|
|
18
|
+
def initialize(env = ENV)
|
|
19
|
+
@env = env
|
|
20
|
+
@service_name = ''
|
|
21
|
+
@endpoint = nil
|
|
22
|
+
@environment = nil
|
|
23
|
+
@version = nil
|
|
24
|
+
@minimum_log_level = Hypertube::Utils::Logging::LogsLevel::INFO
|
|
25
|
+
@enable_console_logging = true
|
|
26
|
+
@flush_after_calls = nil
|
|
27
|
+
end
|
|
28
|
+
|
|
29
|
+
# A runtime hosted by the Hypertube native launcher loads its receiver from the extracted Binaries folder.
|
|
30
|
+
def resolve_flush_after_calls(loaded_features = $LOADED_FEATURES)
|
|
31
|
+
return flush_after_calls unless flush_after_calls.nil?
|
|
32
|
+
|
|
33
|
+
loaded_features.any? { |path| path.tr('\\', '/').end_with?(HOSTED_RECEIVER) }
|
|
34
|
+
end
|
|
35
|
+
|
|
36
|
+
def minimum_log_level=(level)
|
|
37
|
+
@minimum_log_level = level.is_a?(String) ? Hypertube::Utils::Logging::LogsLevel.parse(level) : level
|
|
38
|
+
end
|
|
39
|
+
|
|
40
|
+
def resolve_endpoint
|
|
41
|
+
(present(endpoint) || present(@env[ENDPOINT_VARIABLE]) || DEFAULT_ENDPOINT).chomp('/')
|
|
42
|
+
end
|
|
43
|
+
|
|
44
|
+
def resolve_environment
|
|
45
|
+
present(environment) || present(@env[ENVIRONMENT_VARIABLE])
|
|
46
|
+
end
|
|
47
|
+
|
|
48
|
+
def resolve_version
|
|
49
|
+
present(version) || present(@env[VERSION_VARIABLE])
|
|
50
|
+
end
|
|
51
|
+
|
|
52
|
+
def validate!
|
|
53
|
+
raise ArgumentError, 'service_name must be configured for Datadog telemetry.' if present(service_name).nil?
|
|
54
|
+
return if minimum_log_level.is_a?(Integer)
|
|
55
|
+
|
|
56
|
+
raise ArgumentError,
|
|
57
|
+
'minimum_log_level must be a Hypertube LogsLevel.'
|
|
58
|
+
end
|
|
59
|
+
|
|
60
|
+
private
|
|
61
|
+
|
|
62
|
+
def present(value)
|
|
63
|
+
text = value&.to_s&.strip
|
|
64
|
+
text.nil? || text.empty? ? nil : text
|
|
65
|
+
end
|
|
66
|
+
end
|
|
67
|
+
end
|
|
68
|
+
end
|
|
69
|
+
end
|
|
@@ -0,0 +1,143 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
require 'opentelemetry/sdk'
|
|
4
|
+
require 'opentelemetry-logs-sdk'
|
|
5
|
+
require 'opentelemetry/exporter/otlp'
|
|
6
|
+
require 'opentelemetry-exporter-otlp-logs'
|
|
7
|
+
require 'graftcode/instrumentation'
|
|
8
|
+
require_relative 'call_flusher'
|
|
9
|
+
require_relative 'logger'
|
|
10
|
+
|
|
11
|
+
module Graftcode
|
|
12
|
+
module Telemetry
|
|
13
|
+
module Datadog
|
|
14
|
+
class GraftCodeDatadogConnectorPipeline
|
|
15
|
+
DEFAULT_FLUSH_TIMEOUT = 5
|
|
16
|
+
TRACES_PATH = '/v1/traces'
|
|
17
|
+
LOGS_PATH = '/v1/logs'
|
|
18
|
+
|
|
19
|
+
attr_reader :service_name, :endpoint, :tracer, :logger, :tracer_provider, :logger_provider
|
|
20
|
+
|
|
21
|
+
def initialize(options, span_exporter: nil, log_record_exporter: nil, &on_close)
|
|
22
|
+
options.validate!
|
|
23
|
+
assign_metadata(options, on_close)
|
|
24
|
+
setup_telemetry(options, span_exporter, log_record_exporter)
|
|
25
|
+
configure_opentelemetry!
|
|
26
|
+
setup_application_services(options)
|
|
27
|
+
at_exit { close }
|
|
28
|
+
end
|
|
29
|
+
|
|
30
|
+
def flushes_after_calls?
|
|
31
|
+
!@call_flusher.nil?
|
|
32
|
+
end
|
|
33
|
+
|
|
34
|
+
def in_span(name, kind: :internal, attributes: nil, &block)
|
|
35
|
+
tracer.in_span(name, kind: kind, attributes: attributes, &block)
|
|
36
|
+
end
|
|
37
|
+
|
|
38
|
+
def flush(timeout = DEFAULT_FLUSH_TIMEOUT)
|
|
39
|
+
@close_mutex.synchronize do
|
|
40
|
+
return true if @closed
|
|
41
|
+
|
|
42
|
+
traces = @tracer_provider.force_flush(timeout: timeout)
|
|
43
|
+
logs = @logger_provider.force_flush(timeout: timeout)
|
|
44
|
+
traces == OpenTelemetry::SDK::Trace::Export::SUCCESS && logs == OpenTelemetry::SDK::Logs::Export::SUCCESS
|
|
45
|
+
end
|
|
46
|
+
end
|
|
47
|
+
|
|
48
|
+
def close
|
|
49
|
+
@close_mutex.synchronize do
|
|
50
|
+
return if @closed
|
|
51
|
+
|
|
52
|
+
@closed = true
|
|
53
|
+
end
|
|
54
|
+
|
|
55
|
+
Hypertube::Utils::Abstractions::HypertubeBroker.detach(@call_flusher) unless @call_flusher.nil?
|
|
56
|
+
@instrumentation.close
|
|
57
|
+
@tracer_provider.shutdown(timeout: DEFAULT_FLUSH_TIMEOUT)
|
|
58
|
+
@logger_provider.shutdown(timeout: DEFAULT_FLUSH_TIMEOUT)
|
|
59
|
+
@on_close&.call(self)
|
|
60
|
+
end
|
|
61
|
+
alias shutdown close
|
|
62
|
+
|
|
63
|
+
def closed?
|
|
64
|
+
@closed
|
|
65
|
+
end
|
|
66
|
+
|
|
67
|
+
private
|
|
68
|
+
|
|
69
|
+
def assign_metadata(options, on_close)
|
|
70
|
+
@service_name = options.service_name.strip
|
|
71
|
+
@endpoint = options.resolve_endpoint
|
|
72
|
+
@on_close = on_close
|
|
73
|
+
@close_mutex = Mutex.new
|
|
74
|
+
@closed = false
|
|
75
|
+
end
|
|
76
|
+
|
|
77
|
+
def setup_telemetry(options, span_exporter, log_record_exporter)
|
|
78
|
+
resource = build_resource(options)
|
|
79
|
+
@tracer_provider = OpenTelemetry::SDK::Trace::TracerProvider.new(resource: resource)
|
|
80
|
+
@tracer_provider.add_span_processor(span_processor(span_exporter))
|
|
81
|
+
@logger_provider = OpenTelemetry::SDK::Logs::LoggerProvider.new(resource: resource)
|
|
82
|
+
@logger_provider.add_log_record_processor(log_record_processor(log_record_exporter))
|
|
83
|
+
end
|
|
84
|
+
|
|
85
|
+
def configure_opentelemetry!
|
|
86
|
+
OpenTelemetry.tracer_provider = @tracer_provider
|
|
87
|
+
OpenTelemetry.logger_provider = @logger_provider
|
|
88
|
+
OpenTelemetry.propagation = OpenTelemetry::Context::Propagation::CompositeTextMapPropagator.compose_propagators(
|
|
89
|
+
[
|
|
90
|
+
OpenTelemetry::Trace::Propagation::TraceContext.text_map_propagator,
|
|
91
|
+
OpenTelemetry::Baggage::Propagation.text_map_propagator
|
|
92
|
+
]
|
|
93
|
+
)
|
|
94
|
+
end
|
|
95
|
+
|
|
96
|
+
def setup_application_services(options)
|
|
97
|
+
@tracer = @tracer_provider.tracer(service_name, VERSION)
|
|
98
|
+
@logger = GraftCodeDatadogLogger.new(
|
|
99
|
+
service_name,
|
|
100
|
+
@logger_provider.logger(name: service_name, version: VERSION),
|
|
101
|
+
options.minimum_log_level,
|
|
102
|
+
options.enable_console_logging ? $stdout : nil
|
|
103
|
+
)
|
|
104
|
+
@instrumentation = Graftcode::Instrumentation.attach(
|
|
105
|
+
@tracer_provider,
|
|
106
|
+
minimum_log_level: options.minimum_log_level,
|
|
107
|
+
logger_provider: @logger_provider
|
|
108
|
+
)
|
|
109
|
+
@call_flusher = CallFlusher.new(self) if options.resolve_flush_after_calls
|
|
110
|
+
Hypertube::Utils::Abstractions::HypertubeBroker.attach(@call_flusher) unless @call_flusher.nil?
|
|
111
|
+
end
|
|
112
|
+
|
|
113
|
+
def build_resource(options)
|
|
114
|
+
attributes = { 'service.name' => service_name }
|
|
115
|
+
environment = options.resolve_environment
|
|
116
|
+
version = options.resolve_version
|
|
117
|
+
attributes['deployment.environment.name'] = environment unless environment.nil?
|
|
118
|
+
attributes['service.version'] = version unless version.nil?
|
|
119
|
+
|
|
120
|
+
OpenTelemetry::SDK::Resources::Resource.default.merge(
|
|
121
|
+
OpenTelemetry::SDK::Resources::Resource.create(attributes)
|
|
122
|
+
)
|
|
123
|
+
end
|
|
124
|
+
|
|
125
|
+
def span_processor(exporter)
|
|
126
|
+
return OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(exporter) unless exporter.nil?
|
|
127
|
+
|
|
128
|
+
OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(
|
|
129
|
+
OpenTelemetry::Exporter::OTLP::Exporter.new(endpoint: "#{endpoint}#{TRACES_PATH}")
|
|
130
|
+
)
|
|
131
|
+
end
|
|
132
|
+
|
|
133
|
+
def log_record_processor(exporter)
|
|
134
|
+
return OpenTelemetry::SDK::Logs::Export::SimpleLogRecordProcessor.new(exporter) unless exporter.nil?
|
|
135
|
+
|
|
136
|
+
OpenTelemetry::SDK::Logs::Export::BatchLogRecordProcessor.new(
|
|
137
|
+
OpenTelemetry::Exporter::OTLP::Logs::LogsExporter.new(endpoint: "#{endpoint}#{LOGS_PATH}")
|
|
138
|
+
)
|
|
139
|
+
end
|
|
140
|
+
end
|
|
141
|
+
end
|
|
142
|
+
end
|
|
143
|
+
end
|
|
@@ -0,0 +1,135 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
require 'opentelemetry/sdk'
|
|
4
|
+
|
|
5
|
+
module Graftcode
|
|
6
|
+
module Telemetry
|
|
7
|
+
module Datadog
|
|
8
|
+
class GraftCodeDatadogRequestTelemetryMiddleware
|
|
9
|
+
CONTROLLER_KEY = 'graft.controller'
|
|
10
|
+
CONTROLLER_SUFFIX = 'Controller'
|
|
11
|
+
RAILS_CONTROLLER_KEY = 'action_controller.instance'
|
|
12
|
+
SINATRA_ROUTE_KEY = 'sinatra.route'
|
|
13
|
+
RESOURCE_NAME = 'resource.name'
|
|
14
|
+
|
|
15
|
+
def initialize(app, telemetry:)
|
|
16
|
+
raise ArgumentError, 'telemetry' if telemetry.nil?
|
|
17
|
+
|
|
18
|
+
@app = app
|
|
19
|
+
@telemetry = telemetry
|
|
20
|
+
end
|
|
21
|
+
|
|
22
|
+
def call(env)
|
|
23
|
+
method = env['REQUEST_METHOD'].to_s
|
|
24
|
+
path = resolve_path(env)
|
|
25
|
+
span, token = start_request_tracing(env, method, path)
|
|
26
|
+
|
|
27
|
+
begin
|
|
28
|
+
dispatch_request(env, span)
|
|
29
|
+
rescue Exception => e # rubocop:disable Lint/RescueException
|
|
30
|
+
record_request_failure(span, e)
|
|
31
|
+
raise
|
|
32
|
+
ensure
|
|
33
|
+
complete(span, env, method, path)
|
|
34
|
+
OpenTelemetry::Context.detach(token)
|
|
35
|
+
end
|
|
36
|
+
end
|
|
37
|
+
|
|
38
|
+
def self.operation_name(service_name, method, path, controller)
|
|
39
|
+
return "#{service_name}.#{controller}" unless controller.nil? || controller.strip.empty?
|
|
40
|
+
|
|
41
|
+
"#{service_name} #{method} #{path.nil? || path.empty? ? '/' : path}"
|
|
42
|
+
end
|
|
43
|
+
|
|
44
|
+
def self.controller_name(env)
|
|
45
|
+
explicit = explicit_controller_name(env)
|
|
46
|
+
return explicit if explicit
|
|
47
|
+
|
|
48
|
+
rails_controller_name(env[RAILS_CONTROLLER_KEY])
|
|
49
|
+
end
|
|
50
|
+
|
|
51
|
+
def self.explicit_controller_name(env)
|
|
52
|
+
explicit = env[CONTROLLER_KEY]
|
|
53
|
+
return nil unless explicit.is_a?(String) && !explicit.strip.empty?
|
|
54
|
+
|
|
55
|
+
explicit
|
|
56
|
+
end
|
|
57
|
+
|
|
58
|
+
def self.rails_controller_name(controller)
|
|
59
|
+
return nil if controller.nil?
|
|
60
|
+
|
|
61
|
+
strip_controller_suffix(short_class_name(controller))
|
|
62
|
+
end
|
|
63
|
+
|
|
64
|
+
def self.short_class_name(controller)
|
|
65
|
+
controller.class.name.to_s.split('::').last.to_s
|
|
66
|
+
end
|
|
67
|
+
|
|
68
|
+
def self.strip_controller_suffix(name)
|
|
69
|
+
return name unless name.end_with?(CONTROLLER_SUFFIX) && name.length > CONTROLLER_SUFFIX.length
|
|
70
|
+
|
|
71
|
+
name.delete_suffix(CONTROLLER_SUFFIX)
|
|
72
|
+
end
|
|
73
|
+
|
|
74
|
+
private
|
|
75
|
+
|
|
76
|
+
def start_request_tracing(env, method, path)
|
|
77
|
+
parent = extract_parent(env)
|
|
78
|
+
span = @telemetry.tracer.start_span(
|
|
79
|
+
self.class.operation_name(@telemetry.service_name, method, path, nil),
|
|
80
|
+
with_parent: parent,
|
|
81
|
+
kind: :server,
|
|
82
|
+
attributes: { 'http.method' => method, 'http.route' => path }
|
|
83
|
+
)
|
|
84
|
+
token = OpenTelemetry::Context.attach(OpenTelemetry::Trace.context_with_span(span))
|
|
85
|
+
[span, token]
|
|
86
|
+
end
|
|
87
|
+
|
|
88
|
+
def dispatch_request(env, span)
|
|
89
|
+
status, headers, body = @app.call(env)
|
|
90
|
+
apply_response_status(span, status)
|
|
91
|
+
[status, headers, body]
|
|
92
|
+
end
|
|
93
|
+
|
|
94
|
+
def extract_parent(env)
|
|
95
|
+
OpenTelemetry::Trace::Propagation::TraceContext.text_map_propagator.extract(
|
|
96
|
+
env,
|
|
97
|
+
getter: OpenTelemetry::Common::Propagation.rack_env_getter
|
|
98
|
+
)
|
|
99
|
+
end
|
|
100
|
+
|
|
101
|
+
def apply_response_status(span, status)
|
|
102
|
+
span.set_attribute('http.status_code', status.to_i)
|
|
103
|
+
span.status = OpenTelemetry::Trace::Status.error if status.to_i >= 500
|
|
104
|
+
end
|
|
105
|
+
|
|
106
|
+
def record_request_failure(span, exception)
|
|
107
|
+
span.record_exception(exception)
|
|
108
|
+
span.status = OpenTelemetry::Trace::Status.error(exception.message.to_s)
|
|
109
|
+
end
|
|
110
|
+
|
|
111
|
+
def complete(span, env, method, path)
|
|
112
|
+
route = route_template(env) || path
|
|
113
|
+
name = self.class.operation_name(@telemetry.service_name, method, route, self.class.controller_name(env))
|
|
114
|
+
|
|
115
|
+
span.set_attribute('http.route', route)
|
|
116
|
+
span.set_attribute(RESOURCE_NAME, name)
|
|
117
|
+
span.name = name
|
|
118
|
+
span.finish
|
|
119
|
+
end
|
|
120
|
+
|
|
121
|
+
def route_template(env)
|
|
122
|
+
route = env[SINATRA_ROUTE_KEY]
|
|
123
|
+
return nil unless route.is_a?(String)
|
|
124
|
+
|
|
125
|
+
route.split(' ', 2).last
|
|
126
|
+
end
|
|
127
|
+
|
|
128
|
+
def resolve_path(env)
|
|
129
|
+
path = "#{env['SCRIPT_NAME']}#{env['PATH_INFO']}"
|
|
130
|
+
path.empty? ? '/' : path
|
|
131
|
+
end
|
|
132
|
+
end
|
|
133
|
+
end
|
|
134
|
+
end
|
|
135
|
+
end
|
|
@@ -0,0 +1,10 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
require_relative 'datadog/version'
|
|
4
|
+
require_relative 'datadog/options'
|
|
5
|
+
require_relative 'datadog/message_template'
|
|
6
|
+
require_relative 'datadog/call_flusher'
|
|
7
|
+
require_relative 'datadog/logger'
|
|
8
|
+
require_relative 'datadog/pipeline'
|
|
9
|
+
require_relative 'datadog/connector'
|
|
10
|
+
require_relative 'datadog/request_telemetry_middleware'
|
metadata
ADDED
|
@@ -0,0 +1,205 @@
|
|
|
1
|
+
--- !ruby/object:Gem::Specification
|
|
2
|
+
name: graftcode-telemetry-datadog
|
|
3
|
+
version: !ruby/object:Gem::Version
|
|
4
|
+
version: 1.0.5
|
|
5
|
+
platform: ruby
|
|
6
|
+
authors:
|
|
7
|
+
- Graftcode S.A.
|
|
8
|
+
bindir: bin
|
|
9
|
+
cert_chain: []
|
|
10
|
+
date: 1980-01-02 00:00:00.000000000 Z
|
|
11
|
+
dependencies:
|
|
12
|
+
- !ruby/object:Gem::Dependency
|
|
13
|
+
name: graftcode-instrumentation
|
|
14
|
+
requirement: !ruby/object:Gem::Requirement
|
|
15
|
+
requirements:
|
|
16
|
+
- - "~>"
|
|
17
|
+
- !ruby/object:Gem::Version
|
|
18
|
+
version: '1.0'
|
|
19
|
+
type: :runtime
|
|
20
|
+
prerelease: false
|
|
21
|
+
version_requirements: !ruby/object:Gem::Requirement
|
|
22
|
+
requirements:
|
|
23
|
+
- - "~>"
|
|
24
|
+
- !ruby/object:Gem::Version
|
|
25
|
+
version: '1.0'
|
|
26
|
+
- !ruby/object:Gem::Dependency
|
|
27
|
+
name: opentelemetry-exporter-otlp
|
|
28
|
+
requirement: !ruby/object:Gem::Requirement
|
|
29
|
+
requirements:
|
|
30
|
+
- - "~>"
|
|
31
|
+
- !ruby/object:Gem::Version
|
|
32
|
+
version: '0.30'
|
|
33
|
+
type: :runtime
|
|
34
|
+
prerelease: false
|
|
35
|
+
version_requirements: !ruby/object:Gem::Requirement
|
|
36
|
+
requirements:
|
|
37
|
+
- - "~>"
|
|
38
|
+
- !ruby/object:Gem::Version
|
|
39
|
+
version: '0.30'
|
|
40
|
+
- !ruby/object:Gem::Dependency
|
|
41
|
+
name: opentelemetry-exporter-otlp-logs
|
|
42
|
+
requirement: !ruby/object:Gem::Requirement
|
|
43
|
+
requirements:
|
|
44
|
+
- - "~>"
|
|
45
|
+
- !ruby/object:Gem::Version
|
|
46
|
+
version: '0.2'
|
|
47
|
+
type: :runtime
|
|
48
|
+
prerelease: false
|
|
49
|
+
version_requirements: !ruby/object:Gem::Requirement
|
|
50
|
+
requirements:
|
|
51
|
+
- - "~>"
|
|
52
|
+
- !ruby/object:Gem::Version
|
|
53
|
+
version: '0.2'
|
|
54
|
+
- !ruby/object:Gem::Dependency
|
|
55
|
+
name: opentelemetry-logs-sdk
|
|
56
|
+
requirement: !ruby/object:Gem::Requirement
|
|
57
|
+
requirements:
|
|
58
|
+
- - "~>"
|
|
59
|
+
- !ruby/object:Gem::Version
|
|
60
|
+
version: '0.4'
|
|
61
|
+
type: :runtime
|
|
62
|
+
prerelease: false
|
|
63
|
+
version_requirements: !ruby/object:Gem::Requirement
|
|
64
|
+
requirements:
|
|
65
|
+
- - "~>"
|
|
66
|
+
- !ruby/object:Gem::Version
|
|
67
|
+
version: '0.4'
|
|
68
|
+
- !ruby/object:Gem::Dependency
|
|
69
|
+
name: opentelemetry-sdk
|
|
70
|
+
requirement: !ruby/object:Gem::Requirement
|
|
71
|
+
requirements:
|
|
72
|
+
- - "~>"
|
|
73
|
+
- !ruby/object:Gem::Version
|
|
74
|
+
version: '1.8'
|
|
75
|
+
type: :runtime
|
|
76
|
+
prerelease: false
|
|
77
|
+
version_requirements: !ruby/object:Gem::Requirement
|
|
78
|
+
requirements:
|
|
79
|
+
- - "~>"
|
|
80
|
+
- !ruby/object:Gem::Version
|
|
81
|
+
version: '1.8'
|
|
82
|
+
- !ruby/object:Gem::Dependency
|
|
83
|
+
name: hypertube-ruby-sdk
|
|
84
|
+
requirement: !ruby/object:Gem::Requirement
|
|
85
|
+
requirements:
|
|
86
|
+
- - ">="
|
|
87
|
+
- !ruby/object:Gem::Version
|
|
88
|
+
version: 3.2.0
|
|
89
|
+
type: :development
|
|
90
|
+
prerelease: false
|
|
91
|
+
version_requirements: !ruby/object:Gem::Requirement
|
|
92
|
+
requirements:
|
|
93
|
+
- - ">="
|
|
94
|
+
- !ruby/object:Gem::Version
|
|
95
|
+
version: 3.2.0
|
|
96
|
+
- !ruby/object:Gem::Dependency
|
|
97
|
+
name: rack
|
|
98
|
+
requirement: !ruby/object:Gem::Requirement
|
|
99
|
+
requirements:
|
|
100
|
+
- - "~>"
|
|
101
|
+
- !ruby/object:Gem::Version
|
|
102
|
+
version: '3.1'
|
|
103
|
+
type: :development
|
|
104
|
+
prerelease: false
|
|
105
|
+
version_requirements: !ruby/object:Gem::Requirement
|
|
106
|
+
requirements:
|
|
107
|
+
- - "~>"
|
|
108
|
+
- !ruby/object:Gem::Version
|
|
109
|
+
version: '3.1'
|
|
110
|
+
- !ruby/object:Gem::Dependency
|
|
111
|
+
name: rspec
|
|
112
|
+
requirement: !ruby/object:Gem::Requirement
|
|
113
|
+
requirements:
|
|
114
|
+
- - "~>"
|
|
115
|
+
- !ruby/object:Gem::Version
|
|
116
|
+
version: '3.13'
|
|
117
|
+
type: :development
|
|
118
|
+
prerelease: false
|
|
119
|
+
version_requirements: !ruby/object:Gem::Requirement
|
|
120
|
+
requirements:
|
|
121
|
+
- - "~>"
|
|
122
|
+
- !ruby/object:Gem::Version
|
|
123
|
+
version: '3.13'
|
|
124
|
+
- !ruby/object:Gem::Dependency
|
|
125
|
+
name: rubocop
|
|
126
|
+
requirement: !ruby/object:Gem::Requirement
|
|
127
|
+
requirements:
|
|
128
|
+
- - "~>"
|
|
129
|
+
- !ruby/object:Gem::Version
|
|
130
|
+
version: '1.92'
|
|
131
|
+
type: :development
|
|
132
|
+
prerelease: false
|
|
133
|
+
version_requirements: !ruby/object:Gem::Requirement
|
|
134
|
+
requirements:
|
|
135
|
+
- - "~>"
|
|
136
|
+
- !ruby/object:Gem::Version
|
|
137
|
+
version: '1.92'
|
|
138
|
+
- !ruby/object:Gem::Dependency
|
|
139
|
+
name: rubocop-performance
|
|
140
|
+
requirement: !ruby/object:Gem::Requirement
|
|
141
|
+
requirements:
|
|
142
|
+
- - "~>"
|
|
143
|
+
- !ruby/object:Gem::Version
|
|
144
|
+
version: '1.27'
|
|
145
|
+
type: :development
|
|
146
|
+
prerelease: false
|
|
147
|
+
version_requirements: !ruby/object:Gem::Requirement
|
|
148
|
+
requirements:
|
|
149
|
+
- - "~>"
|
|
150
|
+
- !ruby/object:Gem::Version
|
|
151
|
+
version: '1.27'
|
|
152
|
+
- !ruby/object:Gem::Dependency
|
|
153
|
+
name: rubocop-rspec
|
|
154
|
+
requirement: !ruby/object:Gem::Requirement
|
|
155
|
+
requirements:
|
|
156
|
+
- - "~>"
|
|
157
|
+
- !ruby/object:Gem::Version
|
|
158
|
+
version: '3.10'
|
|
159
|
+
type: :development
|
|
160
|
+
prerelease: false
|
|
161
|
+
version_requirements: !ruby/object:Gem::Requirement
|
|
162
|
+
requirements:
|
|
163
|
+
- - "~>"
|
|
164
|
+
- !ruby/object:Gem::Version
|
|
165
|
+
version: '3.10'
|
|
166
|
+
description: Sends Graftcode traces and logs to the Datadog Agent over OTLP, with
|
|
167
|
+
a Rack request middleware and an application logger.
|
|
168
|
+
email:
|
|
169
|
+
- support@graftcode.com
|
|
170
|
+
executables: []
|
|
171
|
+
extensions: []
|
|
172
|
+
extra_rdoc_files: []
|
|
173
|
+
files:
|
|
174
|
+
- README.md
|
|
175
|
+
- lib/graftcode/telemetry/datadog.rb
|
|
176
|
+
- lib/graftcode/telemetry/datadog/call_flusher.rb
|
|
177
|
+
- lib/graftcode/telemetry/datadog/connector.rb
|
|
178
|
+
- lib/graftcode/telemetry/datadog/logger.rb
|
|
179
|
+
- lib/graftcode/telemetry/datadog/message_template.rb
|
|
180
|
+
- lib/graftcode/telemetry/datadog/options.rb
|
|
181
|
+
- lib/graftcode/telemetry/datadog/pipeline.rb
|
|
182
|
+
- lib/graftcode/telemetry/datadog/request_telemetry_middleware.rb
|
|
183
|
+
- lib/graftcode/telemetry/datadog/version.rb
|
|
184
|
+
licenses:
|
|
185
|
+
- MIT
|
|
186
|
+
metadata:
|
|
187
|
+
rubygems_mfa_required: 'false'
|
|
188
|
+
rdoc_options: []
|
|
189
|
+
require_paths:
|
|
190
|
+
- lib
|
|
191
|
+
required_ruby_version: !ruby/object:Gem::Requirement
|
|
192
|
+
requirements:
|
|
193
|
+
- - ">="
|
|
194
|
+
- !ruby/object:Gem::Version
|
|
195
|
+
version: '3.1'
|
|
196
|
+
required_rubygems_version: !ruby/object:Gem::Requirement
|
|
197
|
+
requirements:
|
|
198
|
+
- - ">="
|
|
199
|
+
- !ruby/object:Gem::Version
|
|
200
|
+
version: '0'
|
|
201
|
+
requirements: []
|
|
202
|
+
rubygems_version: 3.6.9
|
|
203
|
+
specification_version: 4
|
|
204
|
+
summary: Datadog telemetry for Graftcode (Hypertube) applications in Ruby
|
|
205
|
+
test_files: []
|