add supported versions workflow #4210

quinna-h · 2024-12-09T18:52:46Z

What does this PR do?

Adds a script find_gem_version_bounds.rb that parses gemfiles to get the minimum and maximum supported version for integrations, which is run in the workflow Generate Supported Versions
The script generate_table_versions.rb outputs the integrations and minimum supported versions in a markdown table.
Adds the gem names in the integration declarations

Generated PR example: #4236

Motivation:
Part of Autodoc generation for supported versions.

Change log entry
No.

Additional Notes:

How to test the change?

github-actions · 2024-12-09T18:53:10Z

Thank you for updating Change log entry section 👏

^{Visited at: 2024-12-12 08:50:22 UTC}

datadog-datadog-prod-us1 · 2024-12-09T18:53:21Z

find_min_gemfile.rb

+require 'rubygems'
+require 'json'
+
+def parse_gemfiles(directory = 'gemfiles/')


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

find_min_gemfile.rb

datadog-datadog-prod-us1 · 2024-12-09T18:53:21Z

find_min_gemfile.rb

+    end
+  end  
+
+def get_integration_names(directory = 'lib/datadog/tracing/contrib/')


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

find_min_gemfile.rb

pr-commenter · 2024-12-09T19:04:12Z

Benchmarks

Benchmark execution time: 2024-12-24 15:05:51

Comparing candidate commit 3b8cff4 in PR branch quinna.halim/add-supported-versions-table with baseline commit 7fd1feb in branch master.

Found 0 performance improvements and 0 performance regressions! Performance is the same for 31 metrics, 2 unstable metrics.

datadog-datadog-prod-us1 · 2024-12-09T19:08:01Z

find_min_gemfile.rb

+
+# Helper: Parse a Gemfile.lock-style entry
+# matches on ex. actionmailer (= 6.0.6)
+def parse_gemfile_lock_entry(line)


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

datadog-datadog-prod-us1 · 2024-12-09T19:08:01Z

find_min_gemfile.rb

+# 1. "pessimistic" versions, ex. '~> 1.2.3'
+# 2. '>= 1.2.3'
+# 3. 1.2.3
+def extract_version(constraint)


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

datadog-datadog-prod-us1 · 2024-12-09T19:08:01Z

find_min_gemfile.rb

+
+# Helper: Parse a Gemfile-style gem declaration
+# ex. gem 'ruby-kafka', '~> 5.0'
+def parse_gemfile_entry(line)


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

datadog-datadog-prod-us1 · 2024-12-09T19:08:01Z

find_min_gemfile.rb

+end
+
+# Helper: Validate the version format
+def version_valid?(version)


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

datadog-datadog-prod-us1 · 2024-12-11T18:00:32Z

.github/scripts/find_min_gemfile.rb

+  end
+end
+
+def get_integration_names(directory = 'lib/datadog/tracing/contrib/')


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

datadog-datadog-prod-us1 · 2024-12-11T18:00:32Z

.github/scripts/find_min_gemfile.rb

+end
+
+# Helper: Validate the version format
+def version_valid?(version)


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

datadog-datadog-prod-us1 · 2024-12-11T18:00:32Z

.github/scripts/find_min_gemfile.rb

+# 1. "pessimistic" versions, ex. '~> 1.2.3'
+# 2. '>= 1.2.3'
+# 3. 1.2.3
+def extract_version(constraint)


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

datadog-datadog-prod-us1 · 2024-12-11T18:00:32Z

.github/scripts/find_min_gemfile.rb

+
+# Helper: Parse a Gemfile-style gem declaration
+# ex. gem 'ruby-kafka', '~> 5.0'
+def parse_gemfile_entry(line)


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

datadog-datadog-prod-us1 · 2024-12-11T18:00:32Z

.github/scripts/find_min_gemfile.rb

+
+# Helper: Parse a Gemfile.lock-style entry
+# matches on ex. actionmailer (= 6.0.6)
+def parse_gemfile_lock_entry(line)


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

datadog-datadog-prod-us1 · 2024-12-11T18:00:32Z

.github/scripts/find_min_gemfile.rb

+require 'rubygems'
+require 'json'
+
+def parse_gemfiles(directory = 'gemfiles/')


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

datadog-datadog-prod-us1 · 2024-12-11T18:03:01Z

Datadog Report

Branch report: quinna.halim/add-supported-versions-table
Commit report: 3b8cff4
Test service: dd-trace-rb

✅ 0 Failed, 22109 Passed, 1475 Skipped, 5m 28.22s Total Time

datadog-datadog-prod-us1 · 2024-12-11T18:21:17Z

.github/scripts/find_gem_version_bounds.rb

+
+# Helper: Parse a Gemfile.lock-style entry
+# matches on ex. actionmailer (= 6.0.6)
+def parse_gemfile_lock_entry(line)


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

datadog-datadog-prod-us1 · 2024-12-11T18:21:17Z

.github/scripts/find_gem_version_bounds.rb

+
+# Helper: Parse a Gemfile-style gem declaration
+# ex. gem 'ruby-kafka', '~> 5.0'
+def parse_gemfile_entry(line)


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

datadog-datadog-prod-us1 · 2024-12-11T18:21:17Z

.github/scripts/find_gem_version_bounds.rb

+require 'rubygems'
+require 'json'
+
+def parse_gemfiles(directory = 'gemfiles/')


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

datadog-datadog-prod-us1 · 2024-12-11T18:21:17Z

.github/scripts/find_gem_version_bounds.rb

+end
+
+# Helper: Validate the version format
+def version_valid?(version)


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

datadog-datadog-prod-us1 · 2024-12-11T18:21:17Z

.github/scripts/find_gem_version_bounds.rb

+# 1. "pessimistic" versions, ex. '~> 1.2.3'
+# 2. '>= 1.2.3'
+# 3. 1.2.3
+def extract_version(constraint)


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

datadog-datadog-prod-us1 · 2024-12-11T18:21:17Z

.github/scripts/find_gem_version_bounds.rb

+  end
+end
+
+def get_integration_names(directory = 'lib/datadog/tracing/contrib/')


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

.github/scripts/find_gem_version_bounds.rb

marcotc · 2024-12-13T22:06:35Z

integration_versions.md

+
+| Integration | Ruby Min |  Ruby Max | JRuby Min | JRuby Max |
+|-------------|----------|-----------|----------|----------|
+| action_cable | 5.2.8.1 | 7.1.3.4 | 5.2.8.1 | 6.1.7.8 |


My suggestion for excluded versions (e.g. != 3.7.0) is to add an extra column (Ruby Unsupported & JRuby Unsupported) and add these individually excluded versions in it.

@marcotc Are there currently versions that need are excluded within supported ranges of gems or is this something that would be a nice to have?

integration_versions.md

marcotc · 2024-12-13T22:20:14Z

Potentially either the existing Update Latest Dependency workflow or a new workflow

I'd say add it to Update Latest Dependency for now. It should technically be on every PR that changes dependencies, but would be tricky to coordinate two automated commits at the same time (this and the existing Lock Dependency action).

datadog-datadog-prod-us1 · 2024-12-18T18:26:28Z

.github/scripts/find_gem_version_bounds.rb

+  end
+end
+
+def parse_gemfile(gemfile_path)


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

.github/scripts/find_gem_version_bounds.rb

datadog-datadog-prod-us1 · 2024-12-18T19:28:40Z

.github/scripts/find_gem_version_bounds.rb

+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'datadog'
+
+def parse_gemfiles(directory = 'gemfiles/')


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

datadog-datadog-prod-us1 · 2024-12-18T19:28:41Z

.github/scripts/find_gem_version_bounds.rb

+  end
+end
+
+def update_gem_versions(runtime, gem_name, version, min_gems, max_gems)


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

datadog-datadog-prod-us1 · 2024-12-18T19:28:41Z

.github/scripts/find_gem_version_bounds.rb

+  [min_gems['ruby'], min_gems['jruby'], max_gems['ruby'], max_gems['jruby']]
+end
+
+def process_gemfile(gemfile_name, runtime, min_gems, max_gems)


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

datadog-datadog-prod-us1 · 2024-12-18T19:28:41Z

.github/scripts/find_gem_version_bounds.rb

+  end
+end
+
+def process_lockfile(gemfile_name, runtime, min_gems, max_gems)


🔵 Code Quality Violation

Avoid top-level methods definition. Organize methods in modules/classes. (...read more)

This rule emphasizes the importance of organizing methods within modules or classes in Ruby. In Ruby, it's considered a best practice to wrap methods within classes or modules. This is because it helps in grouping related methods together, which in turn makes the code easier to understand, maintain, and reuse.

Not adhering to this rule can lead to a disorganized codebase, making it hard for other developers to understand and maintain the code. It can also lead to potential name clashes if a method is defined in the global scope.

To avoid violating this rule, always define your methods within a class or a module. For example, instead of writing def some_method; end, you should write class SomeClass def some_method; end end. This not only adheres to the rule but also improves the readability and maintainability of your code.

datadog-datadog-prod-us1 · 2024-12-18T19:28:41Z

.github/scripts/find_gem_version_bounds.rb

+end
+
+def process_gemfile(gemfile_name, runtime, min_gems, max_gems)
+  begin


⚪ Code Quality Violation

Use the method's implicit 'begin' instead of adding an explicit 'begin' block (...read more)

In Ruby, every method has an implicit begin...end block. Therefore, using an explicit begin...end block at the beginning of a method is redundant and can lead to unnecessary code complexity. This rule is designed to ensure that your code is as clean and efficient as possible.

The importance of this rule lies in the practice of writing clean, maintainable, and efficient code. Unnecessary code can lead to confusion for other developers, making the codebase more difficult to understand and maintain. It can also lead to potential bugs or performance issues.

To adhere to this rule, ensure that you do not use an explicit begin...end block at the beginning of a method. Instead, you can use the method's implicit begin and only use an explicit begin...end block when you want to handle exceptions in a specific part of your method. This practice will lead to cleaner and more efficient code.

quinna-h · 2024-12-18T19:29:27Z

Potentially either the existing Update Latest Dependency workflow or a new workflow

I'd say add it to Update Latest Dependency for now. It should technically be on every PR that changes dependencies, but would be tricky to coordinate two automated commits at the same time (this and the existing Lock Dependency action).

I think we are going to end up putting it in a separate workflow, as we want it to be tied to the tracer release process (but for now make it manual, aka triggered on workflow dispatch)

bouwkast

LGTM

We should get a language experts review on this and the output table here to ensure that they are happy with the integrations and associated versions: https://github.com/DataDog/dd-trace-rb/pull/4236/files#diff-f0b9875c282b2a3ae40002cd5ea7085509e744df2ba94d0301f5c0ba313203fd

.github/scripts/generate_table_versions.rb

bouwkast · 2024-12-19T22:09:30Z

.github/scripts/find_gem_version_bounds.rb

+
+# TODO: The gem information should reside in the integration declaration instead of here.
+
+mapping = {


There are some that I don't see and I don't think have a clear automation path that we could potentially just hardcode in:

Net/HTTP and Makara (via Active Record) are the only two I see (may have missed one though)

Just went through the list of them here: https://docs.datadoghq.com/tracing/trace_collection/compatibility/ruby/#integrations

left comments about these on the generated PR: #4236

Co-authored-by: Steven Bouwkamp <[email protected]>

quinna-h · 2024-12-20T16:16:23Z

.github/workflows/generate-supported-versions.yml

+on:
+  push:
+    branches:
+      - quinna.halim/add-supported-versions-table


note to self: remove before merge

codecov-commenter · 2024-12-23T20:34:42Z

Codecov Report

Attention: Patch coverage is 50.00000% with 15 lines in your changes missing coverage. Please review.

Project coverage is 97.73%. Comparing base (11b9ae1) to head (3b8cff4).
Report is 4 commits behind head on master.

Files with missing lines	Patch %	Lines
...atadog/tracing/contrib/action_cable/integration.rb	50.00%	1 Missing ⚠️
...tadog/tracing/contrib/action_mailer/integration.rb	50.00%	1 Missing ⚠️
...datadog/tracing/contrib/action_pack/integration.rb	50.00%	1 Missing ⚠️
...datadog/tracing/contrib/action_view/integration.rb	50.00%	1 Missing ⚠️
.../datadog/tracing/contrib/active_job/integration.rb	50.00%	1 Missing ⚠️
...tadog/tracing/contrib/active_record/integration.rb	50.00%	1 Missing ⚠️
...adog/tracing/contrib/active_support/integration.rb	50.00%	1 Missing ⚠️
lib/datadog/tracing/contrib/aws/integration.rb	50.00%	1 Missing ⚠️
...dog/tracing/contrib/concurrent_ruby/integration.rb	50.00%	1 Missing ⚠️
lib/datadog/tracing/contrib/httprb/integration.rb	50.00%	1 Missing ⚠️
... and 5 more

Additional details and impacted files

@@            Coverage Diff             @@
##           master    #4210      +/-   ##
==========================================
- Coverage   97.74%   97.73%   -0.02%     
==========================================
  Files        1355     1355              
  Lines       82333    82374      +41     
  Branches     4226     4228       +2     
==========================================
+ Hits        80477    80508      +31     
- Misses       1856     1866      +10

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

quinna-h added 2 commits December 9, 2024 12:55

add supported version script and table

3f4560a

update script

1980b6f

quinna-h added the dev/internal Other internal work that does not need to be included in the changelog label Dec 9, 2024

datadog-datadog-prod-us1 bot reviewed Dec 9, 2024

View reviewed changes

rubocop lint

1b2986e

datadog-datadog-prod-us1 bot reviewed Dec 9, 2024

View reviewed changes

quinna-h requested a review from TonyCTHsu December 11, 2024 15:11

modify script locations, add description to md table

5bee321

datadog-datadog-prod-us1 bot reviewed Dec 11, 2024

View reviewed changes

improve table output

b2818a9

wip

53b807f

datadog-datadog-prod-us1 bot reviewed Dec 11, 2024

View reviewed changes

marcotc reviewed Dec 13, 2024

View reviewed changes

.github/scripts/find_gem_version_bounds.rb Outdated Show resolved Hide resolved

marcotc reviewed Dec 13, 2024

View reviewed changes

.github/scripts/find_gem_version_bounds.rb Outdated Show resolved Hide resolved

marcotc reviewed Dec 13, 2024

View reviewed changes

.github/scripts/find_gem_version_bounds.rb Outdated Show resolved Hide resolved

marcotc reviewed Dec 13, 2024

View reviewed changes

.github/scripts/find_gem_version_bounds.rb Outdated Show resolved Hide resolved

marcotc reviewed Dec 13, 2024

View reviewed changes

integration_versions.md Outdated Show resolved Hide resolved

refactor code

df5640a

datadog-datadog-prod-us1 bot reviewed Dec 18, 2024

View reviewed changes

wip

2b15400

datadog-datadog-prod-us1 bot reviewed Dec 18, 2024

View reviewed changes

Merge branch 'master' into quinna.halim/add-supported-versions-table

112db1f

quinna-h added 2 commits December 18, 2024 17:04

add supported versions

3b5aae2

add branch for testing

4ada6cf

remove json to avoid merge conflict issues

b4526e2

quinna-h requested a review from bouwkast December 19, 2024 19:44

update PR body

d44249b

github-actions bot added the dev/github Github repository maintenance and automation label Dec 19, 2024

bouwkast approved these changes Dec 19, 2024

View reviewed changes

Update .github/scripts/generate_table_versions.rb

514be2c

Co-authored-by: Steven Bouwkamp <[email protected]>

quinna-h commented Dec 20, 2024

View reviewed changes

switch to use gem declarations instead of hardcoded mappings

65aee38

github-actions bot added integrations Involves tracing integrations tracing labels Dec 23, 2024

quinna-h added 2 commits December 23, 2024 15:48

linting checks

6fb1de7

cleanup comments

3b8cff4


		# TODO: The gem information should reside in the integration declaration instead of here.

		mapping = {

add supported versions workflow #4210

Are you sure you want to change the base?

add supported versions workflow #4210

Conversation

quinna-h commented Dec 9, 2024 • edited Loading

github-actions bot commented Dec 9, 2024 • edited Loading

datadog-datadog-prod-us1 bot Dec 9, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Dec 9, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

pr-commenter bot commented Dec 9, 2024 • edited Loading

Benchmarks

datadog-datadog-prod-us1 bot Dec 9, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Dec 9, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Dec 9, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Dec 9, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Dec 11, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Dec 11, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Dec 11, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Dec 11, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Dec 11, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Dec 11, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot commented Dec 11, 2024 • edited Loading

Datadog Report

datadog-datadog-prod-us1 bot Dec 11, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Dec 11, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Dec 11, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Dec 11, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Dec 11, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Dec 11, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

marcotc Dec 13, 2024

Choose a reason for hiding this comment

bouwkast Dec 19, 2024

Choose a reason for hiding this comment

marcotc commented Dec 13, 2024

datadog-datadog-prod-us1 bot Dec 18, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Dec 18, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Dec 18, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Dec 18, 2024

Choose a reason for hiding this comment

quinna-h commented Dec 9, 2024 •

edited

Loading

github-actions bot commented Dec 9, 2024 •

edited

Loading

pr-commenter bot commented Dec 9, 2024 •

edited

Loading

datadog-datadog-prod-us1 bot commented Dec 11, 2024 •

edited

Loading

codecov-commenter commented Dec 23, 2024 •

edited

Loading