Module: Datadog::Contrib::Rails::Framework

Defined in:
lib/ddtrace/contrib/rails/framework.rb

Overview

Rails framework code, used to essentially:

  • handle configuration entries which are specific to Datadog tracing
  • instrument parts of the framework when needed

Class Method Summary collapse

Class Method Details

.activate_action_cable!(datadog_config, rails_config) ⇒ Object 



91
92
93
94
95
96
97
98
 
# File 'lib/ddtrace/contrib/rails/framework.rb', line 91

def self.activate_action_cable!(datadog_config, rails_config)
  return unless defined?(::ActionCable)

  datadog_config.use(
    :action_cable,
    service_name: "#{rails_config[:service_name]}-#{Contrib::ActionCable::Ext::SERVICE_NAME}"
  )
end

.activate_action_mailer!(datadog_config, rails_config) ⇒ Object 



100
101
102
103
104
105
106
107
 
# File 'lib/ddtrace/contrib/rails/framework.rb', line 100

def self.activate_action_mailer!(datadog_config, rails_config)
  return unless defined?(::ActionMailer)

  datadog_config.use(
    :action_mailer,
    service_name: "#{rails_config[:service_name]}-#{Contrib::ActionMailer::Ext::SERVICE_NAME}"
  )
end

.activate_action_pack!(datadog_config, rails_config) ⇒ Object 



109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/ddtrace/contrib/rails/framework.rb', line 109

def self.activate_action_pack!(datadog_config, rails_config)
  return unless defined?(::ActionPack)

  # TODO: This is configuring ActionPack but not patching. It will queue ActionPack
  #       for patching, but patching won't take place until Datadog.configure completes.
  #       Should we manually patch here?

  datadog_config.use(
    :action_pack,
    service_name: rails_config[:service_name]
  )
end

.activate_action_view!(datadog_config, rails_config) ⇒ Object 



122
123
124
125
126
127
128
129
 
# File 'lib/ddtrace/contrib/rails/framework.rb', line 122

def self.activate_action_view!(datadog_config, rails_config)
  return unless defined?(::ActionView)

  datadog_config.use(
    :action_view,
    service_name: rails_config[:service_name]
  )
end

.activate_active_job!(datadog_config, rails_config) ⇒ Object 



131
132
133
134
135
136
137
138
139
 
# File 'lib/ddtrace/contrib/rails/framework.rb', line 131

def self.activate_active_job!(datadog_config, rails_config)
  return unless defined?(::ActiveJob)

  datadog_config.use(
    :active_job,
    service_name: rails_config[:job_service],
    log_injection: rails_config[:log_injection]
  )
end

.activate_active_record!(datadog_config, rails_config) ⇒ Object 



141
142
143
144
145
146
147
148
 
# File 'lib/ddtrace/contrib/rails/framework.rb', line 141

def self.activate_active_record!(datadog_config, rails_config)
  return unless defined?(::ActiveRecord)

  datadog_config.use(
    :active_record,
    service_name: rails_config[:database_service]
  )
end

.activate_active_support!(datadog_config, rails_config) ⇒ Object 



82
83
84
85
86
87
88
89
 
# File 'lib/ddtrace/contrib/rails/framework.rb', line 82

def self.activate_active_support!(datadog_config, rails_config)
  return unless defined?(::ActiveSupport)

  datadog_config.use(
    :active_support,
    cache_service: rails_config[:cache_service]
  )
end

.activate_lograge!(datadog_config, rails_config) ⇒ Object 



150
151
152
153
154
155
156
157
158
 
# File 'lib/ddtrace/contrib/rails/framework.rb', line 150

def self.activate_lograge!(datadog_config, rails_config)
  return unless defined?(::Lograge)

  if rails_config[:log_injection]
    datadog_config.use(
      :lograge
    )
  end
end

.activate_rack!(datadog_config, rails_config) ⇒ Object 



72
73
74
75
76
77
78
79
80
 
# File 'lib/ddtrace/contrib/rails/framework.rb', line 72

def self.activate_rack!(datadog_config, rails_config)
  datadog_config.use(
    :rack,
    application: ::Rails.application,
    service_name: rails_config[:service_name],
    middleware_names: rails_config[:middleware_names],
    distributed_tracing: rails_config[:distributed_tracing]
  )
end

.activate_semantic_logger!(datadog_config, rails_config) ⇒ Object 



160
161
162
163
164
165
166
167
168
 
# File 'lib/ddtrace/contrib/rails/framework.rb', line 160

def self.activate_semantic_logger!(datadog_config, rails_config)
  return unless defined?(::SemanticLogger)

  if rails_config[:log_injection]
    datadog_config.use(
      :semantic_logger
    )
  end
end

.config_with_defaults(datadog_config) ⇒ Object 



60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/ddtrace/contrib/rails/framework.rb', line 60

def self.config_with_defaults(datadog_config)
  # We set defaults here instead of in the patcher because we need to wait
  # for the Rails application to be fully initialized.
  datadog_config[:rails].tap do |config|
    config[:service_name] ||= (Datadog.configure.service_without_fallback || Utils.app_name)
    config[:database_service] ||= "#{config[:service_name]}-#{Contrib::ActiveRecord::Utils.adapter_name}"
    config[:controller_service] ||= config[:service_name]
    config[:cache_service] ||= "#{config[:service_name]}-cache"
    config[:job_service] ||= "#{config[:service_name]}-#{Contrib::ActiveJob::Ext::SERVICE_NAME}"
  end
end

.setup ⇒ Object

After the Rails application finishes initializing, we configure the Rails integration and all its sub-components with the application information available. We do this after the initialization because not all the information we require is available before then.



31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/ddtrace/contrib/rails/framework.rb', line 31

def self.setup
  # NOTE: #configure has the side effect of rebuilding trace components.
  #       During a typical Rails application lifecycle, we will see trace
  #       components initialized twice because of this. This is necessary
  #       because key configuration is not available until after the Rails
  #       application has fully loaded, and some of this configuration is
  #       used to reconfigure tracer components with Rails-sourced defaults.
  #       This is a trade-off we take to get nice defaults.
  Datadog.configure do |datadog_config|
    rails_config = config_with_defaults(datadog_config)

    # By default, default service would be guessed from the script
    # being executed, but here we know better, get it from Rails config.
    # Don't set this if service has been explicitly provided by the user.
    datadog_config.service ||= rails_config[:service_name]

    activate_rack!(datadog_config, rails_config)
    activate_action_cable!(datadog_config, rails_config)
    activate_action_mailer!(datadog_config, rails_config)
    activate_active_support!(datadog_config, rails_config)
    activate_action_pack!(datadog_config, rails_config)
    activate_action_view!(datadog_config, rails_config)
    activate_active_job!(datadog_config, rails_config)
    activate_active_record!(datadog_config, rails_config)
    activate_lograge!(datadog_config, rails_config)
    activate_semantic_logger!(datadog_config, rails_config)
  end
end