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 



87
88
89
90
91
92
93
94
 
# File 'lib/ddtrace/contrib/rails/framework.rb', line 87

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_pack!(datadog_config, rails_config) ⇒ Object 



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

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 



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

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_record!(datadog_config, rails_config) ⇒ Object 



118
119
120
121
122
123
124
125
 
# File 'lib/ddtrace/contrib/rails/framework.rb', line 118

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 



78
79
80
81
82
83
84
85
 
# File 'lib/ddtrace/contrib/rails/framework.rb', line 78

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 



127
128
129
130
131
132
133
134
135
 
# File 'lib/ddtrace/contrib/rails/framework.rb', line 127

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 



68
69
70
71
72
73
74
75
76
 
# File 'lib/ddtrace/contrib/rails/framework.rb', line 68

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 



137
138
139
140
141
142
143
144
145
 
# File 'lib/ddtrace/contrib/rails/framework.rb', line 137

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 



57
58
59
60
61
62
63
64
65
66
 
# File 'lib/ddtrace/contrib/rails/framework.rb', line 57

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"
  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.



30
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
 
# File 'lib/ddtrace/contrib/rails/framework.rb', line 30

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_active_support!(datadog_config, rails_config)
    activate_action_pack!(datadog_config, rails_config)
    activate_action_view!(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