RubyGems - codemonitor - Versions diffs - 0.7.1 → 0.7.5 - Mend

codemonitor 0.7.1 → 0.7.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3827599eb7fa2efbf7519ac50cab319cbb558ccd8c8919bbbc655699c12c10e8
-  data.tar.gz: 574ea905f2ab2643a83e807a9109a2d3761e2b89e6d657aad9e9c7c4d0cca4be
+  metadata.gz: 62ece0078a173b6863e1cfe9e08ca70150d270abe25ec08aba06601f15ea2516
+  data.tar.gz: 40323f63b3fc1982bae1bb56c1f80ea16c4e11736d4d1280cfe4afc58c343fe4
 SHA512:
-  metadata.gz: 1dbcd9264909f8a556b97752c1c600bca72a072799855cd897485d1acbde01ece7277a17662db12056d7ff37230c100d47a4dcdfb99efe1e24de35de885cd7c2
-  data.tar.gz: 63bd28af1b58d502e4a1f767050b3062d37994e5bdf90a4b0592162286ea9eebd7b843018f9d4978910551f829cffd70e07038a3d04d65e562fdef4874e2ea66
+  metadata.gz: 1445c31e4ddfd0492a4bf1ebb8b939702c9c9bafbcadddc209a33ab90185b8593ee41d21904465329de751e926cb9f6888123dde679f56888cdf8c6c6fb3c73b
+  data.tar.gz: e37bc0f7965f010d686137975889e1d0d7292f2237ccd4c1c01f44ff16ee37789e0574e71d93fa5b69cab95636124ce5e6c4a09616ddaed64febb89863fddcd6

data/Gemfile.lock CHANGED Viewed

@@ -1,32 +1,32 @@
 PATH
   remote: .
   specs:
-    codemonitor (0.7.0)
+    codemonitor (0.7.5)
       dogapi (~> 1.45)
       octokit (~> 9.0)
 GEM
   remote: https://rubygems.org/
   specs:
-    addressable (2.8.7)
-      public_suffix (>= 2.0.2, < 7.0)
+    addressable (2.8.8)
+      public_suffix (>= 2.0.2, < 8.0)
     ast (2.4.2)
     coderay (1.1.3)
     diff-lcs (1.3)
     dogapi (1.45.0)
       multi_json
-    faraday (2.13.4)
+    faraday (2.14.0)
       faraday-net_http (>= 2.0, < 3.5)
       json
       logger
-    faraday-net_http (3.4.1)
-      net-http (>= 0.5.0)
-    json (2.13.2)
+    faraday-net_http (3.4.2)
+      net-http (~> 0.5)
+    json (2.18.1)
     logger (1.7.0)
     method_source (1.0.0)
-    multi_json (1.17.0)
-    net-http (0.6.0)
-      uri
+    multi_json (1.19.1)
+    net-http (0.9.1)
+      uri (>= 0.11.1)
     octokit (9.2.0)
       faraday (>= 1, < 3)
       sawyer (~> 0.9)
@@ -36,7 +36,7 @@ GEM
     pry (0.13.1)
       coderay (~> 1.1)
       method_source (~> 1.0)
-    public_suffix (6.0.2)
+    public_suffix (7.0.2)
     rainbow (3.0.0)
     rake (13.0.3)
     regexp_parser (2.1.1)
@@ -66,11 +66,11 @@ GEM
     rubocop-ast (1.5.0)
       parser (>= 3.0.1.1)
     ruby-progressbar (1.11.0)
-    sawyer (0.9.2)
+    sawyer (0.9.3)
       addressable (>= 2.3.5)
       faraday (>= 0.17.3, < 3)
     unicode-display_width (1.7.0)
-    uri (1.0.3)
+    uri (1.1.1)
 PLATFORMS
   ruby
@@ -84,4 +84,4 @@ DEPENDENCIES
   rubocop (~> 0.80)
 BUNDLED WITH
-   2.3.12
+   2.7.2

data/README.md CHANGED Viewed

@@ -1,145 +1,452 @@
 # 🖥️ CodeMonitor
-A engine to collect multiple metrics from your repository and push them to a
-time series provider.
+**CodeMonitor** is a powerful Ruby gem that collects code quality metrics, dependency information, test coverage, and other important statistics from your repository. It aggregates data from multiple analysis tools (linters, type checkers, test frameworks, etc.) and sends them to time series databases or monitoring providers like Datadog for tracking trends over time.
+## 📊 What Does It Do?
-# Engines
+CodeMonitor acts as a centralized metrics collection hub for your codebase. It:
+- **Collects metrics** from various development tools and analysis extractors
+- **Aggregates data** from linters (ESLint, Rubocop, Semgrep), type checkers (Sorbet), test coverage tools (Jest, SimpleCov), dependency analyzers (npm, Knip, Packwerk), and more
+- **Normalizes metrics** into a consistent format
+- **Pushes data** to monitoring providers (Datadog, Console output)
+- **Tracks trends** over time to help you monitor code quality, technical debt, and project health
+## 🚀 Installation
+Add this line to your application's Gemfile:
+```ruby
+gem 'codemonitor'
+```
+And then execute:
+```bash
+bundle install
+```
+Or install it yourself as:
+```bash
+gem install codemonitor
+```
+## 💻 Usage
+### Basic Usage
+Run CodeMonitor in your project directory:
+```bash
+codemonitor
+```
+By default, it will:
+1. Auto-detect which extractors are available (based on configuration files)
+2. Collect metrics from all detected extractors
+3. Output results to the console
+### Configuration
+Configure CodeMonitor using environment variables:
+- **`CODEMONITOR_PROVIDER`**: Choose where to send metrics (`console` or `datadog`). Default: `console`
+- **`CODEMONITOR_EXTRACTORS`**: Comma-separated list of specific extractors to run (e.g., `git,eslint,npm`). If not set, all available extractors run.
+Example:
+```bash
+# Send metrics to Datadog
+CODEMONITOR_PROVIDER=datadog DATADOG_API_KEY=your_key codemonitor
+# Run only specific extractors
+CODEMONITOR_EXTRACTORS=git,npm,eslint codemonitor
+```
+# Extractors
+Extractors are the data collectors that extract metrics from various tools and sources. Each extractor automatically activates when its requirements are met.
 ## Git
-Collect multiple metrics from the a Git repository.
+Collects repository statistics including commits, branches, tags, contributors, and file metrics.
-**Requirements / Setup**:
+**Requirements**:
-You need a `.git` folder present in the current folder:
+- A `.git` folder in the current directory
 **Options**:
-`CODEMONITOR_GIT_FILES_THRESHOLD`: Don't emit metrics about number of files, from those that are above of this threshold. (Default: `0`)
+- `CODEMONITOR_GIT_FILES_THRESHOLD`: Filter out file extension metrics below this count (Default: `0`)
-## Eslint
+**Metrics**:
-Collect multiple metrics from the a project with [Eslint](https://eslint.org/) configured.
+| Metric | Description |
+|--------|-------------|
+| `git_number_of_commits` | Total number of commits in the repository |
+| `git_number_of_branches` | Total number of branches |
+| `git_number_of_tags` | Total number of tags |
+| `git_number_of_contributors` | Total number of unique contributors |
+| `git_number_of_files` | Total number of tracked files |
+| `git_number_of_ignores_files` | Number of ignored files |
+| `git_number_of_lines` | Total lines of code across all files |
+| `git_file_extensions_*` | File count per extension (e.g., `git_file_extensions_rb`, `git_file_extensions_js`) |
-**Requirements / Setup**:
+## ESLint
-You need a `.eslintrc.js` and a `eslint.output.json` file present in the current folder.
+Collects JavaScript/TypeScript linting metrics including violations by severity and rule.
-You can generate the `eslint.output.json` file with this example command:
+**Requirements**:
-```
+- `eslint.output.json` file in the current directory
+Generate the required file:
+```bash
 eslint -f json -o eslint.output.json
 ```
 **Options**:
-`CODEMONITOR_ESLINT_THRESHOLD`: Don't emit metrics about eslint rules that are above of this threshold. (Default: `10`)
+- `CODEMONITOR_ESLINT_THRESHOLD`: Only report rules with violations >= this threshold (Default: `10`)
+**Metrics**:
+| Metric | Description |
+|--------|-------------|
+| `eslint_number_of_offended_files` | Number of files with ESLint violations |
+| `eslint_number_of_offenses` | Total number of ESLint violations |
+| `eslint_number_of_correctable` | Number of auto-fixable violations |
+| `eslint_severity_warning` | Number of warnings |
+| `eslint_severity_error` | Number of errors |
+| `eslint_rule_*` | Violation count per rule (e.g., `eslint_rule_no_console`) |
+## npm
+Collects Node.js dependency information including counts, computed dependencies, and vulnerability data from npm audit.
-## Npm
+**Requirements**:
-Collect multiple metrics from the a NodeJS.
+- `package.json` file in the current directory
+- `package-lock.json` file in the current directory
-**Requirements / Setup**:
+**Metrics**:
-You need a `package.json` file present in the current folder.
+| Metric | Description |
+|--------|-------------|
+| `npm_number_of_prod_dependencies` | Number of production dependencies |
+| `npm_number_of_dev_dependencies` | Number of development dependencies |
+| `npm_number_of_scripts` | Number of npm scripts defined |
+| `npm_number_of_computed_prod_dependencies` | Total production dependencies (including transitive) |
+| `npm_number_of_computed_dev_dependencies` | Total dev dependencies (including transitive) |
+| `npm_number_of_computed_optional_dependencies` | Total optional dependencies |
+| `npm_number_of_computed_peer_dependencies` | Total peer dependencies |
+| `npm_number_of_computed_peer_optional_dependencies` | Total optional peer dependencies |
+| `npm_number_of_computed_total_dependencies` | Grand total of all dependencies |
+| `npm_number_of_vulnerable_dependencies_info` | Vulnerabilities: info severity |
+| `npm_number_of_vulnerable_dependencies_low` | Vulnerabilities: low severity |
+| `npm_number_of_vulnerable_dependencies_moderate` | Vulnerabilities: moderate severity |
+| `npm_number_of_vulnerable_dependencies_high` | Vulnerabilities: high severity |
+| `npm_number_of_vulnerable_dependencies_critical` | Vulnerabilities: critical severity |
+| `npm_number_of_vulnerable_dependencies_total` | Total number of vulnerabilities |
 ## Packwerk
-Collect multiple metrics from the a Ruby project with [Packwerk](https://github.com/Shopify/packwerk) configured.
+Collects metrics from Shopify's [Packwerk](https://github.com/Shopify/packwerk) package system for Ruby, tracking dependency and privacy violations.
-**Requirements / Setup**:
+**Requirements**:
-You need a `deprecated_references.yml` files present in the current project.
+- `package_todo.yml` files present in the project (in any subdirectory)
+**Metrics**:
+| Metric | Description |
+|--------|-------------|
+| `packwerk_number_of_dependency_violations` | Number of package dependency violations |
+| `packwerk_number_of_privacy_violations` | Number of package privacy violations |
 ## Rubocop
-Collect multiple metrics from the a Ruby project with [Rubocop](https://github.com/rubocop/rubocop) configured.
+Collects Ruby linting metrics from [Rubocop](https://github.com/rubocop/rubocop), including violations by severity and cop.
-**Requirements / Setup**:
+**Requirements**:
-You need a `.rubocop.yml` and a `rubocop.output.json` file present in the current folder.
+- `rubocop.output.json` file in the current directory
-You can generate the `rubocop.output.json` file with this example command:
+Generate the required file:
-```
-bundle exec srb tc --metrics-prefix 'codemetrics' --metrics-file sorbet.output.json
+```bash
+bundle exec rubocop -f json -o rubocop.output.json
 ```
 **Options**:
-`CODEMONITOR_RUBOCOP_THRESHOLD`: Don't emit metrics about rubocop cops that are above of this threshold. (Default: `50`)
+- `CODEMONITOR_RUBOCOP_THRESHOLD`: Only report cops with violations >= this threshold (Default: `50`)
+**Metrics**:
+| Metric | Description |
+|--------|-------------|
+| `rubocop_number_of_offenses` | Total number of Rubocop violations |
+| `rubocop_number_of_correctable` | Number of auto-correctable violations |
+| `rubocop_severity_*` | Violations by severity (e.g., `rubocop_severity_warning`) |
+| `rubocop_cop_*` | Violations per cop (e.g., `rubocop_cop_style_frozen_string_literal_comment`) |
 ## Semgrep
-Collect multiple metrics from the a with [Semgrep](https://semgrep.dev/) configured.
+Collects security and code quality findings from [Semgrep](https://semgrep.dev/).
-**Requirements / Setup**:
+**Requirements**:
-You need a `.semgrep.yml` and a `semgrep.output.json` file present in the current folder.
+- `semgrep.output.json` file in the current directory
-You can generate the `semgrep.output.json` file with this example command:
+Generate the required file:
-```
+```bash
 semgrep --json -o semgrep.output.json
 ```
 **Options**:
-`CODEMONITOR_SEMGREP_THRESHOLD`: Don't emit metrics about rubocop cops that are above of this threshold. (Default: `50`)
+- `CODEMONITOR_SEMGREP_THRESHOLD`: Only report check IDs with findings >= this threshold (Default: `50`)
+**Metrics**:
+| Metric | Description |
+|--------|-------------|
+| `semgrep_number_of_offenses` | Total number of Semgrep findings |
+| `semgrep_number_of_errors` | Number of Semgrep errors during analysis |
+| `semgrep_check_*` | Findings per check ID |
 ## Knip
-Collect multiple metrics from [Knip](https://knip.dev/)
+Collects unused code metrics from [Knip](https://knip.dev/), identifying unused dependencies, exports, and types.
-**Requirements / Setup**:
+**Requirements**:
-You need a `knip.output.json` file present in the current folder.
+- `knip.output.json` file in the current directory
-You can generate the `knip.output.json` file with this example command:
+Generate the required file:
-```
+```bash
 knip --reporter json > knip.output.json
 ```
+**Metrics**:
+| Metric | Description |
+|--------|-------------|
+| `knip_number_of_dependecies` | Unused dependencies |
+| `knip_number_of_devDependencies` | Unused dev dependencies |
+| `knip_number_of_optionalPeerDependencies` | Unused optional peer dependencies |
+| `knip_number_of_unlisted` | Unlisted dependencies |
+| `knip_number_of_binaries` | Unused binaries |
+| `knip_number_of_unresolved` | Unresolved imports |
+| `knip_number_of_exports` | Unused exports |
+| `knip_number_of_types` | Unused types |
+| `knip_number_of_enumMembers` | Unused enum members |
+| `knip_number_of_duplicates` | Duplicate exports |
 ## Sorbet
-Collect multiple metrics from [Sorbet](https://sorbet.org/) configured.
+Collects type coverage metrics from [Sorbet](https://sorbet.org/), Stripe's type checker for Ruby.
-**Requirements / Setup**:
+**Requirements**:
-You need a `sorbet.output.json` file present in the current folder.
+- `sorbet.output.json` file in the current directory
-You can generate the `sorbet.output.json` file with this example command:
+Generate the required file:
-```
+```bash
 bundle exec srb tc --metrics-prefix 'codemetrics' --metrics-file sorbet.output.json
 ```
-## SCC
+**Metrics**:
+| Metric | Description |
+|--------|-------------|
+| `sorbet_number_of_sig_count` | Number of type signatures |
+| `sorbet_number_of_input_classes_total` | Total number of classes |
+| `sorbet_number_of_input_sends_total` | Total number of method calls |
+| `sorbet_number_of_input_files` | Number of Ruby files analyzed |
+| `sorbet_number_of_input_methods_total` | Total number of methods |
+| `sorbet_number_of_input_modules_total` | Total number of modules |
+| `sorbet_number_of_sigil_true` | Files with `typed: true` |
+| `sorbet_number_of_sigil_false` | Files with `typed: false` |
+| `sorbet_number_of_sigil_autogenerated` | Files with `typed: autogenerated` |
+| `sorbet_number_of_sigil_strong` | Files with `typed: strong` |
+| `sorbet_number_of_sigil_strict` | Files with `typed: strict` |
+| `sorbet_number_of_sigil_ignore` | Files with `typed: ignore` |
+## SCC (Sloc Cloc and Code)
+Collects code statistics from [SCC](https://github.com/boyter/scc), including lines of code, complexity, and language breakdowns.
+**Requirements**:
+- `scc.output.json` file in the current directory
+Generate the required file:
+```bash
+scc -f json > scc.output.json
+```
+**Metrics**:
+| Metric | Description |
+|--------|-------------|
+| `scc_total_bytes` | Total bytes across all files |
+| `scc_total_lines` | Total lines across all files |
+| `scc_total_code` | Total lines of code |
+| `scc_total_comment` | Total comment lines |
+| `scc_total_blank` | Total blank lines |
+| `scc_total_complexity` | Total cyclomatic complexity |
+| `scc_total_count` | Total number of files |
+| `scc_total_weightedcomplexity` | Weighted complexity score |
+| `scc_type_*_*` | Per-language metrics (e.g., `scc_type_ruby_code`, `scc_type_javascript_lines`) |
+## Jest
+Collects JavaScript/TypeScript test coverage metrics from Jest's JSON summary reporter.
+**Requirements**:
+- `jest_json_summary.output.json` file in the current directory
+Configure Jest to generate this file using the `json-summary` reporter in your `jest.config.js`.
+**Metrics**:
+| Metric | Description |
+|--------|-------------|
+| `jest_json_summary_lines_total` | Total lines in test coverage |
+| `jest_json_summary_lines_covered` | Covered lines |
+| `jest_json_summary_lines_skipped` | Skipped lines |
+| `jest_json_summary_lines_pct` | Line coverage percentage |
+| `jest_json_summary_statements_*` | Statement coverage metrics |
+| `jest_json_summary_functions_*` | Function coverage metrics |
+| `jest_json_summary_branches_*` | Branch coverage metrics |
+## SimpleCov
+Collects Ruby test coverage metrics from [SimpleCov](https://github.com/simplecov-ruby/simplecov).
+**Requirements**:
+- `simplecov_json_coverage.output.json` file in the current directory
+Configure SimpleCov to use the JSON formatter in your test setup.
-Collect multiple metrics from [SCC](https://github.com/boyter/scc) configured.
+**Metrics**:
-**Requirements / Setup**:
+| Metric | Description |
+|--------|-------------|
+| `simplecov_json_coverage_metrics_covered_percent` | Code coverage percentage |
+| `simplecov_json_coverage_metrics_covered_strength` | Coverage strength score |
+| `simplecov_json_coverage_metrics_covered_lines` | Number of covered lines |
+| `simplecov_json_coverage_metrics_total_lines` | Total number of lines |
-You need a `scc.output.json` file present in the current folder.
+## TSC (TypeScript Compiler)
-You can generate the `scc.output.json` file with this example command:
+Collects TypeScript compiler diagnostics and performance metrics from `tsc --extendedDiagnostics` output.
+**Requirements**:
+- `tsc.output.txt` file in the current directory
+Generate the required file:
+```bash
+pnpm tsc --extendedDiagnostics --incremental false > tsc.output.txt
 ```
-scc -f json scc.output.json
+Or using npm:
+```bash
+npm run tsc -- --extendedDiagnostics --incremental false > tsc.output.txt
 ```
+**Metrics**:
+| Metric | Description |
+|--------|-------------|
+| `tsc_files` | Total number of files analyzed |
+| `tsc_lines_of_library` | Lines of library code |
+| `tsc_lines_of_definitions` | Lines of type definitions |
+| `tsc_lines_of_typescript` | Lines of TypeScript code |
+| `tsc_lines_of_javascript` | Lines of JavaScript code |
+| `tsc_lines_of_json` | Lines of JSON files |
+| `tsc_lines_of_other` | Lines of other file types |
+| `tsc_identifiers` | Total number of identifiers |
+| `tsc_symbols` | Total number of symbols |
+| `tsc_types` | Total number of types |
+| `tsc_instantiations` | Total number of type instantiations |
+| `tsc_memory_used_kb` | Memory used by compiler (in kilobytes) |
+| `tsc_assignability_cache_size` | Size of assignability cache |
+| `tsc_identity_cache_size` | Size of identity cache |
+| `tsc_subtype_cache_size` | Size of subtype cache |
+| `tsc_strict_subtype_cache_size` | Size of strict subtype cache |
+| `tsc_io_read_time_seconds` | Time spent reading files (seconds) |
+| `tsc_parse_time_seconds` | Time spent parsing (seconds) |
+| `tsc_resolve_module_time_seconds` | Time spent resolving modules (seconds) |
+| `tsc_resolve_type_reference_time_seconds` | Time spent resolving type references (seconds) |
+| `tsc_resolve_library_time_seconds` | Time spent resolving libraries (seconds) |
+| `tsc_program_time_seconds` | Time spent on program construction (seconds) |
+| `tsc_bind_time_seconds` | Time spent binding (seconds) |
+| `tsc_check_time_seconds` | Time spent type checking (seconds) |
+| `tsc_print_time_seconds` | Time spent printing (seconds) |
+| `tsc_emit_time_seconds` | Time spent emitting output (seconds) |
+| `tsc_total_time_seconds` | Total compilation time (seconds) |
+## GitHub
+Collects pull request metrics directly from GitHub, including open PRs and lead time.
+**Requirements**:
+- `GITHUB_TOKEN` environment variable with a GitHub personal access token
+- `GITHUB_REPOSITORY` environment variable (format: `owner/repo`)
+**Options**:
+- `GITHUB_SINCE_DAYS`: Number of days to look back for lead time calculation (Default: `30`)
+Example:
+```bash
+GITHUB_TOKEN=ghp_xxx GITHUB_REPOSITORY=owner/repo codemonitor
+```
+**Metrics**:
+| Metric | Description |
+|--------|-------------|
+| `github_number_of_open_pull_requests` | Number of open pull requests |
+| `github_number_of_lead_time_in_days` | Average lead time for merged PRs (in days) |
 # Providers
+Providers determine where the collected metrics are sent. CodeMonitor supports multiple output destinations.
 ## Console
-Simply outputs all metrics to the console.
+Outputs all metrics to standard output in a simple text format.
 **Usage**:
-The console provider prints metrics in the format `metric_name: value`. If metrics include tags (using the `#` delimiter format), they are printed as is:
+```bash
+codemonitor  # Console is the default provider
+# OR
+CODEMONITOR_PROVIDER=console codemonitor
+```
+**Output Format**:
+The console provider prints metrics in the format `metric_name: value`. If metrics include tags (using the `#` delimiter), they are displayed as-is:
 ```
 requests: 100
@@ -150,25 +457,114 @@ latency#backend,region:us-east-1,env:prod: 150
 ## Datadog
-Sends metrics to Datadog using the Datadog API. Supports metric tagging for better organization and filtering.
+Sends metrics to [Datadog](https://www.datadoghq.com/) using the Datadog API for monitoring and visualization over time.
+**Usage**:
+```bash
+CODEMONITOR_PROVIDER=datadog DATADOG_API_KEY=your_api_key codemonitor
+```
 **Environment Variables**:
-- `DATADOG_API_KEY` (required): your Datadog API key
-- `DATADOG_PREFIX` (optional): prefix to add to all metric names (default: `'codemonitor.'`)
+- `DATADOG_API_KEY` (required): Your Datadog API key
+- `DATADOG_PREFIX` (optional): Prefix added to all metric names (default: `'codemonitor.'`)
 **Metric Tagging**:
-The Datadog provider supports adding tags to metrics by including them in the metric name using the `#` delimiter:
+The Datadog provider supports adding tags to metrics for better organization and filtering. Include tags in the metric name using the `#` delimiter:
+- **Format**: `metric_name#tag1,tag2:value,tag3`
+- **Example**: `requests#frontend,app:webserver` → sends metric `requests` with tags `['frontend', 'app:webserver']`
+- Tags follow Datadog's standard format: simple tags (`tag`) or key-value pairs (`key:value`)
+More about Datadog tagging: [Datadog Tagging Documentation](https://docs.datadoghq.com/getting_started/tagging/)
+## 🔧 Advanced Usage
+### Running Specific Extractors
+To run only specific extractors, use the `CODEMONITOR_EXTRACTORS` environment variable:
+```bash
+# Run only Git and ESLint extractors
+CODEMONITOR_EXTRACTORS=git,eslint codemonitor
+# Run npm and Rubocop with Datadog output
+CODEMONITOR_PROVIDER=datadog DATADOG_API_KEY=xxx CODEMONITOR_EXTRACTORS=npm,rubocop codemonitor
+```
+### Interactive Mode
+CodeMonitor can accept metrics directly from standard input using the `--interactive` flag. This allows you to send custom metrics without needing to configure extractors:
+```bash
+codemonitor --interactive <<EOF
+{
+  metric_name: 100,
+  another_metric: 200,
+  "tagged_metric#tag1,tag2:value": 300
+}
+EOF
+```
+The interactive mode reads from stdin until it encounters two consecutive empty lines. The input must be a valid Ruby hash. This is useful for:
+- Sending ad-hoc metrics
+- Integrating with scripts that generate metrics dynamically
+- Testing providers without setting up extractors
+## Environment Variables
+- `CODEMONITOR_PROVIDER`: Provider to use (default: `console`, options: `console`, `datadog`)
+- `CODEMONITOR_EXTRACTORS`: Comma-separated list of extractors to run (default: all extractors)
+For provider-specific configuration, see the [Providers](#providers) section below.
+### CI/CD Integration
+CodeMonitor is designed to run in CI/CD pipelines. Here's an example GitHub Actions workflow:
+```yaml
+name: Code Metrics
+on: [push]
+jobs:
+  metrics:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      # Generate output files for various tools
+      - name: Run ESLint
+        run: eslint -f json -o eslint.output.json || true
+      - name: Run Rubocop
+        run: bundle exec rubocop -f json -o rubocop.output.json || true
+      # Collect and send metrics
+      - name: Run CodeMonitor
+        env:
+          CODEMONITOR_PROVIDER: datadog
+          DATADOG_API_KEY: ${{ secrets.DATADOG_API_KEY }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+        run: codemonitor
+```
+### Best Practices
+1. **Generate tool outputs before running CodeMonitor**: Most extractors require JSON output files from their respective tools
+2. **Use thresholds wisely**: Adjust threshold values to focus on significant metrics and reduce noise
+3. **Track trends over time**: Send metrics to Datadog or similar to visualize trends and set up alerts
+4. **Run in CI/CD**: Automate metric collection on every commit or pull request
+5. **Combine multiple extractors**: Use Git + linters + test coverage for a comprehensive health overview
-- Format: `metric_name#tag1,tag2:value,tag3`
-- Example: `requests#frontend,app:webserver` → sends metric `requests` with tags `['frontend', 'app:webserver']`
-- Tags follow Datadog's standard format where tags can be simple (`tag`) or key-value pairs (`key:value`)
+## 🤝 Contribute
-More about tagging: [https://docs.datadoghq.com/getting_started/tagging/](https://docs.datadoghq.com/getting_started/tagging/)
+This project started as a side project, so there's always room for improvement! If you have ideas for new extractors, better metrics, or code improvements, pull requests are very welcome. 😊
-# Contribute
+## 📝 License
-This project started as a side project, so I'm sure that is full
-of mistakes and areas to be improve. If you think you can tweak the code to
-make it better, I'll really appreciate a pull request. ;)
+This project is available under the MIT License. See the LICENSE file for details.

data/engines/tsc/extractor.rb ADDED Viewed

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+module Engines
+  module Tsc
+    class Extractor
+      METRICS = %i[
+        tsc_files
+        tsc_lines_of_library
+        tsc_lines_of_definitions
+        tsc_lines_of_typescript
+        tsc_lines_of_javascript
+        tsc_lines_of_json
+        tsc_lines_of_other
+        tsc_identifiers
+        tsc_symbols
+        tsc_types
+        tsc_instantiations
+        tsc_memory_used_kb
+        tsc_assignability_cache_size
+        tsc_identity_cache_size
+        tsc_subtype_cache_size
+        tsc_strict_subtype_cache_size
+        tsc_io_read_time_seconds
+        tsc_parse_time_seconds
+        tsc_resolve_module_time_seconds
+        tsc_resolve_type_reference_time_seconds
+        tsc_resolve_library_time_seconds
+        tsc_program_time_seconds
+        tsc_bind_time_seconds
+        tsc_check_time_seconds
+        tsc_print_time_seconds
+        tsc_emit_time_seconds
+        tsc_total_time_seconds
+      ].freeze
+      def call(provider)
+        metrics = METRICS.map do |metric|
+          [metric, send(metric)]
+        end.to_h
+        provider.emit(metrics)
+      end
+      def requirements?
+        File.exist?('tsc.output.txt')
+      end
+      private
+      def tsc_output
+        @tsc_output ||= File.read('tsc.output.txt')
+      end
+      def extract_integer(pattern)
+        match = tsc_output.match(pattern)
+        return 0 if match.nil?
+        match[1].gsub(/\s+/, '').to_i
+      end
+      def extract_time(pattern)
+        match = tsc_output.match(pattern)
+        return 0.0 if match.nil?
+        time_str = match[1]
+        # Convert time format like "0.63s" to 0.63
+        time_str.sub(/s$/, '').to_f
+      end
+      def tsc_files
+        extract_integer(/^Files:\s+(\d+)/)
+      end
+      def tsc_lines_of_library
+        extract_integer(/^Lines of Library:\s+(\d+)/)
+      end
+      def tsc_lines_of_definitions
+        extract_integer(/^Lines of Definitions:\s+(\d+)/)
+      end
+      def tsc_lines_of_typescript
+        extract_integer(/^Lines of TypeScript:\s+(\d+)/)
+      end
+      def tsc_lines_of_javascript
+        extract_integer(/^Lines of JavaScript:\s+(\d+)/)
+      end
+      def tsc_lines_of_json
+        extract_integer(/^Lines of JSON:\s+(\d+)/)
+      end
+      def tsc_lines_of_other
+        extract_integer(/^Lines of Other:\s+(\d+)/)
+      end
+      def tsc_identifiers
+        extract_integer(/^Identifiers:\s+(\d+)/)
+      end
+      def tsc_symbols
+        extract_integer(/^Symbols:\s+(\d+)/)
+      end
+      def tsc_types
+        extract_integer(/^Types:\s+(\d+)/)
+      end
+      def tsc_instantiations
+        extract_integer(/^Instantiations:\s+(\d+)/)
+      end
+      def tsc_memory_used_kb
+        # Extract memory in KB (e.g., "6942037K" -> 6942037)
+        match = tsc_output.match(/^Memory used:\s+(\d+)K/)
+        return 0 if match.nil?
+        match[1].to_i
+      end
+      def tsc_assignability_cache_size
+        extract_integer(/^Assignability cache size:\s+(\d+)/)
+      end
+      def tsc_identity_cache_size
+        extract_integer(/^Identity cache size:\s+(\d+)/)
+      end
+      def tsc_subtype_cache_size
+        extract_integer(/^Subtype cache size:\s+(\d+)/)
+      end
+      def tsc_strict_subtype_cache_size
+        extract_integer(/^Strict subtype cache size:\s+(\d+)/)
+      end
+      def tsc_io_read_time_seconds
+        extract_time(/^I\/O Read time:\s+([\d.]+s)/)
+      end
+      def tsc_parse_time_seconds
+        extract_time(/^Parse time:\s+([\d.]+s)/)
+      end
+      def tsc_resolve_module_time_seconds
+        extract_time(/^ResolveModule time:\s+([\d.]+s)/)
+      end
+      def tsc_resolve_type_reference_time_seconds
+        extract_time(/^ResolveTypeReference time:\s+([\d.]+s)/)
+      end
+      def tsc_resolve_library_time_seconds
+        extract_time(/^ResolveLibrary time:\s+([\d.]+s)/)
+      end
+      def tsc_program_time_seconds
+        extract_time(/^Program time:\s+([\d.]+s)/)
+      end
+      def tsc_bind_time_seconds
+        extract_time(/^Bind time:\s+([\d.]+s)/)
+      end
+      def tsc_check_time_seconds
+        extract_time(/^Check time:\s+([\d.]+s)/)
+      end
+      def tsc_print_time_seconds
+        extract_time(/^printTime time:\s+([\d.]+s)/)
+      end
+      def tsc_emit_time_seconds
+        extract_time(/^Emit time:\s+([\d.]+s)/)
+      end
+      def tsc_total_time_seconds
+        extract_time(/^Total time:\s+([\d.]+s)/)
+      end
+    end
+  end
+end

data/exe/codemonitor CHANGED Viewed

@@ -18,6 +18,7 @@ require_relative '../engines/scc/extractor'
 require_relative '../engines/semgrep/extractor'
 require_relative '../engines/simplecov-json-coverage/extractor'
 require_relative '../engines/sorbet/extractor'
+require_relative '../engines/tsc/extractor'
 PROVIDERS = {
   console: Providers::Console,
@@ -38,30 +39,69 @@ EXTRACTORS = {
   scc: Engines::Scc::Extractor,
   semgrep: Engines::Semgrep::Extractor,
   simplecov_json_coverage: Engines::SimpleCovJsonCoverage::Extractor,
-  sorbet: Engines::Sorbet::Extractor
+  sorbet: Engines::Sorbet::Extractor,
+  tsc: Engines::Tsc::Extractor
 }.freeze
+# Parse command-line arguments
+interactive_mode = ARGV.include?('--interactive')
 config_provider = ENV['CODEMONITOR_PROVIDER'] || 'console'
 config_extractors = ENV['CODEMONITOR_EXTRACTORS']
 provider = PROVIDERS[config_provider.to_sym].new
-extractors = if config_extractors
-               EXTRACTORS.slice(*config_extractors.split(',').map(&:to_sym)).values
-             else
-               EXTRACTORS.values
-             end
 puts '# process start'
-# Run all the extractors and collect the data
-extractors
-  .map(&:new)
-  .map do |extractor|
-    raise "Requirements not fullfiled in #{extractor.class.name}" unless extractor.requirements?
+if interactive_mode
+  # Read from stdin until two consecutive empty lines
+  lines = []
+  empty_line_count = 0
+  while empty_line_count < 2
+    line = $stdin.gets
+    break unless line
+    line = line.chomp
-    extractor.call(provider)
+    if line.empty?
+      empty_line_count += 1
+    else
+      empty_line_count = 0
+      lines << line
+    end
   end
+  # Join the lines and evaluate as a Ruby hash
+  input_str = lines.join("\n")
+  begin
+    metrics = eval(input_str)
+    raise "Input must be a Hash" unless metrics.is_a?(Hash)
+    provider.emit(metrics)
+  rescue SyntaxError, StandardError => e
+    puts "Error parsing input: #{e.message}"
+    exit 1
+  end
+else
+  # Original behavior: run extractors
+  extractors = if config_extractors
+                 EXTRACTORS.slice(*config_extractors.split(',').map(&:to_sym)).values
+               else
+                 EXTRACTORS.values
+               end
+  # Run all the extractors and collect the data
+  extractors
+    .map(&:new)
+    .map do |extractor|
+      raise "Requirements not fullfiled in #{extractor.class.name}" unless extractor.requirements?
+      extractor.call(provider)
+    end
+end
 # Send all the data to the provider
 provider.send

data/lib/codemonitor/version.rb CHANGED Viewed

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module CodeMonitor
-  VERSION = "0.7.1"
+  VERSION = "0.7.5"
 end

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: codemonitor
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.5
 platform: ruby
 authors:
 - Ferran Basora
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-09-04 00:00:00.000000000 Z
+date: 2026-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dogapi
@@ -144,6 +144,7 @@ files:
 - engines/semgrep/extractor.rb
 - engines/simplecov-json-coverage/extractor.rb
 - engines/sorbet/extractor.rb
+- engines/tsc/extractor.rb
 - exe/codemonitor
 - lib/codemonitor/version.rb
 - lib/shell.rb