diff --git a/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/fetcher/LabelFetcher.java b/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/fetcher/LabelFetcher.java
index 604fbb18..3381db12 100644
--- a/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/fetcher/LabelFetcher.java
+++ b/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/fetcher/LabelFetcher.java
@@ -5,8 +5,7 @@
 import java.util.concurrent.CompletableFuture;
 import javax.inject.Inject;
 import org.hypertrace.core.graphql.common.fetcher.InjectableDataFetcher;
-import org.hypertrace.core.graphql.common.request.ContextualRequestBuilder;
-import org.hypertrace.graphql.label.dao.LabelDao;
+import org.hypertrace.graphql.label.joiner.EntityAndRuleJoinerBuilder;
 import org.hypertrace.graphql.label.schema.LabelResultSet;
 
 public class LabelFetcher extends InjectableDataFetcher<LabelResultSet> {
@@ -16,19 +15,18 @@ public LabelFetcher() {
   }
 
   static final class LabelFetcherImpl implements DataFetcher<CompletableFuture<LabelResultSet>> {
-    private final ContextualRequestBuilder requestBuilder;
-    private final LabelDao labelDao;
+    private final EntityAndRuleJoinerBuilder requestBuilder;
 
     @Inject
-    LabelFetcherImpl(ContextualRequestBuilder requestBuilder, LabelDao labelDao) {
+    LabelFetcherImpl(EntityAndRuleJoinerBuilder requestBuilder) {
       this.requestBuilder = requestBuilder;
-      this.labelDao = labelDao;
     }
 
     @Override
     public CompletableFuture<LabelResultSet> get(DataFetchingEnvironment environment) {
-      return this.labelDao
-          .getLabels(this.requestBuilder.build(environment.getContext()))
+      return this.requestBuilder
+          .build(environment.getContext(), environment.getSelectionSet())
+          .flatMap(request -> request.joinLabelsWithEntitiesAndRules())
           .toCompletionStage()
           .toCompletableFuture();
     }
diff --git a/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/joiner/EntityAndRuleJoiner.java b/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/joiner/EntityAndRuleJoiner.java
new file mode 100644
index 00000000..03e2be2c
--- /dev/null
+++ b/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/joiner/EntityAndRuleJoiner.java
@@ -0,0 +1,15 @@
+package org.hypertrace.graphql.label.joiner;
+
+import io.reactivex.rxjava3.core.Single;
+import org.hypertrace.graphql.label.schema.LabelResultSet;
+
+public interface EntityAndRuleJoiner {
+
+  /**
+   * Produces label result set after joining labels with associated entities and label application
+   * rules
+   *
+   * @return label result set
+   */
+  Single<LabelResultSet> joinLabelsWithEntitiesAndRules();
+}
diff --git a/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/joiner/EntityAndRuleJoinerBuilder.java b/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/joiner/EntityAndRuleJoinerBuilder.java
new file mode 100644
index 00000000..8a3fc42d
--- /dev/null
+++ b/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/joiner/EntityAndRuleJoinerBuilder.java
@@ -0,0 +1,10 @@
+package org.hypertrace.graphql.label.joiner;
+
+import graphql.schema.DataFetchingFieldSelectionSet;
+import io.reactivex.rxjava3.core.Single;
+import org.hypertrace.core.graphql.context.GraphQlRequestContext;
+
+public interface EntityAndRuleJoinerBuilder {
+  Single<EntityAndRuleJoiner> build(
+      GraphQlRequestContext context, DataFetchingFieldSelectionSet selectionSet);
+}
diff --git a/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/joiner/LabelApplicationRulesRequest.java b/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/joiner/LabelApplicationRulesRequest.java
new file mode 100644
index 00000000..77989f94
--- /dev/null
+++ b/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/joiner/LabelApplicationRulesRequest.java
@@ -0,0 +1,5 @@
+package org.hypertrace.graphql.label.joiner;
+
+public interface LabelApplicationRulesRequest {
+  int limit();
+}
diff --git a/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/joiner/LabeledEntitiesRequest.java b/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/joiner/LabeledEntitiesRequest.java
new file mode 100644
index 00000000..9f3fd0eb
--- /dev/null
+++ b/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/joiner/LabeledEntitiesRequest.java
@@ -0,0 +1,11 @@
+package org.hypertrace.graphql.label.joiner;
+
+import graphql.schema.DataFetchingFieldSelectionSet;
+
+public interface LabeledEntitiesRequest {
+  String entityType();
+
+  int limit();
+
+  DataFetchingFieldSelectionSet selectionSet();
+}
diff --git a/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/schema/Label.java b/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/schema/Label.java
index 059333e2..da6996f3 100644
--- a/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/schema/Label.java
+++ b/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/schema/Label.java
@@ -1,10 +1,30 @@
 package org.hypertrace.graphql.label.schema;
 
+import graphql.annotations.annotationTypes.GraphQLField;
 import graphql.annotations.annotationTypes.GraphQLName;
+import graphql.annotations.annotationTypes.GraphQLNonNull;
 import org.hypertrace.core.graphql.common.schema.id.Identifiable;
+import org.hypertrace.core.graphql.common.schema.results.arguments.page.LimitArgument;
+import org.hypertrace.graphql.label.schema.rule.LabelApplicationRuleResultSet;
 
 @GraphQLName(Label.TYPE_NAME)
-public interface Label extends Identifiable, LabelData, LabeledEntities {
+public interface Label extends Identifiable, LabelData {
   String TYPE_NAME = "Label";
   String ARGUMENT_NAME = "label";
+  String LABELED_ENTITIES_QUERY_NAME = "labeledEntities";
+  String ENTITY_TYPE_ARGUMENT_NAME = "type";
+  String LABEL_APPLICATION_RULES_QUERY_NAME = "labelApplicationRules";
+
+  @GraphQLField
+  @GraphQLNonNull
+  @GraphQLName(LABELED_ENTITIES_QUERY_NAME)
+  LabeledEntityResultSet labeledEntities(
+      @GraphQLNonNull @GraphQLName(ENTITY_TYPE_ARGUMENT_NAME) String entityType,
+      @GraphQLName(LimitArgument.ARGUMENT_NAME) int limit);
+
+  @GraphQLField
+  @GraphQLNonNull
+  @GraphQLName(LABEL_APPLICATION_RULES_QUERY_NAME)
+  LabelApplicationRuleResultSet labelApplicationRules(
+      @GraphQLName(LimitArgument.ARGUMENT_NAME) int limit);
 }
diff --git a/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/schema/LabeledEntities.java b/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/schema/LabeledEntities.java
deleted file mode 100644
index 8d3e78c3..00000000
--- a/hypertrace-graphql-labels-schema-api/src/main/java/org/hypertrace/graphql/label/schema/LabeledEntities.java
+++ /dev/null
@@ -1,20 +0,0 @@
-package org.hypertrace.graphql.label.schema;
-
-import graphql.annotations.annotationTypes.GraphQLField;
-import graphql.annotations.annotationTypes.GraphQLName;
-import graphql.annotations.annotationTypes.GraphQLNonNull;
-import org.hypertrace.core.graphql.common.schema.results.arguments.page.LimitArgument;
-
-@GraphQLName(LabeledEntities.TYPE_NAME)
-public interface LabeledEntities {
-  String TYPE_NAME = "LabeledEntities";
-  String LABELED_ENTITIES_QUERY_NAME = "labeledEntities";
-  String ENTITY_TYPE_ARGUMENT_NAME = "type";
-
-  @GraphQLField
-  @GraphQLNonNull
-  @GraphQLName(LABELED_ENTITIES_QUERY_NAME)
-  LabeledEntityResultSet labeledEntities(
-      @GraphQLNonNull @GraphQLName(ENTITY_TYPE_ARGUMENT_NAME) String entityType,
-      @GraphQLName(LimitArgument.ARGUMENT_NAME) int limit);
-}
diff --git a/hypertrace-graphql-labels-schema-impl/build.gradle.kts b/hypertrace-graphql-labels-schema-impl/build.gradle.kts
index 50a46c62..48b48c7c 100644
--- a/hypertrace-graphql-labels-schema-impl/build.gradle.kts
+++ b/hypertrace-graphql-labels-schema-impl/build.gradle.kts
@@ -28,6 +28,8 @@ dependencies {
   implementation("org.hypertrace.core.graphql:hypertrace-core-graphql-rx-utils")
   implementation("org.hypertrace.core.graphql:hypertrace-core-graphql-deserialization")
 
+  implementation(project(":hypertrace-graphql-entity-schema"))
+
   implementation(project(":hypertrace-graphql-service-config"))
 }
 
diff --git a/hypertrace-graphql-labels-schema-impl/src/main/java/org/hypertrace/graphql/label/dao/LabelResponseConverter.java b/hypertrace-graphql-labels-schema-impl/src/main/java/org/hypertrace/graphql/label/dao/LabelResponseConverter.java
index 703ead87..e0322fae 100644
--- a/hypertrace-graphql-labels-schema-impl/src/main/java/org/hypertrace/graphql/label/dao/LabelResponseConverter.java
+++ b/hypertrace-graphql-labels-schema-impl/src/main/java/org/hypertrace/graphql/label/dao/LabelResponseConverter.java
@@ -4,14 +4,17 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.stream.Collectors;
 import lombok.Value;
 import lombok.experimental.Accessors;
+import org.hypertrace.core.graphql.common.utils.CollectorUtils;
+import org.hypertrace.graphql.entity.schema.Entity;
+import org.hypertrace.graphql.entity.schema.EntityResultSet;
 import org.hypertrace.graphql.label.schema.Label;
 import org.hypertrace.graphql.label.schema.LabelResultSet;
 import org.hypertrace.graphql.label.schema.LabeledEntity;
 import org.hypertrace.graphql.label.schema.LabeledEntityResultSet;
+import org.hypertrace.graphql.label.schema.rule.LabelApplicationRuleResultSet;
 import org.hypertrace.label.config.service.v1.CreateLabelResponse;
 import org.hypertrace.label.config.service.v1.GetLabelsResponse;
 import org.hypertrace.label.config.service.v1.UpdateLabelResponse;
@@ -48,7 +51,42 @@ private Label convertLabel(org.hypertrace.label.config.service.v1.Label label) {
         label.getData().getKey(),
         label.getData().hasColor() ? label.getData().getColor() : null,
         label.getData().hasDescription() ? label.getData().getDescription() : null,
-        Collections.emptyMap());
+        Collections.emptyMap(),
+        null);
+  }
+
+  public Single<Label> convertLabel(
+      Label label,
+      Map<String, EntityResultSet> entityResultMap,
+      LabelApplicationRuleResultSet labelApplicationRuleResultSet) {
+    Label convertedLabel =
+        new DefaultLabel(
+            label.id(),
+            label.key(),
+            label.color(),
+            label.description(),
+            getLabeledEntityResultSetMap(entityResultMap),
+            labelApplicationRuleResultSet);
+    return Single.just(convertedLabel);
+  }
+
+  private Map<String, LabeledEntityResultSet> getLabeledEntityResultSetMap(
+      Map<String, EntityResultSet> entityResultMap) {
+    return entityResultMap.entrySet().stream()
+        .map(entry -> Map.entry(entry.getKey(), getLabeledEntityResultSet(entry.getValue())))
+        .collect(CollectorUtils.immutableMapEntryCollector());
+  }
+
+  private LabeledEntityResultSet getLabeledEntityResultSet(EntityResultSet entityResultSet) {
+    List<LabeledEntity> labeledEntities = convertEntities(entityResultSet);
+    return new DefaultLabeledEntityResultSet(
+        labeledEntities, labeledEntities.size(), entityResultSet.total());
+  }
+
+  private List<LabeledEntity> convertEntities(EntityResultSet entityResultSet) {
+    return entityResultSet.results().stream()
+        .map(DefaultLabeledEntity::new)
+        .collect(Collectors.toList());
   }
 
   @Value
@@ -66,16 +104,17 @@ private static class DefaultLabel implements Label {
     String key;
     String color;
     String description;
-    Map<String, List<LabeledEntity>> labeledEntitiesMap;
+    Map<String, LabeledEntityResultSet> labeledEntityResultSetMap;
+    LabelApplicationRuleResultSet labelApplicationRuleResultSet;
 
     @Override
     public LabeledEntityResultSet labeledEntities(String entityType, int limit) {
-      List<LabeledEntity> labeledEntities =
-          Optional.ofNullable(labeledEntitiesMap.get(entityType)).orElse(Collections.emptyList());
-      List<LabeledEntity> labeledEntitiesWithLimit =
-          labeledEntities.size() > limit ? labeledEntities.subList(0, limit) : labeledEntities;
-      return new DefaultLabeledEntityResultSet(
-          labeledEntitiesWithLimit, labeledEntitiesWithLimit.size(), labeledEntities.size());
+      return labeledEntityResultSetMap.get(entityType);
+    }
+
+    @Override
+    public LabelApplicationRuleResultSet labelApplicationRules(int limit) {
+      return labelApplicationRuleResultSet;
     }
   }
 
@@ -90,12 +129,16 @@ private static class DefaultLabeledEntityResultSet implements LabeledEntityResul
   @Value
   @Accessors(fluent = true)
   private static class DefaultLabeledEntity implements LabeledEntity {
-    String id;
-    Map<String, Object> attributeValues;
+    Entity entity;
+
+    @Override
+    public String id() {
+      return entity.id();
+    }
 
     @Override
     public Object attribute(String key) {
-      return this.attributeValues.get(key);
+      return this.entity.attribute(key);
     }
   }
 }
diff --git a/hypertrace-graphql-labels-schema-impl/src/main/java/org/hypertrace/graphql/label/joiner/DefaultEntityAndRuleJoinerBuilder.java b/hypertrace-graphql-labels-schema-impl/src/main/java/org/hypertrace/graphql/label/joiner/DefaultEntityAndRuleJoinerBuilder.java
new file mode 100644
index 00000000..a569781c
--- /dev/null
+++ b/hypertrace-graphql-labels-schema-impl/src/main/java/org/hypertrace/graphql/label/joiner/DefaultEntityAndRuleJoinerBuilder.java
@@ -0,0 +1,374 @@
+package org.hypertrace.graphql.label.joiner;
+
+import static io.reactivex.rxjava3.core.Single.zip;
+import static org.hypertrace.graphql.label.schema.Label.LABELED_ENTITIES_QUERY_NAME;
+import static org.hypertrace.graphql.label.schema.Label.LABEL_APPLICATION_RULES_QUERY_NAME;
+
+import graphql.schema.DataFetchingFieldSelectionSet;
+import graphql.schema.SelectedField;
+import io.reactivex.rxjava3.core.Observable;
+import io.reactivex.rxjava3.core.Single;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+import javax.inject.Inject;
+import lombok.AllArgsConstructor;
+import lombok.Value;
+import lombok.experimental.Accessors;
+import lombok.extern.slf4j.Slf4j;
+import org.hypertrace.core.graphql.common.request.AttributeAssociation;
+import org.hypertrace.core.graphql.common.request.AttributeRequest;
+import org.hypertrace.core.graphql.common.request.ContextualRequest;
+import org.hypertrace.core.graphql.common.request.ContextualRequestBuilder;
+import org.hypertrace.core.graphql.common.request.FilterRequestBuilder;
+import org.hypertrace.core.graphql.common.request.ResultSetRequest;
+import org.hypertrace.core.graphql.common.request.ResultSetRequestBuilder;
+import org.hypertrace.core.graphql.common.schema.arguments.TimeRangeArgument;
+import org.hypertrace.core.graphql.common.schema.attributes.AttributeScope;
+import org.hypertrace.core.graphql.common.schema.results.ResultSet;
+import org.hypertrace.core.graphql.common.schema.results.arguments.filter.FilterArgument;
+import org.hypertrace.core.graphql.common.schema.results.arguments.filter.FilterOperatorType;
+import org.hypertrace.core.graphql.common.schema.results.arguments.filter.FilterType;
+import org.hypertrace.core.graphql.common.schema.results.arguments.page.LimitArgument;
+import org.hypertrace.core.graphql.common.utils.CollectorUtils;
+import org.hypertrace.core.graphql.context.GraphQlRequestContext;
+import org.hypertrace.core.graphql.deserialization.ArgumentDeserializer;
+import org.hypertrace.core.graphql.utils.schema.GraphQlSelectionFinder;
+import org.hypertrace.core.graphql.utils.schema.SelectionQuery;
+import org.hypertrace.graphql.entity.dao.EntityDao;
+import org.hypertrace.graphql.entity.request.EdgeSetGroupRequest;
+import org.hypertrace.graphql.entity.request.EntityLabelRequest;
+import org.hypertrace.graphql.entity.request.EntityRequest;
+import org.hypertrace.graphql.entity.schema.EntityResultSet;
+import org.hypertrace.graphql.entity.schema.argument.EntityTypeStringArgument;
+import org.hypertrace.graphql.label.dao.LabelApplicationRuleDao;
+import org.hypertrace.graphql.label.dao.LabelDao;
+import org.hypertrace.graphql.label.dao.LabelResponseConverter;
+import org.hypertrace.graphql.label.schema.Label;
+import org.hypertrace.graphql.label.schema.LabelResultSet;
+import org.hypertrace.graphql.label.schema.rule.LabelApplicationRule;
+import org.hypertrace.graphql.label.schema.rule.LabelApplicationRuleResultSet;
+import org.hypertrace.graphql.metric.request.MetricAggregationRequest;
+import org.hypertrace.graphql.metric.request.MetricRequest;
+import org.hypertrace.graphql.metric.schema.argument.AggregatableOrderArgument;
+
+@Slf4j
+class DefaultEntityAndRuleJoinerBuilder implements EntityAndRuleJoinerBuilder {
+
+  private static final Integer DEFAULT_LIMIT = 10;
+  private static final int ZERO_OFFSET = 0;
+
+  private static final SelectionQuery RESULT_SET_LABELED_ENTITIES_SELECTION_QUERY =
+      SelectionQuery.builder()
+          .selectionPath(List.of(ResultSet.RESULT_SET_RESULTS_NAME, LABELED_ENTITIES_QUERY_NAME))
+          .build();
+
+  private static final SelectionQuery RESULT_SET_LABEL_APPLICATION_RULES_SELECTION_QUERY =
+      SelectionQuery.builder()
+          .selectionPath(
+              List.of(ResultSet.RESULT_SET_RESULTS_NAME, LABEL_APPLICATION_RULES_QUERY_NAME))
+          .build();
+
+  private final LabelApplicationRuleResultSet EMPTY_LABEL_APPLICATION_RULE_RESULT_SET =
+      new DefaultLabelApplicationRuleResultSet(Collections.emptyList(), 0, 0);
+
+  private final ContextualRequestBuilder requestBuilder;
+  private final ResultSetRequestBuilder resultSetRequestBuilder;
+  private final FilterRequestBuilder filterRequestBuilder;
+  private final LabelDao labelDao;
+  private final LabelApplicationRuleDao labelApplicationRuleDao;
+  private final EntityDao entityDao;
+  private final LabelResponseConverter responseConverter;
+  private final GraphQlSelectionFinder selectionFinder;
+  private final ArgumentDeserializer argumentDeserializer;
+
+  @Inject
+  DefaultEntityAndRuleJoinerBuilder(
+      ContextualRequestBuilder requestBuilder,
+      ResultSetRequestBuilder resultSetRequestBuilder,
+      FilterRequestBuilder filterRequestBuilder,
+      LabelDao labelDao,
+      LabelApplicationRuleDao labelApplicationRuleDao,
+      EntityDao entityDao,
+      LabelResponseConverter responseConverter,
+      GraphQlSelectionFinder selectionFinder,
+      ArgumentDeserializer argumentDeserializer) {
+    this.requestBuilder = requestBuilder;
+    this.resultSetRequestBuilder = resultSetRequestBuilder;
+    this.filterRequestBuilder = filterRequestBuilder;
+    this.labelDao = labelDao;
+    this.labelApplicationRuleDao = labelApplicationRuleDao;
+    this.entityDao = entityDao;
+    this.responseConverter = responseConverter;
+    this.selectionFinder = selectionFinder;
+    this.argumentDeserializer = argumentDeserializer;
+  }
+
+  @Override
+  public Single<EntityAndRuleJoiner> build(
+      GraphQlRequestContext context, DataFetchingFieldSelectionSet selectionSet) {
+    return zip(
+        buildContextualRequest(context),
+        buildLabeledEntitiesRequestIfPresentInResultSet(selectionSet),
+        buildLabelApplicationRulesRequestIfPresentInResultSet(selectionSet),
+        (contextualRequest, labeledEntitiesRequests, labelApplicationRulesRequest) ->
+            new DefaultEntityAndRuleJoiner(
+                context, contextualRequest, labeledEntitiesRequests, labelApplicationRulesRequest));
+  }
+
+  private Single<ContextualRequest> buildContextualRequest(GraphQlRequestContext context) {
+    return Single.just(this.requestBuilder.build(context));
+  }
+
+  private Single<List<LabeledEntitiesRequest>> buildLabeledEntitiesRequestIfPresentInResultSet(
+      DataFetchingFieldSelectionSet selectionSet) {
+    return Single.just(
+        this.selectionFinder
+            .findSelections(selectionSet, RESULT_SET_LABELED_ENTITIES_SELECTION_QUERY)
+            .map(
+                selectedField ->
+                    new DefaultLabeledEntitiesRequest(
+                        getEntityType(selectedField),
+                        getLimit(selectedField),
+                        selectedField.getSelectionSet()))
+            .collect(Collectors.toList()));
+  }
+
+  private Single<Optional<LabelApplicationRulesRequest>>
+      buildLabelApplicationRulesRequestIfPresentInResultSet(
+          DataFetchingFieldSelectionSet selectionSet) {
+    return Single.just(
+        this.selectionFinder
+            .findSelections(selectionSet, RESULT_SET_LABEL_APPLICATION_RULES_SELECTION_QUERY)
+            .findAny()
+            .map(
+                selectedField -> new DefaultLabelApplicationRulesRequest(getLimit(selectedField))));
+  }
+
+  private String getEntityType(SelectedField selectedField) {
+    return this.argumentDeserializer
+        .deserializePrimitive(selectedField.getArguments(), EntityTypeStringArgument.class)
+        .orElseThrow();
+  }
+
+  private int getLimit(SelectedField selectedField) {
+    return this.argumentDeserializer
+        .deserializePrimitive(selectedField.getArguments(), LimitArgument.class)
+        .orElse(DEFAULT_LIMIT);
+  }
+
+  @AllArgsConstructor
+  private class DefaultEntityAndRuleJoiner implements EntityAndRuleJoiner {
+    private final GraphQlRequestContext context;
+    private final ContextualRequest contextualRequest;
+    private final List<LabeledEntitiesRequest> labeledEntitiesRequests;
+    private final Optional<LabelApplicationRulesRequest> labelApplicationRulesRequest;
+
+    @Override
+    public Single<LabelResultSet> joinLabelsWithEntitiesAndRules() {
+      return zip(
+              labelDao.getLabels(contextualRequest),
+              getLabelApplicationRuleResultSet(),
+              this::getUpdatedLabelResultSet)
+          .flatMap(labelResultSet -> labelResultSet);
+    }
+
+    private Single<LabelApplicationRuleResultSet> getLabelApplicationRuleResultSet() {
+      return labelApplicationRulesRequest
+          .map(request -> labelApplicationRuleDao.getLabelApplicationRules(contextualRequest))
+          .orElse(Single.just(EMPTY_LABEL_APPLICATION_RULE_RESULT_SET));
+    }
+
+    private Single<LabelResultSet> getUpdatedLabelResultSet(
+        LabelResultSet labelResultSet,
+        LabelApplicationRuleResultSet labelApplicationRuleResultSet) {
+      return getUpdatedLabels(labelResultSet, labelApplicationRuleResultSet)
+          .flatMap(responseConverter::convert);
+    }
+
+    private Single<List<Label>> getUpdatedLabels(
+        LabelResultSet labelResultSet,
+        LabelApplicationRuleResultSet labelApplicationRuleResultSet) {
+      return Observable.fromIterable(labelResultSet.results())
+          .flatMapSingle(label -> this.getUpdatedLabel(label, labelApplicationRuleResultSet))
+          .collect(Collectors.toList());
+    }
+
+    private Single<Label> getUpdatedLabel(
+        Label label, LabelApplicationRuleResultSet labelApplicationRuleResultSet) {
+      return zip(
+              getEntityResultSetMap(label),
+              filterLabelApplicationRuleResultSet(label, labelApplicationRuleResultSet),
+              (entityResultMap, filteredLabelApplicationRuleResultSet) ->
+                  responseConverter.convertLabel(
+                      label, entityResultMap, filteredLabelApplicationRuleResultSet))
+          .flatMap(updatedLabel -> updatedLabel);
+    }
+
+    private Single<LabelApplicationRuleResultSet> filterLabelApplicationRuleResultSet(
+        Label label, LabelApplicationRuleResultSet resultSet) {
+      if (resultSet.equals(EMPTY_LABEL_APPLICATION_RULE_RESULT_SET)) {
+        return Single.just(resultSet);
+      }
+      String labelId = label.id();
+      List<LabelApplicationRule> labelApplicationRules =
+          resultSet.results().stream()
+              .filter(rule -> this.hasMatchingLabelId(rule, labelId))
+              .collect(Collectors.toList());
+      int limit = labelApplicationRulesRequest.get().limit();
+      List<LabelApplicationRule> labelApplicationRuleSubList =
+          labelApplicationRules.size() > limit
+              ? labelApplicationRules.subList(ZERO_OFFSET, limit)
+              : labelApplicationRules;
+      return Single.just(
+          new DefaultLabelApplicationRuleResultSet(
+              labelApplicationRuleSubList,
+              labelApplicationRules.size(),
+              labelApplicationRuleSubList.size()));
+    }
+
+    private boolean hasMatchingLabelId(LabelApplicationRule rule, String labelId) {
+      if (rule.labelApplicationRuleData().action().staticLabels() != null) {
+        return rule.labelApplicationRuleData().action().staticLabels().ids().contains(labelId);
+      }
+      return false;
+    }
+
+    private Single<Map<String, EntityResultSet>> getEntityResultSetMap(Label label) {
+      String labelId = label.id();
+      return Observable.fromIterable(labeledEntitiesRequests)
+          .flatMapSingle(request -> getEntityResultSetMapEntry(labelId, request))
+          .collect(CollectorUtils.immutableMapEntryCollector());
+    }
+
+    private Single<Map.Entry<String, EntityResultSet>> getEntityResultSetMapEntry(
+        String labelId, LabeledEntitiesRequest request) {
+      return buildEntityRequestForType(
+              context, request.entityType(), labelId, request.limit(), request.selectionSet())
+          .flatMap(entityDao::getEntities)
+          .map(resultSet -> Map.entry(request.entityType(), resultSet));
+    }
+
+    private Single<EntityRequest> buildEntityRequestForType(
+        GraphQlRequestContext context,
+        String entityType,
+        String labelId,
+        int limit,
+        DataFetchingFieldSelectionSet selectionSet) {
+      return buildLabelIdFilter(context, entityType, labelId)
+          .flatMap(
+              filterArguments ->
+                  buildEntityRequest(context, entityType, limit, filterArguments, selectionSet));
+    }
+
+    private Single<EntityRequest> buildEntityRequest(
+        GraphQlRequestContext context,
+        String entityType,
+        int entityIdsToFilterSize,
+        List<AttributeAssociation<FilterArgument>> filterArguments,
+        DataFetchingFieldSelectionSet selectionSet) {
+      boolean fetchTotal =
+          selectionFinder
+                  .findSelections(
+                      selectionSet, SelectionQuery.namedChild(ResultSet.RESULT_SET_TOTAL_NAME))
+                  .count()
+              > 0;
+      return resultSetRequestBuilder
+          .build(
+              context,
+              entityType,
+              entityIdsToFilterSize,
+              ZERO_OFFSET,
+              new InstantTimeRange(),
+              List.<AttributeAssociation<AggregatableOrderArgument>>of(), // Order does not matter
+              filterArguments,
+              selectionSet.getFields().stream(),
+              Optional.empty())
+          .map(request -> new DefaultEntityRequest(entityType, request, fetchTotal));
+    }
+
+    private Single<List<AttributeAssociation<FilterArgument>>> buildLabelIdFilter(
+        GraphQlRequestContext context, String entityScope, String labelId) {
+      return filterRequestBuilder.build(context, entityScope, Set.of(new LabelIdFilter(labelId)));
+    }
+  }
+
+  @Value
+  @Accessors(fluent = true)
+  private static class DefaultEntityRequest implements EntityRequest {
+    String entityType;
+    ResultSetRequest<AggregatableOrderArgument> resultSetRequest;
+    List<MetricRequest> metricRequests = Collections.emptyList(); // Only support attributes for now
+    boolean fetchTotal;
+    EdgeSetGroupRequest incomingEdgeRequests = new EmptyEdgeSetGroupRequest();
+    EdgeSetGroupRequest outgoingEdgeRequests = new EmptyEdgeSetGroupRequest();
+    boolean includeInactive = true; // When joining we want the entity regardless of time range
+    Optional<EntityLabelRequest> labelRequest = Optional.empty();
+  }
+
+  @Value
+  @Accessors(fluent = true)
+  private static class EmptyEdgeSetGroupRequest implements EdgeSetGroupRequest {
+    Set<String> entityTypes = Collections.emptySet();
+    Collection<AttributeRequest> attributeRequests = Collections.emptyList();
+    Collection<MetricAggregationRequest> metricAggregationRequests = Collections.emptyList();
+    AttributeRequest neighborIdAttribute = null;
+    AttributeRequest neighborTypeAttribute = null;
+
+    @Override
+    public Single<EntityRequest> buildNeighborRequest(
+        String entityType, Collection<String> neighborIds) {
+      return Single.error(
+          new UnsupportedOperationException(
+              "Does not support fetching neighbors for joined entities"));
+    }
+  }
+
+  @Value
+  @Accessors(fluent = true)
+  private static class InstantTimeRange implements TimeRangeArgument {
+    // Bug in gateway requires this time range be larger, even though we don't care about it
+    Instant startTime = Instant.now().minus(15, ChronoUnit.MINUTES);
+    Instant endTime = Instant.now();
+  }
+
+  @Value
+  @Accessors(fluent = true)
+  private static class LabelIdFilter implements FilterArgument {
+    FilterType type = FilterType.ATTRIBUTE;
+    String key = "labels";
+    FilterOperatorType operator = FilterOperatorType.EQUALS;
+    String value;
+    AttributeScope idType = null;
+    String idScope = null;
+  }
+
+  @Value
+  @Accessors(fluent = true)
+  private static class DefaultLabeledEntitiesRequest implements LabeledEntitiesRequest {
+    String entityType;
+    int limit;
+    DataFetchingFieldSelectionSet selectionSet;
+  }
+
+  @Value
+  @Accessors(fluent = true)
+  private static class DefaultLabelApplicationRulesRequest implements LabelApplicationRulesRequest {
+    int limit;
+  }
+
+  @Value
+  @Accessors(fluent = true)
+  private static class DefaultLabelApplicationRuleResultSet
+      implements LabelApplicationRuleResultSet {
+    List<LabelApplicationRule> results;
+    long total;
+    long count;
+  }
+}
diff --git a/hypertrace-graphql-labels-schema-impl/src/main/java/org/hypertrace/graphql/label/joiner/LabelJoinerModule.java b/hypertrace-graphql-labels-schema-impl/src/main/java/org/hypertrace/graphql/label/joiner/LabelJoinerModule.java
index 33d7ad70..8680175e 100644
--- a/hypertrace-graphql-labels-schema-impl/src/main/java/org/hypertrace/graphql/label/joiner/LabelJoinerModule.java
+++ b/hypertrace-graphql-labels-schema-impl/src/main/java/org/hypertrace/graphql/label/joiner/LabelJoinerModule.java
@@ -8,6 +8,7 @@ public class LabelJoinerModule extends AbstractModule {
   @Override
   protected void configure() {
     bind(LabelJoinerBuilder.class).to(DefaultLabelJoinerBuilder.class);
+    bind(EntityAndRuleJoinerBuilder.class).to(DefaultEntityAndRuleJoinerBuilder.class);
 
     requireBinding(LabelDao.class);
   }