feat: add Uptime methods to PID and ActorSystem

actors/actor_system.go

@@ -147,6 +147,8 @@ type ActorSystem interface {
 	// Port returns the actor system node port.
 	// This is the bind port for remote communication
 	Port() int32
+	// Uptime returns the number of seconds since the actor system started
+	Uptime() int64
 	// handleRemoteAsk handles a synchronous message to another actor and expect a response.
 	// This block until a response is received or timed out.
 	handleRemoteAsk(ctx context.Context, to *PID, message proto.Message, timeout time.Duration) (response proto.Message, err error)
@@ -250,6 +252,7 @@ type actorSystem struct {
 	userGuardian   *PID
 	systemGuardian *PID
 	janitor        *PID
+	startedAt      *atomic.Int64
 }
 
 // enforce compilation error when all methods of the ActorSystem interface are not implemented
@@ -287,6 +290,7 @@ func NewActorSystem(name string, opts ...Option) (ActorSystem, error) {
 		port:                   0,
 		host:                   "127.0.0.1",
 		actors:                 newTree(),
+		startedAt:              atomic.NewInt64(0),
 	}
 
 	system.started.Store(false)
@@ -320,6 +324,14 @@ func NewActorSystem(name string, opts ...Option) (ActorSystem, error) {
 	return system, nil
 }
 
+// Uptime returns the number of seconds since the actor system started
+func (x *actorSystem) Uptime() int64 {
+	if x.started.Load() {
+		return time.Now().Unix() - x.startedAt.Load()
+	}
+	return 0
+}
+
 // Host returns the actor system node host address
 // This is the bind address for remote communication
 func (x *actorSystem) Host() string {
@@ -728,7 +740,7 @@ func (x *actorSystem) Start(ctx context.Context) error {
 	}
 
 	x.scheduler.Start(ctx)
-
+	x.startedAt.Store(time.Now().Unix())
 	x.logger.Infof("%s started..:)", x.name)
 	return nil
 }

actors/actor_system_test.go

@@ -79,6 +79,7 @@ func TestActorSystem(t *testing.T) {
 		assert.Error(t, err)
 		assert.EqualError(t, err, ErrActorSystemNotStarted.Error())
 		assert.Nil(t, actorRef)
+		assert.Zero(t, sys.Uptime())
 	})
 	t.Run("With Spawn an actor when started", func(t *testing.T) {
 		ctx := context.TODO()
@@ -95,6 +96,8 @@ func TestActorSystem(t *testing.T) {
 		assert.NoError(t, err)
 		assert.NotNil(t, actorRef)
 
+		assert.NotZero(t, sys.Uptime())
+
 		// stop the actor after some time
 		lib.Pause(time.Second)
 		err = sys.Stop(ctx)

actors/pid.go

@@ -143,6 +143,7 @@ type PID struct {
 	remoting *Remoting
 
 	goScheduler *goScheduler
+	startedAt   *atomic.Int64
 }
 
 // newPID creates a new pid
@@ -177,6 +178,7 @@ func newPID(ctx context.Context, address *address.Address, actor Actor, opts ...
 		remoting:              NewRemoting(),
 		goScheduler:           newGoScheduler(300),
 		supervisorStrategies:  newStrategiesMap(),
+		startedAt:             atomic.NewInt64(0),
 	}
 
 	pid.initMaxRetries.Store(DefaultInitMaxRetries)
@@ -214,9 +216,18 @@ func newPID(ctx context.Context, address *address.Address, actor Actor, opts ...
 	receiveContext.build(ctx, NoSender, pid, new(goaktpb.PostStart), true)
 	pid.doReceive(receiveContext)
 
+	pid.startedAt.Store(time.Now().Unix())
 	return pid, nil
 }
 
+// Uptime returns the number of seconds since the actor started
+func (pid *PID) Uptime() int64 {
+	if pid.IsRunning() {
+		return time.Now().Unix() - pid.startedAt.Load()
+	}
+	return 0
+}
+
 // ID is a convenient method that returns the actor unique identifier
 // An actor unique identifier is its address in the actor system.
 func (pid *PID) ID() string {
@@ -1268,6 +1279,8 @@ func (pid *PID) reset() {
 	pid.initTimeout.Store(DefaultInitTimeout)
 	pid.behaviorStack.Reset()
 	pid.processedCount.Store(0)
+	pid.restartCount.Store(0)
+	pid.startedAt.Store(0)
 	pid.stopping.Store(false)
 	pid.suspended.Store(false)
 	pid.supervisorStrategies.Reset()

actors/pid_test.go

@@ -283,11 +283,16 @@ func TestRestart(t *testing.T) {
 		require.NoError(t, err)
 		assert.NotNil(t, pid)
 
+		lib.Pause(time.Second)
+
+		assert.NotZero(t, pid.Uptime())
+
 		// stop the actor
 		err = pid.Shutdown(ctx)
 		assert.NoError(t, err)
 
 		lib.Pause(time.Second)
+		assert.Zero(t, pid.Uptime())
 
 		// let us send a message to the actor
 		err = Tell(ctx, pid, new(testpb.TestSend))
@@ -298,6 +303,7 @@ func TestRestart(t *testing.T) {
 		err = pid.Restart(ctx)
 		assert.NoError(t, err)
 		assert.True(t, pid.IsRunning())
+		assert.NotZero(t, pid.Uptime())
 		// let us send 10 public to the actor
 		count := 10
 		for i := 0; i < count; i++ {