Add actions job log buffer and profiler

cmd/github-mcp-server/generate_docs.go

@@ -64,7 +64,7 @@ func generateReadmeDocs(readmePath string) error {
 	t, _ := translations.TranslationHelper()
 
 	// Create toolset group with mock clients
-	tsg := github.DefaultToolsetGroup(false, mockGetClient, mockGetGQLClient, mockGetRawClient, t)
+	tsg := github.DefaultToolsetGroup(false, mockGetClient, mockGetGQLClient, mockGetRawClient, t, 5000)
 
 	// Generate toolsets documentation
 	toolsetsDoc := generateToolsetsDoc(tsg)
@@ -302,7 +302,7 @@ func generateRemoteToolsetsDoc() string {
 	t, _ := translations.TranslationHelper()
 
 	// Create toolset group with mock clients
-	tsg := github.DefaultToolsetGroup(false, mockGetClient, mockGetGQLClient, mockGetRawClient, t)
+	tsg := github.DefaultToolsetGroup(false, mockGetClient, mockGetGQLClient, mockGetRawClient, t, 5000)
 
 	// Generate table header
 	buf.WriteString("| Name | Description | API URL | 1-Click Install (VS Code) | Read-only Link | 1-Click Read-only Install (VS Code) |\n")

cmd/github-mcp-server/main.go

@@ -55,6 +55,7 @@ var (
  ExportTranslations: viper.GetBool("export-translations"),
  EnableCommandLogging: viper.GetBool("enable-command-logging"),
  LogFilePath: viper.GetString("log-file"),
+ ContentWindowSize: viper.GetInt("content-window-size"),
  }
  return ghmcp.RunStdioServer(stdioServerConfig)
  },
@@ -75,6 +76,7 @@ func init() {
 	rootCmd.PersistentFlags().Bool("enable-command-logging", false, "When enabled, the server will log all command requests and responses to the log file")
 	rootCmd.PersistentFlags().Bool("export-translations", false, "Save translations to a JSON file")
 	rootCmd.PersistentFlags().String("gh-host", "", "Specify the GitHub hostname (for GitHub Enterprise etc.)")
+	rootCmd.PersistentFlags().Int("content-window-size", 5000, "Specify the content window size")
 
 	// Bind flag to viper
 	_ = viper.BindPFlag("toolsets", rootCmd.PersistentFlags().Lookup("toolsets"))
@@ -84,6 +86,7 @@ func init() {
 	_ = viper.BindPFlag("enable-command-logging", rootCmd.PersistentFlags().Lookup("enable-command-logging"))
 	_ = viper.BindPFlag("export-translations", rootCmd.PersistentFlags().Lookup("export-translations"))
 	_ = viper.BindPFlag("host", rootCmd.PersistentFlags().Lookup("gh-host"))
+	_ = viper.BindPFlag("content-window-size", rootCmd.PersistentFlags().Lookup("content-window-size"))
 
 	// Add subcommands
 	rootCmd.AddCommand(stdioCmd)

internal/ghmcp/server.go

@@ -47,6 +47,9 @@ type MCPServerConfig struct {
 
 	// Translator provides translated text for the server tooling
 	Translator translations.TranslationHelperFunc
+
+	// Content window size
+	ContentWindowSize int
 }
 
 const stdioServerLogPrefix = "stdioserver"
@@ -132,7 +135,7 @@ func NewMCPServer(cfg MCPServerConfig) (*server.MCPServer, error) {
 	}
 
 	// Create default toolsets
-	tsg := github.DefaultToolsetGroup(cfg.ReadOnly, getClient, getGQLClient, getRawClient, cfg.Translator)
+	tsg := github.DefaultToolsetGroup(cfg.ReadOnly, getClient, getGQLClient, getRawClient, cfg.Translator, cfg.ContentWindowSize)
 	err = tsg.EnableToolsets(enabledToolsets)
 
 	if err != nil {
@@ -180,6 +183,9 @@ type StdioServerConfig struct {
 
 	// Path to the log file if not stderr
 	LogFilePath string
+
+	// Content window size
+	ContentWindowSize int
 }
 
 // RunStdioServer is not concurrent safe.
@@ -191,13 +197,14 @@ func RunStdioServer(cfg StdioServerConfig) error {
 	t, dumpTranslations := translations.TranslationHelper()
 
 	ghServer, err := NewMCPServer(MCPServerConfig{
- Version: cfg.Version,
- Host: cfg.Host,
- Token: cfg.Token,
- EnabledToolsets: cfg.EnabledToolsets,
- DynamicToolsets: cfg.DynamicToolsets,
- ReadOnly: cfg.ReadOnly,
- Translator: t,
+ Version: cfg.Version,
+ Host: cfg.Host,
+ Token: cfg.Token,
+ EnabledToolsets: cfg.EnabledToolsets,
+ DynamicToolsets: cfg.DynamicToolsets,
+ ReadOnly: cfg.ReadOnly,
+ Translator: t,
+ ContentWindowSize: cfg.ContentWindowSize,
 	})
 	if err != nil {
  return fmt.Errorf("failed to create MCP server: %w", err)

internal/profiler/profiler.go

@@ -0,0 +1,215 @@
+package profiler
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"runtime"
+	"strconv"
+	"time"
+
+	"log/slog"
+	"math"
+)
+
+// Profile represents performance metrics for an operation
+type Profile struct {
+	Operation string `json:"operation"`
+	Duration time.Duration `json:"duration_ns"`
+	MemoryBefore uint64 `json:"memory_before_bytes"`
+	MemoryAfter uint64 `json:"memory_after_bytes"`
+	MemoryDelta int64 `json:"memory_delta_bytes"`
+	LinesCount int `json:"lines_count,omitempty"`
+	BytesCount int64 `json:"bytes_count,omitempty"`
+	Timestamp time.Time `json:"timestamp"`
+}
+
+// String returns a human-readable representation of the profile
+func (p *Profile) String() string {
+	return fmt.Sprintf("[%s] %s: duration=%v, memory_delta=%+dB, lines=%d, bytes=%d",
+ p.Timestamp.Format("15:04:05.000"),
+ p.Operation,
+ p.Duration,
+ p.MemoryDelta,
+ p.LinesCount,
+ p.BytesCount,
+	)
+}
+
+func safeMemoryDelta(after, before uint64) int64 {
+	if after > math.MaxInt64 || before > math.MaxInt64 {
+ if after >= before {
+ diff := after - before
+ if diff > math.MaxInt64 {
+ return math.MaxInt64
+ }
+ return int64(diff)
+ }
+ diff := before - after
+ if diff > math.MaxInt64 {
+ return -math.MaxInt64
+ }
+ return -int64(diff)
+	}
+
+	return int64(after) - int64(before)
+}
+
+// Profiler provides minimal performance profiling capabilities
+type Profiler struct {
+	logger *slog.Logger
+	enabled bool
+}
+
+// New creates a new Profiler instance
+func New(logger *slog.Logger, enabled bool) *Profiler {
+	return &Profiler{
+ logger: logger,
+ enabled: enabled,
+	}
+}
+
+// ProfileFunc profiles a function execution
+func (p *Profiler) ProfileFunc(ctx context.Context, operation string, fn func() error) (*Profile, error) {
+	if !p.enabled {
+ return nil, fn()
+	}
+
+	profile := &Profile{
+ Operation: operation,
+ Timestamp: time.Now(),
+	}
+
+	var memBefore runtime.MemStats
+	runtime.ReadMemStats(&memBefore)
+	profile.MemoryBefore = memBefore.Alloc
+
+	start := time.Now()
+	err := fn()
+	profile.Duration = time.Since(start)
+
+	var memAfter runtime.MemStats
+	runtime.ReadMemStats(&memAfter)
+	profile.MemoryAfter = memAfter.Alloc
+	profile.MemoryDelta = safeMemoryDelta(memAfter.Alloc, memBefore.Alloc)
+
+	if p.logger != nil {
+ p.logger.InfoContext(ctx, "Performance profile", "profile", profile.String())
+	}
+
+	return profile, err
+}
+
+// ProfileFuncWithMetrics profiles a function execution and captures additional metrics
+func (p *Profiler) ProfileFuncWithMetrics(ctx context.Context, operation string, fn func() (int, int64, error)) (*Profile, error) {
+	if !p.enabled {
+ _, _, err := fn()
+ return nil, err
+	}
+
+	profile := &Profile{
+ Operation: operation,
+ Timestamp: time.Now(),
+	}
+
+	var memBefore runtime.MemStats
+	runtime.ReadMemStats(&memBefore)
+	profile.MemoryBefore = memBefore.Alloc
+
+	start := time.Now()
+	lines, bytes, err := fn()
+	profile.Duration = time.Since(start)
+	profile.LinesCount = lines
+	profile.BytesCount = bytes
+
+	var memAfter runtime.MemStats
+	runtime.ReadMemStats(&memAfter)
+	profile.MemoryAfter = memAfter.Alloc
+	profile.MemoryDelta = safeMemoryDelta(memAfter.Alloc, memBefore.Alloc)
+
+	if p.logger != nil {
+ p.logger.InfoContext(ctx, "Performance profile", "profile", profile.String())
+	}
+
+	return profile, err
+}
+
+// Start begins timing an operation and returns a function to complete the profiling
+func (p *Profiler) Start(ctx context.Context, operation string) func(lines int, bytes int64) *Profile {
+	if !p.enabled {
+ return func(int, int64) *Profile { return nil }
+	}
+
+	profile := &Profile{
+ Operation: operation,
+ Timestamp: time.Now(),
+	}
+
+	var memBefore runtime.MemStats
+	runtime.ReadMemStats(&memBefore)
+	profile.MemoryBefore = memBefore.Alloc
+
+	start := time.Now()
+
+	return func(lines int, bytes int64) *Profile {
+ profile.Duration = time.Since(start)
+ profile.LinesCount = lines
+ profile.BytesCount = bytes
+
+ var memAfter runtime.MemStats
+ runtime.ReadMemStats(&memAfter)
+ profile.MemoryAfter = memAfter.Alloc
+ profile.MemoryDelta = safeMemoryDelta(memAfter.Alloc, memBefore.Alloc)
+
+ if p.logger != nil {
+ p.logger.InfoContext(ctx, "Performance profile", "profile", profile.String())
+ }
+
+ return profile
+	}
+}
+
+var globalProfiler *Profiler
+
+// IsProfilingEnabled checks if profiling is enabled via environment variables
+func IsProfilingEnabled() bool {
+	if enabled, err := strconv.ParseBool(os.Getenv("GITHUB_MCP_PROFILING_ENABLED")); err == nil {
+ return enabled
+	}
+	return false
+}
+
+// Init initializes the global profiler
+func Init(logger *slog.Logger, enabled bool) {
+	globalProfiler = New(logger, enabled)
+}
+
+// InitFromEnv initializes the global profiler using environment variables
+func InitFromEnv(logger *slog.Logger) {
+	globalProfiler = New(logger, IsProfilingEnabled())
+}
+
+// ProfileFunc profiles a function using the global profiler
+func ProfileFunc(ctx context.Context, operation string, fn func() error) (*Profile, error) {
+	if globalProfiler == nil {
+ return nil, fn()
+	}
+	return globalProfiler.ProfileFunc(ctx, operation, fn)
+}
+
+// ProfileFuncWithMetrics profiles a function with metrics using the global profiler
+func ProfileFuncWithMetrics(ctx context.Context, operation string, fn func() (int, int64, error)) (*Profile, error) {
+	if globalProfiler == nil {
+ _, _, err := fn()
+ return nil, err
+	}
+	return globalProfiler.ProfileFuncWithMetrics(ctx, operation, fn)
+}
+
+// Start begins timing using the global profiler
+func Start(ctx context.Context, operation string) func(int, int64) *Profile {
+	if globalProfiler == nil {
+ return func(int, int64) *Profile { return nil }
+	}
+	return globalProfiler.Start(ctx, operation)
+}

pkg/buffer/buffer.go

@@ -0,0 +1,69 @@
+package buffer
+
+import (
+	"bufio"
+	"fmt"
+	"net/http"
+	"strings"
+)
+
+// ProcessResponseAsRingBufferToEnd reads the body of an HTTP response line by line,
+// storing only the last maxJobLogLines lines using a ring buffer (sliding window).
+// This efficiently retains the most recent lines, overwriting older ones as needed.
+//
+// Parameters:
+//
+//	httpResp: The HTTP response whose body will be read.
+//	maxJobLogLines: The maximum number of log lines to retain.
+//
+// Returns:
+//
+//	string: The concatenated log lines (up to maxJobLogLines), separated by newlines.
+//	int: The total number of lines read from the response.
+//	*http.Response: The original HTTP response.
+//	error: Any error encountered during reading.
+//
+// The function uses a ring buffer to efficiently store only the last maxJobLogLines lines.
+// If the response contains more lines than maxJobLogLines, only the most recent lines are kept.
+func ProcessResponseAsRingBufferToEnd(httpResp *http.Response, maxJobLogLines int) (string, int, *http.Response, error) {
+	lines := make([]string, maxJobLogLines)
+	validLines := make([]bool, maxJobLogLines)
+	totalLines := 0
+	writeIndex := 0
+
+	scanner := bufio.NewScanner(httpResp.Body)
+	scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024)
+
+	for scanner.Scan() {
+ line := scanner.Text()
+ totalLines++
+
+ lines[writeIndex] = line
+ validLines[writeIndex] = true
+ writeIndex = (writeIndex + 1) % maxJobLogLines
+	}
+
+	if err := scanner.Err(); err != nil {
+ return "", 0, httpResp, fmt.Errorf("failed to read log content: %w", err)
+	}
+
+	var result []string
+	linesInBuffer := totalLines
+	if linesInBuffer > maxJobLogLines {
+ linesInBuffer = maxJobLogLines
+	}
+
+	startIndex := 0
+	if totalLines > maxJobLogLines {
+ startIndex = writeIndex
+	}
+
+	for i := 0; i < linesInBuffer; i++ {
+ idx := (startIndex + i) % maxJobLogLines
+ if validLines[idx] {
+ result = append(result, lines[idx])
+ }
+	}
+
+	return strings.Join(result, "\n"), totalLines, httpResp, nil
+}