summaryrefslogtreecommitdiff
path: root/app/models/integrations/datadog.rb
blob: 27c2fcf266b40ccb450355d076e3be100e6c0493 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
# frozen_string_literal: true

module Integrations
  class Datadog < Integration
    include HasWebHook
    extend Gitlab::Utils::Override

    DEFAULT_DOMAIN = 'datadoghq.com'
    URL_TEMPLATE = 'https://webhooks-http-intake.logs.%{datadog_domain}/api/v2/webhook'
    URL_TEMPLATE_API_KEYS = 'https://app.%{datadog_domain}/account/settings#api'
    URL_API_KEYS_DOCS = "https://docs.#{DEFAULT_DOMAIN}/account_management/api-app-keys/"

    SUPPORTED_EVENTS = %w[
      pipeline job
    ].freeze

    prop_accessor :datadog_site, :api_url, :api_key, :datadog_service, :datadog_env

    with_options if: :activated? do
      validates :api_key, presence: true, format: { with: /\A\w+\z/ }
      validates :datadog_site, format: { with: /\A[\w\.]+\z/, allow_blank: true }
      validates :api_url, public_url: { allow_blank: true }
      validates :datadog_site, presence: true, unless: -> (obj) { obj.api_url.present? }
      validates :api_url, presence: true, unless: -> (obj) { obj.datadog_site.present? }
    end

    def initialize_properties
      super

      self.datadog_site ||= DEFAULT_DOMAIN
    end

    def self.supported_events
      SUPPORTED_EVENTS
    end

    def self.default_test_event
      'pipeline'
    end

    def configurable_events
      [] # do not allow to opt out of required hooks
    end

    def title
      'Datadog'
    end

    def description
      'Trace your GitLab pipelines with Datadog'
    end

    def help
      nil
    end

    def self.to_param
      'datadog'
    end

    def fields
      [
        {
          type: 'text',
          name: 'datadog_site',
          placeholder: DEFAULT_DOMAIN,
          help: 'Choose the Datadog site to send data to. Set to "datadoghq.eu" to send data to the EU site',
          required: false
        },
        {
          type: 'text',
          name: 'api_url',
          title: 'API URL',
          help: '(Advanced) Define the full URL for your Datadog site directly',
          required: false
        },
        {
          type: 'password',
          name: 'api_key',
          title: _('API key'),
          non_empty_password_title: s_('ProjectService|Enter new API key'),
          non_empty_password_help: s_('ProjectService|Leave blank to use your current API key'),
          help: "<a href=\"#{api_keys_url}\" target=\"_blank\">API key</a> used for authentication with Datadog",
          required: true
        },
        {
          type: 'text',
          name: 'datadog_service',
          title: 'Service',
          placeholder: 'gitlab-ci',
          help: 'Name of this GitLab instance that all data will be tagged with'
        },
        {
          type: 'text',
          name: 'datadog_env',
          title: 'Env',
          help: 'The environment tag that traces will be tagged with'
        }
      ]
    end

    override :hook_url
    def hook_url
      url = api_url.presence || sprintf(URL_TEMPLATE, datadog_domain: datadog_domain)
      url = URI.parse(url)
      query = {
        "dd-api-key" => api_key,
        service: datadog_service.presence,
        env: datadog_env.presence
      }.compact
      url.query = query.to_query
      url.to_s
    end

    def api_keys_url
      return URL_API_KEYS_DOCS unless datadog_site.presence

      sprintf(URL_TEMPLATE_API_KEYS, datadog_domain: datadog_domain)
    end

    def execute(data)
      object_kind = data[:object_kind]
      object_kind = 'job' if object_kind == 'build'
      return unless supported_events.include?(object_kind)

      execute_web_hook!(data, "#{object_kind} hook")
    end

    def test(data)
      begin
        result = execute(data)
        return { success: false, result: result[:message] } if result[:http_status] != 200
      rescue StandardError => error
        return { success: false, result: error }
      end

      { success: true, result: result[:message] }
    end

    private

    def datadog_domain
      # Transparently ignore "app" prefix from datadog_site as the official docs table in
      # https://docs.datadoghq.com/getting_started/site/ is confusing for internal URLs.
      # US3 needs to keep a prefix but other datacenters cannot have the listed "app" prefix
      datadog_site.delete_prefix("app.")
    end
  end
end