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 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,9 @@
1
+ # frozen_string_literal: true
2
+
3
+ module Graftcode
4
+ module Telemetry
5
+ module Datadog
6
+ VERSION = '1.0.0'
7
+ end
8
+ end
9
+ 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: []