datadog_api_client 1.11.0 → 2.0.2

data/.generator/src/generator/cli.py

@@ -12,9 +12,9 @@ MODULE_NAME = "DatadogAPIClient"
 
 
 @click.command()
-@click.option(
-    "-i",
-    "--input",
+@click.argument(
+    "specs",
+    nargs=-1,
     type=click.Path(exists=True, file_okay=True, dir_okay=False, path_type=pathlib.Path),
 )
 @click.option(
@@ -22,14 +22,10 @@ MODULE_NAME = "DatadogAPIClient"
     "--output",
     type=click.Path(path_type=pathlib.Path),
 )
-def cli(input, output):
+def cli(specs, output):
     """
     Generate a Ruby code snippet from OpenAPI specification.
     """
-    spec = openapi.load(input)
-
-    version = input.parent.name
-
     env = Environment(loader=FileSystemLoader(str(pathlib.Path(__file__).parent / "templates")))
 
     env.filters["accept_headers"] = openapi.accept_headers
@@ -48,8 +44,6 @@ def cli(input, output):
     env.globals["gem_name"] = GEM_NAME
     env.globals["module_name"] = MODULE_NAME
     env.globals["enumerate"] = enumerate
-    env.globals["version"] = version
-    env.globals["openapi"] = spec
     env.globals["get_name"] = openapi.get_name
     env.globals["type_to_ruby"] = openapi.type_to_ruby
     env.globals["get_type_for_attribute"] = openapi.get_type_for_attribute
@@ -63,38 +57,61 @@ def cli(input, output):
     package_j2 = env.get_template("package.j2")
 
     extra_files = {
-        "api_client.rb": env.get_template("api_client.j2"),
-        "api_error.rb": env.get_template("api_error.j2"),
-        "configuration.rb": env.get_template("configuration.j2"),
         "model_base.rb": env.get_template("model_base.j2"),
     }
 
-    apis = openapi.apis(spec)
-    models = openapi.models(spec)
-
-    package = output / GEM_NAME / f"{version}.rb"
-    package.parent.mkdir(parents=True, exist_ok=True)
-    with package.open("w") as fp:
-        fp.write(package_j2.render(apis=apis, models=models))
-
-    gem_path = output / GEM_NAME / version
-    gem_path.mkdir(parents=True, exist_ok=True)
+    common_files = {
+        "api_client.rb": env.get_template("api_client.j2"),
+        "configuration.rb": env.get_template("configuration.j2"),
+        "inflector.rb": env.get_template("inflector.j2"),
+    }
 
-    for name, template in extra_files.items():
-        filename = gem_path / name
+    all_specs = {}
+    all_apis = {}
+    all_models = {}
+    for spec_path in specs:
+        version = spec_path.parent.name
+
+        spec = openapi.load(spec_path)
+        all_specs[version] = spec
+
+        apis = openapi.apis(spec)
+        all_apis[version] = apis
+
+        models = openapi.models(spec)
+        all_models[version] = models
+
+        env.globals["openapi"] = spec
+        env.globals["version"] = version
+
+        gem_path = output / GEM_NAME / version
+        gem_path.mkdir(parents=True, exist_ok=True)
+
+        for name, template in extra_files.items():
+            filename = gem_path / name
+            with filename.open("w") as fp:
+                fp.write(template.render(apis=apis, models=models))
+
+        for name, model in models.items():
+            filename = formatter.snake_case(name) + ".rb"
+            model_path = gem_path / "models" / filename
+            model_path.parent.mkdir(parents=True, exist_ok=True)
+            with model_path.open("w") as fp:
+                fp.write(model_j2.render(name=name, model=model))
+
+        for name, operations in apis.items():
+            filename = formatter.snake_case(name) + "_api.rb"
+            api_path = gem_path / "api" / filename
+            api_path.parent.mkdir(parents=True, exist_ok=True)
+            with api_path.open("w") as fp:
+                fp.write(api_j2.render(name=name, operations=operations))
+
+    models_output = output / GEM_NAME / "models.rb"
+    with models_output.open("w") as fp:
+        fp.write(package_j2.render(all_apis=all_apis, all_models=all_models))
+
+    common_output = output / GEM_NAME
+    for name, template in common_files.items():
+        filename = common_output / name
         with filename.open("w") as fp:
-            fp.write(template.render(apis=apis, models=models))
-
-    for name, model in models.items():
-        filename = formatter.snake_case(name) + ".rb"
-        model_path = gem_path / "models" / filename
-        model_path.parent.mkdir(parents=True, exist_ok=True)
-        with model_path.open("w") as fp:
-            fp.write(model_j2.render(name=name, model=model))
-
-    for name, operations in apis.items():
-        filename = formatter.snake_case(name) + "_api.rb"
-        api_path = gem_path / "api" / filename
-        api_path.parent.mkdir(parents=True, exist_ok=True)
-        with api_path.open("w") as fp:
-            fp.write(api_j2.render(name=name, operations=operations))
+            fp.write(template.render(all_apis=all_apis, all_specs=all_specs, all_models=all_models))

data/.generator/src/generator/openapi.py

@@ -32,7 +32,10 @@ def type_to_ruby(schema, alternative_name=None):
     if name:
         if "enum" in schema:
             return name
-        if not (schema.get("additionalProperties") and not schema.get("properties")) and schema.get("type", "object") == "object":
+        if (
+            not (schema.get("additionalProperties") and not schema.get("properties"))
+            and schema.get("type", "object") == "object"
+        ):
             return name
 
     type_ = schema.get("type")
@@ -117,9 +120,9 @@ def child_models(schema, alternative_name=None, seen=None):
             seen=seen,
         )
 
-    if (
-        schema.get("type") == "object" or "properties" in schema or has_sub_models
-    ) and not ("additionalProperties" in schema and "properties" not in schema):
+    if (schema.get("type") == "object" or "properties" in schema or has_sub_models) and not (
+        "additionalProperties" in schema and "properties" not in schema
+    ):
         if not has_sub_models and name is None:
             # this is a basic map object so we don't need a type
             return
@@ -458,7 +461,6 @@ def get_default(operation, attribute_path):
 
 
 def get_container(operation, attribute_path, with_type=False):
-
     def get_type(parameter):
         if with_type:
             return f", {get_type_for_parameter(parameter)}"
@@ -468,7 +470,11 @@ def get_container(operation, attribute_path, with_type=False):
     for name, parameter in parameters(operation):
         if name == attribute_name:
             if parameter["required"]:
-                return '{}, "{}"{}'.format(name, ".".join(formatter.attribute_name(a) for a in attribute_path.split(".")[1:]), get_type(parameter))
+                return '{}, "{}"{}'.format(
+                    name,
+                    ".".join(formatter.attribute_name(a) for a in attribute_path.split(".")[1:]),
+                    get_type(parameter),
+                )
     return f'opts, "{formatter.attribute_path(attribute_path)}"{get_type(parameter)}'
 
 

data/.generator/src/generator/templates/api.j2

@@ -9,7 +9,7 @@ module {{ module_name }}::{{ version|upper }}
   class {{ classname }}
     attr_accessor :api_client
 
-    def initialize(api_client = APIClient.default)
+    def initialize(api_client = {{ module_name }}::APIClient.default)
       @api_client = api_client
     end
 
@@ -40,15 +40,14 @@ module {{ module_name }}::{{ version|upper }}
     {%- endfor %}
     # @return [Array<({% if returnType %}{{ returnType }}{% else %}nil{% endif %}, Integer, Hash)>] {% if returnType %}{{ returnType }} data{% else %}nil{% endif %}, response status code and response headers
     def {{ operation.operationId|snake_case }}_with_http_info({% for name, parameter in operation|parameters if parameter.required %}{{ name|attribute_name }}, {% endfor %}opts = {})
-
-      if @api_client.config.unstable_operations.has_key?(:{{ operation.operationId|snake_case }})
-        unstable_enabled = @api_client.config.unstable_operations[:{{ operation.operationId|snake_case }}]
-        if unstable_enabled
-          @api_client.config.logger.warn format("Using unstable operation '%s'", "{{ operation.operationId|snake_case }}")
-        else
-          raise APIError.new(message: format("Unstable operation '%s' is disabled", "{{ operation.operationId|snake_case }}"))
-        end
+      {%- if "x-unstable" in operation %}
+      unstable_enabled = @api_client.config.unstable_operations["{{ version }}.{{ operation.operationId|snake_case }}".to_sym]
+      if unstable_enabled
+        @api_client.config.logger.warn format("Using unstable operation '%s'", "{{ version }}.{{ operation.operationId|snake_case }}")
+      else
+        raise {{ module_name }}::APIError.new(message: format("Unstable operation '%s' is disabled", "{{ version }}.{{ operation.operationId|snake_case }}"))
       end
+      {%- endif %}
 
       if @api_client.config.debugging
         @api_client.config.logger.debug 'Calling API: {{classname}}.{{ operation.operationId|snake_case }} ...'
@@ -198,7 +197,8 @@ module {{ module_name }}::{{ version|upper }}
         :form_params => form_params,
         :body => post_body,
         :auth_names => auth_names,
-        :return_type => return_type
+        :return_type => return_type,
+        :api_version => "{{ version|upper }}"
       )
 
       data, status_code, headers = @api_client.call_api(Net::HTTP::{{ httpMethod|camel_case }}, local_var_path, new_options)
@@ -218,8 +218,9 @@ module {{ module_name }}::{{ version|upper }}
     #
     # @yield [{{ get_type_at_path(operation, pagination.resultsPath) }}] Paginated items
     def {{ operation.operationId|snake_case }}_with_pagination({% for name, parameter in operation|parameters if parameter.required %}{{ name|attribute_name }}, {% endfor %}opts = {})
+        api_version = "{{ version|upper }}"
         page_size = @api_client.get_attribute_from_path({{ get_container(operation, pagination.limitParam) }}, {{ get_default(operation, pagination.limitParam) }})
-        @api_client.set_attribute_from_path({{ get_container(operation, pagination.limitParam, True) }}, page_size)
+        @api_client.set_attribute_from_path(api_version, {{ get_container(operation, pagination.limitParam, True) }}, page_size)
         while true do
             response = {{ operation.operationId|snake_case }}({% for name, parameter in operation|parameters if parameter.required %}{{ name|attribute_name }}, {% endfor %}opts)
             @api_client.get_attribute_from_path(response, "{{ pagination.resultsPath|attribute_path }}").each { |item| yield(item) }
@@ -227,10 +228,10 @@ module {{ module_name }}::{{ version|upper }}
               break
             end
             {%- if pagination.pageOffsetParam %}
-            @api_client.set_attribute_from_path({{ get_container(operation, pagination.pageOffsetParam, True) }}, @api_client.get_attribute_from_path({{ get_container(operation, pagination.pageOffsetParam) }}, 0) + page_size)
+            @api_client.set_attribute_from_path(api_version, {{ get_container(operation, pagination.pageOffsetParam, True) }}, @api_client.get_attribute_from_path({{ get_container(operation, pagination.pageOffsetParam) }}, 0) + page_size)
             {%- endif %}
             {%- if pagination.cursorParam %}
-            @api_client.set_attribute_from_path({{ get_container(operation, pagination.cursorParam, True) }}, @api_client.get_attribute_from_path(response, "{{ pagination.cursorPath }}"))
+            @api_client.set_attribute_from_path(api_version, {{ get_container(operation, pagination.cursorParam, True) }}, @api_client.get_attribute_from_path(response, "{{ pagination.cursorPath }}"))
             {%- endif %}
         end
     end

data/.generator/src/generator/templates/api_client.j2

@@ -8,8 +8,12 @@ require 'logger'
 require 'tempfile'
 require 'time'
 require 'httparty'
+begin
+  require 'zstandard'
+rescue LoadError
+end
 
-module {{ module_name }}::{{ version|upper }}
+module {{ module_name }}
   class APIClient
     # The Configuration object holding settings to be used in the API client.
     attr_accessor :config
@@ -100,7 +104,7 @@ module {{ module_name }}::{{ version|upper }}
       end
 
       if opts[:return_type]
-        data = deserialize(response, opts[:return_type])
+        data = deserialize(opts[:api_version], response, opts[:return_type])
       else
         data = nil
       end
@@ -187,6 +191,8 @@ module {{ module_name }}::{{ version|upper }}
         gzip.close
       elsif header_params['Content-Encoding'] == 'deflate'
         data = Zlib::deflate(data)
+      elsif header_params['Content-Encoding'] == 'zstd1'
+        data = Zstandard.deflate(data)
       end
       data
     end
@@ -205,9 +211,10 @@ module {{ module_name }}::{{ version|upper }}
 
     # Deserialize the response to the given return type.
     #
+    # @param [String] the api version
     # @param [Response] response HTTP response
     # @param [String] return_type some examples: "User", "Array<User>", "Hash<String, Integer>"
-    def deserialize(response, return_type)
+    def deserialize(api_version, response, return_type)
       body = response.body
 
       # handle file downloading - return the File instance processed in request callbacks
@@ -240,14 +247,14 @@ module {{ module_name }}::{{ version|upper }}
         end
       end
 
-      convert_to_type data, return_type
+      convert_to_type data, return_type, api_version
     end
 
     # Convert data to the given return type.
     # @param [Object] data Data to be converted
     # @param [String] return_type Return type
     # @return [Mixed] Data in a particular type
-    def convert_to_type(data, return_type)
+    def convert_to_type(data, return_type, api_version)
       return nil if data.nil?
       case return_type
       when 'String'
@@ -270,16 +277,16 @@ module {{ module_name }}::{{ version|upper }}
       when /\AArray<(.+)>\z/
         # e.g. Array<Pet>
         sub_type = $1
-        data.map { |item| convert_to_type(item, sub_type) }
+        data.map { |item| convert_to_type(item, sub_type, api_version) }
       when /\AHash\<String, (.+)\>\z/
         # e.g. Hash<String, Integer>
         sub_type = $1
         {}.tap do |hash|
-          data.each { |k, v| hash[k] = convert_to_type(v, sub_type) }
+          data.each { |k, v| hash[k] = convert_to_type(v, sub_type, api_version) }
         end
       else
         # models (e.g. Pet) or oneOf
-        klass = {{ module_name }}::{{ version|upper }}.const_get(return_type)
+        klass = {{ module_name }}.const_get(api_version).const_get(return_type)
         klass.respond_to?(:openapi_one_of) ? klass.build(data) : klass.build_from_hash(data)
       end
     end
@@ -296,7 +303,7 @@ module {{ module_name }}::{{ version|upper }}
     def build_request_url(path, opts = {})
       # Add leading and trailing slashes to path
       path = "/#{path}".gsub(/\/+/, '/')
-      @config.base_url(opts[:operation]) + path
+      @config.base_url("#{opts[:api_version].respond_to?(:downcase) ? opts[:api_version].downcase : opts[:api_version]}.#{opts[:operation]}") + path
     end
 
     # Update header and query params based on authentication settings.
@@ -411,12 +418,13 @@ module {{ module_name }}::{{ version|upper }}
 
     # Set an attribute at the given path
     #
+    # @param [String] api_version The api version
     # @param [Object] obj The source object
     # @param [String] attribute_path The path spefication, separated by "."
     # @param [Object] builder The class matching the top level attribute
     # @param [Object] value The value to set
     # @!visibility private
-    def set_attribute_from_path(obj, attribute_path, builder, value)
+    def set_attribute_from_path(api_version, obj, attribute_path, builder, value)
       attrs = attribute_path.split(".")
       last = attrs.pop
       i = 0
@@ -427,7 +435,7 @@ module {{ module_name }}::{{ version|upper }}
         else
           obj = obj.send(attr)
         end
-        builder = DatadogAPIClient::V2.const_get(builder.openapi_types[attr.to_sym]) if i > 0
+        builder = DatadogAPIClient.const_get(api_version).const_get(builder.openapi_types[attr.to_sym]) if i > 0
         obj = builder.new if obj.nil?
         i += 1
       end
@@ -439,4 +447,48 @@ module {{ module_name }}::{{ version|upper }}
       end
     end
   end
+
+  class APIError < StandardError
+    attr_reader :code, :response_headers, :response_body
+
+    # Usage examples:
+    #   APIError.new
+    #   APIError.new("message")
+    #   APIError.new(:code => 500, :response_headers => {}, :response_body => "")
+    #   APIError.new(:code => 404, :message => "Not Found")
+    def initialize(arg = nil)
+      if arg.is_a? Hash
+        if arg.key?(:message) || arg.key?('message')
+          super(arg[:message] || arg['message'])
+        else
+          super arg
+        end
+
+        arg.each do |k, v|
+          instance_variable_set "@#{k}", v
+        end
+      else
+        super arg
+      end
+    end
+
+    # Override to_s to display a friendly error message
+    def to_s
+      message
+    end
+
+    def message
+      if @message.nil?
+        msg = "Error message: the server returns an error"
+      else
+        msg = @message
+      end
+
+      msg += "\nHTTP status code: #{code}" if code
+      msg += "\nResponse headers: #{response_headers}" if response_headers
+      msg += "\nResponse body: #{response_body}" if response_body
+
+      msg
+    end
+  end
 end

data/.generator/src/generator/templates/configuration.j2

@@ -2,7 +2,7 @@
 {% include "api_info.j2" %}
 =end
 
-module {{ module_name }}::{{ version|upper }}
+module {{ module_name }}
   class Configuration
     # Defines url scheme
     attr_accessor :scheme
@@ -148,13 +148,15 @@ module {{ module_name }}::{{ version|upper }}
       @compress = true
       @logger = defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
       @unstable_operations = {
-      {%- for path in openapi.paths.values() %}
-      {%- for operation in path.values() %}
+      {%- for version, apis in all_apis.items() %}
+      {%- for operations in apis.values() %}
+      {%- for _, _, operation in operations|sort(attribute="2.operationId") %}
       {%- if "x-unstable" in operation %}
-            {{ operation.operationId|snake_case }}: false,
+            "{{ version }}.{{ operation.operationId|snake_case }}": false,
       {%- endif %}
       {%- endfor %}
       {%- endfor %}
+      {%- endfor %}
       }
       @server_variables[:site] = ENV['DD_SITE'] if ENV.key? 'DD_SITE'
       {%- for name, schema in openapi.components.securitySchemes.items() if "x-env-name" in schema and schema.in == "header" and schema.type == "apiKey" %}
@@ -191,10 +193,10 @@ module {{ module_name }}::{{ version|upper }}
 
     # Returns base URL for specified operation based on server settings
     def base_url(operation = nil)
-      index = server_operation_index.fetch(operation, server_index)
+      index = server_operation_index.fetch(operation.to_sym, server_index)
       return "#{scheme}://#{[host, base_path].join('/').gsub(/\/+/, '/')}".sub(/\/+\z/, '') if index == nil
 
-      server_url(index, server_operation_variables.fetch(operation, server_variables), operation_server_settings[operation])
+      server_url(index, server_operation_variables.fetch(operation.to_sym, server_variables), operation_server_settings[operation.to_sym])
     end
 
     # Gets API key (with prefix if set).
@@ -294,11 +296,12 @@ module {{ module_name }}::{{ version|upper }}
 
     def operation_server_settings
       {
-        {%- for path in openapi.paths.values() %}
+        {%- for version, spec in all_specs.items() %}
+        {%- for path in spec.paths.values() %}
         {%- for operation in path.values() %}
         {%- for server in operation.servers %}
         {%- if loop.first %}
-        {{ operation.operationId|snake_case }}: [
+        "{{ version }}.{{ operation.operationId|snake_case }}": [
         {%- endif %}
           {{ server_configuration(server)|indent(10) }}{% if not loop.last %},{% endif %}
         {%- if loop.last %}  
@@ -307,6 +310,7 @@ module {{ module_name }}::{{ version|upper }}
         {%- endfor %}
         {%- endfor %}
         {%- endfor %}
+        {%- endfor %}
       }
     end
 

data/.generator/src/generator/templates/example.j2

@@ -8,7 +8,7 @@ require 'datadog_api_client'
 {%- if context._enable_operations %}
 DatadogAPIClient::V2.configure do |config|
 {%- for operation in context._enable_operations %}
-  config.unstable_operations[:{{ operation|snake_case }}] = true
+  config.unstable_operations["{{ version }}.{{ operation|snake_case }}".to_sym] = true
 {%- endfor %}
 end
 {%- endif %}
@@ -33,8 +33,13 @@ opts = {
 {%- endfor %}
 }
 {%- endif %}
+
+{%- if context.pagination %}
+api_instance.{{ context.api_request.operation_id|snake_case }}_with_pagination({{ parameters }}) { |item| puts item }
+{%- else %}
 {%- if context.status_code != 204 %}
 p api_instance.{{ context.api_request.operation_id|snake_case }}({{ parameters }})
 {%- else %}
 api_instance.{{ context.api_request.operation_id|snake_case }}({{ parameters }})
 {%- endif %}
+{%- endif %}

data/.generator/src/generator/templates/inflector.j2

@@ -0,0 +1,28 @@
+require 'zeitwerk'
+
+module {{ module_name }}
+  class {{ module_name }}Inflector < Zeitwerk::Inflector
+    def camelize(basename, abspath)
+      model_name = "#{abspath.match('v[0-9]')}.#{basename}"
+      overrides[model_name] || basename.split('_').each(&:capitalize!).join
+    end
+
+    def overrides
+      @overrides ||= {
+        # Models
+        {%- for version, models in all_models.items() %}
+        {%- for model in models|sort %}
+          "{{ version }}.{{ model|snake_case }}" => "{{ model }}",
+        {%- endfor %}
+        {%- endfor %}
+        # APIs
+        {%- for version, apis in all_apis.items() %}
+        {%- for api in apis|sort %}
+        {%- set name = api.replace(" ", "") + "API" %}
+        "{{ version }}.{{ api|snake_case }}_api" => "{{ name }}"{%-if not loop.last %},{% endif %}
+        {%- endfor %}{%-if not loop.last %},{% endif %}
+        {%- endfor %}
+        }
+    end
+  end
+end

data/.generator/src/generator/templates/model_base.j2

@@ -10,7 +10,7 @@ module {{ module_name }}::{{ version|upper }}
     # @!visibility private
     def build_from_hash(value)
       constantValues = self.class.constants.select { |c| self.class::const_get(c) == value }
-      constantValues.empty? ? {{ module_name }}::{{ version|upper }}::UnparsedObject.new(value) : value
+      constantValues.empty? ? {{ module_name }}::UnparsedObject.new(value) : value
     end
 
     module ClassMethods
@@ -107,7 +107,7 @@ module {{ module_name }}::{{ version|upper }}
         # models (e.g. Pet) or oneOf
         klass = {{ module_name }}::{{ version|upper }}.const_get(type)
         res = klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
-        if res.instance_of? {{ module_name }}::{{ version|upper }}::UnparsedObject
+        if res.instance_of? {{ module_name }}::UnparsedObject
           self._unparsed = true
         end
         res

data/.generator/src/generator/templates/model_oneof.j2

@@ -81,7 +81,7 @@
           data
         else
           self._unparsed = true
-          {{ module_name }}::{{ version|upper }}::UnparsedObject.new(data)
+          {{ module_name }}::UnparsedObject.new(data)
         end
 
       {%- endif %}

data/.generator/src/generator/templates/package.j2

@@ -5,22 +5,17 @@
 # Common files
 require 'datadog_api_client/version'
 require 'datadog_api_client/user_agent'
-require '{{ gem_name }}/{{ version }}/api_client'
-require '{{ gem_name }}/{{ version }}/api_error'
-require '{{ gem_name }}/{{ version }}/configuration'
+require '{{ gem_name }}/api_client'
+require '{{ gem_name }}/configuration'
+require '{{ gem_name }}/api_key_configuration'
 
-# Models
+# Model base
+## Load in the model_base modules which also initializes the V1 and V2 namespaces
+{%- for version, models in all_models.items() %}
 require '{{ gem_name }}/{{ version }}/model_base'
-{%- for model in models|sort %}
-require '{{ gem_name }}/{{ version }}/models/{{ model|snake_case }}'
 {%- endfor %}
 
-# APIs
-{%- for api in apis|sort %}
-require '{{ gem_name }}/{{ version }}/api/{{ api|snake_case }}_api'
-{%- endfor %}
-
-module {{ module_name }}::{{ version|upper }}
+module {{ module_name }}
   class << self
     # Customize default settings for the SDK using block.
     #   {{ module_name }}::{{ version|upper }}.configure do |config|

data/.github/workflows/approved_status.yml

@@ -26,8 +26,6 @@ jobs:
           app_id: ${{ secrets.PIPELINE_GITHUB_APP_ID }}
           private_key: ${{ secrets.PIPELINE_GITHUB_APP_PRIVATE_KEY }}
           repository: DataDog/datadog-api-spec
-      - name: Checkout code
-        uses: actions/checkout@v2
       - name: Post PR review status check
         uses: DataDog/github-actions/post-review-status@v1.0.0
         with:

data/.github/workflows/codeql-analysis.yml

@@ -0,0 +1,49 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ "master" ]
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'ruby' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        
+        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+        
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2

data/.github/workflows/docs.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           # Fetch all history for applying timestamps to every page
           fetch-depth: 0

data/.github/workflows/prepare_release.yml

@@ -21,7 +21,7 @@ jobs:
         with:
           app_id: ${{ secrets.PIPELINE_GITHUB_APP_ID }}
           private_key: ${{ secrets.PIPELINE_GITHUB_APP_PRIVATE_KEY }}
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
           token: ${{ steps.get_token.outputs.token }}

data/.github/workflows/publish.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     if: github.event_name == 'workflow_dispatch' || (github.event_name == 'release' && github.event.action == 'published')
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           ref: ${{ github.event.release.tag_name }}