pack_stats 0.0.1

data/lib/pack_stats/private/metrics/public_usage.rb

@@ -0,0 +1,36 @@
+# typed: strict
+# frozen_string_literal: true
+
+module PackStats
+  module Private
+    module Metrics
+      class PublicUsage
+        extend T::Sig
+
+        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, we 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
+      end
+    end
+  end
+end

data/lib/pack_stats/private/metrics/rubocop_usage.rb

@@ -0,0 +1,98 @@
+# typed: strict
+# frozen_string_literal: true
+
+module PackStats
+  module Private
+    module Metrics
+      class RubocopUsage
+        extend T::Sig
+
+        sig { params(prefix: String, packages: T::Array[ParsePackwerk::Package], package_tags: T::Array[Tag]).returns(T::Array[GaugeMetric]) }
+        def self.get_metrics(prefix, packages, package_tags)
+          [
+            *get_rubocop_exclusions(prefix, packages, package_tags),
+            *get_rubocop_usage_metrics(prefix, packages, package_tags)
+          ]
+        end
+
+        sig { params(prefix: String, packages: T::Array[ParsePackwerk::Package], package_tags: T::Array[Tag]).returns(T::Array[GaugeMetric]) }
+        def self.get_rubocop_usage_metrics(prefix, packages, package_tags)
+          metrics = T.let([], T::Array[GaugeMetric])
+          
+          rubocops.each do |cop_name|
+            ['false', 'true', 'strict'].each do |enabled_mode|
+              count_of_packages = ParsePackwerk.all.count do |package|
+                # We will likely want a rubocop-packs API for this, to be able to ask if a cop is enabled for a pack.
+                # It's possible we will want to allow these to be enabled at the top-level `.rubocop.yml`,
+                # in which case we wouldn't get the right metrics with this approach. However, we can also accept
+                # that as a current limitation.
+                rubocop_yml_file = package.directory.join(RuboCop::Packs::PACK_LEVEL_RUBOCOP_YML)
+                next false if !rubocop_yml_file.exist?
+                rubocop_yml = YAML.load_file(rubocop_yml_file)
+                cop_config = rubocop_yml[cop_name]
+
+                strict_mode = cop_config && cop_config['FailureMode'] == 'strict'
+                enabled = cop_config && cop_config['Enabled']
+                case enabled_mode
+                when 'false'
+                  !enabled
+                when 'true'
+                  enabled && !strict_mode
+                when 'strict'
+                  !!strict_mode
+                end
+              end
+
+              metric_name = "#{prefix}.rubocops.#{to_tag_name(cop_name)}.#{enabled_mode}.count"
+              metrics << GaugeMetric.for(metric_name, count_of_packages, package_tags)
+            end
+          end
+
+          metrics
+        end
+
+        sig { params(prefix: String, packages: T::Array[ParsePackwerk::Package], package_tags: T::Array[Tag]).returns(T::Array[GaugeMetric]) }
+        def self.get_rubocop_exclusions(prefix, packages, package_tags)
+          rubocops.flat_map do |cop_name|
+            metric_name = "#{prefix}.rubocops.#{to_tag_name(cop_name)}.exclusions.count"
+            all_exclusions_count = ParsePackwerk.all.sum { |package| exclude_count_for_package_and_protection(package, cop_name)}
+            GaugeMetric.for(metric_name, all_exclusions_count, package_tags)
+          end
+        end
+
+        # TODO: `rubocop-packs` may want to expose API for this
+        sig { params(package: ParsePackwerk::Package, cop_name: String).returns(Integer) }
+        def self.exclude_count_for_package_and_protection(package, cop_name)
+          if package.name == ParsePackwerk::ROOT_PACKAGE_NAME
+            rubocop_todo = package.directory.join('.rubocop_todo.yml')
+          else
+            rubocop_todo = package.directory.join(RuboCop::Packs::PACK_LEVEL_RUBOCOP_TODO_YML)
+          end
+
+          if rubocop_todo.exist?
+            loaded_rubocop_todo = YAML.load_file(rubocop_todo)
+            cop_config = loaded_rubocop_todo.fetch(cop_name, {})
+            cop_config.fetch('Exclude', []).count
+          else
+            0
+          end
+        end
+
+        sig { returns(T::Array[String])}
+        def self.rubocops
+          [
+            'Packs/ClassMethodsAsPublicApis',
+            'Packs/RootNamespaceIsPackName',
+            'Packs/TypedPublicApis',
+            'Packs/DocumentedPublicApis',
+          ]
+        end
+
+        sig { params(cop_name: String).returns(String) }
+        def self.to_tag_name(cop_name)
+          cop_name.gsub('/', '_').downcase
+        end
+      end
+    end
+  end
+end

data/lib/pack_stats/private/metrics.rb

@@ -0,0 +1,49 @@
+# typed: strict
+# frozen_string_literal: true
+
+module PackStats
+  module Private
+    module Metrics
+      extend T::Sig
+      UNKNOWN_OWNER = T.let('Unknown', String)
+
+      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(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),
+          *Metrics.tags_for_team(CodeOwnership.for_package(package)&.name),
+        ]
+      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 || Metrics::UNKNOWN_OWNER)]
+      end
+
+      sig { params(name: String).returns(String) }
+      def self.humanized_package_name(name)
+        if name == ParsePackwerk::ROOT_PACKAGE_NAME
+          'root'
+        else
+          name
+        end
+      end
+
+      sig { params(violations: T::Array[ParsePackwerk::Violation]).returns(Integer) }
+      def self.file_count(violations)
+        violations.sum { |v| v.files.count }
+      end
+
+      sig { params(package: ParsePackwerk::Package).returns(T::Boolean) }
+      def self.has_readme?(package)
+        package.directory.join('README.md').exist?
+      end
+    end
+  end
+end

data/lib/pack_stats/private/source_code_file.rb

@@ -0,0 +1,24 @@
+# typed: strict
+
+module PackStats
+  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(CodeTeams::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/pack_stats/private.rb

@@ -0,0 +1,54 @@
+# typed: strict
+
+module PackStats
+  module Private
+    extend T::Sig
+
+    METRIC_REPLACEMENTS = T.let({
+      # enforce_dependencies
+      'packwerk_checkers.enforce_dependencies.false' => 'prevent_this_package_from_violating_its_stated_dependencies.no',
+      'packwerk_checkers.enforce_dependencies.true' => 'prevent_this_package_from_violating_its_stated_dependencies.fail_the_build_if_new_instances_appear',
+      'packwerk_checkers.enforce_dependencies.strict' => 'prevent_this_package_from_violating_its_stated_dependencies.fail_the_build_on_any_instances',
+      # enforce_privacy
+      'packwerk_checkers.enforce_privacy.false' => 'prevent_other_packages_from_using_this_packages_internals.no',
+      'packwerk_checkers.enforce_privacy.true' => 'prevent_other_packages_from_using_this_packages_internals.fail_the_build_if_new_instances_appear',
+      'packwerk_checkers.enforce_privacy.strict' => 'prevent_other_packages_from_using_this_packages_internals.fail_the_build_on_any_instances',
+      # Packs/TypedPublicApis
+      'rubocops.packs_typedpublicapis.false' => 'prevent_this_package_from_exposing_an_untyped_api.no',
+      'rubocops.packs_typedpublicapis.true' => 'prevent_this_package_from_exposing_an_untyped_api.fail_the_build_if_new_instances_appear',
+      'rubocops.packs_typedpublicapis.strict' => 'prevent_this_package_from_exposing_an_untyped_api.fail_the_build_on_any_instances',
+      'rubocops.packs_typedpublicapis.exclusions' => 'prevent_this_package_from_exposing_an_untyped_api.rubocop_exclusions',
+      # Packs/RootNamespaceIsPackName
+      'rubocops.packs_rootnamespaceispackname.false' => 'prevent_this_package_from_creating_other_namespaces.no',
+      'rubocops.packs_rootnamespaceispackname.true' => 'prevent_this_package_from_creating_other_namespaces.fail_the_build_if_new_instances_appear',
+      'rubocops.packs_rootnamespaceispackname.strict' => 'prevent_this_package_from_creating_other_namespaces.fail_the_build_on_any_instances',
+      'rubocops.packs_rootnamespaceispackname.exclusions' => 'prevent_this_package_from_creating_other_namespaces.rubocop_exclusions',
+      # Packs/ClassMethodsAsPublicApis
+      'rubocops.packs_classmethodsaspublicapis.false' => 'prevent_this_package_from_exposing_instance_method_public_apis.no',
+      'rubocops.packs_classmethodsaspublicapis.true' => 'prevent_this_package_from_exposing_instance_method_public_apis.fail_the_build_if_new_instances_appear',
+      'rubocops.packs_classmethodsaspublicapis.strict' => 'prevent_this_package_from_exposing_instance_method_public_apis.fail_the_build_on_any_instances',
+      'rubocops.packs_classmethodsaspublicapis.exclusions' => 'prevent_this_package_from_exposing_instance_method_public_apis.rubocop_exclusions',
+      # Packs/DocumentedPublicApis
+      'rubocops.packs_documentedpublicapis.false' => 'prevent_this_package_from_exposing_undocumented_public_apis.no',
+      'rubocops.packs_documentedpublicapis.true' => 'prevent_this_package_from_exposing_undocumented_public_apis.fail_the_build_if_new_instances_appear',
+      'rubocops.packs_documentedpublicapis.strict' => 'prevent_this_package_from_exposing_undocumented_public_apis.fail_the_build_on_any_instances',
+      'rubocops.packs_documentedpublicapis.exclusions' => 'prevent_this_package_from_exposing_undocumented_public_apis.rubocop_exclusions',
+    }, T::Hash[String, String])
+
+    sig { params(metrics: T::Array[GaugeMetric]).returns(T::Array[GaugeMetric]) }
+    def self.convert_metrics_to_legacy(metrics)
+      metrics.map do |metric|
+        new_metric = metric
+        METRIC_REPLACEMENTS.each do |current_name, legacy_name|
+          new_metric = new_metric.with(
+            name: new_metric.name.gsub(current_name, legacy_name)
+          )
+        end
+
+        new_metric
+      end
+    end
+  end
+
+  private_constant :Private
+end

data/lib/pack_stats/tag.rb

@@ -0,0 +1,28 @@
+# typed: strict
+
+module PackStats
+  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/pack_stats/tags.rb

@@ -0,0 +1,20 @@
+# typed: strict
+
+module PackStats
+  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/pack_stats.rb

@@ -0,0 +1,154 @@
+# typed: strict
+
+require 'sorbet-runtime'
+require 'json'
+require 'yaml'
+require 'benchmark'
+require 'code_teams'
+require 'code_ownership'
+require 'pathname'
+require 'pack_stats/private'
+require 'pack_stats/private/source_code_file'
+require 'pack_stats/private/datadog_reporter'
+require 'parse_packwerk'
+require 'pack_stats/tag'
+require 'pack_stats/tags'
+require 'pack_stats/gauge_metric'
+
+module PackStats
+  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,
+      # See note on get_metrics
+      use_gusto_legacy_names: 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,
+    use_gusto_legacy_names: 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,
+      use_gusto_legacy_names: use_gusto_legacy_names,
+    )
+
+    # This helps us debug what metrics are being sent
+    if verbose
+      all_metrics.each do |metric|
+        puts "Sending metric: #{metric}"
+      end
+    end
+
+    if use_gusto_legacy_names
+      all_metrics = Private.convert_metrics_to_legacy(all_metrics)
+    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,
+      # It is not recommended to set this to true.
+      # Gusto uses this to preserve historical trends in Dashboards as the names of
+      # things changed, but new dashboards can use names that better match current tooling conventions.
+      # The behavior of setting this parameter to true might change without warning
+      use_gusto_legacy_names: T::Boolean
+    ).returns(T::Array[GaugeMetric])
+  end
+  def self.get_metrics(
+    source_code_pathnames:,
+    componentized_source_code_locations:,
+    packaged_source_code_locations:,
+    app_name:,
+    use_gusto_legacy_names: false
+  )
+    all_metrics = 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
+    )
+
+    if use_gusto_legacy_names
+      all_metrics = Private.convert_metrics_to_legacy(all_metrics)
+    end
+
+    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]
+    ).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,4 @@
+--dir
+.
+--ignore=/vendor/bundle
+--enable-experimental-requires-ancestor