pack_stats 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 60606e6b527c76b27deaac01ad5991ebe06ec7db76bc5fe9eb707d0cfdde9c56
+  data.tar.gz: ec768521fe361499a52bb29b59b97d23249ef9bd6a9c1bc3c543c8d46d6ccc08
+SHA512:
+  metadata.gz: f33cff3e350f90dbd71cf07433df45bfc170fd9c2101e5713cae1976e034385af98fbc76eddc01ac0ed78009f6e23f2b2f43797999d1fd6e8405fbdb50c013b1
+  data.tar.gz: f04b2b9ac1e3cdf3fcdf0811a1d2a9d1b0a8b2864278ed892caf61c1676fcf762839d24f03ef0f7625895ec37287dcaf3cc034c7ab672468d9b5b1ccf18a15a6

data/README.md

@@ -0,0 +1,127 @@
+# PackStats
+
+This gem is used to report opinionated statistics about modularization to DataDog and other observability systems.
+
+# Configuring Ownership
+The gem reports metrics per-team, where each team is configured based on metadata included in Packwerk package.yml files.
+
+Define your teams as described in the [Code Team - Package Based Ownership](https://github.com/rubyatscale/code_ownership#package-based-ownership) documentation.
+
+# Usage
+The main method to this gem is `PackStats#report_to_datadog!`. Refer to the Sorbet signature for this method for the exact types to be passed in.
+
+This is an example of how to use this API:
+
+```ruby
+PackStats.report_to_datadog!(
+  #
+  # A properly initialized `Dogapi::Client`
+  # Example: Dogapi::Client.new(ENV.fetch('DATADOG_API_KEY')
+  #
+  datadog_client: datadog_client,
+  #
+  # Time attached to the metrics
+  # Example: Time.now
+  #
+  report_time: report_time
+  #
+  # This is used to determine what files to look at for building statistics about what types of files are packaged, componentized, or unpackaged.
+  # This is an array of `Pathname`. `Pathname` can be relative or absolute paths.
+  #
+  # Example: source_code_pathnames = Pathname.glob('./**/**.rb')
+  #
+  source_code_pathnames: source_code_pathnames,
+  #
+  # A file is determined to be componentized if it exists in any of these directories.
+  # This is an array of `Pathname`. `Pathname` can be relative or absolute paths.
+  #
+  # Example: [Pathname.new("./gems")]
+  #
+  componentized_source_code_locations: componentized_source_code_locations,
+  #
+  # A file is determined to be packaged if it exists in any of these directories.
+  # This is an array of `Pathname`. `Pathname` can be relative or absolute paths.
+  #
+  # Example: [Pathname.new("./packs")]
+  #
+  packaged_source_code_locations: packaged_source_code_locations,
+)
+```
+
+It's recommended to run this in CI on the main/development branch so each new commit has metrics emitted for it.
+
+# Tracking Privacy and Dependency Violations Reliably
+With [`packwerk`](https://github.com/Shopify/packwerk), privacy and dependency violations do not show up until a package has set `enforce_privacy` and `enforce_dependency` (respectively) to `true`. As such, when you're first starting off, you'll see no violations, and then periodic large increases as teams start using these protections. If you're interested in looking at privacy and dependency violations over time as if all packages were enforcing dependencies and privacy the whole time, we recommend setting these values to be true before running modularization statistics in your CI.
+
+```ruby
+require 'pack_stats'
+
+namespace(:modularization) do
+  desc(
+    'Publish modularization stats to datadog. ' \
+      'Example: bin/rails "modularization:upload_statistics"'
+  )
+  task(:upload_statistics, [:verbose] => :environment) do |_, args|
+    ignored_paths = Pathname.glob('spec/fixtures/**/**')
+    source_code_pathnames = Pathname.glob('{app,components,lib,packs,spec}/**/**').select(&:file?) - ignored_paths
+
+    # To correctly track violations, we rewrite all `package.yml` files with
+    # `enforce_dependencies` and `enforce_privacy` set to true, then update deprecations.
+    old_packages = ParsePackwerk.all
+    old_packages.each do |package|
+      new_package = ParsePackwerk::Package.new(
+        dependencies: package.dependencies,
+        enforce_dependencies: true,
+        enforce_privacy: true,
+        metadata: package.metadata,
+        name: package.name
+      )
+      ParsePackwerk.write_package_yml!(new_package)
+    end
+
+    Packwerk::Cli.new.execute_command(['update-deprecations'])
+
+    # Now we reset it back so that the protection values are the same as the native packwerk configuration
+    old_packages.each do |package|
+      new_package = ParsePackwerk::Package.new(
+        dependencies: package.dependencies,
+        enforce_dependencies: package.enforce_dependencies,
+        enforce_privacy: package.enforce_privacy,
+        metadata: package.metadata,
+        name: package.name
+      )
+      ParsePackwerk.write_package_yml!(new_package)
+    end
+
+    PackStats.report_to_datadog!(
+      datadog_client: Dogapi::Client.new(ENV.fetch('DATADOG_API_KEY')),
+      app_name: Rails.application.class.module_parent_name,
+      source_code_pathnames: source_code_pathnames,
+      verbose: args[:verbose] == 'true' || false
+    )
+  end
+end
+```
+
+# Using Other Observability Tools
+
+Right now this tool sends metrics to DataDog early. However, if you want to use this with other tools, you can call `PackStats.get_metrics(...)` to get generic metrics that you can then send to whatever observability provider you use.
+
+# Setting Up Your Dashboards
+
+Gusto has two dashboards that we've created to view these metrics. We've also exported and released the Dashboard JSON for each of these dashboards. You can create a new dashboard and then click "import dashboard JSON" to get a jump start on tracking your metrics. Note you may want to make some tweaks to these dashboards to better fit your organization's circumstances and goals.
+
+## [Modularization] Executive Summary
+
+This helps answer questions like:
+- How are we doing on reducing dependency and privacy violations in your monolith overall?
+- How are we doing overall on adopting package protections?
+
+[Dashboard JSON](docs/executive_summary.json)
+
+## [Modularization] Per-Package and Per-Team
+- How is each team and package doing on reducing dependency and privacy violations in your monolith?
+- What is the total count of dependency/privacy violations for each pack/team and what's the change since last month?
+- Which pack/team does my pack/team have the most dependency/privacy violations on?
+
+[Dashboard JSON](docs/per_package_and_per_team.json)

data/lib/pack_stats/gauge_metric.rb

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

data/lib/pack_stats/private/datadog_reporter.rb

@@ -0,0 +1,61 @@
+# 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/rubocop_usage'
+require 'pack_stats/private/metrics/packages'
+require 'pack_stats/private/metrics/packages_by_team'
+require 'pack_stats/private/metrics/nested_packs'
+
+module PackStats
+  module Private
+    class DatadogReporter
+      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:)
+        packages = ParsePackwerk.all
+
+        [
+          *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
+        params(
+          datadog_client: Dogapi::Client,
+          # Since `gauge` buckets data points we need to use the same time for all API calls
+          # to ensure they fall into the same bucket.
+          report_time: Time,
+          metrics: T::Array[GaugeMetric]
+        ).void
+      end
+      def self.report!(datadog_client:, report_time:, metrics:)
+        #
+        # Batching the metrics sends a post request to DD
+        # we want to split this up into chunks of 1000 so that as we add more metrics,
+        # our payload is not rejected for being too large
+        #
+        metrics.each_slice(1000).each do |metric_slice|
+          datadog_client.batch_metrics do
+            metric_slice.each do |metric|
+              datadog_client.emit_points(metric.name, [[report_time, metric.count]], type: 'gauge', tags: metric.tags.map(&:to_s))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# typed: strict
+# frozen_string_literal: true
+
+module PackStats
+  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/pack_stats/private/metrics/nested_packs.rb

@@ -0,0 +1,137 @@
+# typed: strict
+# frozen_string_literal: true
+
+module PackStats
+  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
+
+          inbound_violations_by_pack_group = {}
+          all_cross_pack_group_violations.group_by(&:to_package_name).each do |to_package_name, violations|
+            violations.each do |violation|
+              pack_group_for_violation = packs_by_group[violation.to_package_name]
+              inbound_violations_by_pack_group[pack_group_for_violation] ||= []
+              inbound_violations_by_pack_group[pack_group_for_violation] << violation
+            end
+          end
+
+          pack_groups.each do |pack_group|
+            tags = [
+              *package_tags,
+              Tag.for('pack_group', Metrics.humanized_package_name(pack_group.name)),
+            ]
+
+            outbound_dependency_violations = pack_group.cross_group_violations.select(&:dependency?)
+            inbound_privacy_violations = inbound_violations_by_pack_group.fetch(pack_group.name, []).select(&:privacy?)
+            all_metrics << GaugeMetric.for('by_pack_group.outbound_dependency_violations.count', Metrics.file_count(outbound_dependency_violations), tags)
+            all_metrics << GaugeMetric.for('by_pack_group.inbound_privacy_violations.count', Metrics.file_count(inbound_privacy_violations), tags)
+          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/pack_stats/private/metrics/packages.rb

@@ -0,0 +1,105 @@
+# typed: strict
+# frozen_string_literal: true
+
+module PackStats
+  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])
+
+          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', packages.sum { |package| Metrics.file_count(package.violations.select(&:dependency?)) }, package_tags)
+          all_metrics << GaugeMetric.for('all_packages.privacy_violations.count', 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.with_violations.count', 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::PackwerkCheckerUsage.get_checker_metrics('all_packages', packages, package_tags)
+          all_metrics += Metrics::RubocopUsage.get_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)
+
+            #
+            # VIOLATIONS (implicit dependencies)
+            #
+            outbound_violations = 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)
+
+            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/pack_stats/private/metrics/packages_by_team.rb

@@ -0,0 +1,69 @@
+# typed: strict
+# frozen_string_literal: true
+
+module PackStats
+  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_packages.group_by { |package| CodeOwnership.for_package(package)&.name }.each do |team_name, packages_by_team|
+            # 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)
+
+            team_tags = Metrics.tags_for_team(team_name) + [app_level_tag]
+            all_metrics << GaugeMetric.for('by_team.all_packages.count', packages_by_team.count, team_tags)
+            all_metrics += Metrics::PackwerkCheckerUsage.get_checker_metrics('by_team', packages_by_team, team_tags)
+            all_metrics += Metrics::PublicUsage.get_public_usage_metrics('by_team', packages_by_team, team_tags)
+            #
+            # VIOLATIONS (implicit dependencies)
+            #
+            outbound_violations = 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 = 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', packages_by_team.count { |package| Metrics.has_readme?(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/pack_stats/private/metrics/packwerk_checker_usage.rb

@@ -0,0 +1,52 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'rubocop-packs'
+
+module PackStats
+  module Private
+    module Metrics
+      class PackwerkCheckerUsage
+        extend T::Sig
+        
+        # Later, we might find a way we can get this directly from `packwerk`
+        class PackwerkChecker < T::Struct
+          const :setting, String
+          const :strict_mode, String
+        end
+
+        sig { params(prefix: String, packages: T::Array[ParsePackwerk::Package], package_tags: T::Array[Tag]).returns(T::Array[GaugeMetric]) }
+        def self.get_checker_metrics(prefix, packages, package_tags)
+          metrics = T.let([], T::Array[GaugeMetric])
+
+          checkers = [
+            PackwerkChecker.new(setting: 'enforce_dependencies', strict_mode: 'enforce_dependencies_strictly'),
+            PackwerkChecker.new(setting: 'enforce_privacy', strict_mode: 'enforce_privacy_strictly')
+          ]
+
+          checkers.each do |checker|
+            ['false', 'true', 'strict'].each do |enabled_mode|
+              count_of_packages = ParsePackwerk.all.count do |package|
+                strict_mode = package.metadata[checker.strict_mode]
+                enabled = YAML.load_file(package.yml)[checker.setting]
+                case enabled_mode
+                when 'false'
+                  !enabled
+                when 'true'
+                  enabled && !strict_mode
+                when 'strict'
+                  !!strict_mode
+                end
+              end
+
+              metric_name = "#{prefix}.packwerk_checkers.#{checker.setting}.#{enabled_mode}.count"
+              metrics << GaugeMetric.for(metric_name, count_of_packages, package_tags)
+            end
+          end
+
+          metrics
+        end
+      end
+    end
+  end
+end