modularization_statistics 1.33.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dfd014b44b30778ec250a807009b4803b8e4b81c99e4fcc46d70cfca8feca8bb
+  data.tar.gz: ba83025eaa394685d99a28eadb5a7e30893107396b1c723b055e7ab6c6e09895
+SHA512:
+  metadata.gz: ebad79ae91d8d0731d259574f515375ed2306cb6b89458e969141f5c02ff4c88f67f926e7eec2ffc29659c5486d49f61bcbe51fcec5f4157aa277c9ad46b2c7c
+  data.tar.gz: 3b833b67284142468e86361797fec62761db59e9917db398179593bd2df6e4de4bb392a8ce6b999fe91f7bde496aeabba1165b3341e69ba989ac733e2f27de4c

data/README.md

@@ -0,0 +1,67 @@
+# ModularizationStatistics
+
+This gem is used to report opinionated statistics about modularization to DataDog and other observability systems.
+
+# Usage
+The main method to this gem is `ModularizationStatistics#report_to_datadog!`. Refer to the Sorbet signature for this method for the exact types to be passed in.
+
+This is an example of how to use this API:
+
+```ruby
+ModularizationStatistics.report_to_datadog!(
+  #
+  # A properly initialized `Dogapi::Client`
+  # Example: Dogapi::Client.new(ENV.fetch('DATADOG_API_KEY')
+  #
+  datadog_client: datadog_client,
+  #
+  # Time attached to the metrics
+  # Example: Time.now
+  #
+  report_time: report_time
+  # 
+  # This is used to determine what files to look at for building statistics about what types of files are packaged, componentized, or unpackaged. 
+  # This is an array of `Pathname`. `Pathname` can be relative or absolute paths.
+  #
+  # Example: source_code_pathnames = Pathname.glob('./**/**.rb')
+  #
+  source_code_pathnames: source_code_pathnames,
+  #
+  # A file is determined to be componentized if it exists in any of these directories.
+  # This is an array of `Pathname`. `Pathname` can be relative or absolute paths.
+  #
+  # Example: [Pathname.new("./gems")]
+  #
+  componentized_source_code_locations: componentized_source_code_locations,
+  # 
+  # A file is determined to be packaged if it exists in any of these directories.
+  # This is an array of `Pathname`. `Pathname` can be relative or absolute paths.
+  #
+  # Example: [Pathname.new("./packs")]
+  #
+  packaged_source_code_locations: packaged_source_code_locations,
+)
+```
+
+# Using Other Observability Tools
+
+Right now this tool sends metrics to DataDog early. However, if you want to use this with other tools, you can call `ModularizationStatistics.get_metrics(...)` to get generic metrics that you can then send to whatever observability provider you use.
+
+# Setting Up Your Dashboards
+
+Gusto has two dashboards that we've created to view these metrics. We've also exported and released the Dashboard JSON for each of these dashboards. You can create a new dashboard and then click "import dashboard JSON" to get a jump start on tracking your metrics. Note you may want to make some tweaks to these dashboards to better fit your organization's circumstances and goals.
+
+## [Modularization] Executive Summary
+
+This helps answer questions like:
+- How are we doing on reducing dependency and privacy violations in your monolith overall?
+- How are we doing overall on adopting package protections?
+
+[Dashboard JSON](docs/executive_summary.json)
+
+## [Modularization] Per-Package and Per-Team
+- How is each team and package doing on reducing dependency and privacy violations in your monolith?
+- What is the total count of dependency/privacy violations for each pack/team and what's the change since last month?
+- Which pack/team does my pack/team have the most dependency/privacy violations on?
+
+[Dashboard JSON](docs/per_package_and_per_team.json)

data/lib/modularization_statistics/gauge_metric.rb

@@ -0,0 +1,39 @@
+# typed: strict
+
+module ModularizationStatistics
+  class GaugeMetric < T::Struct
+    extend T::Sig
+
+    const :name, String
+    const :count, Integer
+    const :tags, T::Array[Tag]
+
+    sig { params(metric_name: String, count: Integer, tags: T::Array[Tag]).returns(GaugeMetric) }
+    def self.for(metric_name, count, tags)
+      name = "modularization.#{metric_name}"
+      # https://docs.datadoghq.com/metrics/custom_metrics/#naming-custom-metrics
+      # Metric names must not exceed 200 characters. Fewer than 100 is preferred from a UI perspective
+      if name.length > 200
+        raise StandardError.new("Metrics names must not exceed 200 characters: #{name}") # rubocop:disable Style/RaiseArgs
+      end
+
+      new(
+        name: name,
+        count: count,
+        tags: tags
+      )
+    end
+
+    sig { returns(String) }
+    def to_s
+      "#{name} with count #{count}, with tags #{tags.map(&:to_s).join(', ')}"
+    end
+
+    sig { params(other: GaugeMetric).returns(T::Boolean) }
+    def ==(other)
+      other.name == self.name &&
+        other.count == self.count &&
+        other.tags == self.tags
+    end
+  end
+end

data/lib/modularization_statistics/private/datadog_reporter.rb

@@ -0,0 +1,325 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'dogapi'
+
+module ModularizationStatistics
+  module Private
+    class DatadogReporter
+      extend T::Sig
+
+      UNKNOWN_OWNER = T.let('Unknown', String)
+
+      sig do
+        params(
+          source_code_files: T::Array[SourceCodeFile],
+          app_name: String
+        ).returns(T::Array[GaugeMetric])
+      end
+      def self.get_metrics(source_code_files:, app_name:)
+        all_metrics = T.let([], T::Array[GaugeMetric])
+        app_level_tag = Tag.for('app', app_name)
+
+        source_code_files.group_by { |file| file.team_owner&.name }.each do |team_name, files_for_team|
+          file_tags = tags_for_team(team_name) + [app_level_tag]
+          all_metrics += get_file_metrics('by_team', file_tags, files_for_team)
+        end
+
+        file_tags = [app_level_tag]
+        all_metrics += get_file_metrics('totals', file_tags, source_code_files)
+
+        packages = ParsePackwerk.all
+        all_metrics += get_package_metrics(packages, app_name)
+        all_metrics += get_package_metrics_by_team(packages, app_name)
+
+        all_metrics
+      end
+
+      sig do
+        params(
+          datadog_client: Dogapi::Client,
+          # Since `gauge` buckets data points we need to use the same time for all API calls
+          # to ensure they fall into the same bucket.
+          report_time: Time,
+          metrics: T::Array[GaugeMetric]
+        ).void
+      end
+      def self.report!(datadog_client:, report_time:, metrics:)
+        #
+        # Batching the metrics sends a post request to DD
+        # we want to split this up into chunks of 1000 so that as we add more metrics,
+        # our payload is not rejected for being too large
+        #
+        metrics.each_slice(1000).each do |metric_slice|
+          datadog_client.batch_metrics do
+            metric_slice.each do |metric|
+              datadog_client.emit_points(metric.name, [[report_time, metric.count]], type: 'gauge', tags: metric.tags.map(&:to_s))
+            end
+          end
+        end
+      end
+
+      sig { params(package: ParsePackwerk::Package, app_name: String).returns(T::Array[Tag]) }
+      def self.tags_for_package(package, app_name)
+        [
+          Tag.new(key: 'package', value: humanized_package_name(package.name)),
+          Tag.new(key: 'app', value: app_name),
+          *tags_for_team(CodeOwnership.for_package(package)&.name),
+        ]
+      end
+
+      sig { params(team_name: T.nilable(String)).returns(T::Array[Tag]) }
+      def self.tags_for_team(team_name)
+        [Tag.for('team', team_name || UNKNOWN_OWNER)]
+      end
+
+      sig { params(team_name: T.nilable(String)).returns(T::Array[Tag]) }
+      def self.tags_for_to_team(team_name)
+        [Tag.for('to_team', team_name || UNKNOWN_OWNER)]
+      end
+
+      private_class_method :tags_for_package
+
+      sig do
+        params(
+          packages: T::Array[ParsePackwerk::Package],
+          app_name: String
+        ).returns(T::Array[GaugeMetric])
+      end
+      def self.get_package_metrics(packages, app_name)
+        all_metrics = []
+        app_level_tag = Tag.for('app', app_name)
+        package_tags = T.let([app_level_tag], T::Array[Tag])
+        protected_packages = packages.map { |p| PackageProtections::ProtectedPackage.from(p) }
+
+        all_metrics << GaugeMetric.for('all_packages.count', packages.count, package_tags)
+        all_metrics << GaugeMetric.for('all_packages.dependencies.count', packages.sum { |package| package.dependencies.count }, package_tags)
+        all_metrics << GaugeMetric.for('all_packages.dependency_violations.count', protected_packages.sum { |package| file_count(package.violations.select(&:dependency?)) }, package_tags)
+        all_metrics << GaugeMetric.for('all_packages.privacy_violations.count', protected_packages.sum { |package| file_count(package.violations.select(&:privacy?)) }, package_tags)
+        all_metrics << GaugeMetric.for('all_packages.enforcing_dependencies.count', packages.count(&:enforces_dependencies?), package_tags)
+        all_metrics << GaugeMetric.for('all_packages.enforcing_privacy.count', packages.count(&:enforces_privacy?), package_tags)
+
+        all_metrics << GaugeMetric.for('all_packages.notify_on_package_yml_changes.count', packages.count { |p| p.metadata['notify_on_package_yml_changes'] }, package_tags)
+        all_metrics << GaugeMetric.for('all_packages.notify_on_new_violations.count', packages.count { |p| p.metadata['notify_on_new_violations'] }, package_tags)
+
+        all_metrics << GaugeMetric.for('all_packages.with_violations.count', protected_packages.count { |package| package.violations.any? }, package_tags)
+        all_metrics += self.get_public_usage_metrics('all_packages', packages, package_tags)
+        all_metrics << GaugeMetric.for('all_packages.has_readme.count', packages.count { |package| has_readme?(package) }, package_tags)
+
+        all_metrics += self.get_protections_metrics('all_packages', protected_packages, package_tags)
+        all_metrics << GaugeMetric.for('all_packages.package_based_file_ownership.count', packages.count { |package| !package.metadata['owner'].nil? }, package_tags)
+
+        inbound_violations_by_package = protected_packages.flat_map(&:violations).group_by(&:to_package_name)
+
+        protected_packages.each do |protected_package|
+          package = protected_package.original_package
+          package_tags = tags_for_package(package, app_name)
+
+          #
+          # VIOLATIONS (implicit dependencies)
+          #
+          outbound_violations = protected_package.violations
+          inbound_violations = inbound_violations_by_package[package.name] || []
+          all_dependency_violations = (outbound_violations + inbound_violations).select(&:dependency?)
+          all_privacy_violations = (outbound_violations + inbound_violations).select(&:privacy?)
+
+          all_metrics << GaugeMetric.for('by_package.dependency_violations.count', file_count(all_dependency_violations), package_tags)
+          all_metrics << GaugeMetric.for('by_package.privacy_violations.count', file_count(all_privacy_violations), package_tags)
+
+          all_metrics << GaugeMetric.for('by_package.outbound_dependency_violations.count', file_count(outbound_violations.select(&:dependency?)), package_tags)
+          all_metrics << GaugeMetric.for('by_package.inbound_dependency_violations.count', file_count(inbound_violations.select(&:dependency?)), package_tags)
+
+          all_metrics << GaugeMetric.for('by_package.outbound_privacy_violations.count', file_count(outbound_violations.select(&:privacy?)), package_tags)
+          all_metrics << GaugeMetric.for('by_package.inbound_privacy_violations.count', file_count(inbound_violations.select(&:privacy?)), package_tags)
+
+          all_metrics += self.get_public_usage_metrics('by_package', [package], package_tags)
+
+          protected_package.violations.group_by(&:to_package_name).each do |to_package_name, violations|
+            to_package = ParsePackwerk.find(to_package_name)
+            if to_package.nil?
+              raise StandardError, "Could not find matching package #{to_package_name}"
+            end
+
+            tags = package_tags + [Tag.for('to_package', humanized_package_name(to_package_name))] + tags_for_to_team(CodeOwnership.for_package(to_package)&.name)
+            all_metrics << GaugeMetric.for('by_package.outbound_dependency_violations.per_package.count', file_count(violations.select(&:dependency?)), tags)
+            all_metrics << GaugeMetric.for('by_package.outbound_privacy_violations.per_package.count', file_count(violations.select(&:privacy?)), tags)
+          end
+        end
+
+        inbound_explicit_dependency_by_package = {}
+        packages.each do |package|
+          package.dependencies.each do |explicit_dependency|
+            inbound_explicit_dependency_by_package[explicit_dependency] ||= []
+            inbound_explicit_dependency_by_package[explicit_dependency] << package.name
+          end
+        end
+
+        packages.each do |package| # rubocop:disable Style/CombinableLoops
+          package_tags = tags_for_package(package, app_name)
+
+          #
+          # EXPLICIT DEPENDENCIES
+          #
+          package.dependencies.each do |explicit_dependency|
+            to_package = ParsePackwerk.find(explicit_dependency)
+            if to_package.nil?
+              raise StandardError, "Could not find matching package #{explicit_dependency}"
+            end
+
+            tags = package_tags + [Tag.for('to_package', humanized_package_name(explicit_dependency))] + tags_for_to_team(CodeOwnership.for_package(to_package)&.name)
+            all_metrics << GaugeMetric.for('by_package.outbound_explicit_dependencies.per_package.count', 1, tags)
+          end
+
+          all_metrics << GaugeMetric.for('by_package.outbound_explicit_dependencies.count', package.dependencies.count, package_tags)
+          all_metrics << GaugeMetric.for('by_package.inbound_explicit_dependencies.count', inbound_explicit_dependency_by_package[package.name]&.count || 0, package_tags)
+        end
+
+        all_metrics
+      end
+
+      sig do
+        params(
+          all_packages: T::Array[ParsePackwerk::Package],
+          app_name: String
+        ).returns(T::Array[GaugeMetric])
+      end
+      def self.get_package_metrics_by_team(all_packages, app_name)
+        all_metrics = T.let([], T::Array[GaugeMetric])
+        app_level_tag = Tag.for('app', app_name)
+        all_protected_packages = all_packages.map { |p| PackageProtections::ProtectedPackage.from(p) }
+        all_protected_packages.group_by { |protected_package| CodeOwnership.for_package(protected_package.original_package)&.name }.each do |team_name, protected_packages_by_team|
+          # We look at `all_packages` because we care about ALL inbound violations across all teams
+          inbound_violations_by_package = all_protected_packages.flat_map(&:violations).group_by(&:to_package_name)
+
+          team_tags = tags_for_team(team_name) + [app_level_tag]
+          all_metrics << GaugeMetric.for('by_team.all_packages.count', protected_packages_by_team.count, team_tags)
+          all_metrics += self.get_protections_metrics('by_team', protected_packages_by_team, team_tags)
+          all_metrics += self.get_public_usage_metrics('by_team', protected_packages_by_team.map(&:original_package), team_tags)
+
+          all_metrics << GaugeMetric.for('by_team.notify_on_package_yml_changes.count', protected_packages_by_team.count { |p| p.metadata['notify_on_package_yml_changes'] }, team_tags)
+          all_metrics << GaugeMetric.for('by_team.notify_on_new_violations.count', protected_packages_by_team.count { |p| p.metadata['notify_on_new_violations'] }, team_tags)
+
+          #
+          # VIOLATIONS (implicit dependencies)
+          #
+          outbound_violations = protected_packages_by_team.flat_map(&:violations)
+          # Here we only look at packages_by_team because we only care about inbound violations onto packages for this team
+          inbound_violations = protected_packages_by_team.flat_map { |package| inbound_violations_by_package[package.name] || [] }
+          all_dependency_violations = (outbound_violations + inbound_violations).select(&:dependency?)
+          all_privacy_violations = (outbound_violations + inbound_violations).select(&:privacy?)
+
+          all_metrics << GaugeMetric.for('by_team.dependency_violations.count', file_count(all_dependency_violations), team_tags)
+          all_metrics << GaugeMetric.for('by_team.privacy_violations.count', file_count(all_privacy_violations), team_tags)
+
+          all_metrics << GaugeMetric.for('by_team.outbound_dependency_violations.count', file_count(outbound_violations.select(&:dependency?)), team_tags)
+          all_metrics << GaugeMetric.for('by_team.inbound_dependency_violations.count', file_count(inbound_violations.select(&:dependency?)), team_tags)
+
+          all_metrics << GaugeMetric.for('by_team.outbound_privacy_violations.count', file_count(outbound_violations.select(&:privacy?)), team_tags)
+          all_metrics << GaugeMetric.for('by_team.inbound_privacy_violations.count', file_count(inbound_violations.select(&:privacy?)), team_tags)
+
+          all_metrics << GaugeMetric.for('by_team.has_readme.count', protected_packages_by_team.count { |protected_package| has_readme?(protected_package.original_package) }, team_tags)
+
+          grouped_outbound_violations = outbound_violations.group_by do |violation|
+            to_package = ParsePackwerk.find(violation.to_package_name)
+            if to_package.nil?
+              raise StandardError, "Could not find matching package #{violation.to_package_name}"
+            end
+
+            CodeOwnership.for_package(to_package)&.name
+          end
+
+          grouped_outbound_violations.each do |to_team_name, violations|
+            tags = team_tags + tags_for_to_team(to_team_name)
+            all_metrics << GaugeMetric.for('by_team.outbound_dependency_violations.per_team.count', file_count(violations.select(&:dependency?)), tags)
+            all_metrics << GaugeMetric.for('by_team.outbound_privacy_violations.per_team.count', file_count(violations.select(&:privacy?)), tags)
+          end
+        end
+
+        all_metrics
+      end
+
+      private_class_method :get_package_metrics
+
+      sig do
+        params(
+          metric_name_suffix: String,
+          tags: T::Array[Tag],
+          files: T::Array[SourceCodeFile]
+        ).returns(T::Array[GaugeMetric])
+      end
+      def self.get_file_metrics(metric_name_suffix, tags, files)
+        [
+          GaugeMetric.for("component_files.#{metric_name_suffix}", files.count(&:componentized_file?), tags),
+          GaugeMetric.for("packaged_files.#{metric_name_suffix}", files.count(&:packaged_file?), tags),
+          GaugeMetric.for("all_files.#{metric_name_suffix}", files.count, tags),
+        ]
+      end
+
+      private_class_method :get_file_metrics
+
+      sig { params(prefix: String, protected_packages: T::Array[PackageProtections::ProtectedPackage], package_tags: T::Array[Tag]).returns(T::Array[GaugeMetric]) }
+      def self.get_protections_metrics(prefix, protected_packages, package_tags)
+        PackageProtections.all.flat_map do |protection|
+          PackageProtections::ViolationBehavior.each_value.map do |violation_behavior|
+            # https://github.com/Gusto/package_protections/pull/42 changed the public API of these violation behaviors.
+            # To preserve our ability to understand historical trends, we map to the old values.
+            # This allows our dashboards to continue to operate as expected.
+            # Note if we ever open source mod stats, we should probably inject this behavior so that new clients can see the new keys in their metrics.
+            violation_behavior_map = {
+              PackageProtections::ViolationBehavior::FailOnAny => 'fail_the_build_on_any_instances',
+              PackageProtections::ViolationBehavior::FailNever => 'no',
+              PackageProtections::ViolationBehavior::FailOnNew => 'fail_the_build_if_new_instances_appear',
+            }
+            violation_behavior_name = violation_behavior_map[violation_behavior]
+            metric_name = "#{prefix}.#{protection.identifier}.#{violation_behavior_name}.count"
+            count_of_packages = protected_packages.count { |p| p.violation_behavior_for(protection.identifier) == violation_behavior }
+            GaugeMetric.for(metric_name, count_of_packages, package_tags)
+          end
+        end
+      end
+
+      sig { params(prefix: String, packages: T::Array[ParsePackwerk::Package], package_tags: T::Array[Tag]).returns(T::Array[GaugeMetric]) }
+      def self.get_public_usage_metrics(prefix, packages, package_tags)
+        packages_except_for_root = packages.reject { |package| package.name == ParsePackwerk::ROOT_PACKAGE_NAME }
+        all_files = packages_except_for_root.flat_map do |package|
+          package.directory.glob('**/**.rb')
+        end
+
+        all_public_files = T.let([], T::Array[Pathname])
+        is_using_public_directory = 0
+        packages_except_for_root.each do |package|
+          public_files = package.directory.glob('app/public/**/**.rb')
+          all_public_files += public_files
+          is_using_public_directory += 1 if public_files.any?
+        end
+
+        # In Datadog, can divide public files by all files to get the ratio.
+        # This is not a metric that we are targeting -- its for observability and reflection only.
+        [
+          GaugeMetric.for("#{prefix}.all_files.count", all_files.count, package_tags),
+          GaugeMetric.for("#{prefix}.public_files.count", all_public_files.count, package_tags),
+          GaugeMetric.for("#{prefix}.using_public_directory.count", is_using_public_directory, package_tags),
+        ]
+      end
+
+      sig { params(package: ParsePackwerk::Package).returns(T::Boolean) }
+      def self.has_readme?(package)
+        package.directory.join('README.md').exist?
+      end
+
+      sig { params(violations: T::Array[ParsePackwerk::Violation]).returns(Integer) }
+      def self.file_count(violations)
+        violations.sum { |v| v.files.count }
+      end
+
+      sig { params(name: String).returns(String) }
+      def self.humanized_package_name(name)
+        if name == ParsePackwerk::ROOT_PACKAGE_NAME
+          'root'
+        else
+          name
+        end
+      end
+    end
+  end
+end

data/lib/modularization_statistics/private/source_code_file.rb

@@ -0,0 +1,24 @@
+# typed: strict
+
+module ModularizationStatistics
+  module Private
+    class SourceCodeFile < T::Struct
+      extend T::Sig
+
+      const :is_componentized_file, T::Boolean
+      const :is_packaged_file, T::Boolean
+      const :team_owner, T.nilable(Teams::Team)
+      const :pathname, Pathname
+
+      sig { returns(T::Boolean) }
+      def componentized_file?
+        self.is_componentized_file
+      end
+
+      sig { returns(T::Boolean) }
+      def packaged_file?
+        self.is_packaged_file
+      end
+    end
+  end
+end

data/lib/modularization_statistics/private.rb

@@ -0,0 +1,8 @@
+# typed: strict
+
+module ModularizationStatistics
+  module Private
+  end
+
+  private_constant :Private
+end

data/lib/modularization_statistics/tag.rb

@@ -0,0 +1,28 @@
+# typed: strict
+
+module ModularizationStatistics
+  class Tag < T::Struct
+    extend T::Sig
+    const :key, String
+    const :value, String
+
+    sig { returns(String) }
+    def to_s
+      "#{key}:#{value}"
+    end
+
+    sig { params(key: String, value: String).returns(Tag) }
+    def self.for(key, value)
+      new(
+        key: key,
+        value: value
+      )
+    end
+
+    sig { params(other: Tag).returns(T::Boolean) }
+    def ==(other)
+      other.key == self.key &&
+        other.value == self.value
+    end
+  end
+end

data/lib/modularization_statistics/tags.rb

@@ -0,0 +1,20 @@
+# typed: strict
+
+module ModularizationStatistics
+  module Tags
+    extend T::Sig
+
+    sig { params(colon_delimited_tag_strings: T::Array[String]).returns(T::Array[Tag]) }
+    def self.for(colon_delimited_tag_strings)
+      colon_delimited_tag_strings.map do |colon_delimited_tag_string|
+        key, value = colon_delimited_tag_string.split(':')
+        raise StandardError, "Improperly formatted tag `#{colon_delimited_tag_string}`" if key.nil? || value.nil?
+
+        Tag.new(
+          key: key,
+          value: value
+        )
+      end
+    end
+  end
+end

data/lib/modularization_statistics.rb

@@ -0,0 +1,134 @@
+# typed: strict
+
+require 'sorbet-runtime'
+require 'json'
+require 'yaml'
+require 'benchmark'
+require 'teams'
+require 'code_ownership'
+require 'pathname'
+require 'modularization_statistics/private/source_code_file'
+require 'modularization_statistics/private/datadog_reporter'
+require 'parse_packwerk'
+require 'package_protections'
+require 'modularization_statistics/tag'
+require 'modularization_statistics/tags'
+require 'modularization_statistics/gauge_metric'
+
+module ModularizationStatistics
+  extend T::Sig
+
+  ROOT_PACKAGE_NAME = T.let('root'.freeze, String)
+
+  DEFAULT_COMPONENTIZED_SOURCE_CODE_LOCATIONS = T.let(
+    [
+      Pathname.new('components'),
+      Pathname.new('gems'),
+    ].freeze, T::Array[Pathname]
+  )
+
+  DEFAULT_PACKAGED_SOURCE_CODE_LOCATIONS = T.let(
+    [
+      Pathname.new('packs'),
+      Pathname.new('packages'),
+    ].freeze, T::Array[Pathname]
+  )
+
+  sig do
+    params(
+      datadog_client: Dogapi::Client,
+      app_name: String,
+      source_code_pathnames: T::Array[Pathname],
+      componentized_source_code_locations: T::Array[Pathname],
+      packaged_source_code_locations: T::Array[Pathname],
+      report_time: Time,
+      verbose: T::Boolean
+    ).void
+  end
+  def self.report_to_datadog!(
+    datadog_client:,
+    app_name:,
+    source_code_pathnames:,
+    componentized_source_code_locations: DEFAULT_COMPONENTIZED_SOURCE_CODE_LOCATIONS,
+    packaged_source_code_locations: DEFAULT_PACKAGED_SOURCE_CODE_LOCATIONS,
+    report_time: Time.now, # rubocop:disable Rails/TimeZone
+    verbose: false
+  )
+
+    all_metrics = self.get_metrics(
+      source_code_pathnames: source_code_pathnames,
+      componentized_source_code_locations: componentized_source_code_locations,
+      packaged_source_code_locations: packaged_source_code_locations,
+      app_name: app_name
+    )
+
+    # This helps us debug what metrics are being sent
+    if verbose
+      all_metrics.each do |metric|
+        puts "Sending metric: #{metric}"
+      end
+    end
+
+    Private::DatadogReporter.report!(
+      datadog_client: datadog_client,
+      report_time: report_time,
+      metrics: all_metrics
+    )
+  end
+
+  sig do
+    params(
+      source_code_pathnames: T::Array[Pathname],
+      componentized_source_code_locations: T::Array[Pathname],
+      packaged_source_code_locations: T::Array[Pathname],
+      app_name: String
+    ).returns(T::Array[GaugeMetric])
+  end
+  def self.get_metrics(
+    source_code_pathnames:,
+    componentized_source_code_locations:,
+    packaged_source_code_locations:,
+    app_name:
+  )
+    Private::DatadogReporter.get_metrics(
+      source_code_files: source_code_files(
+        source_code_pathnames: source_code_pathnames,
+        componentized_source_code_locations: componentized_source_code_locations,
+        packaged_source_code_locations: packaged_source_code_locations
+      ),
+      app_name: app_name
+    )
+  end
+
+  sig do
+    params(
+      source_code_pathnames: T::Array[Pathname],
+      componentized_source_code_locations: T::Array[Pathname],
+      packaged_source_code_locations: T::Array[Pathname]
+    ).returns(T::Array[Private::SourceCodeFile])
+  end
+  def self.source_code_files(
+    source_code_pathnames:,
+    componentized_source_code_locations:,
+    packaged_source_code_locations:
+  )
+
+    # Sorbet has the wrong signatures for `Pathname#find`, whoops!
+    componentized_file_set = Set.new(componentized_source_code_locations.select(&:exist?).flat_map { |pathname| T.unsafe(pathname).find.to_a })
+    packaged_file_set = Set.new(packaged_source_code_locations.select(&:exist?).flat_map { |pathname| T.unsafe(pathname).find.to_a })
+
+    source_code_pathnames.map do |pathname|
+      componentized_file = componentized_file_set.include?(pathname)
+      packaged_file = packaged_file_set.include?(pathname)
+
+      Private::SourceCodeFile.new(
+        pathname: pathname,
+        team_owner: CodeOwnership.for_file(pathname.to_s),
+        is_componentized_file: componentized_file,
+        is_packaged_file: packaged_file
+      )
+    end
+  end
+
+  private_class_method :source_code_files
+end

data/sorbet/config

@@ -0,0 +1,3 @@
+--dir
+.
+--ignore=/vendor/bundle