diff --git a/engine-rest/engine-rest-openapi/src/main/templates/lib/commons/history-process-instance.ftl b/engine-rest/engine-rest-openapi/src/main/templates/lib/commons/history-process-instance.ftl
index 086b3aacceb..d5532b1cf92 100644
--- a/engine-rest/engine-rest-openapi/src/main/templates/lib/commons/history-process-instance.ftl
+++ b/engine-rest/engine-rest-openapi/src/main/templates/lib/commons/history-process-instance.ftl
@@ -237,6 +237,12 @@
     "desc": "Only include historic process instances which belong to no tenant. Value may only be `true`, as `false` is the default behavior."
   },
 
+  "activityIdIn": {
+    "type": "array",
+    "itemType": "string",
+    "desc": "Restrict to instances with an active activity with one of the given ids. This filter behaves differently as `activeActivityIdIn` since it also yields results when filtering for activities with an incident. ${listTypeDescription}"
+  },
+
   "executedActivityIdIn": {
     "type": "array",
     "itemType": "string",
diff --git a/engine-rest/engine-rest/src/main/java/org/camunda/bpm/engine/rest/dto/history/HistoricProcessInstanceQueryDto.java b/engine-rest/engine-rest/src/main/java/org/camunda/bpm/engine/rest/dto/history/HistoricProcessInstanceQueryDto.java
index da4e861a544..c944c2288ed 100644
--- a/engine-rest/engine-rest/src/main/java/org/camunda/bpm/engine/rest/dto/history/HistoricProcessInstanceQueryDto.java
+++ b/engine-rest/engine-rest/src/main/java/org/camunda/bpm/engine/rest/dto/history/HistoricProcessInstanceQueryDto.java
@@ -109,6 +109,7 @@ public class HistoricProcessInstanceQueryDto extends AbstractQueryDto<HistoricPr
   private Boolean withoutTenantId;
   private List<String> executedActivityIdIn;
   private List<String> activeActivityIdIn;
+  private List<String> activityIdIn;
   private Boolean active;
   private Boolean suspended;
   private Boolean completed;
@@ -342,6 +343,11 @@ public void setActiveActivityIdIn(List<String> activeActivityIdIn) {
     this.activeActivityIdIn = activeActivityIdIn;
   }
 
+  @CamundaQueryParam(value = "activityIdIn", converter = StringListConverter.class)
+  public void setActivityIdIn(List<String> activityIdIn) {
+    this.activityIdIn = activityIdIn;
+  }
+
   @CamundaQueryParam(value = "executedJobAfter", converter = DateConverter.class)
   public void setExecutedJobAfter(Date executedJobAfter) {
     this.executedJobAfter = executedJobAfter;
@@ -548,6 +554,10 @@ protected void applyFilters(HistoricProcessInstanceQuery query) {
       query.activeActivityIdIn(activeActivityIdIn.toArray(new String[0]));
     }
 
+    if(activityIdIn!= null && !activityIdIn.isEmpty()) {
+      query.activityIdIn(activityIdIn.toArray(new String[0]));
+    }
+
     if (executedJobAfter != null) {
       query.executedJobAfter(executedJobAfter);
     }
diff --git a/engine-rest/engine-rest/src/test/java/org/camunda/bpm/engine/rest/history/HistoricProcessInstanceRestServiceQueryTest.java b/engine-rest/engine-rest/src/test/java/org/camunda/bpm/engine/rest/history/HistoricProcessInstanceRestServiceQueryTest.java
index b5734cc32f0..7ed79ed567b 100644
--- a/engine-rest/engine-rest/src/test/java/org/camunda/bpm/engine/rest/history/HistoricProcessInstanceRestServiceQueryTest.java
+++ b/engine-rest/engine-rest/src/test/java/org/camunda/bpm/engine/rest/history/HistoricProcessInstanceRestServiceQueryTest.java
@@ -74,6 +74,7 @@ public class HistoricProcessInstanceRestServiceQueryTest extends AbstractRestSer
   protected static final String QUERY_PARAM_EXECUTED_ACTIVITY_IDS = "executedActivityIdIn";
   protected static final String QUERY_PARAM_ACTIVE_ACTIVITY_IDS = "activeActivityIdIn";
   protected static final String QUERY_PARAM_INCIDENT_IDS = "incidentIdIn";
+  protected static final String QUERY_PARAM_ACTIVE_OR_FAILING_ACTIVITY_IDS = "activityIdIn";
 
   @ClassRule
   public static TestContainerRule rule = new TestContainerRule();
@@ -2346,4 +2347,32 @@ public void testQueryByIncidentIdInAsPost() {
     verify(mockedQuery).incidentIdIn("1", "2");
   }
 
+  @Test
+  public void testQueryByActivityIdIn() {
+    given()
+        .queryParam(QUERY_PARAM_ACTIVE_OR_FAILING_ACTIVITY_IDS, "1,2")
+        .then().expect()
+        .statusCode(Status.OK.getStatusCode())
+        .when()
+        .get(HISTORIC_PROCESS_INSTANCE_RESOURCE_URL);
+
+    verify(mockedQuery).activityIdIn("1", "2");
+  }
+
+  @Test
+  public void testQueryByActivityIdInAsPost() {
+    Map<String, List<String>> parameters = new HashMap<String, List<String>>();
+    parameters.put(QUERY_PARAM_ACTIVE_OR_FAILING_ACTIVITY_IDS, Arrays.asList("1", "2"));
+
+    given()
+        .contentType(POST_JSON_CONTENT_TYPE)
+        .body(parameters)
+        .then().expect()
+        .statusCode(Status.OK.getStatusCode())
+        .when()
+        .post(HISTORIC_PROCESS_INSTANCE_RESOURCE_URL);
+
+    verify(mockedQuery).activityIdIn("1", "2");
+  }
+
 }
diff --git a/engine/src/main/java/org/camunda/bpm/engine/history/HistoricProcessInstanceQuery.java b/engine/src/main/java/org/camunda/bpm/engine/history/HistoricProcessInstanceQuery.java
index e8034aa7df9..46fa51c951c 100644
--- a/engine/src/main/java/org/camunda/bpm/engine/history/HistoricProcessInstanceQuery.java
+++ b/engine/src/main/java/org/camunda/bpm/engine/history/HistoricProcessInstanceQuery.java
@@ -440,6 +440,11 @@ public interface HistoricProcessInstanceQuery extends Query<HistoricProcessInsta
    */
   HistoricProcessInstanceQuery activeActivityIdIn(String... ids);
 
+  /**
+   * Only select historic process instances with an active activity with one of the given ids. This filter behaves differently as `activeActivityIdIn` since it also yields results when filtering for activities with an incident.
+   */
+  HistoricProcessInstanceQuery activityIdIn(String... ids);
+
   /**
    * Only select historic process instances that executed an job after the given date.
    */
diff --git a/engine/src/main/java/org/camunda/bpm/engine/impl/HistoricProcessInstanceQueryImpl.java b/engine/src/main/java/org/camunda/bpm/engine/impl/HistoricProcessInstanceQueryImpl.java
index 96fa6793aa8..ba4a6fa7bb2 100644
--- a/engine/src/main/java/org/camunda/bpm/engine/impl/HistoricProcessInstanceQueryImpl.java
+++ b/engine/src/main/java/org/camunda/bpm/engine/impl/HistoricProcessInstanceQueryImpl.java
@@ -91,6 +91,7 @@ public class HistoricProcessInstanceQueryImpl extends AbstractVariableQueryImpl<
   protected boolean isTenantIdSet;
   protected String[] executedActivityIds;
   protected String[] activeActivityIds;
+  protected String[] activityIds;
   protected String state;
   protected String[] incidentIds;
 
@@ -478,6 +479,10 @@ public String[] getActiveActivityIds() {
     return activeActivityIds;
   }
 
+  public String[] getActivityIds() {
+    return activityIds;
+  }
+
   public String getBusinessKey() {
     return businessKey;
   }
@@ -781,6 +786,14 @@ public HistoricProcessInstanceQuery activeActivityIdIn(String... ids) {
     return this;
   }
 
+  @Override
+  public HistoricProcessInstanceQuery activityIdIn(String... ids) {
+    ensureNotNull(BadUserRequestException.class, "activity ids", (Object[]) ids);
+    ensureNotContainsNull(BadUserRequestException.class, "activity ids", Arrays.asList(ids));
+    this.activityIds = ids;
+    return this;
+  }
+
   @Override
   public HistoricProcessInstanceQuery active() {
     ensureNull(BadUserRequestException.class, "Already querying for historic process instance with another state", state, state);
diff --git a/engine/src/main/resources/org/camunda/bpm/engine/impl/mapping/entity/HistoricProcessInstance.xml b/engine/src/main/resources/org/camunda/bpm/engine/impl/mapping/entity/HistoricProcessInstance.xml
index db97831716b..45dd2cbe23e 100644
--- a/engine/src/main/resources/org/camunda/bpm/engine/impl/mapping/entity/HistoricProcessInstance.xml
+++ b/engine/src/main/resources/org/camunda/bpm/engine/impl/mapping/entity/HistoricProcessInstance.xml
@@ -173,7 +173,7 @@
 
   <update id="updateHistoricProcessInstanceByProcessInstanceId"
           parameterType="java.util.Map">
-    update 
+    update
       <if test="maxResults != null">
         ${limitBeforeWithoutOffset}
       </if>
@@ -317,7 +317,7 @@
     <result property="state" column="STATE_" jdbcType="VARCHAR"/>
     <result property="restartedProcessInstanceId" column="RESTARTED_PROC_INST_ID_" jdbcType="VARCHAR"/>
   </resultMap>
-  
+
   <resultMap type="org.camunda.bpm.engine.impl.util.ImmutablePair" id="deploymentIdMapping">
     <id property="left" column="DEPLOYMENT_ID_" jdbcType="VARCHAR" />
     <id property="right" column="ID_" jdbcType="VARCHAR" />
@@ -366,7 +366,7 @@
     <include refid="selectHistoricProcessInstancesByQueryCriteriaSql"/>
     ${countDistinctAfterEnd}
   </select>
-  
+
   <select id="selectHistoricProcessInstanceDeploymentIdMappingsByQueryCriteria" parameterType="org.camunda.bpm.engine.impl.HistoricProcessInstanceQueryImpl" resultMap="deploymentIdMapping">
     select distinct RES.DEPLOYMENT_ID_, RES.ID_
     <include refid="selectHistoricProcessInstancesByQueryCriteriaSql"/>
@@ -402,6 +402,7 @@
 
     <bind name="INC_JOIN" value="false" />
     <bind name="HAI_JOIN" value="false" />
+    <bind name="INCACT_JOIN" value="false" />
     <bind name="JOIN_TYPE" value="'inner join'" />
 
     <foreach collection="queries" item="query">
@@ -413,9 +414,13 @@
         <bind name="INC_JOIN" value="true" />
       </if>
 
-      <if test="query != null &amp;&amp; (query.executedActivityIds != null and query.executedActivityIds.length > 0) || (query.activeActivityIds != null and query.activeActivityIds.length > 0)">
+      <if test="query != null &amp;&amp; (query.executedActivityIds != null and query.executedActivityIds.length > 0) || (query.activeActivityIds != null and query.activeActivityIds.length > 0) || (query.activityIds != null and query.activityIds.length > 0)">
         <bind name="HAI_JOIN" value="true" />
       </if>
+
+      <if test="query != null &amp;&amp; (query.activityIds != null and query.activityIds.length > 0)">
+        <bind name="INCACT_JOIN" value="true" />
+      </if>
     </foreach>
 
     <if test="INC_JOIN">
@@ -425,8 +430,12 @@
       LEFT JOIN ${prefix}ACT_HI_ACTINST HAI
       ON HAI.PROC_INST_ID_ = SELF.ID_
     </if>
-    
-    <!-- actual value conditions are checked in the WHERE part; 
+
+    <if test="INCACT_JOIN">
+      LEFT JOIN ${prefix}ACT_HI_INCIDENT INCACT on SELF.PROC_INST_ID_ = INCACT.PROC_INST_ID_
+    </if>
+
+    <!-- actual value conditions are checked in the WHERE part;
        however here we must join once for every variable condition.
        It is important that in the WHERE part we use the same table
        names for the respective conditions (i.e. VI0, VI1, VI2, ...) -->
@@ -634,6 +643,21 @@
               )
             </if>
 
+            <if test="query.activityIds != null and query.activityIds.length > 0">
+              ${queryType} (
+                  (
+                  HAI.END_TIME_ IS NULL
+                  AND HAI.ACT_ID_ IN
+                  <foreach item="activityId" index="index" collection="query.activityIds" open="(" separator="," close=")">
+                    #{activityId}
+                  </foreach>
+                  ) OR INCACT.ACTIVITY_ID_ IN
+                  <foreach item="activityId" index="index" collection="query.activityIds" open="(" separator="," close=")">
+                    #{activityId}
+                  </foreach>
+                )
+            </if>
+
             <if test="query.executedActivityIds != null and query.executedActivityIds.length > 0">
               ${queryType} (
                 HAI.END_TIME_ IS NOT NULL
diff --git a/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java b/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
index e08efa5d1db..a342a9ff0e7 100644
--- a/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
+++ b/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
@@ -36,9 +36,11 @@
 import java.util.Date;
 import java.util.GregorianCalendar;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 
+import java.util.Set;
 import java.util.stream.Collectors;
 import org.apache.commons.lang3.time.DateUtils;
 import org.camunda.bpm.engine.BadUserRequestException;
@@ -58,17 +60,22 @@
 import org.camunda.bpm.engine.history.HistoricVariableInstance;
 import org.camunda.bpm.engine.impl.history.HistoryLevel;
 import org.camunda.bpm.engine.impl.history.event.HistoricProcessInstanceEventEntity;
+import org.camunda.bpm.engine.impl.persistence.entity.JobEntity;
 import org.camunda.bpm.engine.impl.util.ClockUtil;
 import org.camunda.bpm.engine.repository.ProcessDefinition;
 import org.camunda.bpm.engine.runtime.Incident;
 import org.camunda.bpm.engine.runtime.Job;
 import org.camunda.bpm.engine.runtime.ProcessInstance;
+import org.camunda.bpm.engine.runtime.ProcessInstanceQuery;
 import org.camunda.bpm.engine.task.Task;
 import org.camunda.bpm.engine.test.Deployment;
 import org.camunda.bpm.engine.test.ProcessEngineRule;
 import org.camunda.bpm.engine.test.RequiredHistoryLevel;
+import org.camunda.bpm.engine.test.api.mgmt.FailingDelegate;
 import org.camunda.bpm.engine.test.api.runtime.migration.models.CallActivityModels;
+import org.camunda.bpm.engine.test.api.runtime.migration.models.CompensationModels;
 import org.camunda.bpm.engine.test.api.runtime.migration.models.ProcessModels;
+import org.camunda.bpm.engine.test.api.runtime.util.ChangeVariablesDelegate;
 import org.camunda.bpm.engine.test.util.ProcessEngineTestRule;
 import org.camunda.bpm.engine.test.util.ProvidedProcessEngineRule;
 import org.camunda.bpm.engine.variable.Variables;
@@ -89,6 +96,23 @@ public class HistoricProcessInstanceTest {
   public ProcessEngineRule engineRule = new ProvidedProcessEngineRule();
   public ProcessEngineTestRule testHelper = new ProcessEngineTestRule(engineRule);
 
+  public static final BpmnModelInstance FORK_JOIN_SUB_PROCESS_MODEL = ProcessModels.newModel()
+      .startEvent()
+      .subProcess("subProcess")
+      .embeddedSubProcess()
+      .startEvent()
+      .parallelGateway("fork")
+      .userTask("userTask1")
+      .name("completeMe")
+      .parallelGateway("join")
+      .endEvent()
+      .moveToNode("fork")
+      .userTask("userTask2")
+      .connectTo("join")
+      .subProcessDone()
+      .endEvent()
+      .done();
+
   @Rule
   public RuleChain chain = RuleChain.outerRule(engineRule).around(testHelper);
 
@@ -1548,6 +1572,556 @@ public void testHistoricProcInstQueryWithActiveActivityIds() {
     assertEquals(result.get(0).getId(), processInstance.getId());
   }
 
+  @Test
+  public void testQueryByNullActivityId() {
+    try {
+      historyService.createHistoricProcessInstanceQuery().activeActivityIdIn((String[]) null).list();
+      fail("exception expected");
+    }
+    catch (BadUserRequestException e) {
+      assertThat(e.getMessage()).contains("activity ids is null");
+    }
+  }
+
+  @Test
+  public void testQueryByNullActivityIds() {
+    try {
+      historyService.createHistoricProcessInstanceQuery()
+          .activityIdIn((String[]) null);
+      fail("exception expected");
+    }
+    catch (BadUserRequestException e) {
+      assertThat(e.getMessage()).contains("activity ids is null");
+    }
+  }
+
+  @Test
+  public void testQueryByUnknownActivityId() {
+    HistoricProcessInstanceQuery query = historyService.createHistoricProcessInstanceQuery()
+        .activityIdIn("unknown");
+
+    assertEquals(0, query.count());
+    assertEquals(0, query.list().size());
+  }
+
+  @Test
+  public void testQueryByLeafActivityId() {
+    // given
+    ProcessDefinition oneTaskDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
+    ProcessDefinition gatewaySubProcessDefinition = testHelper.deployAndGetDefinition(FORK_JOIN_SUB_PROCESS_MODEL);
+
+    // when
+    ProcessInstance oneTaskInstance1 = runtimeService.startProcessInstanceById(oneTaskDefinition.getId());
+    ProcessInstance oneTaskInstance2 = runtimeService.startProcessInstanceById(oneTaskDefinition.getId());
+    ProcessInstance gatewaySubProcessInstance1 = runtimeService.startProcessInstanceById(gatewaySubProcessDefinition.getId());
+    ProcessInstance gatewaySubProcessInstance2 = runtimeService.startProcessInstanceById(gatewaySubProcessDefinition.getId());
+
+    Task task = engineRule.getTaskService().createTaskQuery()
+        .processInstanceId(gatewaySubProcessInstance2.getId())
+        .taskName("completeMe")
+        .singleResult();
+    engineRule.getTaskService().complete(task.getId());
+
+    // then
+    HistoricProcessInstanceQuery query = historyService.createHistoricProcessInstanceQuery().activityIdIn("userTask");
+    assertReturnedProcessInstances(query, oneTaskInstance1, oneTaskInstance2);
+
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("userTask1", "userTask2");
+    assertReturnedProcessInstances(query, gatewaySubProcessInstance1, gatewaySubProcessInstance2);
+
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("userTask", "userTask1");
+    assertReturnedProcessInstances(query, oneTaskInstance1, oneTaskInstance2, gatewaySubProcessInstance1);
+
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("userTask", "userTask1", "userTask2");
+    assertReturnedProcessInstances(query, oneTaskInstance1, oneTaskInstance2, gatewaySubProcessInstance1, gatewaySubProcessInstance2);
+
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("join");
+    assertReturnedProcessInstances(query, gatewaySubProcessInstance2);
+  }
+
+  @Test
+  public void testQueryByNonLeafActivityId() {
+    // given
+    ProcessDefinition processDefinition = testHelper.deployAndGetDefinition(FORK_JOIN_SUB_PROCESS_MODEL);
+
+    // when
+    runtimeService.startProcessInstanceById(processDefinition.getId());
+
+    // then
+    ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery().activityIdIn("subProcess", "fork");
+
+    assertEquals(0, query.count());
+    assertEquals(0, query.list().size());
+  }
+
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  public void testQueryByAsyncBeforeActivityId() {
+    // For a historic instance when AsyncBefore is used the historic activity is only created when the execution is scheduled
+    // For process instances that have a token just before a AsyncBefore activity
+    //  In the runtimeInstanceQuery activityIdIn filter returns instances that are not scheduled yet
+    //  In historicInstanceQuery activityIdIn filter does not return instances that are not scheduled yet
+
+    // given
+    ProcessDefinition testProcess = testHelper.deployAndGetDefinition(ProcessModels.newModel()
+        .startEvent("start").camundaAsyncBefore()
+        .subProcess("subProcess").camundaAsyncBefore()
+        .embeddedSubProcess()
+        .startEvent()
+        .serviceTask("task").camundaAsyncBefore().camundaExpression("${true}")
+        .endEvent()
+        .subProcessDone()
+        .endEvent("end").camundaAsyncBefore()
+        .done()
+    );
+
+    // when
+    ProcessInstance instanceBeforeStart = runtimeService.startProcessInstanceById(testProcess.getId());
+    ProcessInstance instanceBeforeSubProcess = runtimeService.startProcessInstanceById(testProcess.getId());
+    executeJobForProcessInstance(instanceBeforeSubProcess);
+    ProcessInstance instanceBeforeTask = runtimeService.startProcessInstanceById(testProcess.getId());
+    executeJobForProcessInstance(instanceBeforeTask);
+    executeJobForProcessInstance(instanceBeforeTask);
+    ProcessInstance instanceBeforeEnd = runtimeService.startProcessInstanceById(testProcess.getId());
+    executeJobForProcessInstance(instanceBeforeEnd);
+    executeJobForProcessInstance(instanceBeforeEnd);
+    executeJobForProcessInstance(instanceBeforeEnd);
+
+    // then
+    HistoricProcessInstanceQuery historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("start");
+    assertNull(historicQuery.singleResult());
+    ProcessInstanceQuery runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("start");
+    assertEquals(instanceBeforeStart.getId(), runtimeQuery.singleResult().getProcessInstanceId());
+
+    historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess");
+    assertReturnedProcessInstances(historicQuery, instanceBeforeTask);
+    runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("subProcess");
+    assertEquals(instanceBeforeSubProcess.getId(), runtimeQuery.singleResult().getProcessInstanceId());
+
+    historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("task");
+    assertNull(historicQuery.singleResult());
+    runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("task");
+    assertEquals(instanceBeforeTask.getId(), runtimeQuery.singleResult().getProcessInstanceId());
+
+    historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("end");
+    assertNull(historicQuery.singleResult());
+    runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("end");
+    assertEquals(instanceBeforeEnd.getId(), runtimeQuery.singleResult().getProcessInstanceId());
+  }
+
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  public void testQueryByAsyncAfterActivityId() {
+    // For a historic activity the end time is set after it is executed => the activity is not considered active anymore,
+    //    this is not changed if AsyncAfter is used
+    //    if the task is a subprocess end time will only be set after the subprocess is terminated
+    // For the runtime query the execution is still visible if AsyncAfter is used (I assume we delete the execution when scheduling next activity)
+
+    // given
+    ProcessDefinition testProcess = testHelper.deployAndGetDefinition(ProcessModels.newModel()
+        .startEvent("start").camundaAsyncAfter()
+        .subProcess("subProcess").camundaAsyncAfter()
+        .embeddedSubProcess()
+        .startEvent()
+        .serviceTask("task").camundaAsyncAfter().camundaExpression("${true}")
+        .endEvent()
+        .subProcessDone()
+        .endEvent("end").camundaAsyncAfter()
+        .done()
+    );
+
+    // when
+    ProcessInstance instanceAfterStart = runtimeService.startProcessInstanceById(testProcess.getId());
+    ProcessInstance instanceAfterTask = runtimeService.startProcessInstanceById(testProcess.getId());
+    executeJobForProcessInstance(instanceAfterTask);
+    ProcessInstance instanceAfterSubProcess = runtimeService.startProcessInstanceById(testProcess.getId());
+    executeJobForProcessInstance(instanceAfterSubProcess);
+    executeJobForProcessInstance(instanceAfterSubProcess);
+    ProcessInstance instanceAfterEnd = runtimeService.startProcessInstanceById(testProcess.getId());
+    executeJobForProcessInstance(instanceAfterEnd);
+    executeJobForProcessInstance(instanceAfterEnd);
+    executeJobForProcessInstance(instanceAfterEnd);
+
+    HistoricProcessInstanceQuery historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("start");
+    assertNull(historicQuery.singleResult());
+    ProcessInstanceQuery runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("start");
+    assertEquals(instanceAfterStart.getId(), runtimeQuery.singleResult().getProcessInstanceId());
+
+    historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("task");
+    assertNull(historicQuery.singleResult());
+    runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("task");
+    assertEquals(instanceAfterTask.getId(), runtimeQuery.singleResult().getProcessInstanceId());
+
+    historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess");
+    assertReturnedProcessInstances(historicQuery, instanceAfterTask);
+    runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("subProcess");
+    assertEquals(instanceAfterSubProcess.getId(), runtimeQuery.singleResult().getProcessInstanceId());
+
+    historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("end");
+    assertNull(historicQuery.singleResult());
+    runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("end");
+    assertEquals(instanceAfterEnd.getId(), runtimeQuery.singleResult().getProcessInstanceId());
+  }
+
+  @Test
+  public void testQueryByActivityIdBeforeCompensation() {
+    // given
+    ProcessDefinition testProcess = testHelper.deployAndGetDefinition(CompensationModels.COMPENSATION_ONE_TASK_SUBPROCESS_MODEL);
+
+    // when
+    runtimeService.startProcessInstanceById(testProcess.getId());
+    testHelper.completeTask("userTask1");
+
+    // then
+    ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery().activityIdIn("subProcess");
+
+    assertEquals(0, query.count());
+    assertEquals(0, query.list().size());  }
+
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  public void testQueryByActivityIdDuringCompensation() {
+    // After completing user task we are expecting "subProcess", "compensationEvent", "compensationHandler" to have an activity
+    // Based on historic data only "compensationEvent", "compensationHandler" have active events
+
+    // given
+    ProcessDefinition testProcess = testHelper.deployAndGetDefinition(CompensationModels.COMPENSATION_ONE_TASK_SUBPROCESS_MODEL);
+
+    // when
+    ProcessInstance processInstance = runtimeService.startProcessInstanceById(testProcess.getId());
+    testHelper.completeTask("userTask1");
+    testHelper.completeTask("userTask2");
+
+    // then
+    HistoricProcessInstanceQuery historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess");
+    assertNull(historicQuery.singleResult());
+    ProcessInstanceQuery runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("subProcess");
+    assertEquals(processInstance.getId(), runtimeQuery.singleResult().getProcessInstanceId());
+
+    historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("compensationEvent");
+    assertReturnedProcessInstances(historicQuery, processInstance);
+    runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("compensationEvent");
+    assertEquals(processInstance.getId(), runtimeQuery.singleResult().getProcessInstanceId());
+
+    historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("compensationHandler");
+    assertReturnedProcessInstances(historicQuery, processInstance);
+    runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("compensationEvent");
+    assertEquals(processInstance.getId(), runtimeQuery.singleResult().getProcessInstanceId());
+  }
+
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  public void testHistoricProcInstQueryWithActivityIdsWithOneId() {
+    // given
+    String USER_TASK_1 = "userTask1";
+    deployment(ProcessModels.TWO_TASKS_PROCESS);
+    runtimeService.startProcessInstanceByKey("Process");
+    runtimeService.startProcessInstanceByKey("Process");
+
+    List<Task> tasks = taskService.createTaskQuery().list();
+    assertEquals(2, tasks.size());
+    taskService.complete(tasks.get(0).getId());
+
+    // when
+    List<HistoricProcessInstance> result = historyService
+        .createHistoricProcessInstanceQuery()
+        .activityIdIn(USER_TASK_1)
+        .list();
+
+    // then
+    assertNotNull(result);
+    assertEquals(1, result.size());
+    assertEquals(result.get(0).getId(), tasks.get(1).getProcessInstanceId());
+  }
+
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  public void testHistoricProcInstQueryWithActivityIdsWithMultipleIds() {
+    // given
+    String USER_TASK_1 = "userTask1";
+    String USER_TASK_2 = "userTask2";
+    deployment(ProcessModels.TWO_TASKS_PROCESS);
+    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("Process");
+    ProcessInstance processInstance2 = runtimeService.startProcessInstanceByKey("Process");
+
+    List<Task> tasks = taskService.createTaskQuery().list();
+    assertEquals(2, tasks.size());
+    taskService.complete(tasks.get(0).getId());
+
+    // when
+    List<HistoricProcessInstance> result = historyService
+        .createHistoricProcessInstanceQuery()
+        .activityIdIn(USER_TASK_1, USER_TASK_2)
+        .list();
+
+    // then
+    assertNotNull(result);
+    assertEquals(2, result.size());
+    assertThat(result.stream().map(HistoricProcessInstance::getId).collect(Collectors.toList()))
+        .containsExactlyInAnyOrder(processInstance.getId(),processInstance2.getId());
+  }
+
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  public void testHistoricProcInstQueryWithActivityIdsWhenDeletedCompetedInstancesExist() {
+    // given
+    String USER_TASK_1 = "userTask1";
+    String USER_TASK_2 = "userTask2";
+    deployment(ProcessModels.TWO_TASKS_PROCESS);
+    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("Process");
+    ProcessInstance processInstance2 = runtimeService.startProcessInstanceByKey("Process");
+
+    List<Task> tasks = taskService.createTaskQuery().list();
+    assertEquals(2, tasks.size());
+    taskService.complete(tasks.get(0).getId());
+
+    ProcessInstance completedProcessInstance = runtimeService.startProcessInstanceByKey("Process");
+    Task task = taskService.createTaskQuery().processInstanceId(completedProcessInstance.getId()).singleResult();
+    taskService.complete(task.getId());
+    task = taskService.createTaskQuery().processInstanceId(completedProcessInstance.getId()).singleResult();
+    taskService.complete(task.getId());
+
+
+    ProcessInstance deletedProcessInstance = runtimeService.startProcessInstanceByKey("Process");
+    runtimeService.deleteProcessInstance(deletedProcessInstance.getId(), "Testing");
+
+    // when
+    List<HistoricProcessInstance> result = historyService
+        .createHistoricProcessInstanceQuery()
+        .activityIdIn(USER_TASK_1, USER_TASK_2)
+        .list();
+
+    // then
+    assertNotNull(result);
+    assertEquals(2, result.size());
+    assertThat(result.stream().map(HistoricProcessInstance::getId).collect(Collectors.toList()))
+        .containsExactlyInAnyOrder(processInstance.getId(), processInstance2.getId());
+  }
+
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  @Deployment(resources = {"org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.testHistoricProcessInstanceQueryActivityIdInWithIncident.bpmn"})
+  public void testHistoricProcInstQueryWithActivityIdsWithFailingActivity() {
+    // given
+    runtimeService.startProcessInstanceByKey("failingProcess");
+    testHelper.executeAvailableJobs();
+
+    runtimeService.startProcessInstanceByKey("failingProcess");
+
+    // assume
+    assertEquals(2, historyService.createHistoricProcessInstanceQuery().count());
+    assertEquals(2, historyService.createHistoricProcessInstanceQuery().list().size());
+
+    assertEquals(1, historyService.createHistoricProcessInstanceQuery().withIncidents().count());
+    assertEquals(1, historyService.createHistoricProcessInstanceQuery().withIncidents().list().size());
+    HistoricProcessInstance failingInstance =  historyService.createHistoricProcessInstanceQuery().withIncidents().singleResult();
+
+    // when
+    List<HistoricProcessInstance> result = historyService
+        .createHistoricProcessInstanceQuery()
+        .activityIdIn("serviceTask")
+        .list();
+
+    // then
+    assertNotNull(result);
+    assertEquals(1, result.size());
+    assertEquals(result.get(0).getId(), failingInstance.getId());
+  }
+
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  @Deployment(resources={"org/camunda/bpm/engine/test/api/runtime/failingSubProcessCreateOneIncident.bpmn20.xml"})
+  public void shouldQueryByActivityIdInWithActivityIdOfFailingSubprocess() {
+    // given
+    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("failingSubProcess");
+
+    testHelper.executeAvailableJobs();
+
+    // when
+    HistoricProcessInstance historicPI =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess").singleResult();
+
+    // then
+    assertThat(historicPI).isNotNull();
+    assertThat(historicPI.getId()).isEqualTo(processInstance.getId());
+  }
+
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  @Deployment(resources={"org/camunda/bpm/engine/test/api/runtime/failingSubProcessCreateOneIncident.bpmn20.xml"})
+  public void shouldQueryByActivityIdInWithActivityIdOfFailingSubServiceTask() {
+    // given
+    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("failingSubProcess");
+
+    testHelper.executeAvailableJobs();
+
+    // when
+    HistoricProcessInstance historicPI =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("serviceTask").singleResult();
+
+    // then
+    assertThat(historicPI).isNotNull();
+    assertThat(historicPI.getId()).isEqualTo(processInstance.getId());
+  }
+
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  @Deployment(resources={"org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.subprocess.bpmn20.xml"})
+  public void shouldQueryByActivityIdInWithActivityIdOfSubprocess() {
+    // given
+    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("subprocess");
+
+    TaskService taskService = engineRule.getTaskService();
+    Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId()).singleResult();
+    assertNotNull(task);
+    taskService.complete(task.getId());
+    // when
+    HistoricProcessInstance historicPI =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess").singleResult();
+
+    // then
+    assertThat(historicPI).isNotNull();
+    assertThat(historicPI.getId()).isEqualTo(processInstance.getId());
+  }
+
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  @Deployment(resources={"org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.subprocess.bpmn20.xml"})
+  public void shouldQueryByActivityIdInWithActivityIdOfSubServiceTask() {
+    // given
+    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("subprocess");
+
+    TaskService taskService = engineRule.getTaskService();
+    Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId()).singleResult();
+    assertNotNull(task);
+    taskService.complete(task.getId());
+    // when
+    HistoricProcessInstance historicPI =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("innerTask").singleResult();
+
+    // then
+    assertThat(historicPI).isNotNull();
+    assertThat(historicPI.getId()).isEqualTo(processInstance.getId());
+  }
+
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  @Deployment(resources={"org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.failingSubprocessWithAsyncBeforeTask.bpmn20.xml"})
+  public void shouldQueryByActivityIdInWithMultipleScopeAndIncident() {
+    // given
+    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("failingSubProcess");
+    ProcessInstance processInstance2 = runtimeService.startProcessInstanceByKey("failingSubProcess");
+
+    TaskService taskService = engineRule.getTaskService();
+    Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId()).singleResult();
+    taskService.complete(task.getId());
+
+    testHelper.executeAvailableJobs();
+
+    // when
+    List<HistoricProcessInstance> queryByInnerServiceActivityId =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("innerServiceTask").list();
+    List<HistoricProcessInstance>  queryBySubProcessActivityId =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess").list();
+    List<HistoricProcessInstance>  queryByOuterProcessActivityId =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("outerTask").list();
+    List<HistoricProcessInstance> queryByOuterAndInnedActivityId =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("innerServiceTask", "outerTask").list();
+
+    // then
+    assertThat(queryByInnerServiceActivityId.size()).isEqualTo(1);
+    assertThat(queryByInnerServiceActivityId.get(0).getId()).isEqualTo(processInstance.getId());
+
+    assertThat(queryBySubProcessActivityId.size()).isEqualTo(1);
+    assertThat(queryBySubProcessActivityId.get(0).getId()).isEqualTo(processInstance.getId());
+
+    assertThat(queryByOuterProcessActivityId.size()).isEqualTo(1);
+    assertThat(queryByOuterProcessActivityId.get(0).getId()).isEqualTo(processInstance2.getId());
+
+    assertThat(queryByOuterAndInnedActivityId.size()).isEqualTo(2);
+    assertThat(queryByOuterAndInnedActivityId.stream()
+        .map(HistoricProcessInstance::getId)
+        .collect(Collectors.toList()))
+        .containsExactlyInAnyOrderElementsOf(Arrays.asList(processInstance.getId(), processInstance2.getId()));
+  }
+
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  @Deployment(resources={"org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.subprocessWithAsyncBeforeTask.bpmn20.xml"})
+  public void shouldQueryByActivityIdInWithMultipleScope() {
+    // given
+    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("failingSubProcess");
+    ProcessInstance processInstance2 = runtimeService.startProcessInstanceByKey("failingSubProcess");
+
+    TaskService taskService = engineRule.getTaskService();
+    Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId()).singleResult();
+    taskService.complete(task.getId());
+
+    // when
+    List<HistoricProcessInstance> queryByInnerServiceActivityId =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("innerTask").list();
+    List<HistoricProcessInstance>  queryBySubProcessActivityId =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess").list();
+    List<HistoricProcessInstance>  queryByOuterProcessActivityId =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("outerTask").list();
+    List<HistoricProcessInstance> queryByOuterAndInnedActivityId =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("innerTask", "outerTask").list();
+
+    // then
+    assertThat(queryByInnerServiceActivityId.size()).isEqualTo(1);
+    assertThat(queryByInnerServiceActivityId.get(0).getId()).isEqualTo(processInstance.getId());
+
+    assertThat(queryBySubProcessActivityId.size()).isEqualTo(1);
+    assertThat(queryBySubProcessActivityId.get(0).getId()).isEqualTo(processInstance.getId());
+
+    assertThat(queryByOuterProcessActivityId.size()).isEqualTo(1);
+    assertThat(queryByOuterProcessActivityId.get(0).getId()).isEqualTo(processInstance2.getId());
+
+    assertThat(queryByOuterAndInnedActivityId.size()).isEqualTo(2);
+    assertThat(queryByOuterAndInnedActivityId.stream()
+        .map(HistoricProcessInstance::getId)
+        .collect(Collectors.toList()))
+        .containsExactlyInAnyOrderElementsOf(Arrays.asList(processInstance.getId(), processInstance2.getId()));
+  }
+
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  public void shouldQueryByActivityIdWhereIncidentOccurred() {
+    // given
+    testHelper.deploy(Bpmn.createExecutableProcess("process")
+      .startEvent()
+      .serviceTask("theTask")
+        .camundaAsyncBefore()
+        .camundaClass(ChangeVariablesDelegate.class)
+      .serviceTask("theTask2").camundaClass(ChangeVariablesDelegate.class)
+      .serviceTask("theTask3").camundaClass(FailingDelegate.class)
+      .endEvent()
+      .done());
+
+    runtimeService.startProcessInstanceByKey("process", Variables.createVariables().putValue("fail", true));
+    JobEntity job = (JobEntity) managementService.createJobQuery().singleResult();
+
+    // when: incident is raised
+    for(int i = 0; i<3; i++) {
+      try {
+        managementService.executeJob(job.getId());
+        fail("Exception expected");
+      } catch (Exception e) {
+        // exception expected
+      }
+    }
+
+    // then
+    HistoricProcessInstance theTask = historyService.createHistoricProcessInstanceQuery()
+        .activityIdIn("theTask")
+        .singleResult();
+    assertThat(theTask).isNotNull();
+    HistoricProcessInstance theTask3 = historyService.createHistoricProcessInstanceQuery()
+        .activityIdIn("theTask3")
+        .singleResult();
+    assertThat(theTask3).isNull();
+  }
+
   @Test
   public void testHistoricProcInstQueryWithActiveActivityIdsNull() {
     try {
@@ -2105,4 +2679,39 @@ protected void executeJob(Job job) {
     }
   }
 
+
+  protected void assertReturnedProcessInstances(HistoricProcessInstanceQuery query, ProcessInstance... processInstances) {
+    int expectedSize = processInstances.length;
+    assertEquals(expectedSize, query.count());
+    assertEquals(expectedSize, query.list().size());
+
+    verifyResultContainsExactly(query.list(), collectProcessInstanceIds(Arrays.asList(processInstances)));
+  }
+
+  protected void verifyResultContainsExactly(List<HistoricProcessInstance> instances, Set<String> processInstanceIds) {
+    Set<String> retrievedInstanceIds = collectHistoricProcessInstanceIds(instances);
+    assertEquals(processInstanceIds, retrievedInstanceIds);
+  }
+
+  protected Set<String> collectProcessInstanceIds(List<ProcessInstance> instances) {
+    Set<String> retrievedInstanceIds = new HashSet<>();
+    for (ProcessInstance instance : instances) {
+      retrievedInstanceIds.add(instance.getId());
+    }
+    return retrievedInstanceIds;
+  }
+
+  protected Set<String> collectHistoricProcessInstanceIds(List<HistoricProcessInstance> instances) {
+    Set<String> retrievedInstanceIds = new HashSet<>();
+    for (HistoricProcessInstance instance : instances) {
+      retrievedInstanceIds.add(instance.getId());
+    }
+    return retrievedInstanceIds;
+  }
+
+  protected void executeJobForProcessInstance(ProcessInstance processInstance) {
+    Job job = managementService.createJobQuery().processInstanceId(processInstance.getId()).singleResult();
+    managementService.executeJob(job.getId());
+  }
+
 }
diff --git a/engine/src/test/resources/org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.failingSubprocessWithAsyncBeforeTask.bpmn20.xml b/engine/src/test/resources/org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.failingSubprocessWithAsyncBeforeTask.bpmn20.xml
new file mode 100644
index 00000000000..1121cdbdc15
--- /dev/null
+++ b/engine/src/test/resources/org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.failingSubprocessWithAsyncBeforeTask.bpmn20.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
+             xmlns:camunda="http://camunda.org/schema/1.0/bpmn"
+             targetNamespace="Examples">
+
+  <process id="failingSubProcess" name="Failing SubProcess" isExecutable="true">
+
+    <startEvent id="start" />
+    <sequenceFlow id="flow1" sourceRef="start" targetRef="outerTask" />
+    <userTask id="outerTask" />
+    <sequenceFlow id="flow2" sourceRef="outerTask" targetRef="subProcess" />
+
+    <subProcess id="subProcess">
+      <startEvent id="subProcessStart" />
+      <sequenceFlow id="flow3" sourceRef="subProcessStart" targetRef="innerServiceTask" />
+      <serviceTask id="innerServiceTask" camunda:asyncBefore="true"
+                   camunda:class="org.camunda.bpm.engine.test.api.runtime.FailingDelegate" name="Service Task"/>
+      <sequenceFlow id="flow4" sourceRef="innerServiceTask" targetRef="subProcessEnd" />
+      <endEvent id="subProcessEnd" />
+    </subProcess>
+
+    <sequenceFlow id="flow5" sourceRef="subProcess" targetRef="end" />
+    <endEvent id="end" />
+
+  </process>
+
+</definitions>
diff --git a/engine/src/test/resources/org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.subprocessWithAsyncBeforeTask.bpmn20.xml b/engine/src/test/resources/org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.subprocessWithAsyncBeforeTask.bpmn20.xml
new file mode 100644
index 00000000000..a94192d7022
--- /dev/null
+++ b/engine/src/test/resources/org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.subprocessWithAsyncBeforeTask.bpmn20.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
+             xmlns:camunda="http://camunda.org/schema/1.0/bpmn"
+             targetNamespace="Examples">
+
+  <process id="failingSubProcess" name="Failing SubProcess" isExecutable="true">
+
+    <startEvent id="start" />
+    <sequenceFlow id="flow1" sourceRef="start" targetRef="outerTask" />
+    <userTask id="outerTask" />
+    <sequenceFlow id="flow2" sourceRef="outerTask" targetRef="subProcess" />
+
+    <subProcess id="subProcess">
+      <startEvent id="subProcessStart" />
+      <sequenceFlow id="flow3" sourceRef="subProcessStart" targetRef="innerTask" />
+      <userTask id="innerTask" />
+      <sequenceFlow id="flow4" sourceRef="innerTask" targetRef="subProcessEnd" />
+      <endEvent id="subProcessEnd" />
+    </subProcess>
+
+    <sequenceFlow id="flow5" sourceRef="subProcess" targetRef="end" />
+    <endEvent id="end" />
+
+  </process>
+
+</definitions>
diff --git a/engine/src/test/resources/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.testHistoricProcessInstanceQueryActivityIdInWithIncident.bpmn b/engine/src/test/resources/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.testHistoricProcessInstanceQueryActivityIdInWithIncident.bpmn
new file mode 100644
index 00000000000..83d72e92729
--- /dev/null
+++ b/engine/src/test/resources/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.testHistoricProcessInstanceQueryActivityIdInWithIncident.bpmn
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
+             xmlns:camunda="http://camunda.org/schema/1.0/bpmn"
+             targetNamespace="Examples">
+
+  <process id="failingProcess" name="Failing Process" isExecutable="true">
+
+    <startEvent id="start" />
+    <sequenceFlow id="flow1" sourceRef="start" targetRef="serviceTask" />
+    <serviceTask id="serviceTask" camunda:asyncBefore="true" camunda:class="org.camunda.bpm.engine.test.api.runtime.FailingDelegate" name="Service Task"/>
+    <sequenceFlow id="flow2" sourceRef="serviceTask" targetRef="end" />
+    <endEvent id="end" />
+
+  </process>
+
+</definitions>
\ No newline at end of file