pack_stats 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce560ffcca29a3a4648737e5f2b8bb2c5a74ea0c97a0c449485254946a2ef533
-  data.tar.gz: 7ab159d493e0b9cf92cbf58581147feb50fd24ffbd10920d8f59da5167ff6e6f
+  metadata.gz: 8053c602af521d61db8a3e333a61b30b5ee7443a96cc45f2932c77b13f34a2df
+  data.tar.gz: f64229355da5b0f4d398bbcc7a6810f638170574539b05e1b5195bfae3d9f85d
 SHA512:
-  metadata.gz: 05235d4235fb6d82686463c0883d2bb987e96f6f659e8e4728ef03ab2a8cfc2b658c43c1891dd2343267614f7a5ef1976b61c76dbe7cccb78afb011e89df1184
-  data.tar.gz: e5d5cad1d468a180818b0110b4bcc120f40e5b2bb7a4ecbbc4c99b6d8a53f83e0b3e76130e928d797649ca21d02ef4dc89790fc8bd8887233acaf183a031153c
+  metadata.gz: 6ffd883823bba83d22f392f3cacc5dbd9e54264fc69bb48c489656f5cc01c3c202d22773a03fc446568c65027eb2d3f95c3a5f709eafa22acedd5c27f8c5fb49
+  data.tar.gz: 50af4cdd4389c7588d6de7b8eecb2f94697e4cd372578d58916edbbd6ca602a1634e3f985a6243e8630d5cc14b74383bb671134fa9ceca8631d4fbf113497f4d

data/lib/pack_stats/gauge_metric.rb

@@ -1,4 +1,5 @@
 # typed: strict
+# frozen_string_literal: true
 
 module PackStats
   class GaugeMetric < T::Struct
@@ -14,20 +15,20 @@ module PackStats
       # 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
+        raise StandardError, "Metrics names must not exceed 200 characters: #{name}"
       end
 
       all_tags = [*tags, max_enforcements_tag]
       new(
-        name: name,
-        count: count,
+        name:,
+        count:,
         tags: all_tags
       )
     end
 
     sig { returns(String) }
     def to_s
-      "#{name} with count #{count}, with tags #{tags.map(&:to_s).join(', ')}"
+      "#{name} with count #{count}, with tags #{tags.join(", ")}"
     end
 
     sig { params(other: GaugeMetric).returns(T::Boolean) }
@@ -40,12 +41,12 @@ module PackStats
     sig { params(tag_value: T::Boolean).void }
     def self.set_max_enforcements_tag(tag_value)
       @max_enforcements_tag = T.let(@max_enforcements_tag, T.nilable(Tag))
-      @max_enforcements_tag = Tag.new(key: 'max_enforcements', value: tag_value ? 'true' : 'false')
+      @max_enforcements_tag = Tag.new(key: "max_enforcements", value: tag_value ? "true" : "false")
     end
 
     sig { returns(Tag) }
     def self.max_enforcements_tag
-      @max_enforcements_tag || Tag.new(key: 'max_enforcements', value: 'false')
+      @max_enforcements_tag || Tag.new(key: "max_enforcements", value: "false")
     end
   end
 end

data/lib/pack_stats/private/datadog_reporter.rb

@@ -1,14 +1,14 @@
 # typed: strict
 # frozen_string_literal: true
 
-require 'dogapi'
-require 'pack_stats/private/metrics'
-require 'pack_stats/private/metrics/files'
-require 'pack_stats/private/metrics/public_usage'
-require 'pack_stats/private/metrics/packwerk_checker_usage'
-require 'pack_stats/private/metrics/dependencies'
-require 'pack_stats/private/metrics/packages'
-require 'pack_stats/private/metrics/packages_by_team'
+require "dogapi"
+require "pack_stats/private/metrics"
+require "pack_stats/private/metrics/files"
+require "pack_stats/private/metrics/public_usage"
+require "pack_stats/private/metrics/packwerk_checker_usage"
+require "pack_stats/private/metrics/dependencies"
+require "pack_stats/private/metrics/packages"
+require "pack_stats/private/metrics/packages_by_team"
 
 module PackStats
   module Private
@@ -19,7 +19,8 @@ module PackStats
         params(
           source_code_files: T::Array[SourceCodeFile],
           app_name: String
-        ).returns(T::Array[GaugeMetric])
+        )
+          .returns(T::Array[GaugeMetric])
       end
       def self.get_metrics(source_code_files:, app_name:)
         packages = ParsePackwerk.all
@@ -27,7 +28,7 @@ module PackStats
         [
           *Metrics::Files.get_metrics(source_code_files, app_name),
           *Metrics::Packages.get_package_metrics(packages, app_name),
-          *Metrics::PackagesByTeam.get_package_metrics_by_team(packages, app_name),
+          *Metrics::PackagesByTeam.get_package_metrics_by_team(packages, app_name)
         ]
       end
 
@@ -38,7 +39,8 @@ module PackStats
           # to ensure they fall into the same bucket.
           report_time: Time,
           metrics: T::Array[GaugeMetric]
-        ).void
+        )
+          .void
       end
       def self.report!(datadog_client:, report_time:, metrics:)
         #
@@ -49,7 +51,12 @@ module PackStats
         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))
+              datadog_client.emit_points(
+                metric.name,
+                [[report_time, metric.count]],
+                type: "gauge",
+                tags: metric.tags.map(&:to_s)
+              )
             end
           end
         end

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

@@ -7,8 +7,12 @@ module PackStats
       class Dependencies
         extend T::Sig
 
-        sig { params(prefix: String, packages: T::Array[ParsePackwerk::Package], app_name: String).returns(T::Array[GaugeMetric]) }
-        def self.get_metrics(prefix, packages, app_name)
+        sig do
+          params(_prefix: String, packages: T::Array[ParsePackwerk::Package], app_name: String).returns(
+            T::Array[GaugeMetric]
+          )
+        end
+        def self.get_metrics(_prefix, packages, app_name)
           all_metrics = T.let([], T::Array[GaugeMetric])
           inbound_explicit_dependency_by_package = {}
           packages.each do |package|
@@ -18,7 +22,7 @@ module PackStats
             end
           end
 
-          packages.each do |package| # rubocop:disable Style/CombinableLoops
+          packages.each do |package|
             package_tags = Metrics.tags_for_package(package, app_name)
 
             #
@@ -31,12 +35,19 @@ module PackStats
               end
 
               owner = Private.package_owner(to_package)
-              tags = package_tags + [Tag.for('other_package', Metrics.humanized_package_name(explicit_dependency))] + Metrics.tags_for_other_team(owner)
-              all_metrics << GaugeMetric.for('by_package.dependencies.by_other_package.count', 1, tags)
+              tags = package_tags +
+                [Tag.for("other_package", Metrics.humanized_package_name(explicit_dependency))] +
+                Metrics.tags_for_other_team(owner)
+              all_metrics << GaugeMetric.for("by_package.dependencies.by_other_package.count", 1, tags)
             end
 
-            all_metrics << GaugeMetric.for('by_package.dependencies.count', package.dependencies.count, package_tags)
-            all_metrics << GaugeMetric.for('by_package.depended_on.count', inbound_explicit_dependency_by_package[package.name]&.count || 0, package_tags)
+            all_metrics << GaugeMetric.for("by_package.dependencies.count", package.dependencies.count, package_tags)
+            all_metrics <<
+              GaugeMetric.for(
+                "by_package.depended_on.count",
+                inbound_explicit_dependency_by_package[package.name]&.count || 0,
+                package_tags
+              )
           end
 
           all_metrics

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

@@ -11,19 +11,20 @@ module PackStats
           params(
             source_code_files: T::Array[SourceCodeFile],
             app_name: String
-          ).returns(T::Array[GaugeMetric])
+          )
+            .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)
+          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 = Metrics.tags_for_team(team_name) + [app_level_tag]
-            all_metrics += get_file_metrics('by_team', file_tags, files_for_team)
+            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)
+          all_metrics += get_file_metrics("totals", file_tags, source_code_files)
           all_metrics
         end
 
@@ -32,13 +33,14 @@ module PackStats
             metric_name_suffix: String,
             tags: T::Array[Tag],
             files: T::Array[SourceCodeFile]
-          ).returns(T::Array[GaugeMetric])
+          )
+            .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),
+            GaugeMetric.for("all_files.#{metric_name_suffix}", files.count, tags)
           ]
         end
       end

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

@@ -11,33 +11,52 @@ module PackStats
           params(
             packages: T::Array[ParsePackwerk::Package],
             app_name: String
-          ).returns(T::Array[GaugeMetric])
+          )
+            .returns(T::Array[GaugeMetric])
         end
         def self.get_package_metrics(packages, app_name)
           all_metrics = []
-          app_level_tag = Tag.for('app', app_name)
+          app_level_tag = Tag.for("app", app_name)
           package_tags = T.let([app_level_tag], T::Array[Tag])
 
-          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.count", packages.count, package_tags)
+          all_metrics <<
+            GaugeMetric.for(
+              "all_packages.dependencies.count",
+              packages.sum { |package| package.dependencies.count },
+              package_tags
+            )
 
           PackwerkCheckerUsage::CHECKERS.each do |checker|
-            violation_count = packages.sum { |package| Metrics.file_count(package.violations.select{|v| v.type == checker.violation_type}) }
+            violation_count = packages.sum do |package|
+              Metrics.file_count(package.violations.select { |v| v.type == checker.violation_type })
+            end
+
             tags = package_tags + [checker.violation_type_tag]
             all_metrics << GaugeMetric.for("all_packages.violations.count", violation_count, tags)
           end
 
-          all_metrics += Metrics::PublicUsage.get_public_usage_metrics('all_packages', packages, package_tags)
-          all_metrics << GaugeMetric.for('all_packages.has_readme.count', packages.count { |package| Metrics.has_readme?(package) }, package_tags)
-
-          all_metrics += Metrics::PackwerkCheckerUsage.get_checker_metrics('all_packages', packages, package_tags)
-          all_metrics << GaugeMetric.for('all_packages.package_based_file_ownership.count', packages.count { |package| !package.metadata['owner'].nil? }, package_tags)
+          all_metrics += Metrics::PublicUsage.get_public_usage_metrics("all_packages", packages, package_tags)
+          all_metrics <<
+            GaugeMetric.for(
+              "all_packages.has_readme.count",
+              packages.count { |package| Metrics.has_readme?(package) },
+              package_tags
+            )
+
+          all_metrics += Metrics::PackwerkCheckerUsage.get_checker_metrics("all_packages", 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 = packages.flat_map(&:violations).group_by(&:to_package_name)
 
           packages.each do |package|
             package_tags = Metrics.tags_for_package(package, app_name)
-            all_metrics += Metrics::PublicUsage.get_public_usage_metrics('by_package', [package], package_tags)
+            all_metrics += Metrics::PublicUsage.get_public_usage_metrics("by_package", [package], package_tags)
 
             outbound_violations = package.violations
             inbound_violations = inbound_violations_by_package[package.name] || []
@@ -47,32 +66,45 @@ module PackStats
 
               case direction
               when PackwerkCheckerUsage::Direction::Outbound
-                all_violations_of_type = outbound_violations.select { |v| v.type == checker.violation_type } 
+                all_violations_of_type = outbound_violations.select { |v| v.type == checker.violation_type }
 
                 packages.each do |other_package|
-                  violations = package.violations.select{|v| v.to_package_name == other_package.name && v.type == checker.violation_type }
+                  violations = package.violations.select do |v|
+                    v.to_package_name == other_package.name && v.type == checker.violation_type
+                  end
 
-                  tags = package_tags + [
-                    Tag.for('other_package', Metrics.humanized_package_name(other_package.name)),
-                    *Metrics.tags_for_other_team(Private.package_owner(other_package)),
-                    checker.violation_type_tag
-                  ]
+                  tags = package_tags +
+                    [
+                      Tag.for("other_package", Metrics.humanized_package_name(other_package.name)),
+                      *Metrics.tags_for_other_team(Private.package_owner(other_package)),
+                      checker.violation_type_tag
+                    ]
 
                   count = Metrics.file_count(violations)
                   if count > 0
-                    all_metrics << GaugeMetric.for("by_package.violations.by_other_package.count", Metrics.file_count(violations), tags)
+                    all_metrics <<
+                      GaugeMetric.for(
+                        "by_package.violations.by_other_package.count",
+                        Metrics.file_count(violations),
+                        tags
+                      )
                   end
                 end
+
               when PackwerkCheckerUsage::Direction::Inbound
-                all_violations_of_type = inbound_violations.select { |v| v.type == checker.violation_type } 
+                all_violations_of_type = inbound_violations.select { |v| v.type == checker.violation_type }
 
                 packages.each do |other_package|
-                  violations = other_package.violations.select{|v| v.to_package_name == package.name && v.type == checker.violation_type }
-                  tags = package_tags + [
-                    Tag.for('other_package', Metrics.humanized_package_name(other_package.name)),
-                    *Metrics.tags_for_other_team(Private.package_owner(other_package)),
-                    checker.violation_type_tag
-                  ]
+                  violations = other_package.violations.select do |v|
+                    v.to_package_name == package.name && v.type == checker.violation_type
+                  end
+
+                  tags = package_tags +
+                    [
+                      Tag.for("other_package", Metrics.humanized_package_name(other_package.name)),
+                      *Metrics.tags_for_other_team(Private.package_owner(other_package)),
+                      checker.violation_type_tag
+                    ]
 
                   count = Metrics.file_count(violations)
                   if count > 0
@@ -84,11 +116,12 @@ module PackStats
               end
 
               tags = package_tags + [checker.violation_type_tag]
-              all_metrics << GaugeMetric.for("by_package.violations.count", Metrics.file_count(all_violations_of_type), tags)
+              all_metrics <<
+                GaugeMetric.for("by_package.violations.count", Metrics.file_count(all_violations_of_type), tags)
             end
           end
 
-          all_metrics += Metrics::Dependencies.get_metrics('by_package', packages, app_name)
+          all_metrics += Metrics::Dependencies.get_metrics("by_package", packages, app_name)
 
           all_metrics
         end

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

@@ -11,59 +11,83 @@ module PackStats
           params(
             all_packages: T::Array[ParsePackwerk::Package],
             app_name: String
-          ).returns(T::Array[GaugeMetric])
+          )
+            .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)
+          app_level_tag = Tag.for("app", app_name)
 
-          
           all_packages.group_by { |package| Private.package_owner(package) }.each do |team_name, packages_for_team|
             team_tags = Metrics.tags_for_team(team_name) + [app_level_tag]
-            all_metrics << GaugeMetric.for('by_team.all_packages.count', packages_for_team.count, team_tags)
-            all_metrics += Metrics::PackwerkCheckerUsage.get_checker_metrics('by_team', packages_for_team, team_tags)
-            all_metrics += Metrics::PublicUsage.get_public_usage_metrics('by_team', packages_for_team, team_tags)
-            all_metrics << GaugeMetric.for('by_team.has_readme.count', packages_for_team.count { |package| Metrics.has_readme?(package) }, team_tags)
+            all_metrics << GaugeMetric.for("by_team.all_packages.count", packages_for_team.count, team_tags)
+            all_metrics += Metrics::PackwerkCheckerUsage.get_checker_metrics("by_team", packages_for_team, team_tags)
+            all_metrics += Metrics::PublicUsage.get_public_usage_metrics("by_team", packages_for_team, team_tags)
+            all_metrics <<
+              GaugeMetric.for(
+                "by_team.has_readme.count",
+                packages_for_team.count { |package| Metrics.has_readme?(package) },
+                team_tags
+              )
 
             outbound_violations = packages_for_team.flat_map(&:violations)
             # We look at `all_packages` because we care about ALL inbound violations across all teams
             inbound_violations_by_package = all_packages.flat_map(&:violations).group_by(&:to_package_name)
             # Here we only look at packages_for_team because we only care about inbound violations onto packages for this team
-            inbound_violations = packages_for_team.flat_map { |package| inbound_violations_by_package[package.name] || [] }
+            inbound_violations = packages_for_team.flat_map do |package|
+              inbound_violations_by_package[package.name] || []
+            end
 
             PackwerkCheckerUsage::CHECKERS.each do |checker|
               direction = checker.direction
               case direction
               when PackwerkCheckerUsage::Direction::Outbound
-                all_violations_of_type = outbound_violations.select { |v| v.type == checker.violation_type } 
+                outbound_violations.select { |v| v.type == checker.violation_type }
+
+                violation_count = packages_for_team.sum do |package|
+                  Metrics.file_count(package.violations.select { |v| v.type == checker.violation_type })
+                end
 
-                violation_count = packages_for_team.sum { |package| Metrics.file_count(package.violations.select{|v| v.type == checker.violation_type}) }
                 tags = team_tags + [checker.violation_type_tag]
                 all_metrics << GaugeMetric.for("by_team.violations.count", violation_count, tags)
 
-                all_packages.group_by { |package| Private.package_owner(package) }.each do |other_team_name, other_teams_packages|
-                  violations = outbound_violations.select{|v| other_teams_packages.map(&:name).include?(v.to_package_name) && v.type == checker.violation_type}
-                  tags = team_tags + Metrics.tags_for_other_team(other_team_name) + [checker.violation_type_tag]
-                  count = Metrics.file_count(violations)
-                  if count > 0
-                    all_metrics << GaugeMetric.for("by_team.violations.by_other_team.count", count, tags)
+                all_packages
+                  .group_by { |package| Private.package_owner(package) }
+                  .each do |other_team_name, other_teams_packages|
+                    violations = outbound_violations.select do |v|
+                      other_teams_packages.map(&:name).include?(v.to_package_name) && v.type == checker.violation_type
+                    end
+
+                    tags = team_tags + Metrics.tags_for_other_team(other_team_name) + [checker.violation_type_tag]
+                    count = Metrics.file_count(violations)
+                    if count > 0
+                      all_metrics << GaugeMetric.for("by_team.violations.by_other_team.count", count, tags)
+                    end
                   end
-                end
+
               when PackwerkCheckerUsage::Direction::Inbound
-                all_violations_of_type = inbound_violations.select { |v| v.type == checker.violation_type } 
+                inbound_violations.select { |v| v.type == checker.violation_type }
+
+                violation_count = packages_for_team.sum do |package|
+                  Metrics.file_count(package.violations.select { |v| v.type == checker.violation_type })
+                end
 
-                violation_count = packages_for_team.sum { |package| Metrics.file_count(package.violations.select{|v| v.type == checker.violation_type}) }
                 tags = team_tags + [checker.violation_type_tag]
                 all_metrics << GaugeMetric.for("by_team.violations.count", violation_count, tags)
 
-                all_packages.group_by { |package| Private.package_owner(package) }.each do |other_team_name, other_teams_packages|
-                  violations = other_teams_packages.flat_map(&:violations).select{|v| packages_for_team.map(&:name).include?(v.to_package_name) && v.type == checker.violation_type}
-                  tags = team_tags + Metrics.tags_for_other_team(other_team_name) + [checker.violation_type_tag]
-                  count = Metrics.file_count(violations)
-                  if count > 0
-                    all_metrics << GaugeMetric.for("by_team.violations.by_other_team.count", count, tags)
+                all_packages
+                  .group_by { |package| Private.package_owner(package) }
+                  .each do |other_team_name, other_teams_packages|
+                    violations = other_teams_packages.flat_map(&:violations).select do |v|
+                      packages_for_team.map(&:name).include?(v.to_package_name) && v.type == checker.violation_type
+                    end
+
+                    tags = team_tags + Metrics.tags_for_other_team(other_team_name) + [checker.violation_type_tag]
+                    count = Metrics.file_count(violations)
+                    if count > 0
+                      all_metrics << GaugeMetric.for("by_team.violations.by_other_team.count", count, tags)
+                    end
                   end
-                end
               else
                 T.absurd(direction)
               end

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

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require 'rubocop-packs'
-
 module PackStats
   module Private
     module Metrics
@@ -29,23 +27,39 @@ module PackStats
           sig { returns(Tag) }
           def violation_type_tag
             Tag.new(
-              key: 'violation_type',
+              key: "violation_type",
               value: violation_type
             )
           end
         end
 
-        CHECKERS = T.let([
-          PackwerkChecker.new(key: 'enforce_dependencies', violation_type: 'dependency', direction: Direction::Outbound),
-          PackwerkChecker.new(key: 'enforce_privacy', violation_type: 'privacy', direction: Direction::Inbound),
-          PackwerkChecker.new(key: 'enforce_folder_privacy', violation_type: 'folder_privacy', direction: Direction::Inbound),
-          PackwerkChecker.new(key: 'enforce_layers', violation_type: 'layer', direction: Direction::Outbound),
-          PackwerkChecker.new(key: 'enforce_visibility', violation_type: 'visibility', direction: Direction::Outbound),
-        ], T::Array[PackwerkChecker])
+        CHECKERS = T.let(
+          [
+            PackwerkChecker.new(
+              key: "enforce_dependencies",
+              violation_type: "dependency",
+              direction: Direction::Outbound
+            ),
+            PackwerkChecker.new(key: "enforce_privacy", violation_type: "privacy", direction: Direction::Inbound),
+            PackwerkChecker.new(
+              key: "enforce_folder_privacy",
+              violation_type: "folder_privacy",
+              direction: Direction::Inbound
+            ),
+            PackwerkChecker.new(key: "enforce_layers", violation_type: "layer", direction: Direction::Outbound),
+            PackwerkChecker.new(key: "enforce_visibility", violation_type: "visibility", direction: Direction::Outbound)
+          ].freeze,
+          T::Array[PackwerkChecker]
+        )
 
-        sig { params(prefix: String, packages: T::Array[ParsePackwerk::Package], package_tags: T::Array[Tag]).returns(T::Array[GaugeMetric]) }
+        sig do
+          params(prefix: String, packages: T::Array[ParsePackwerk::Package], package_tags: T::Array[Tag]).returns(
+            T::Array[GaugeMetric]
+          )
+        end
         def self.get_checker_metrics(prefix, packages, package_tags)
           metrics = T.let([], T::Array[GaugeMetric])
+          possible_values = ["false", "true", "strict"]
 
           CHECKERS.each do |checker|
             checker_values = packages.map do |package|
@@ -54,7 +68,7 @@ module PackStats
 
             checker_values_tally = checker_values.map(&:to_s).tally
 
-            ['false', 'true', 'strict'].each do |possible_value|
+            possible_values.each do |possible_value|
               count = checker_values_tally.fetch(possible_value, 0)
               metric_name = "#{prefix}.packwerk_checkers.#{possible_value}.count"
               tags = package_tags + [checker.violation_type_tag]

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

@@ -7,17 +7,21 @@ module PackStats
       class PublicUsage
         extend T::Sig
 
-        sig { params(prefix: String, packages: T::Array[ParsePackwerk::Package], package_tags: T::Array[Tag]).returns(T::Array[GaugeMetric]) }
+        sig do
+          params(prefix: String, packages: T::Array[ParsePackwerk::Package], package_tags: T::Array[Tag]).returns(
+            T::Array[GaugeMetric]
+          )
+        end
         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')
+            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')
+            public_files = package.directory.glob("app/public/**/**.rb")
             all_public_files += public_files
             is_using_public_directory += 1 if public_files.any?
           end
@@ -27,7 +31,7 @@ module PackStats
           [
             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),
+            GaugeMetric.for("#{prefix}.using_public_directory.count", is_using_public_directory, package_tags)
           ]
         end
       end

data/lib/pack_stats/private/metrics.rb

@@ -5,25 +5,25 @@ module PackStats
   module Private
     module Metrics
       extend T::Sig
-      UNKNOWN_OWNER = T.let('Unknown', String)
+
+      UNKNOWN_OWNER = "Unknown"
 
       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)]
+        [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)
-
         tags = [
-          Tag.new(key: 'package', value: humanized_package_name(package.name)),
-          Tag.new(key: 'app', value: app_name),
-          *Metrics.tags_for_team(Private.package_owner(package)),
+          Tag.new(key: "package", value: humanized_package_name(package.name)),
+          Tag.new(key: "app", value: app_name),
+          *Metrics.tags_for_team(Private.package_owner(package))
         ]
 
-        layer = package.config['layer']
+        layer = package.config["layer"]
         if layer
-          tags << Tag.new(key: 'layer', value: layer)
+          tags << Tag.new(key: "layer", value: layer)
         end
 
         tags
@@ -31,13 +31,13 @@ module PackStats
 
       sig { params(team_name: T.nilable(String)).returns(T::Array[Tag]) }
       def self.tags_for_other_team(team_name)
-        [Tag.for('other_team', team_name || Metrics::UNKNOWN_OWNER)]
+        [Tag.for("other_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'
+          "root"
         else
           name
         end
@@ -50,7 +50,7 @@ module PackStats
 
       sig { params(package: ParsePackwerk::Package).returns(T::Boolean) }
       def self.has_readme?(package)
-        package.directory.join('README.md').exist?
+        package.directory.join("README.md").exist?
       end
     end
   end

data/lib/pack_stats/private/source_code_file.rb

@@ -1,4 +1,5 @@
 # typed: strict
+# frozen_string_literal: true
 
 module PackStats
   module Private

data/lib/pack_stats/private.rb

@@ -1,13 +1,15 @@
 # typed: strict
+# frozen_string_literal: true
 
 module PackStats
   module Private
     extend T::Sig
 
-    sig { params(package: ParsePackwerk::Package).returns(T.nilable(String) )}
+    sig { params(package: ParsePackwerk::Package).returns(T.nilable(String)) }
     def self.package_owner(package)
       pack = Packs.find(package.name)
       return nil if pack.nil?
+
       CodeOwnership.for_package(pack)&.name
     end
   end

data/lib/pack_stats/tag.rb

@@ -1,8 +1,10 @@
 # typed: strict
+# frozen_string_literal: true
 
 module PackStats
   class Tag < T::Struct
     extend T::Sig
+
     const :key, String
     const :value, String
 
@@ -14,8 +16,8 @@ module PackStats
     sig { params(key: String, value: String).returns(Tag) }
     def self.for(key, value)
       new(
-        key: key,
-        value: value
+        key:,
+        value:
       )
     end
 

data/lib/pack_stats/tags.rb

@@ -1,4 +1,5 @@
 # typed: strict
+# frozen_string_literal: true
 
 module PackStats
   module Tags
@@ -7,12 +8,12 @@ module PackStats
     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(':')
+        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
+          key:,
+          value:
         )
       end
     end

data/lib/pack_stats.rb

@@ -1,31 +1,33 @@
 # typed: strict
-
-require 'sorbet-runtime'
-require 'json'
-require 'yaml'
-require 'benchmark'
-require 'code_teams'
-require 'code_ownership'
-require 'pathname'
-require 'packs'
-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'
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+require "json"
+require "yaml"
+require "benchmark"
+require "code_teams"
+require "code_ownership"
+require "pathname"
+require "packs"
+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)
+  ROOT_PACKAGE_NAME = "root"
 
   DEFAULT_COMPONENTIZED_SOURCE_CODE_LOCATIONS = T.let(
     [
-      Pathname.new('components'),
-      Pathname.new('gems'),
-    ].freeze, T::Array[Pathname]
+      Pathname.new("components"),
+      Pathname.new("gems")
+    ].freeze,
+    T::Array[Pathname]
   )
 
   sig do
@@ -40,36 +42,36 @@ module PackStats
       packaged_source_code_locations: T.nilable(T::Array[Pathname]),
       # See note on get_metrics
       max_enforcements_tag_value: T::Boolean
-    ).void
+    )
+      .void
   end
   def self.report_to_datadog!(
     datadog_client:,
     app_name:,
     source_code_pathnames:,
     componentized_source_code_locations: DEFAULT_COMPONENTIZED_SOURCE_CODE_LOCATIONS,
-    report_time: Time.now, # rubocop:disable Rails/TimeZone
+    report_time: Time.now,
     verbose: false,
     packaged_source_code_locations: [],
     max_enforcements_tag_value: false
   )
-
     all_metrics = self.get_metrics(
-      source_code_pathnames: source_code_pathnames,
-      componentized_source_code_locations: componentized_source_code_locations,
-      app_name: app_name,
-      max_enforcements_tag_value: max_enforcements_tag_value,
+      source_code_pathnames:,
+      componentized_source_code_locations:,
+      app_name:,
+      max_enforcements_tag_value:
     )
 
     # This helps us debug what metrics are being sent
     if verbose
       all_metrics.each do |metric|
-        puts "Sending metric: #{metric}"
+        puts("Sending metric: #{metric}")
       end
     end
 
     Private::DatadogReporter.report!(
-      datadog_client: datadog_client,
-      report_time: report_time,
+      datadog_client:,
+      report_time:,
       metrics: all_metrics
     )
   end
@@ -86,7 +88,8 @@ module PackStats
       # Once with the violation counts as configured in the app
       # Another time with the violation counts after turning on all enforcements and running `bin/packwerk update`.
       max_enforcements_tag_value: T::Boolean
-    ).returns(T::Array[GaugeMetric])
+    )
+      .returns(T::Array[GaugeMetric])
   end
   def self.get_metrics(
     source_code_pathnames:,
@@ -95,31 +98,31 @@ module PackStats
     packaged_source_code_locations: [],
     max_enforcements_tag_value: false
   )
-
     GaugeMetric.set_max_enforcements_tag(max_enforcements_tag_value)
 
     Private::DatadogReporter.get_metrics(
       source_code_files: source_code_files(
-        source_code_pathnames: source_code_pathnames,
-        componentized_source_code_locations: componentized_source_code_locations,
+        source_code_pathnames:,
+        componentized_source_code_locations:
       ),
-      app_name: app_name
+      app_name:
     )
   end
 
   sig do
     params(
       source_code_pathnames: T::Array[Pathname],
-      componentized_source_code_locations: T::Array[Pathname],
-    ).returns(T::Array[Private::SourceCodeFile])
+      componentized_source_code_locations: T::Array[Pathname]
+    )
+      .returns(T::Array[Private::SourceCodeFile])
   end
   def self.source_code_files(
     source_code_pathnames:,
     componentized_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 })
+    componentized_file_set = Set.new(
+      componentized_source_code_locations.select(&:exist?).flat_map { |pathname| pathname.find.to_a }
+    )
 
     packaged_file_set = Packs.all.flat_map do |pack|
       pack.relative_path.find.to_a
@@ -132,7 +135,7 @@ module PackStats
       packaged_file = packaged_file_set.include?(pathname)
 
       Private::SourceCodeFile.new(
-        pathname: pathname,
+        pathname:,
         team_owner: CodeOwnership.for_file(pathname.to_s),
         is_componentized_file: componentized_file,
         is_packaged_file: packaged_file

metadata

@@ -1,17 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: pack_stats
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Gusto Engineers
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-29 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: code_teams
+  name: code_ownership
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -25,7 +24,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: code_ownership
+  name: code_teams
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -95,13 +94,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rubocop-packs
+  name: base64
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -109,7 +108,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: base64
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -123,7 +122,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -137,7 +136,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -151,19 +150,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rubocop-gusto
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rubyfmt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: sorbet
   requirement: !ruby/object:Gem::Requirement
@@ -223,7 +236,7 @@ metadata:
   source_code_uri: https://github.com/rubyatscale/pack_stats
   changelog_uri: https://github.com/rubyatscale/pack_stats/releases
   allowed_push_host: https://rubygems.org
-post_install_message:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -231,15 +244,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A gem to collect statistics about modularization progress in a Rails application
   using packwerk.