Metadata API: report actor runtime status

dapr/proto/runtime/v1/dapr.proto

@@ -595,14 +595,33 @@ message GetMetadataRequest {
 // GetMetadataResponse is a message that is returned on GetMetadata rpc call.
 message GetMetadataResponse {
   string id = 1;
-  repeated ActiveActorsCount active_actors_count = 2 [json_name = "actors"];
+  // Deprecated alias for actor_runtime.active_actors.
+  repeated ActiveActorsCount active_actors_count = 2 [json_name = "actors", deprecated = true];
   repeated RegisteredComponents registered_components = 3 [json_name = "components"];
   map<string, string> extended_metadata = 4 [json_name = "extended"];
   repeated PubsubSubscription subscriptions = 5 [json_name = "subscriptions"];
   repeated MetadataHTTPEndpoint http_endpoints = 6 [json_name = "httpEndpoints"];
   AppConnectionProperties app_connection_properties = 7 [json_name = "appConnectionProperties"];
   string runtime_version = 8 [json_name = "runtimeVersion"];
   repeated string enabled_features = 9 [json_name = "enabledFeatures"];
+  ActorRuntime actor_runtime = 10 [json_name = "actorRuntime"];
+}
+
+message ActorRuntime {
+  enum ActorRuntimeStatus {
+    INITIALIZING = 0;
+    DISABLED = 1;
+    RUNNING = 2;
+  }
+
+  // Contains an enum indicating whether the actor runtime has been initialized.
+  ActorRuntimeStatus runtime_status = 1 [json_name = "runtimeStatus"];
+  // Count of active actors per type.
+  repeated ActiveActorsCount active_actors = 2 [json_name = "activeActors"];
+  // Indicates whether the actor runtime is ready to host actors.
+  bool host_ready = 3 [json_name = "hostReady"];
+  // Custom message from the placement provider.
+  string placement = 4 [json_name = "placement"];
 }
 
 message ActiveActorsCount {

pkg/actors/actors.go

@@ -78,7 +78,7 @@ type ActorRuntime interface {
 	io.Closer
 	Init(context.Context) error
 	IsActorHosted(ctx context.Context, req *ActorHostedRequest) bool
-	GetActiveActorsCount(ctx context.Context) []*runtimev1pb.ActiveActorsCount
+	GetRuntimeStatus(ctx context.Context) *runtimev1pb.ActorRuntime
 	RegisterInternalActor(ctx context.Context, actorType string, actor InternalActor, actorIdleTimeout time.Duration) error
 }
 
@@ -972,7 +972,21 @@ func (a *actorsRuntime) RegisterInternalActor(ctx context.Context, actorType str
 	return nil
 }
 
-func (a *actorsRuntime) GetActiveActorsCount(ctx context.Context) []*runtimev1pb.ActiveActorsCount {
+func (a *actorsRuntime) GetRuntimeStatus(ctx context.Context) *runtimev1pb.ActorRuntime {
+	// Do not populate RuntimeStatus, which will be populated by the runtime
+	res := &runtimev1pb.ActorRuntime{
+		ActiveActors: a.getActiveActorsCount(ctx),
+	}
+
+	if a.placement != nil {
+		res.HostReady = a.placement.PlacementHealthy() && a.haveCompatibleStorage()
+		res.Placement = a.placement.StatusMessage()
+	}
+
+	return res
+}
+
+func (a *actorsRuntime) getActiveActorsCount(ctx context.Context) []*runtimev1pb.ActiveActorsCount {
 	actorTypes := a.actorsConfig.Config.HostedActorTypes.ListActorTypes()
 	actorCountMap := make(map[string]int32, len(actorTypes))
 	for _, actorType := range actorTypes {

pkg/actors/actors_test.go

@@ -1004,7 +1004,7 @@ func TestActiveActorsCount(t *testing.T) {
 		fakeCallAndActivateActor(testActorsRuntime, "cat", "xyz", testActorsRuntime.clock)
 		fakeCallAndActivateActor(testActorsRuntime, "dog", "xyz", testActorsRuntime.clock)
 
-		actualCounts := testActorsRuntime.GetActiveActorsCount(ctx)
+		actualCounts := testActorsRuntime.getActiveActorsCount(ctx)
 		assert.ElementsMatch(t, expectedCounts, actualCounts)
 	})
 
@@ -1015,7 +1015,7 @@ func TestActiveActorsCount(t *testing.T) {
 		testActorsRuntime.actorsConfig.Config.HostedActorTypes = internal.NewHostedActors([]string{})
 		defer testActorsRuntime.Close()
 
-		actualCounts := testActorsRuntime.GetActiveActorsCount(ctx)
+		actualCounts := testActorsRuntime.getActiveActorsCount(ctx)
 		assert.Equal(t, expectedCounts, actualCounts)
 	})
 }

pkg/actors/internal/placement_service.go

@@ -27,6 +27,11 @@ type PlacementService interface {
 	WaitUntilReady(ctx context.Context) error
 	LookupActor(ctx context.Context, req LookupActorRequest) (LookupActorResponse, error)
 	AddHostedActorType(actorType string, idleTimeout time.Duration) error
+
+	// PlacementHealthy returns true if the placement service is healthy.
+	PlacementHealthy() bool
+	// StatusMessage returns a custom status message.
+	StatusMessage() string
 }
 
 // LookupActorRequest is the request for LookupActor.

pkg/actors/internal_actor_test.go

@@ -264,6 +264,6 @@ func TestInternalActorsNotCounted(t *testing.T) {
 	internalActors[InternalActorTypePrefix+"wfengine.workflow"] = &mockInternalActor{}
 	testActorRuntime, err := newTestActorsRuntimeWithInternalActors(internalActors)
 	require.NoError(t, err)
-	actorCounts := testActorRuntime.GetActiveActorsCount(context.Background())
+	actorCounts := testActorRuntime.getActiveActorsCount(context.Background())
 	assert.Empty(t, actorCounts)
 }

pkg/actors/placement/placement.go

@@ -134,6 +134,17 @@ func NewActorPlacement(opts ActorPlacementOpts) internal.PlacementService {
 	}
 }
 
+func (p *actorPlacement) PlacementHealthy() bool {
+	return p.appHealthy.Load() && p.client.isConnected()
+}
+
+func (p *actorPlacement) StatusMessage() string {
+	if p.client.isConnected() {
+		return "placement: connected"
+	}
+	return "placement: disconnected"
+}
+
 // Register an actor type by adding it to the list of known actor types (if it's not already registered)
 // The placement tables will get updated when the next heartbeat fires
 func (p *actorPlacement) AddHostedActorType(actorType string, idleTimeout time.Duration) error {

pkg/grpc/api_test.go

@@ -4157,23 +4157,9 @@ func TestMetadata(t *testing.T) {
 	})
 
 	mockActors := new(actors.MockActors)
-	mockActors.On("GetActiveActorsCount")
-
-	appConnectionConfig := config.AppConnectionConfig{
-		ChannelAddress:      "1.2.3.4",
-		MaxConcurrency:      10,
-		Port:                5000,
-		Protocol:            "grpc",
-		HealthCheckHTTPPath: "/healthz",
-		HealthCheck: &config.AppHealthConfig{
-			ProbeInterval: 10 * time.Second,
-			ProbeTimeout:  5 * time.Second,
-			ProbeOnly:     true,
-			Threshold:     3,
-		},
-	}
+	mockActors.On("GetRuntimeStatus")
 
-	server, lis := startDaprAPIServer(&api{
+	a := &api{
 		UniversalAPI: &universalapi.UniversalAPI{
 			AppID:     "fakeAPI",
 			Actors:    mockActors,
@@ -4189,10 +4175,26 @@ func TestMetadata(t *testing.T) {
 			ExtendedMetadata: map[string]string{
 				"test": "value",
 			},
-			AppConnectionConfig: appConnectionConfig,
-			GlobalConfig:        &config.Configuration{},
+			AppConnectionConfig: config.AppConnectionConfig{
+				ChannelAddress:      "1.2.3.4",
+				MaxConcurrency:      10,
+				Port:                5000,
+				Protocol:            "grpc",
+				HealthCheckHTTPPath: "/healthz",
+				HealthCheck: &config.AppHealthConfig{
+					ProbeInterval: 10 * time.Second,
+					ProbeTimeout:  5 * time.Second,
+					ProbeOnly:     true,
+					Threshold:     3,
+				},
+			},
+			GlobalConfig: &config.Configuration{},
 		},
-	}, "")
+	}
+	a.UniversalAPI.InitUniversalAPI()
+	a.UniversalAPI.SetActorsInitDone()
+
+	server, lis := startDaprAPIServer(a, "")
 	defer server.Stop()
 
 	clientConn := createTestClient(lis)
@@ -4217,16 +4219,7 @@ func TestMetadata(t *testing.T) {
 		bytes, err := json.Marshal(res)
 		assert.NoError(t, err)
 
-		expectedResponse := `{"id":"fakeAPI",` +
-			`"active_actors_count":[{"type":"abcd","count":10},{"type":"xyz","count":5}],` +
-			`"registered_components":[{"name":"MockComponent1Name","type":"mock.component1Type","version":"v1.0","capabilities":["mock.feat.MockComponent1Name"]},` +
-			`{"name":"MockComponent2Name","type":"mock.component2Type","version":"v1.0","capabilities":["mock.feat.MockComponent2Name"]}],` +
-			`"extended_metadata":{"daprRuntimeVersion":"edge","foo":"bar","test":"value"},` +
-			`"subscriptions":[{"pubsub_name":"test","topic":"topic","rules":{"rules":[{"path":"path"}]},"dead_letter_topic":"dead"}],` +
-			`"http_endpoints":[{"name":"MockHTTPEndpoint"}],` +
-			`"app_connection_properties":{"port":5000,"protocol":"grpc","channel_address":"1.2.3.4","max_concurrency":10,` +
-			`"health":{"health_probe_interval":"10s","health_probe_timeout":"5s","health_threshold":3}},` +
-			`"runtime_version":"edge"}`
+		expectedResponse := `{"id":"fakeAPI","active_actors_count":[{"type":"abcd","count":10},{"type":"xyz","count":5}],"registered_components":[{"name":"MockComponent1Name","type":"mock.component1Type","version":"v1.0","capabilities":["mock.feat.MockComponent1Name"]},{"name":"MockComponent2Name","type":"mock.component2Type","version":"v1.0","capabilities":["mock.feat.MockComponent2Name"]}],"extended_metadata":{"daprRuntimeVersion":"edge","foo":"bar","test":"value"},"subscriptions":[{"pubsub_name":"test","topic":"topic","rules":{"rules":[{"path":"path"}]},"dead_letter_topic":"dead"}],"http_endpoints":[{"name":"MockHTTPEndpoint"}],"app_connection_properties":{"port":5000,"protocol":"grpc","channel_address":"1.2.3.4","max_concurrency":10,"health":{"health_probe_interval":"10s","health_probe_timeout":"5s","health_threshold":3}},"runtime_version":"edge","actor_runtime":{"runtime_status":2,"active_actors":[{"type":"abcd","count":10},{"type":"xyz","count":5}],"host_ready":true}}`
 		assert.Equal(t, expectedResponse, string(bytes))
 	})
 }

pkg/grpc/universalapi/api_metadata.go

@@ -38,10 +38,17 @@ func (a *UniversalAPI) GetMetadata(ctx context.Context, in *runtimev1pb.GetMetad
 	// This is deprecated, but we still need to support it for backward compatibility.
 	extendedMetadata[daprRuntimeVersionKey] = buildinfo.Version()
 
-	// Active actors count
-	activeActorsCount := []*runtimev1pb.ActiveActorsCount{}
-	if a.Actors != nil {
-		activeActorsCount = a.Actors.GetActiveActorsCount(ctx)
+	// Actor runtime
+	var actorRuntime *runtimev1pb.ActorRuntime
+	if a.actorsReady.Load() {
+		if a.Actors == nil {
+			actorRuntime = &runtimev1pb.ActorRuntime{
+				RuntimeStatus: runtimev1pb.ActorRuntime_DISABLED,
+			}
+		} else {
+			actorRuntime = a.Actors.GetRuntimeStatus(ctx)
+			actorRuntime.RuntimeStatus = runtimev1pb.ActorRuntime_RUNNING
+		}
 	}
 
 	// App connection information
@@ -104,12 +111,13 @@ func (a *UniversalAPI) GetMetadata(ctx context.Context, in *runtimev1pb.GetMetad
 		Id:                      a.AppID,
 		ExtendedMetadata:        extendedMetadata,
 		RegisteredComponents:    registeredComponents,
-		ActiveActorsCount:       activeActorsCount,
+		ActiveActorsCount:       actorRuntime.GetActiveActors(), // Alias for backwards-compatibility
 		Subscriptions:           ps,
 		HttpEndpoints:           registeredHTTPEndpoints,
 		AppConnectionProperties: appConnectionProperties,
 		RuntimeVersion:          buildinfo.Version(),
 		EnabledFeatures:         a.GlobalConfig.EnabledFeatures(),
+		ActorRuntime:            actorRuntime,
 	}, nil
 }
 

pkg/grpc/universalapi/api_metadata_test.go

@@ -36,10 +36,7 @@ func TestGetMetadata(t *testing.T) {
 	fakeComponent.Name = "testComponent"
 
 	mockActors := new(actors.MockActors)
-	mockActors.On("GetActiveActorsCount").Return(&runtimev1pb.ActiveActorsCount{
-		Count: 10,
-		Type:  "abcd",
-	})
+	mockActors.On("GetRuntimeStatus")
 
 	compStore := compstore.New()
 	compStore.AddComponent(fakeComponent)
@@ -106,6 +103,7 @@ func TestGetMetadata(t *testing.T) {
 				AppConnectionConfig: appConnectionConfig,
 				GlobalConfig:        &config.Configuration{},
 			}
+			fakeAPI.actorsReady.Store(true)
 
 			response, err := fakeAPI.GetMetadata(context.Background(), &runtimev1pb.GetMetadataRequest{})
 			require.NoError(t, err, "Expected no error")
@@ -125,7 +123,7 @@ func TestGetMetadata(t *testing.T) {
 				`"subscriptions":[{"pubsub_name":"test","topic":"topic","rules":{"rules":[{"path":"path"}]},"dead_letter_topic":"dead"}],` +
 				`"app_connection_properties":{"port":1234,"protocol":"http","channel_address":"1.2.3.4","max_concurrency":10` +
 				healthCheckJSON +
-				`"runtime_version":"edge"}`
+				`"runtime_version":"edge","actor_runtime":{"runtime_status":2,"active_actors":[{"type":"abcd","count":10},{"type":"xyz","count":5}],"host_ready":true}}`
 			assert.Equal(t, expectedResponse, string(bytes))
 		})
 	}

pkg/http/api_metadata.go

@@ -67,7 +67,7 @@ func (a *api) onGetMetadata() http.HandlerFunc {
 					ID:       out.Id,
 					Extended: out.ExtendedMetadata,
 					// We can embed the proto object directly only for as long as the protojson key is == json key
-					ActiveActorsCount:    out.ActiveActorsCount,
+					ActiveActorsCount:    out.ActiveActorsCount, //nolint:staticcheck
 					RegisteredComponents: out.RegisteredComponents,
 					HTTPEndpoints:        out.HttpEndpoints,
 					RuntimeVersion:       out.RuntimeVersion,
@@ -115,6 +115,16 @@ func (a *api) onGetMetadata() http.HandlerFunc {
 					res.Subscriptions = subs
 				}
 
+				// Actor runtime
+				// We need to include the status as string
+				actorRuntime := out.GetActorRuntime()
+				res.ActorRuntime = metadataActorRuntime{
+					Status:       actorRuntime.GetRuntimeStatus().String(),
+					ActiveActors: actorRuntime.GetActiveActors(),
+					HostReady:    actorRuntime.GetHostReady(),
+					Placement:    actorRuntime.GetPlacement(),
+				}
+
 				return res, nil
 			},
 		},
@@ -155,6 +165,14 @@ type metadataResponse struct {
 	Subscriptions           []metadataResponsePubsubSubscription    `json:"subscriptions,omitempty"`
 	HTTPEndpoints           []*runtimev1pb.MetadataHTTPEndpoint     `json:"httpEndpoints,omitempty"`
 	AppConnectionProperties metadataResponseAppConnectionProperties `json:"appConnectionProperties,omitempty"`
+	ActorRuntime            metadataActorRuntime                    `json:"actorRuntime,omitempty"`
+}
+
+type metadataActorRuntime struct {
+	Status       string                           `json:"runtimeStatus"`
+	ActiveActors []*runtimev1pb.ActiveActorsCount `json:"activeActors,omitempty"`
+	HostReady    bool                             `json:"hostReady"`
+	Placement    string                           `json:"placement,omitempty"`
 }
 
 type metadataResponsePubsubSubscription struct {

pkg/http/api_test.go

@@ -1805,7 +1805,7 @@ func TestV1MetadataEndpoint(t *testing.T) {
 	})
 
 	mockActors := new(actors.MockActors)
-	mockActors.On("GetActiveActorsCount")
+	mockActors.On("GetRuntimeStatus")
 
 	appConnectionConfig := config.AppConnectionConfig{
 		ChannelAddress:      "1.2.3.4",
@@ -1849,15 +1849,7 @@ func TestV1MetadataEndpoint(t *testing.T) {
 		assert.Equal(t, 204, resp.StatusCode)
 	})
 
-	const expectedBody = `{"id":"xyz","runtimeVersion":"edge",` +
-		`"actors":[{"type":"abcd","count":10},{"type":"xyz","count":5}],` +
-		`"components":[{"name":"MockComponent1Name","type":"mock.component1Type","version":"v1.0","capabilities":["mock.feat.MockComponent1Name"]},` +
-		`{"name":"MockComponent2Name","type":"mock.component2Type","version":"v1.0","capabilities":["mock.feat.MockComponent2Name"]}],` +
-		`"extended":{"daprRuntimeVersion":"edge","foo":"bar","test":"value"},` +
-		`"subscriptions":[{"pubsubname":"test","topic":"topic","rules":[{"path":"path"}],"deadLetterTopic":"dead"}],` +
-		`"httpEndpoints":[{"name":"MockHTTPEndpoint"}],` +
-		`"appConnectionProperties":{"port":5000,"protocol":"http","channelAddress":"1.2.3.4","maxConcurrency":10,` +
-		`"health":{"healthCheckPath":"/healthz","healthProbeInterval":"10s","healthProbeTimeout":"5s","healthThreshold":3}}}`
+	const expectedBody = `{"id":"xyz","runtimeVersion":"edge","actors":[{"type":"abcd","count":10},{"type":"xyz","count":5}],"components":[{"name":"MockComponent1Name","type":"mock.component1Type","version":"v1.0","capabilities":["mock.feat.MockComponent1Name"]},{"name":"MockComponent2Name","type":"mock.component2Type","version":"v1.0","capabilities":["mock.feat.MockComponent2Name"]}],"extended":{"daprRuntimeVersion":"edge","foo":"bar","test":"value"},"subscriptions":[{"pubsubname":"test","topic":"topic","rules":[{"path":"path"}],"deadLetterTopic":"dead"}],"httpEndpoints":[{"name":"MockHTTPEndpoint"}],"appConnectionProperties":{"port":5000,"protocol":"http","channelAddress":"1.2.3.4","maxConcurrency":10,"health":{"healthCheckPath":"/healthz","healthProbeInterval":"10s","healthProbeTimeout":"5s","healthThreshold":3}},"actorRuntime":{"runtimeStatus":"RUNNING","activeActors":[{"type":"abcd","count":10},{"type":"xyz","count":5}],"hostReady":true}}`
 
 	t.Run("Get Metadata", func(t *testing.T) {
 		resp := fakeServer.DoRequest("GET", "v1.0/metadata", nil, nil)
@@ -1872,7 +1864,7 @@ func TestV1MetadataEndpoint(t *testing.T) {
 
 		assert.Equal(t, 200, resp.StatusCode)
 		assert.Equal(t, expectedBody, string(resp.RawBody))
-		mockActors.AssertNumberOfCalls(t, "GetActiveActorsCount", 1)
+		mockActors.AssertNumberOfCalls(t, "GetRuntimeStatus", 1)
 	})
 
 	fakeServer.Shutdown()