fix activity reporting

Author: aktech

README.md

@@ -135,8 +135,7 @@ This eliminates the need to hardcode deployment paths in your application comman
 ### Process Management
 - `--conda-env` - Conda environment to activate before running command
 - `--workdir` - Working directory for the process
-- `--force-alive` - Force keep-alive to prevent idle culling (default: `true`)
-- `--no-force-alive` - Disable force keep-alive, report only real activity
+- `--keep-alive` - Always report activity to prevent idle culling (default: `false`)
 
 ### Git Repository
 - `--repo` - Git repository URL to clone before starting app

pkg/activity/tracker.go

@@ -0,0 +1,36 @@
+// Package activity provides activity tracking for JupyterHub activity reporting
+package activity
+
+import (
+	"sync"
+	"time"
+)
+
+// Tracker records the last activity timestamp in a thread-safe manner
+// Used to track when the proxied application was last accessed for reporting to JupyterHub
+type Tracker struct {
+	mu           sync.RWMutex
+	lastActivity *time.Time
+}
+
+// NewTracker creates a new activity tracker
+func NewTracker() *Tracker {
+	return &Tracker{}
+}
+
+// RecordActivity records the current time as the last activity timestamp
+// This should be called on every HTTP request to the proxied application
+func (t *Tracker) RecordActivity() {
+	now := time.Now().UTC()
+	t.mu.Lock()
+	t.lastActivity = &now
+	t.mu.Unlock()
+}
+
+// GetLastActivity returns the last recorded activity timestamp
+// Returns nil if no activity has been recorded yet
+func (t *Tracker) GetLastActivity() *time.Time {
+	t.mu.RLock()
+	defer t.mu.RUnlock()
+	return t.lastActivity
+}

pkg/config/config.go

@@ -18,8 +18,8 @@ type Config struct {
 	Command     []string
 	DestPort    int
 	CondaEnv    string
-	WorkDir     string
-	ForceAlive  bool
+	WorkDir    string
+	KeepAlive  bool
 	StripPrefix bool // Strip service prefix before forwarding (default: true for most apps)
 
 	// Git
@@ -86,12 +86,8 @@ Framework-agnostic - works with any web application (Streamlit, Voila, Panel, et
 		"Conda environment to activate")
 	rootCmd.Flags().StringVar(&cfg.WorkDir, "workdir", "",
 		"Working directory for the process")
-	rootCmd.Flags().BoolVar(&cfg.ForceAlive, "force-alive", true,
-		"Force keep-alive (prevent idle culling)")
-
-	// Legacy compatibility flag that sets force-alive to false
-	rootCmd.Flags().BoolVar(&cfg.ForceAlive, "no-force-alive", false,
-		"Disable force keep-alive (report only real activity)")
+	rootCmd.Flags().BoolVar(&cfg.KeepAlive, "keep-alive", false,
+		"Always report activity to prevent idle culling (default: false, report actual activity)")
 
 	// Prefix handling (default: strip prefix like jhsingle-native-proxy)
 	rootCmd.Flags().BoolVar(&cfg.StripPrefix, "strip-prefix", true,

pkg/hub/client.go

@@ -11,6 +11,7 @@ import (
 	"os"
 	"time"
 
+	"github.com/nebari-dev/jhub-app-proxy/pkg/activity"
 	"github.com/nebari-dev/jhub-app-proxy/pkg/logger"
 )
 
@@ -142,23 +143,79 @@ func (c *Client) NotifyActivity(ctx context.Context) error {
 	return nil
 }
 
+// NotifyActivityWithTime notifies JupyterHub of activity with a specific timestamp
+// This is used when keepAlive=false to report actual last activity time
+func (c *Client) NotifyActivityWithTime(ctx context.Context, timestamp time.Time) error {
+	endpoint := fmt.Sprintf("%s/users/%s/activity", c.baseURL, c.username)
+
+	payload := ActivityPayload{
+		LastActivity: timestamp,
+	}
+
+	// Include server-specific activity if server name is set
+	if c.servername != "" {
+		payload.Servers = map[string]ServerActivity{
+			c.servername: {
+				LastActivity: timestamp,
+			},
+		}
+	}
+
+	jsonData, err := json.Marshal(payload)
+	if err != nil {
+		return fmt.Errorf("failed to marshal activity payload: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewBuffer(jsonData))
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("Authorization", fmt.Sprintf("token %s", c.apiToken))
+	req.Header.Set("Content-Type", "application/json")
+
+	start := time.Now()
+	resp, err := c.httpClient.Do(req)
+	duration := time.Since(start)
+
+	if err != nil {
+		c.logger.HubAPICall("POST", endpoint, 0, duration, err)
+		return fmt.Errorf("failed to notify activity: %w", err)
+	}
+	defer resp.Body.Close()
+
+	c.logger.HubAPICall("POST", endpoint, resp.StatusCode, duration, nil)
+
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		body, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("activity notification failed with status %d: %s",
+			resp.StatusCode, string(body))
+	}
+
+	c.logger.Debug("activity notification successful", "timestamp", timestamp)
+	return nil
+}
+
 // StartActivityReporter starts a background goroutine that periodically reports activity
 // Returns a cancel function to stop the reporter
-func (c *Client) StartActivityReporter(ctx context.Context, interval time.Duration, forceAlive bool) context.CancelFunc {
+//
+// If keepAlive is true: Always report current time (prevent idle culling)
+// If keepAlive is false: Only report when there's actual activity tracked by activityTracker
+func (c *Client) StartActivityReporter(ctx context.Context, interval time.Duration, keepAlive bool, activityTracker *activity.Tracker) context.CancelFunc {
 	ctx, cancel := context.WithCancel(ctx)
 
 	go func() {
 		c.logger.Info("starting activity reporter",
 			"interval", interval,
-			"force_alive", forceAlive,
+			"keep_alive", keepAlive,
 			"username", c.username,
 			"servername", c.servername)
 
 		ticker := time.NewTicker(interval)
 		defer ticker.Stop()
 
-		// Report activity immediately on start if force_alive is enabled
-		if forceAlive {
+		// Report activity immediately on start if keepAlive is enabled
+		if keepAlive {
 			if err := c.NotifyActivity(ctx); err != nil {
 				c.logger.Error("failed to notify activity on start", err)
 			}
@@ -170,13 +227,27 @@ func (c *Client) StartActivityReporter(ctx context.Context, interval time.Durati
 				c.logger.Info("activity reporter stopped")
 				return
 			case <-ticker.C:
-				// In force_alive mode, always report activity
-				// In normal mode, only report if there was actual activity
-				// (for now, we always report - activity tracking can be added later)
-				if err := c.NotifyActivity(ctx); err != nil {
-					c.logger.Error("failed to notify activity", err,
-						"username", c.username,
-						"servername", c.servername)
+				if keepAlive {
+					// Always report current time (keep alive forever)
+					if err := c.NotifyActivity(ctx); err != nil {
+						c.logger.Error("failed to notify activity", err,
+							"username", c.username,
+							"servername", c.servername)
+					}
+				} else {
+					// Only report if there was actual activity
+					lastActivity := activityTracker.GetLastActivity()
+					if lastActivity != nil {
+						if err := c.NotifyActivityWithTime(ctx, *lastActivity); err != nil {
+							c.logger.Error("failed to notify activity", err,
+								"username", c.username,
+								"servername", c.servername,
+								"last_activity", lastActivity)
+						}
+					} else {
+						// No activity yet, don't send notification
+						c.logger.Debug("no activity to report yet")
+					}
 				}
 			}
 		}

pkg/router/router.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 	"strings"
 
+	"github.com/nebari-dev/jhub-app-proxy/pkg/activity"
 	"github.com/nebari-dev/jhub-app-proxy/pkg/interim"
 	"github.com/nebari-dev/jhub-app-proxy/pkg/logger"
 	"github.com/nebari-dev/jhub-app-proxy/pkg/process"
@@ -23,6 +24,7 @@ type Router struct {
 	appRootPath       string
 	subprocessURL     string
 	oauthCallbackPath string // Empty if OAuth disabled for jhub-app-proxy
+	activityTracker   *activity.Tracker
 }
 
 // Config contains configuration for the router
@@ -37,6 +39,7 @@ type Config struct {
 	AppRootPath       string
 	SubprocessURL     string
 	OAuthCallbackPath string // Empty if OAuth disabled for jhub-app-proxy
+	ActivityTracker   *activity.Tracker
 }
 
 // New creates a new router with the given configuration
@@ -52,6 +55,7 @@ func New(cfg Config) *Router {
 		appRootPath:       cfg.AppRootPath,
 		subprocessURL:     cfg.SubprocessURL,
 		oauthCallbackPath: cfg.OAuthCallbackPath,
+		activityTracker:   cfg.ActivityTracker,
 	}
 }
 
@@ -147,5 +151,11 @@ func (rtr *Router) handleAppRunning(w http.ResponseWriter, r *http.Request, path
 		"path", path,
 		"backend_url", rtr.subprocessURL,
 		"app_status", "running")
+
+	// Record activity for JupyterHub activity reporting
+	if rtr.activityTracker != nil {
+		rtr.activityTracker.RecordActivity()
+	}
+
 	rtr.proxyHandler.ServeHTTP(w, r)
 }

pkg/server/server.go

@@ -11,6 +11,7 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/nebari-dev/jhub-app-proxy/pkg/activity"
 	"github.com/nebari-dev/jhub-app-proxy/pkg/api"
 	"github.com/nebari-dev/jhub-app-proxy/pkg/auth"
 	"github.com/nebari-dev/jhub-app-proxy/pkg/config"
@@ -24,15 +25,16 @@ import (
 
 // Server represents the HTTP server and its components
 type Server struct {
-	httpServer     *http.Server
-	manager        *process.ManagerWithLogs
-	interimHandler *interim.Handler
-	router         *router.Router
-	logger         *logger.Logger
-	config         *config.Config
-	proxyPort      int
-	subprocessPort int
-	interimPath    string
+	httpServer      *http.Server
+	manager         *process.ManagerWithLogs
+	interimHandler  *interim.Handler
+	router          *router.Router
+	logger          *logger.Logger
+	config          *config.Config
+	proxyPort       int
+	subprocessPort  int
+	interimPath     string
+	activityTracker *activity.Tracker
 }
 
 // Config contains all dependencies needed to create a server
@@ -143,6 +145,9 @@ func New(cfg Config) (*Server, error) {
 		return nil, fmt.Errorf("failed to create proxy handler: %w", err)
 	}
 
+	// Create activity tracker for JupyterHub activity reporting
+	activityTracker := activity.NewTracker()
+
 	// Create main router
 	mainRouter := router.New(router.Config{
 		Logger:            log,
@@ -155,6 +160,7 @@ func New(cfg Config) (*Server, error) {
 		AppRootPath:       appRootPath,
 		SubprocessURL:     cfg.SubprocessURL,
 		OAuthCallbackPath: oauthCallbackPath, // Empty if OAuth disabled
+		ActivityTracker:   activityTracker,
 	})
 
 	// Create HTTP server
@@ -164,15 +170,16 @@ func New(cfg Config) (*Server, error) {
 	}
 
 	return &Server{
-		httpServer:     httpServer,
-		manager:        cfg.Manager,
-		interimHandler: interimHandler,
-		router:         mainRouter,
-		logger:         log,
-		config:         cfg.AppConfig,
-		proxyPort:      cfg.ProxyPort,
-		subprocessPort: cfg.SubprocessPort,
-		interimPath:    interimBasePath,
+		httpServer:      httpServer,
+		manager:         cfg.Manager,
+		interimHandler:  interimHandler,
+		router:          mainRouter,
+		logger:          log,
+		config:          cfg.AppConfig,
+		proxyPort:       cfg.ProxyPort,
+		subprocessPort:  cfg.SubprocessPort,
+		interimPath:     interimBasePath,
+		activityTracker: activityTracker,
 	}, nil
 }
 
@@ -216,7 +223,7 @@ func (s *Server) StartSubprocess(ctx context.Context, cmd []string) {
 	s.interimHandler.MarkAppDeployed()
 
 	if s.config.AuthType == "oauth" {
-		if err := startActivityReporter(ctx, s.config, s.logger); err != nil {
+		if err := startActivityReporter(ctx, s.config, s.logger, s.activityTracker); err != nil {
 			s.logger.Warn("failed to start activity reporter (continuing anyway)", "error", err)
 		}
 	}
@@ -270,7 +277,7 @@ func GetServicePrefix(log *logger.Logger) string {
 }
 
 // startActivityReporter starts the JupyterHub activity reporter
-func startActivityReporter(ctx context.Context, cfg *config.Config, log *logger.Logger) error {
+func startActivityReporter(ctx context.Context, cfg *config.Config, log *logger.Logger, activityTracker *activity.Tracker) error {
 	hubClient, err := hub.NewClientFromEnv(log)
 	if err != nil {
 		return fmt.Errorf("failed to create hub client: %w", err)
@@ -281,11 +288,11 @@ func startActivityReporter(ctx context.Context, cfg *config.Config, log *logger.
 	}
 
 	interval := 5 * time.Minute
-	_ = hubClient.StartActivityReporter(ctx, interval, cfg.ForceAlive)
+	_ = hubClient.StartActivityReporter(ctx, interval, cfg.KeepAlive, activityTracker)
 
 	log.Info("activity reporter started",
 		"interval", interval,
-		"force_alive", cfg.ForceAlive)
+		"keep_alive", cfg.KeepAlive)
 
 	return nil
 }