Eseguire l'escalation di un processo
Questa guida illustra come inoltrare un processo in una coda usando un criterio di eccezione.
Prerequisiti
- Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
- Una risorsa di Servizi di comunicazione distribuita. Creare una risorsa di Servizi di comunicazione.
- Facoltativo: Completare la guida introduttiva per iniziare a usare Il router di processo
- Facoltativo: esaminare la guida pratica alla classificazione dei processi
Panoramica dell'escalation
L'escalation può assumere la forma di diversi comportamenti, tra cui lo spostamento di un processo in una coda diversa e/o la specifica di una priorità più alta. I processi con priorità più alta vengono distribuiti ai ruoli di lavoro prima che i processi abbiano una priorità più bassa. Per questa guida pratica si usano criteri di classificazione e criteri di eccezione e per raggiungere questo obiettivo.
Configurazione dei criteri di classificazione
Creare un criterio di classificazione per gestire la nuova etichetta aggiunta al processo. Questo criterio valuta l'etichetta Escalated e assegna il processo a una delle due code. Il criterio usa anche il motore regole per aumentare la priorità del processo da 1 a 10.
var classificationPolicy = await administrationClient.CreateClassificationPolicyAsync(
new CreateClassificationPolicyOptions(classificationPolicyId: "Classify_XBOX_Voice_Jobs")
{
Name = "Classify XBOX Voice Jobs",
QueueSelectorAttachments =
{
new ConditionalQueueSelectorAttachment(
condition: new ExpressionRouterRule("job.Escalated = true"),
queueSelectors: new List<RouterQueueSelector>
{
new (key: "Id", labelOperator: LabelOperator.Equal, value: new RouterValue("XBOX_Escalation_Queue"))
})
},
PrioritizationRule = new ExpressionRouterRule("If(job.Escalated = true, 10, 1)"),
});
var classificationPolicy = await client.path("/routing/classificationPolicies/{classificationPolicyId}", "Classify_XBOX_Voice_Jobs").patch({
body: {
name: "Classify XBOX Voice Jobs",
queueSelectorAttachments: [{
kind: "conditional",
condition: {
kind: "expression",
expression: 'job.Escalated = true'
},
queueSelectors: [{
key: "Id",
labelOperator: "equal",
value: "XBOX_Escalation_Queue"
}]
}],
prioritizationRule: {
kind: "expression",
expression: "If(job.Escalated = true, 10, 1)"
}
},
contentType: "application/merge-patch+json"
});
classification_policy: ClassificationPolicy = administration_client.upsert_classification_policy(
classification_policy_id = "Classify_XBOX_Voice_Jobs",
name = "Classify XBOX Voice Jobs",
queue_selector_attachments = [
ConditionalQueueSelectorAttachment(
condition = ExpressionRouterRule(expression = 'job.Escalated = true'),
queue_selectors = [
RouterQueueSelector(key = "Id", label_operator = LabelOperator.EQUAL, value = "XBOX_Escalation_Queue")
]
)
],
prioritization_rule = ExpressionRouterRule(expression = "If(job.Escalated = true, 10, 1)")))
ClassificationPolicy classificationPolicy = administrationClient.createClassificationPolicy(
new CreateClassificationPolicyOptions("Classify_XBOX_Voice_Jobs")
.setName("Classify XBOX Voice Jobs")
.setQueueSelectorAttachments(List.of(new ConditionalQueueSelectorAttachment(
new ExpressionRouterRule("job.Escalated = true"),
List.of(new RouterQueueSelector("Id", LabelOperator.EQUAL, new RouterValue("XBOX_Escalation_Queue"))))))
.setPrioritizationRule(new ExpressionRouterRule("If(job.Escalated = true, 10, 1)")));
Configurazione dei criteri di eccezione
Creare un criterio di eccezione associato alla coda, che è il tempo attivato e esegue l'azione del processo da riclassificare.
var exceptionPolicy = await administrationClient.CreateExceptionPolicyAsync(new CreateExceptionPolicyOptions(
exceptionPolicyId: "Escalate_XBOX_Policy",
exceptionRules: new List<ExceptionRule>
{
new(
id: "Escalated_Rule",
trigger: new WaitTimeExceptionTrigger(TimeSpan.FromMinutes(5)),
actions: new List<ExceptionAction>
{
new ReclassifyExceptionAction(classificationPolicyId: classificationPolicy.Value.Id)
{
LabelsToUpsert = { ["Escalated"] = new RouterValue(true) }
}
}
)
}) { Name = "Add escalated label and reclassify XBOX Job requests after 5 minutes" });
await client.path("/routing/exceptionPolicies/{exceptionPolicyId}", "Escalate_XBOX_Policy").patch({
body: {
name: "Add escalated label and reclassify XBOX Job requests after 5 minutes",
exceptionRules: [
{
id: "Escalated_Rule",
trigger: { kind: "waitTime", thresholdSeconds: 5 * 60 },
actions: [{ kind: "reclassify", classificationPolicyId: classificationPolicy.body.id, labelsToUpsert: { Escalated: true }}]
}]
},
contentType: "application/merge-patch+json"
});
administration_client.upsert_exception_policy(
exception_policy_id = "Escalate_XBOX_Policy",
name = "Add escalated label and reclassify XBOX Job requests after 5 minutes",
exception_rules = [
ExceptionRule(
id = "Escalated_Rule",
trigger = WaitTimeExceptionTrigger(threshold_seconds = 5 * 60),
actions = [ReclassifyExceptionAction(
classification_policy_id = classification_policy.id,
labels_to_upsert = { "Escalated": True }
)]
)
]
)
administrationClient.createExceptionPolicy(new CreateExceptionPolicyOptions("Escalate_XBOX_Policy",
List.of(new ExceptionAction("Escalated_Rule", new WaitTimeExceptionTrigger(5 * 60),
List.of(new ReclassifyExceptionAction()
.setClassificationPolicyId(classificationPolicy.getId())
.setLabelsToUpsert(Map.of("Escalated", new RouterValue(true))))))
).setName("Add escalated label and reclassify XBOX Job requests after 5 minutes"));
Configurazione della coda
Creare le code necessarie per i processi regolari ed inoltrati e assegnare i criteri di eccezione alla normale coda.
Nota
Questo passaggio presuppone che siano già stati creati criteri di distribuzione con il nome di Round_Robin_Policy.
var defaultQueue = await administrationClient.CreateQueueAsync(
new CreateQueueOptions(queueId: "XBOX_Queue", distributionPolicyId: "Round_Robin_Policy")
{
Name = "XBOX Queue",
ExceptionPolicyId = exceptionPolicy.Value.Id
});
var escalationQueue = await administrationClient.CreateQueueAsync(
new CreateQueueOptions(queueId: "XBOX_Escalation_Queue", distributionPolicyId: "Round_Robin_Policy")
{
Name = "XBOX Escalation Queue"
});
await administrationClient.path("/routing/queues/{queueId}", "XBOX_Queue").patch({
body: {
distributionPolicyId: "Round_Robin_Policy",
exceptionPolicyId: exceptionPolicy.body.id,
name: "XBOX Queue"
},
contentType: "application/merge-patch+json"
});
await administrationClient.path("/routing/queues/{queueId}", "XBOX_Escalation_Queue").patch({
body: {
distributionPolicyId: "Round_Robin_Policy",
name: "XBOX Escalation Queue"
},
contentType: "application/merge-patch+json"
});
administration_client.upsert_queue(
queue_id = "XBOX_Queue",
distribution_policy_id = "Round_Robin_Policy",
exception_policy_id = exception_policy.id,
name = "XBOX Queue")
administration_client.upsert_queue(
queue_id = "XBOX_Escalation_Queue",
distribution_policy_id = "Round_Robin_Policy",
name = "XBOX Escalation Queue")
administrationClient.createQueue(new CreateQueueOptions("XBOX_Queue", "Round_Robin_Policy")
.setExceptionPolicyId(exceptionPolicy.getId())
.setName("XBOX Queue"));
administrationClient.createQueue(new CreateQueueOptions("XBOX_Escalation_Queue", "Round_Robin_Policy")
.setName("XBOX Escalation Queue"));
Ciclo di vita dei processi
Quando si invia il processo, questo viene aggiunto alla coda XBOX_Queue con il voice canale. Per questo particolare esempio, il requisito consiste nel trovare un ruolo di lavoro con un'etichetta denominata XBOX_Hardware, che ha un valore maggiore o uguale al numero 7.
await client.CreateJobAsync(new CreateJobOptions(jobId: "job1", channelId: "voice", queueId: defaultQueue.Value.Id)
{
RequestedWorkerSelectors =
{
new RouterWorkerSelector(key: "XBOX_Hardware", labelOperator: LabelOperator.GreaterThanOrEqual, value: new RouterValue(7))
}
});
var job = await client.path("/routing/jobs/{jobId}", "job1").patch({
body: {
channelId: "voice",
queueId: defaultQueue.body.id,
requestedWorkerSelectors: [{ key: "XBOX_Hardware", labelOperator: "GreaterThanOrEqual", value: 7 }]
},
contentType: "application/merge-patch+json"
});
administration_client.upsert_job(
job_id = "job1",
channel_id = "voice",
queue_id = default_queue.id,
requested_worker_selectors = [
RouterWorkerSelector(key = "XBOX_Hardware", label_operator = LabelOperator.GreaterThanOrEqual, value = 7)
])
administrationClient.createJob(new CreateJobOptions("job1", "voice", defaultQueue.getId())
.setRequestedWorkerSelectors(List.of(
new RouterWorkerSelector("XBOX_Hardware", LabelOperator.GREATER_THAN_OR_EQUAL, new RouterValue(7)))));
Dopo il completamento della configurazione e l'invio del processo vengono eseguiti i passaggi del ciclo di vita seguenti:
- Il processo viene inviato al router processo e produce gli
RouterJobReceivedeventi eRouterJobQueued. - Successivamente, viene avviato il timer di 5 minuti e viene attivato se non viene assegnato alcun ruolo di lavoro corrispondente. Dopo 5 minuti, Job Router genera un
RouterJobExceptionTriggeredevento e un altroRouterJobQueued. - A questo punto, il processo passa a
XBOX_Escalation_Queuee la priorità è impostata su10.