modularization_statistics 1.34.0 → 1.35.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0d44cafa4c07aed6fb4248234f60f70e6a0f9124b7ad6184f515feb22ef972a
-  data.tar.gz: 3a1ae5714c23a52c63c2cff8616a9f739e3bb68a44abd8e76e35b864e792c2c7
+  metadata.gz: 75ff0dc32b62d7a71ef4670809d77dfd7bac173f95529de171fc22f90f93ba41
+  data.tar.gz: c453e59ffd54ee91e1d535ca55767506f82cc5f43db8418423ed44e80b646c3c
 SHA512:
-  metadata.gz: 750643b2ff0d4705f69c66f049be32d070e50189173e2b44dd3975fde11ed8052c182b24729831e5e4553bc5f23c8d88f76ee5a0b70a85f5f1842c855bbd0d7e
-  data.tar.gz: 434a4e77901c9af6783de0db879daaaf1bb4918835f1a147a0cc5aa0ff7c4c35ba12e306e23db3a65a9b875b97c8503b6e49a2c93b2e2c4014c9c1d01845afd2
+  metadata.gz: a8087b6b892da279242b6e8e40daf3925ccc77e50d6f640712d9e1bc1554ef770785bf84d9fd83f77ab56cbccf2432bccf453139886749665956c5f317cebc7d
+  data.tar.gz: 35d695c1e0f5fd13a5d9e5f97fc2a5f582cfbe1536a479c34f49c81f4e50e2ea0ce4ce5b12c0aee80b11d9a2f998609322801787df7ccbf781cc3e985a064f23

data/lib/modularization_statistics/private/datadog_reporter.rb

@@ -2,14 +2,19 @@
 # frozen_string_literal: true
 
 require 'dogapi'
+require 'modularization_statistics/private/metrics'
+require 'modularization_statistics/private/metrics/files'
+require 'modularization_statistics/private/metrics/public_usage'
+require 'modularization_statistics/private/metrics/protection_usage'
+require 'modularization_statistics/private/metrics/packages'
+require 'modularization_statistics/private/metrics/packages_by_team'
+require 'modularization_statistics/private/metrics/nested_packs'
 
 module ModularizationStatistics
   module Private
     class DatadogReporter
       extend T::Sig
 
-      UNKNOWN_OWNER = T.let('Unknown', String)
-
       sig do
         params(
           source_code_files: T::Array[SourceCodeFile],
@@ -17,22 +22,14 @@ module ModularizationStatistics
         ).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
+        [
+          *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::NestedPacks.get_nested_package_metrics(packages, app_name)
+        ]
       end
 
       sig do
@@ -58,268 +55,6 @@ module ModularizationStatistics
           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/metrics/files.rb

@@ -0,0 +1,47 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ModularizationStatistics
+  module Private
+    module Metrics
+      class Files
+        extend T::Sig
+
+        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 = Metrics.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)
+          all_metrics
+        end
+
+        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
+      end
+    end
+  end
+end

data/lib/modularization_statistics/private/metrics/nested_packs.rb

@@ -0,0 +1,116 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ModularizationStatistics
+  module Private
+    module Metrics
+      class NestedPacks
+        extend T::Sig
+
+        class PackGroup < T::Struct
+          extend T::Sig
+
+          const :name, String
+          const :root, ParsePackwerk::Package
+          const :members, T::Array[ParsePackwerk::Package]
+
+          sig { params(packages: T::Array[ParsePackwerk::Package]).returns(T::Array[PackGroup]) }
+          def self.all_from(packages)
+            packs_by_group = {}
+
+            packages.each do |package|
+              # For a child pack, package.directory is `packs/fruits/apples` (i.e. the directory of the package.yml file).
+              # The package.directory.dirname is therefore `packs/fruits`.
+              # For a standalone pack, package.directory.dirname is `packs`
+              # A pack with no parent is in a pack group of its own name
+              root = ParsePackwerk.find(package.directory.dirname.to_s) || package
+              # Mark the parent pack and child pack as being in the pack group of the parent
+              packs_by_group[root.name] ||= { root: root, members: [] }
+              packs_by_group[root.name][:members] << package
+            end
+
+            packs_by_group.map do |name, pack_data|
+              PackGroup.new(
+                name: name,
+                root: pack_data[:root],
+                members: pack_data[:members],
+              )
+            end
+          end
+
+          sig { returns(Integer) }
+          def children_pack_count
+            members.count do |package|
+              package.name != root.name
+            end
+          end
+
+          sig { returns(T::Boolean) }
+          def has_parent?
+            children_pack_count > 0
+          end
+
+          sig { returns(T::Array[ParsePackwerk::Violation]) }
+          def cross_group_violations
+            all_violations = members.flat_map do |member|
+              ParsePackwerk::DeprecatedReferences.for(member).violations
+            end
+
+            all_violations.select do |violation|
+              !members.map(&:name).include?(violation.to_package_name)
+            end
+          end
+        end
+
+        sig do
+          params(
+            packages: T::Array[ParsePackwerk::Package],
+            app_name: String
+          ).returns(T::Array[GaugeMetric])
+        end
+        def self.get_nested_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])
+
+          pack_groups = PackGroup.all_from(packages)
+          all_pack_groups_count = pack_groups.count
+          child_pack_count = pack_groups.sum(&:children_pack_count)
+          parent_pack_count = pack_groups.count(&:has_parent?)
+          all_cross_pack_group_violations = pack_groups.flat_map(&:cross_group_violations)
+
+          all_metrics << GaugeMetric.for('all_pack_groups.count', all_pack_groups_count, package_tags)
+          all_metrics << GaugeMetric.for('child_packs.count', child_pack_count, package_tags)
+          all_metrics << GaugeMetric.for('parent_packs.count', parent_pack_count, package_tags)
+          all_metrics << GaugeMetric.for('all_pack_groups.privacy_violations.count', Metrics.file_count(all_cross_pack_group_violations.select(&:privacy?)), package_tags)
+          all_metrics << GaugeMetric.for('all_pack_groups.dependency_violations.count', Metrics.file_count(all_cross_pack_group_violations.select(&:dependency?)), package_tags)
+
+          packs_by_group = {}
+          pack_groups.each do |pack_group|
+            pack_group.members.each do |member|
+              packs_by_group[member.name] = pack_group.name
+            end
+          end
+
+          pack_groups.each do |from_pack_group|
+            violations_by_to_pack_group = from_pack_group.cross_group_violations.group_by do |violation|
+              packs_by_group[violation.to_package_name]
+            end
+            violations_by_to_pack_group.each do |to_pack_group_name, violations|
+              tags = [
+                *package_tags,
+                Tag.for('pack_group', Metrics.humanized_package_name(from_pack_group.name)),
+                Tag.for('to_pack_group', Metrics.humanized_package_name(to_pack_group_name)),
+              ]
+
+              all_metrics << GaugeMetric.for('by_pack_group.outbound_dependency_violations.per_pack_group.count', Metrics.file_count(violations.select(&:dependency?)), tags)
+              all_metrics << GaugeMetric.for('by_pack_group.outbound_privacy_violations.per_pack_group.count', Metrics.file_count(violations.select(&:privacy?)), tags)
+            end
+          end
+
+          all_metrics
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ModularizationStatistics
+  module Private
+    module Metrics
+      class Packages
+        extend T::Sig
+
+        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| Metrics.file_count(package.violations.select(&:dependency?)) }, package_tags)
+          all_metrics << GaugeMetric.for('all_packages.privacy_violations.count', protected_packages.sum { |package| Metrics.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 += 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::ProtectionUsage.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 = Metrics.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', Metrics.file_count(all_dependency_violations), package_tags)
+            all_metrics << GaugeMetric.for('by_package.privacy_violations.count', Metrics.file_count(all_privacy_violations), package_tags)
+
+            all_metrics << GaugeMetric.for('by_package.outbound_dependency_violations.count', Metrics.file_count(outbound_violations.select(&:dependency?)), package_tags)
+            all_metrics << GaugeMetric.for('by_package.inbound_dependency_violations.count', Metrics.file_count(inbound_violations.select(&:dependency?)), package_tags)
+
+            all_metrics << GaugeMetric.for('by_package.outbound_privacy_violations.count', Metrics.file_count(outbound_violations.select(&:privacy?)), package_tags)
+            all_metrics << GaugeMetric.for('by_package.inbound_privacy_violations.count', Metrics.file_count(inbound_violations.select(&:privacy?)), package_tags)
+
+            all_metrics += Metrics::PublicUsage.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', Metrics.humanized_package_name(to_package_name))] + Metrics.tags_for_to_team(CodeOwnership.for_package(to_package)&.name)
+              all_metrics << GaugeMetric.for('by_package.outbound_dependency_violations.per_package.count', Metrics.file_count(violations.select(&:dependency?)), tags)
+              all_metrics << GaugeMetric.for('by_package.outbound_privacy_violations.per_package.count', Metrics.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 = Metrics.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', Metrics.humanized_package_name(explicit_dependency))] + Metrics.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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ModularizationStatistics
+  module Private
+    module Metrics
+      class PackagesByTeam
+        extend T::Sig
+
+        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 = Metrics.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 += Metrics::ProtectionUsage.get_protections_metrics('by_team', protected_packages_by_team, team_tags)
+            all_metrics += Metrics::PublicUsage.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', Metrics.file_count(all_dependency_violations), team_tags)
+            all_metrics << GaugeMetric.for('by_team.privacy_violations.count', Metrics.file_count(all_privacy_violations), team_tags)
+
+            all_metrics << GaugeMetric.for('by_team.outbound_dependency_violations.count', Metrics.file_count(outbound_violations.select(&:dependency?)), team_tags)
+            all_metrics << GaugeMetric.for('by_team.inbound_dependency_violations.count', Metrics.file_count(inbound_violations.select(&:dependency?)), team_tags)
+
+            all_metrics << GaugeMetric.for('by_team.outbound_privacy_violations.count', Metrics.file_count(outbound_violations.select(&:privacy?)), team_tags)
+            all_metrics << GaugeMetric.for('by_team.inbound_privacy_violations.count', Metrics.file_count(inbound_violations.select(&:privacy?)), team_tags)
+
+            all_metrics << GaugeMetric.for('by_team.has_readme.count', protected_packages_by_team.count { |protected_package| Metrics.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 + Metrics.tags_for_to_team(to_team_name)
+              all_metrics << GaugeMetric.for('by_team.outbound_dependency_violations.per_team.count', Metrics.file_count(violations.select(&:dependency?)), tags)
+              all_metrics << GaugeMetric.for('by_team.outbound_privacy_violations.per_team.count', Metrics.file_count(violations.select(&:privacy?)), tags)
+            end
+          end
+
+          all_metrics
+        end
+      end
+    end
+  end
+end

data/lib/modularization_statistics/private/metrics/protection_usage.rb

@@ -0,0 +1,33 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ModularizationStatistics
+  module Private
+    module Metrics
+      class ProtectionUsage
+        extend T::Sig
+
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ModularizationStatistics
+  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/modularization_statistics/private/metrics.rb

@@ -0,0 +1,49 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ModularizationStatistics
+  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/sorbet/rbi/gems/{package_protections@0.64.0.rbi → package_protections@1.4.0.rbi}

@@ -12,6 +12,9 @@ module PackageProtections
     sig { void }
     def bust_cache!; end
 
+    sig { params(blk: T.proc.params(arg0: ::PackageProtections::Private::Configuration).void).void }
+    def configure(&blk); end
+
     sig do
       params(
         packages: T::Array[::ParsePackwerk::Package],
@@ -20,14 +23,6 @@ module PackageProtections
     end
     def get_offenses(packages:, new_violations:); end
 
-    sig do
-      params(
-        package_names: T::Array[::String],
-        all_packages: T::Array[::ParsePackwerk::Package]
-      ).returns(T::Array[::ParsePackwerk::Package])
-    end
-    def packages_for_names(package_names, all_packages); end
-
     sig { params(identifier: ::String).returns(T::Hash[T.untyped, T.untyped]) }
     def private_cop_config(identifier); end
 
@@ -102,6 +97,9 @@ module PackageProtections::Private
     sig { void }
     def bust_cache!; end
 
+    sig { returns(::PackageProtections::Private::Configuration) }
+    def config; end
+
     sig do
       params(
         packages: T::Array[::ParsePackwerk::Package],
@@ -113,14 +111,6 @@ module PackageProtections::Private
     sig { params(name: ::String).returns(::PackageProtections::ProtectedPackage) }
     def get_package_with_name(name); end
 
-    sig do
-      params(
-        package_names: T::Array[::String],
-        all_packages: T::Array[::ParsePackwerk::Package]
-      ).returns(T::Array[::ParsePackwerk::Package])
-    end
-    def packages_for_names(package_names, all_packages); end
-
     sig { params(identifier: ::String).returns(T::Hash[T.untyped, T.untyped]) }
     def private_cop_config(identifier); end
 
@@ -195,6 +185,23 @@ class PackageProtections::Private::ColorizedString::Color < ::T::Enum
   end
 end
 
+class PackageProtections::Private::Configuration
+  sig { void }
+  def initialize; end
+
+  sig { void }
+  def bust_cache!; end
+
+  sig { returns(T::Array[::PackageProtections::ProtectionInterface]) }
+  def default_protections; end
+
+  sig { returns(T::Array[::PackageProtections::ProtectionInterface]) }
+  def protections; end
+
+  sig { params(protections: T::Array[::PackageProtections::ProtectionInterface]).void }
+  def protections=(protections); end
+end
+
 class PackageProtections::Private::IncomingPrivacyProtection
   include ::PackageProtections::ProtectionInterface
 
@@ -256,51 +263,6 @@ class PackageProtections::Private::MetadataModifiers
   end
 end
 
-class PackageProtections::Private::MultipleNamespacesProtection
-  include ::PackageProtections::ProtectionInterface
-  include ::PackageProtections::RubocopProtectionInterface
-
-  sig do
-    override
-      .params(
-        packages: T::Array[::PackageProtections::ProtectedPackage]
-      ).returns(T::Array[::PackageProtections::RubocopProtectionInterface::CopConfig])
-  end
-  def cop_configs(packages); end
-
-  sig { params(package: ::PackageProtections::ProtectedPackage).returns(T::Hash[T.untyped, T.untyped]) }
-  def custom_cop_config(package); end
-
-  sig do
-    override
-      .params(
-        protected_packages: T::Array[::PackageProtections::ProtectedPackage]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_existing_violations(protected_packages); end
-
-  sig { override.returns(::String) }
-  def humanized_protection_description; end
-
-  sig { override.returns(::String) }
-  def humanized_protection_name; end
-
-  sig { override.returns(::String) }
-  def identifier; end
-
-  sig do
-    override
-      .params(
-        behavior: ::PackageProtections::ViolationBehavior,
-        package: ::ParsePackwerk::Package
-      ).returns(T.nilable(::String))
-  end
-  def unmet_preconditions_for_behavior(behavior, package); end
-end
-
-PackageProtections::Private::MultipleNamespacesProtection::COP_NAME = T.let(T.unsafe(nil), String)
-PackageProtections::Private::MultipleNamespacesProtection::IDENTIFIER = T.let(T.unsafe(nil), String)
-
 class PackageProtections::Private::OutgoingDependencyProtection
   include ::PackageProtections::ProtectionInterface
 
@@ -359,48 +321,6 @@ class PackageProtections::Private::Output
   end
 end
 
-class PackageProtections::Private::TypedApiProtection
-  include ::PackageProtections::ProtectionInterface
-  include ::PackageProtections::RubocopProtectionInterface
-
-  sig do
-    override
-      .params(
-        packages: T::Array[::PackageProtections::ProtectedPackage]
-      ).returns(T::Array[::PackageProtections::RubocopProtectionInterface::CopConfig])
-  end
-  def cop_configs(packages); end
-
-  sig do
-    override
-      .params(
-        protected_packages: T::Array[::PackageProtections::ProtectedPackage]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_existing_violations(protected_packages); end
-
-  sig { override.returns(::String) }
-  def humanized_protection_description; end
-
-  sig { override.returns(::String) }
-  def humanized_protection_name; end
-
-  sig { override.returns(::String) }
-  def identifier; end
-
-  sig do
-    override
-      .params(
-        behavior: ::PackageProtections::ViolationBehavior,
-        package: ::ParsePackwerk::Package
-      ).returns(T.nilable(::String))
-  end
-  def unmet_preconditions_for_behavior(behavior, package); end
-end
-
-PackageProtections::Private::TypedApiProtection::COP_NAME = T.let(T.unsafe(nil), String)
-PackageProtections::Private::TypedApiProtection::IDENTIFIER = T.let(T.unsafe(nil), String)
-
 class PackageProtections::Private::VisibilityProtection
   include ::PackageProtections::ProtectionInterface
 
@@ -560,16 +480,26 @@ module PackageProtections::RubocopProtectionInterface
   abstract!
 
   sig do
-    abstract
-      .params(
-        packages: T::Array[::PackageProtections::ProtectedPackage]
-      ).returns(T::Array[::PackageProtections::RubocopProtectionInterface::CopConfig])
+    params(
+      packages: T::Array[::PackageProtections::ProtectedPackage]
+    ).returns(T::Array[::PackageProtections::RubocopProtectionInterface::CopConfig])
   end
   def cop_configs(packages); end
 
+  sig { abstract.returns(::String) }
+  def cop_name; end
+
   sig { params(package: ::PackageProtections::ProtectedPackage).returns(T::Hash[T.untyped, T.untyped]) }
   def custom_cop_config(package); end
 
+  sig do
+    override
+      .params(
+        protected_packages: T::Array[::PackageProtections::ProtectedPackage]
+      ).returns(T::Array[::PackageProtections::Offense])
+  end
+  def get_offenses_for_existing_violations(protected_packages); end
+
   sig do
     override
       .params(
@@ -578,6 +508,21 @@ module PackageProtections::RubocopProtectionInterface
   end
   def get_offenses_for_new_violations(new_violations); end
 
+  sig { abstract.returns(T::Array[::String]) }
+  def included_globs_for_pack; end
+
+  sig { abstract.params(file: ::String).returns(::String) }
+  def message_for_fail_on_any(file); end
+
+  sig do
+    override
+      .params(
+        behavior: ::PackageProtections::ViolationBehavior,
+        package: ::ParsePackwerk::Package
+      ).returns(T.nilable(::String))
+  end
+  def unmet_preconditions_for_behavior(behavior, package); end
+
   private
 
   sig { params(rule: ::String).returns(T::Set[::String]) }
@@ -630,3 +575,7 @@ class PackageProtections::ViolationBehavior < ::T::Enum
     def from_raw_value(value); end
   end
 end
+
+module RuboCop; end
+module RuboCop::Cop; end
+module RuboCop::Cop::PackageProtections; end

data/sorbet/rbi/gems/{parse_packwerk@0.10.0.rbi → parse_packwerk@0.12.0.rbi}

@@ -9,9 +9,15 @@ module ParsePackwerk
     sig { returns(T::Array[::ParsePackwerk::Package]) }
     def all; end
 
+    sig { void }
+    def bust_cache!; end
+
     sig { params(name: ::String).returns(T.nilable(::ParsePackwerk::Package)) }
     def find(name); end
 
+    sig { params(file_path: T.any(::Pathname, ::String)).returns(T.nilable(::ParsePackwerk::Package)) }
+    def package_from_path(file_path); end
+
     sig { params(package: ::ParsePackwerk::Package).void }
     def write_package_yml!(package); end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: modularization_statistics
 version: !ruby/object:Gem::Version
-  version: 1.34.0
+  version: 1.35.0
 platform: ruby
 authors:
 - Gusto Engineers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-06-14 00:00:00.000000000 Z
+date: 2022-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: code_teams
@@ -177,6 +177,13 @@ files:
 - lib/modularization_statistics/gauge_metric.rb
 - lib/modularization_statistics/private.rb
 - lib/modularization_statistics/private/datadog_reporter.rb
+- lib/modularization_statistics/private/metrics.rb
+- lib/modularization_statistics/private/metrics/files.rb
+- lib/modularization_statistics/private/metrics/nested_packs.rb
+- lib/modularization_statistics/private/metrics/packages.rb
+- lib/modularization_statistics/private/metrics/packages_by_team.rb
+- lib/modularization_statistics/private/metrics/protection_usage.rb
+- lib/modularization_statistics/private/metrics/public_usage.rb
 - lib/modularization_statistics/private/source_code_file.rb
 - lib/modularization_statistics/tag.rb
 - lib/modularization_statistics/tags.rb
@@ -185,8 +192,8 @@ files:
 - sorbet/rbi/gems/code_teams@1.0.0.rbi
 - sorbet/rbi/gems/dogapi@1.45.0.rbi
 - sorbet/rbi/gems/manual.rbi
-- sorbet/rbi/gems/package_protections@0.64.0.rbi
-- sorbet/rbi/gems/parse_packwerk@0.10.0.rbi
+- sorbet/rbi/gems/package_protections@1.4.0.rbi
+- sorbet/rbi/gems/parse_packwerk@0.12.0.rbi
 - sorbet/rbi/gems/rspec@3.10.0.rbi
 - sorbet/rbi/todo.rbi
 homepage: https://github.com/rubyatscale/modularization_statistics