# GalataJ — Complete Documentation

> GalataJ is a lightweight Java profiler that shows method-level performance metrics inline in IntelliJ IDEA and VS Code. It lets developers profile, compare, and act on performance data without leaving their IDE. The core workflow is: Profile → Compare → Act.

---

## Table of Contents

1. [Overview](#overview)
2. [How It Works](#how-it-works)
3. [Installation](#installation)
4. [Quick Start](#quick-start)
5. [Inline Performance Metrics](#inline-performance-metrics)
6. [Live Profiler Panel](#live-profiler-panel)
7. [Context Detection](#context-detection)
8. [Understanding Metrics](#understanding-metrics)
9. [Session Management](#session-management)
10. [Baseline Tracking & Comparison](#baseline-tracking--comparison)
11. [Export Capabilities](#export-capabilities)
12. [AI Integration](#ai-integration)
13. [Docker Support](#docker-support)
14. [IDE Integration — IntelliJ IDEA](#ide-integration--intellij-idea)
15. [IDE Integration — VS Code / Cursor / Windsurf](#ide-integration--vs-code--cursor--windsurf)
16. [CLI Reference](#cli-reference)
17. [Configuration & Settings](#configuration--settings)
18. [Health Check & Diagnostics](#health-check--diagnostics)
19. [Troubleshooting](#troubleshooting)
20. [Architecture](#architecture)
21. [Pricing](#pricing)
22. [Limitations](#limitations)
23. [FAQ](#faq)
24. [Links & Contact](#links--contact)

---

## Overview

GalataJ is a developer-focused Java profiler designed to eliminate context switching. Instead of switching between your IDE and external profiling tools, GalataJ shows performance data directly in your code editor as inline hints above each method. 

It uses JVM bytecode instrumentation to measure method execution times, call counts, memory allocations, and performance trends — all with approximately 3% overhead. The profiler attaches to running JVMs at runtime, requiring no restarts, no JVM flags, no annotations, and no source code modifications.

### Key Differentiators

- **Zero Context Switching:** All profiling data appears inline in your IDE, no separate windows or tools
- **Runtime Attach:** Connect to any running JVM instantly without restart or configuration
- **Low Overhead:** ~3% overhead makes it practical for everyday development use
- **AI-Ready:** Auto-generated structured markdown files that AI assistants can read for performance analysis
- **Version Control Friendly:** All output files are plain text markdown, suitable for git
- **Dual IDE Support:** Full feature parity between IntelliJ IDEA and VS Code
- **Developer-Focused:** Designed to show WHERE performance problems are in code, not for production monitoring
- **Baseline Tracking:** Detect regressions before they reach production
- **One-Click Health Check:** Automatic diagnosis and fixes for common setup issues
- **Generous Free Tier:** Core profiling features available free forever

---

## How It Works

### Bytecode Instrumentation

GalataJ uses JVM bytecode instrumentation to collect performance data. When you attach the profiler to a running JVM:

1. The GalataJ agent instruments method bytecode at the JVM level
2. It measures execution time, call count, and memory allocations for each method
3. Data is sent to the GalataJ Controller (a lightweight background service)
4. The IDE plugin reads data from the Controller and displays it as inline hints

This approach means:
- No source code changes are needed
- No annotations or build plugins required
- No JVM flags or startup parameters needed
- The profiler can attach to already-running applications
- Instrumentation is transparent and reversible

### Component Architecture

GalataJ consists of four components:

1. **Plugin:** The IDE extension (IntelliJ IDEA or VS Code) that displays metrics inline
2. **CLI:** Command-line tool for scripting, diagnostics, and headless operations
3. **Controller:** Background service running on the developer's machine (HTTP port 9877, TCP port 9876) that receives data from agents and serves it to plugins
4. **Agent:** JVM instrumentation agent (`~/.galataj/agent/agent.jar`) that instruments bytecode and collects metrics

---

## Installation

### Prerequisites

- JDK 8 or later installed on your system
- IntelliJ IDEA 2024.1+ or VS Code 1.80+

### IDE Plugin Installation

**IntelliJ IDEA:**
1. Open Settings → Plugins → Marketplace
2. Search for "GalataJ Profiler"
3. Click Install and restart the IDE
4. Plugin ID: 30260
5. URL: https://plugins.jetbrains.com/plugin/30260-galataj-profiler

**VS Code / Cursor / Windsurf:**
1. Open Extensions panel (Ctrl+Shift+X / Cmd+Shift+X)
2. Search for "GalataJ"
3. Click Install
4. Extension ID: GalataJ.galataj
5. URL: https://marketplace.visualstudio.com/items?itemName=GalataJ.galataj

### CLI Installation

**macOS / Linux:**
```
curl -fsSL https://download.galataj.com/install.sh | bash
```

**Windows (PowerShell):**
```
powershell -c "irm https://download.galataj.com/install.ps1 | iex"
```

The CLI installs the Controller and Agent components automatically.

---

## Quick Start

1. Install the GalataJ plugin from the marketplace (IntelliJ or VS Code)
2. Run your Java application normally (no special configuration needed)
3. Open the GalataJ Profiler panel in your IDE
4. Click "Start Profiling" (IntelliJ: Run menu → Start GalataJ Profiling)
5. Select the JVM you want to profile from the discovered list
6. Performance metrics appear inline above methods in your code within seconds
7. Sort by Avg time in the profiler panel to find your slowest methods

---

## Inline Performance Metrics

GalataJ displays performance metrics as inline hints directly above methods in your editor. In IntelliJ IDEA, these appear as CodeVision hints. In VS Code, they appear as CodeLens hints.

### Metrics Displayed

- **Avg Time:** The average execution time across all calls within the profiling window. This is the primary metric for identifying slow methods.
- **Max Time:** The maximum (slowest) execution time recorded. When Max is significantly higher than Avg, it indicates occasional spikes — possibly due to cold starts, garbage collection, or external service latency.
- **Calls:** The total number of times the method was invoked since profiling started. Useful for identifying hot methods and detecting N+1 query patterns.
- **Trend:** A performance change indicator showing whether the method is getting faster or slower over time.
  - ↑ (up arrow, red) = Performance regression, method is getting slower
  - ↓ (down arrow, green) = Performance improvement, method is getting faster
  - — (dash, gray) = Stable, no significant change
- **Memory / Alloc:** Bytes allocated per call (when available). Helps identify methods causing excessive garbage collection.

### Color Coding

- **Red trend** = Performance regression detected, investigate
- **Green trend** = Performance improvement detected
- **Gray** = No significant change in performance

### Hovering

Hovering over any inline metric shows a detailed breakdown with exact numbers, percentages, and additional context about the method's performance characteristics.

### Real-time Updates

Metrics update in real-time as your application runs. The default update interval is 1 second (configurable in settings).

---

## Live Profiler Panel

The Profiler Panel is a dedicated tool window (IntelliJ) or panel (VS Code) that shows a table of all profiled methods.

### Features

- **Sortable Columns:** Click any column header to sort. Sort by Avg descending to find your slowest methods first.
- **Filterable:** Filter by package name, class name, or method name to focus on specific areas.
- **Click to Navigate:** Click any method row to jump directly to its source code location.
- **Real-time Updates:** The panel updates live as new profiling data arrives.
- **Refresh Button:** Manually refresh the JVM list to discover new processes.

### Columns

| Column | Description |
|--------|-------------|
| Method | Fully qualified class and method name |
| Avg | Average execution time (the most useful metric for finding slow methods) |
| Max | Maximum (worst-case) execution time |
| Calls | Total number of invocations |
| Trend | Performance change indicator (↑ slower, ↓ faster, — stable) |
| Alloc | Memory allocations per call (when available) |

---

## Context Detection

GalataJ automatically detects the context of profiled methods and enriches the inline hints with additional information.

### HTTP Endpoints
For REST controller methods (annotated with `@GetMapping`, `@PostMapping`, `@RequestMapping`, etc.), GalataJ displays the HTTP endpoint path alongside the performance metrics. This makes it easy to correlate API endpoint performance with specific methods.

### Database Queries
For repository methods (Spring Data JPA, etc.), GalataJ shows query pattern information. Combined with call count data, this helps detect N+1 query problems — a very high call count on a repository method often indicates an N+1 issue.

### Scheduled Tasks
Methods annotated with `@Scheduled` display the schedule expression (cron, fixedRate, fixedDelay), making it easy to monitor the performance of background tasks.

### Async Methods
Methods annotated with `@Async` show thread context information, helping you understand the concurrency behavior of your application.

---

## Understanding Metrics

### Execution Time Thresholds

These are general guidelines for interpreting execution times:

| Avg Time | Assessment |
|----------|------------|
| < 1ms | Fast — typically no action needed |
| 1–10ms | Normal — acceptable for most methods |
| 10–100ms | Worth investigating — may be a bottleneck |
| > 100ms | Slow — likely needs optimization |

These thresholds depend on context. A 50ms average is fine for an HTTP endpoint that makes database calls, but concerning for a utility method that should be pure computation.

### Max vs Avg Analysis

- **Max ≈ Avg:** Consistent performance, no spikes
- **Max >> Avg (e.g., 5x or more):** Occasional spikes. Common causes:
  - JIT compilation warming up (early calls are slower)
  - Garbage collection pauses
  - External service latency spikes
  - Lock contention under concurrent load

### Call Count Patterns

- **Very high calls + low avg time:** Possible N+1 query problem. Each call is fast, but thousands of unnecessary calls add up.
- **High calls + high avg time:** Major performance impact. These are your highest-priority optimization targets.
- **Low calls + high avg time:** Individual calls are slow. Optimize the method itself rather than reducing call frequency.
- **Unexpected call count = 0:** Method might not be in the profiled package scope, or hasn't been invoked yet.

### Trend Causes

**Why a method might be getting slower (↑):**
- Data volume growing (e.g., more rows in database)
- Memory pressure causing more frequent GC
- External service (database, API) responding slower
- Code changes introducing inefficiency
- Connection pool exhaustion

**Why a method might be getting faster (↓):**
- Caching warming up and serving cached results
- JIT compiler optimizing hot paths
- Application load decreasing
- Database query plan optimization kicking in

### Memory Allocation Thresholds

| Allocation per Call | Assessment |
|---------------------|------------|
| < 1 KB | Minimal — no concern |
| 1–10 KB | Normal |
| 10–100 KB | Consider optimization — may cause GC pressure |
| > 100 KB | High allocation — likely causing frequent GC pauses |

---

## Session Management

Sessions allow you to save a snapshot of your profiling data at a specific point in time.

### Saving Sessions (Pro)

- **Free Tier:** 1 session save per day
- **Pro Tier:** Unlimited session saves

When you save a session, GalataJ captures:
- All method metrics (avg, max, calls, allocations, trends)
- JVM information (version, arguments, classpath)
- Timestamp
- Context detection data (endpoints, queries, schedules)

### Session History (Pro)

The Session History view shows all saved sessions. You can:
- Search and filter sessions by name or date
- Delete old sessions
- Set any session as the baseline reference
- Open a session to view its full metrics
- Export sessions in multiple formats

---

## Baseline Tracking & Comparison

### Setting a Baseline (Pro)

A baseline is a reference session that represents your "known good" performance state. Set a baseline:
- After a successful release
- Before starting optimization work
- At the beginning of a sprint
- After any significant performance improvement

### Comparing Sessions (Pro)

You can compare any two sessions side-by-side. The comparison view shows:
- Methods that got slower (red, ↑) — regressions
- Methods that got faster (green, ↓) — improvements
- Methods with no significant change (gray)
- New methods that appeared or disappeared between sessions

### Baseline-Live Comparison (Pro)

When a baseline is set, GalataJ continuously compares live profiling data against the baseline and writes the results to `.galataj/baseline-live-compare.md`. This file is automatically updated while profiling is active, making it ideal for AI-assisted regression detection.

---

## Export Capabilities

### Export Formats (Pro)

- **JSON:** Structured data, ideal for programmatic analysis and CI/CD integration
- **CSV:** Spreadsheet-compatible, good for sharing with non-technical stakeholders
- **HTML:** Formatted visual reports, suitable for presentations and documentation
- **Markdown:** Plain text, version-control friendly, ideal for including in PRs and documentation

### What Can Be Exported

- Individual profiling sessions
- Session comparison results (side-by-side)
- Live profiling context (via `.galataj/` files)

---

## AI Integration

GalataJ is designed to work seamlessly with AI coding assistants. It provides structured performance data that AI tools can understand and analyze.

### Context Files (Pro)

When profiling is active, GalataJ automatically generates and maintains two files in the `.galataj/` folder of your project:

**`.galataj/live-performance.md`**
- Real-time hotspot data
- Method-level performance metrics in structured markdown
- Trend analysis and anomaly indicators
- Automatically updated while profiling is active

**`.galataj/baseline-live-compare.md`**
- Side-by-side comparison of baseline vs live performance
- Regression detection with percentage changes
- Only generated when a baseline session is set

These files are plain markdown, readable by any AI tool. Reference them in your AI chat to get performance-aware code suggestions.

### Add to Chat

Every inline metric in the editor has an "Add to Chat" button. Clicking it copies the method's performance context (name, execution time, call count, trend, code location) to your clipboard in a format optimized for AI assistants. Paste it into any AI chat to get performance-specific analysis.

Compatible with: Cursor, ChatGPT, Claude, GitHub Copilot, Windsurf, and any AI tool that accepts text input.

### Built-in AI Prompts

GalataJ provides pre-built prompts for common analysis scenarios:

- **Analyze Regressions:** "Look at the performance data and identify methods with regressions. Suggest root causes and fixes."
- **Suggest Optimizations:** "Based on the profiling data, suggest specific code-level optimizations for the slowest methods."
- **Memory Analysis:** "Analyze memory allocation patterns. Identify methods causing excessive GC pressure."
- **IO vs CPU Analysis:** "Determine whether slow methods are IO-bound (waiting for database, network, file system) or CPU-bound (heavy computation)."

### Custom AI Prompts (Pro)

Save frequently used analysis prompts for quick reuse:
- N+1 query detection prompts
- Framework-specific analysis (Spring Boot, Quarkus, etc.)
- Custom performance criteria for your team

Access: Profiler Panel → Ask AI → Manage Custom Prompts

---

## Docker Support

### Overview (Pro)

GalataJ can profile Java applications running inside local Docker containers. The profiler discovers containers automatically and attaches to the JVM inside them.

### Supported Environments

- Docker Desktop on Windows and macOS
- Docker Engine on Linux
- Docker Compose projects

### Not Supported

- Remote Docker hosts (SSH, remote Docker API)
- Kubernetes clusters
- Distributed tracing across containers

### Method 1: Automatic Attach (JDK Image Required)

If your Docker container uses a JDK image (not JRE), GalataJ can attach automatically:

1. Open the GalataJ Profiler panel
2. Click Refresh — Docker containers with Java processes appear automatically
3. Select the container from the JVM list
4. Start profiling

Recommended JDK images:
- `eclipse-temurin:17-jdk`
- `amazoncorretto:17`
- `azul/zulu-openjdk:17`

### Method 2: -javaagent Approach (Any Java Image)

For JRE images or when automatic attach doesn't work, mount the GalataJ agent and configure it via environment variables.

**docker-compose.yml example:**
```yaml
services:
  myapp:
    image: my-java-app
    volumes:
      - ~/.galataj/agent/agent.jar:/opt/galataj-agent.jar:ro
    environment:
      - JAVA_TOOL_OPTIONS=-javaagent:/opt/galataj-agent.jar
      - GALATAJ_PACKAGE=com.mycompany.myapp
    extra_hosts:
      - "host.docker.internal:host-gateway"
```

**docker run example:**
```bash
docker run \
  -v ~/.galataj/agent/agent.jar:/opt/galataj-agent.jar:ro \
  -e JAVA_TOOL_OPTIONS="-javaagent:/opt/galataj-agent.jar" \
  -e GALATAJ_PACKAGE=com.mycompany.myapp \
  --add-host=host.docker.internal:host-gateway \
  your-image
```

**Dockerfile example:**
```dockerfile
COPY agent.jar /opt/galataj-agent.jar
ENV JAVA_TOOL_OPTIONS="-javaagent:/opt/galataj-agent.jar"
ENV GALATAJ_PACKAGE=com.mycompany.myapp
```

Key environment variables:
- `JAVA_TOOL_OPTIONS`: JVM agent flag
- `GALATAJ_PACKAGE`: The base package to instrument (e.g., `com.mycompany.myapp`)

The `host.docker.internal` host mapping allows the agent inside the container to communicate with the GalataJ Controller running on the host machine.

---

## IDE Integration — IntelliJ IDEA

### Supported Versions
- IntelliJ IDEA 2024.1 or later
- Both Community and Ultimate editions

### Inline Hints (CodeVision)
- Metrics appear as CodeVision hints above methods
- Toggle: Settings → Editor → Inlay Hints → Code Vision → GalataJ
- Restart IDE if hints don't appear after enabling

### Tool Window
- The GalataJ Profiler tool window shows the profiler panel, session history, and settings
- Access: View → Tool Windows → GalataJ Profiler

### Run Menu Integration
- Run → Start GalataJ Profiling
- Run → Stop GalataJ Profiling

### Settings
- Settings → Tools → GalataJ
- Configurable: inline hints on/off, auto-start controller, controller host/port, update interval

---

## IDE Integration — VS Code / Cursor / Windsurf

### Supported Versions
- VS Code 1.80 or later
- Also compatible with Cursor and Windsurf editors

### Inline Hints (CodeLens)
- Metrics appear as CodeLens hints above methods
- Toggle via VS Code settings

### Command Palette
- Ctrl+Shift+P / Cmd+Shift+P → type "GalataJ"
- Available commands: Start Profiling, Stop Profiling, Show Settings, etc.

### Settings
- Settings → search "GalataJ"
- Same configuration options as IntelliJ

---

## CLI Reference

The GalataJ CLI provides command-line access to all profiler operations.

### Installation

**macOS / Linux:**
```
curl -fsSL https://download.galataj.com/install.sh | bash
```

**Windows:**
```
powershell -c "irm https://download.galataj.com/install.ps1 | iex"
```

### Essential Commands

**`galataj doctor`**
Run this first when something doesn't work. It checks all components and reports their status.
- Output: Status of CLI, Java, Controller, Agent, Plugin version
- Auto-fix: Suggests and can apply fixes automatically

**`galataj status`**
Shows the current state of the profiler:
- Controller running/stopped
- Port configuration
- Attached JVMs and their status

**`galataj jvms`**
Lists all discoverable JVMs on the system:
- JVM name, ID, PID
- Environment (local, Docker)
- Attach status

**`galataj attach`**
Attach the profiler to a specific JVM:
- `galataj attach --pid <PID>` — attach by process ID
- `galataj attach --jvm-id <ID>` — attach by JVM ID

**`galataj detach`**
Stop profiling a JVM:
- `galataj detach --jvm-id <ID>`

### Controller Management

- `galataj controller start` — Start the background controller service
- `galataj controller start --port <PORT>` — Start with a custom port
- `galataj controller stop` — Stop the controller

### License Management

- `galataj license status` — Check current license status (Free or Pro)
- `galataj license login <KEY>` — Activate a license key
- `galataj license purchase` — Open the purchase page in browser
- `galataj license validate` — Validate current license against server

### JSON Output

Most commands support the `--json` flag for scripting and CI/CD integration:
```
galataj jvms --json
galataj status --json
galataj doctor --json
```

### Exit Codes

| Code | Meaning |
|------|---------|
| 0 | Success |
| 1 | General error |
| 2 | Controller not running |
| 3 | JVM not found |
| 4 | Attach failed |
| 5 | License error |

---

## Configuration & Settings

### IntelliJ IDEA Settings

Location: Settings → Tools → GalataJ

| Setting | Default | Description |
|---------|---------|-------------|
| Show Inline Hints | On | Display CodeVision hints above methods |
| Auto-start Controller | On | Start controller when IDE launches |
| Controller Host | localhost | Host where controller runs |
| Controller Port | 9876 | TCP port for controller communication |
| Update Interval | 1 second | How often inline metrics refresh |

### VS Code Settings

Location: Settings → search "GalataJ"

Same settings as IntelliJ IDEA, configured through the VS Code Settings UI.

### IntelliJ Inlay Hints

If inline hints are not visible in IntelliJ:
1. Go to Settings → Editor → Inlay Hints → Code Vision
2. Find "GalataJ" and enable it
3. Restart IDE if needed

---

## Health Check & Diagnostics

### Running a Health Check

In the IDE: Open GalataJ Profiler panel → Click "Health Check" or "Run Diagnostics"
In the CLI: `galataj doctor`

### Components Checked

| Component | What It Checks |
|-----------|---------------|
| CLI | GalataJ command-line tool is installed and accessible |
| Java | JDK is available on the system PATH |
| Controller | Controller component exists on disk |
| Controller Running | Controller service is actively running |
| Plugin Version | Whether an update is available |

### Status Indicators

- **OK (Green):** Component is working properly
- **Warning (Yellow):** Non-blocking note (e.g., update available)
- **Error (Red):** Needs fixing before profiling will work

### Overall Status

- **Healthy:** All components OK, ready to profile
- **Degraded:** Some warnings but profiling should work
- **Unhealthy:** Critical issues must be resolved first

### Auto-Fix

Many issues have a one-click "Fix" button that automatically:
- Downloads missing components
- Installs the CLI
- Starts the controller
- Updates to the latest version

---

## Troubleshooting

### JVM Not Showing Up

1. Click "Refresh" in the profiler panel
2. Ensure your Java application is actually running
3. Run the Health Check to verify all components are working
4. Check that the Controller is running: `galataj status`

### No Metrics Appearing

1. Check the IDE status bar — it should show "Profiling" state
2. Ensure your code files are in the profiled package scope
3. Open files from the package being profiled
4. Wait a few seconds for initial data collection
5. Trigger some requests to your application to generate activity

### Inline Hints Not Visible (IntelliJ)

1. Go to Settings → Editor → Inlay Hints → Code Vision
2. Find "GalataJ" and enable the checkbox
3. Restart the IDE

### Controller Won't Start

1. Run Health Check and click the "Fix" button
2. Check if another process is using ports 9876 or 9877
3. Restart the IDE
4. Try manual start: `galataj controller start`

### Docker Attach Failed

If you get "jdk.attach not available":
- **Solution A:** Switch your Docker image from JRE to JDK (e.g., `eclipse-temurin:17-jdk`)
- **Solution B:** Use the `-javaagent` approach instead of automatic attach

### Hard Reinstall

If nothing else works:
1. Uninstall the GalataJ extension/plugin from your IDE
2. Stop the controller: `galataj controller stop`
3. Delete the `~/.galataj` folder from your home directory
4. Reinstall the plugin from the marketplace

---

## Architecture

### System Diagram

```
┌─────────────────┐     ┌──────────────────┐     ┌─────────────────┐
│   IDE Plugin    │────▶│   Controller     │◀────│   JVM Agent     │
│ (IntelliJ/VSC) │     │ (HTTP:9877       │     │ (bytecode       │
│                 │     │  TCP:9876)       │     │  instrumentation)│
└─────────────────┘     └──────────────────┘     └─────────────────┘
                               ▲
                               │
                        ┌──────┴──────┐
                        │    CLI      │
                        │ (galataj)   │
                        └─────────────┘
```

### Data Flow

1. JVM Agent instruments method bytecode at runtime
2. Agent collects metrics (time, calls, allocations) per method
3. Agent sends metrics to Controller via TCP (port 9876)
4. Controller aggregates and stores metrics
5. IDE Plugin polls Controller via HTTP (port 9877) at configurable intervals
6. Plugin renders metrics as inline hints in the editor
7. Plugin writes `.galataj/` context files for AI integration

### File Locations

| Path | Purpose |
|------|---------|
| `~/.galataj/` | Global configuration and components |
| `~/.galataj/agent/agent.jar` | The JVM instrumentation agent |
| `.galataj/` (project root) | Project-specific AI context files |
| `.galataj/live-performance.md` | Real-time hotspot data |
| `.galataj/baseline-live-compare.md` | Baseline vs live comparison |

---

## Pricing

### Free Plan — €0 forever

Core profiling features with no time limit:
- Inline performance metrics (Avg, Max, Calls, Trend)
- Live Profiler Panel with sorting and filtering
- Context detection (HTTP endpoints, database queries, scheduled tasks, async methods)
- "Add to Chat" button for AI assistants
- Runtime attach to local JVMs
- IntelliJ IDEA and VS Code support
- Health Check and auto-fix
- Limited session saves (1 per day)

### Pro Plan — €9/month or €89/year (save 18%)

Everything in Free, plus:
- Unlimited session saves
- Session comparison (side-by-side)
- Export to JSON, CSV, HTML, Markdown
- Baseline tracking and regression detection
- Live Context File (`.galataj/live-performance.md`)
- Baseline-Live Compare File (`.galataj/baseline-live-compare.md`)
- Historical analysis across sessions
- Custom AI prompts
- Unlimited tracked methods
- Local Docker profiling support

### Founders Lifetime Plan — €179 one-time

Everything in Pro, plus:
- Lifetime updates (1+ years of future updates included)
- No recurring payments ever
- Direct developer support (contact the creator directly)
- Access to Founders community
- Priority feature requests
- Limited availability

### Team Plan — Contact for pricing

Everything in Pro, plus:
- Volume licensing for teams
- Single invoice for multiple seats
- Company-friendly billing (contract & invoice-based payment)
- Priority email support
- Custom license duration (on request)

### License Activation

1. Purchase a plan on the GalataJ website
2. Receive a license key via email (processed by Lemon Squeezy)
3. Activate in your IDE:
   - IntelliJ: Settings → GalataJ Profiler → License
   - VS Code: Command Palette → "GalataJ: Show Settings" → License
   - CLI: `galataj license login <KEY>`

### License Scope

- One license = one machine
- Re-enter license key after OS reinstall
- Not transferable to different machines simultaneously

---

## Limitations

### What GalataJ Does NOT Do

- **Not a production monitoring tool.** Use APM solutions (Datadog, New Relic, Dynatrace) for production.
- **No distributed tracing.** GalataJ profiles individual JVMs, not request flows across microservices.
- **No automatic deadlock detection.** GalataJ measures performance, not concurrency issues.
- **No SQL query content capture.** It shows which repository methods are slow, not the SQL text.
- **No production monitoring alerts.** There are no alerting or notification features.

### Unsupported Environments

- Remote server profiling (SSH-based)
- Kubernetes cluster profiling
- Remote Docker hosts
- Production environments (designed for dev/test only)

---

## FAQ

**Q: Does GalataJ work with Spring Boot?**
A: Yes. GalataJ works with any Java application, including Spring Boot, Quarkus, Micronaut, and plain Java. Context detection features are especially useful with Spring Boot (HTTP endpoints, JPA repositories, @Scheduled, @Async).

**Q: Does GalataJ work with Kotlin?**
A: Yes. Since Kotlin compiles to JVM bytecode, GalataJ can profile Kotlin methods the same way it profiles Java methods.

**Q: Does it slow down my application?**
A: GalataJ adds approximately 3% overhead, which is negligible for development and testing. It is not designed for production use.

**Q: Can I use GalataJ with my existing profiling tools?**
A: Yes. GalataJ is complementary to other tools. Use GalataJ for inline, real-time profiling during development. Use APM tools for production monitoring.

**Q: How is this different from IntelliJ's built-in profiler?**
A: GalataJ shows metrics inline in your code (CodeVision hints), updates in real-time, provides trend analysis, supports session comparison, and integrates with AI assistants. The built-in IntelliJ profiler requires you to start a separate profiling session and analyze results in a different window.

**Q: Do I need to modify my build (Maven/Gradle)?**
A: No. GalataJ requires zero build modifications. It attaches to running JVMs at runtime.

**Q: What data does GalataJ collect?**
A: GalataJ collects method execution times, call counts, and memory allocations from your local JVM. All data stays on your machine. No data is sent to external servers.

**Q: Can I profile multiple JVMs simultaneously?**
A: Yes. You can attach the profiler to multiple JVMs and switch between them in the profiler panel.

---

## Links & Contact

### Product Links

- Website: https://galataj.com
- Documentation: https://galataj.com/docs/getting-started/overview/
- Pricing: https://galataj.com/pricing/
- About: https://galataj.com/about/

### Marketplace

- JetBrains Marketplace: https://plugins.jetbrains.com/plugin/30260-galataj-profiler
- VS Code Marketplace: https://marketplace.visualstudio.com/items?itemName=GalataJ.galataj

### Social

- GitHub: https://github.com/yyusufaslan/galataj
- X (Twitter): https://x.com/yyusufaslandev
- LinkedIn: https://linkedin.com/in/yyusufaslan

### Contact

- General: hello@galataj.com
- Support: support@galataj.com

### Legal

- Privacy Policy: https://galataj.com/privacy/
- Terms of Service: https://galataj.com/terms/
- EULA: https://galataj.com/eula/

### Available Languages

GalataJ documentation is available in 11 languages:
English (default), German (de), Turkish (tr), French (fr), Spanish (es), Portuguese (pt), Russian (ru), Polish (pl), Hindi (hi), Traditional Chinese (zh-tw), Simplified Chinese (zh-cn)