code: func (e *engineImpl) kickTriageNow(c context.Context, jobID string) error {
  	assertNotInTransaction(c)
  
  	c = logging.SetField(c, "JobID", jobID)
  
  	// Throttle to once per 2 sec (and make sure it is always in the future).
  	eta := clock.Now(c).Unix()
  	eta = (eta/2 + 1) * 2
  	dedupKey := fmt.Sprintf("triage:%s:%d", jobID, eta)
  
  	// Use cheaper but crappier memcache as a first dedup check.
  	itm := memcache.NewItem(c, dedupKey).SetExpiration(time.Minute)
  	if memcache.Get(c, itm) == nil {
  		logging.Infof(c, "The triage task has already been scheduled")
  		return nil
  	}
  
  	// Enqueue the triage task, if not already there. This is rock solid, but slow
  	// second dedup check.
  	err := e.cfg.Dispatcher.AddTask(c, &tq.Task{
  		DeduplicationKey: dedupKey,
  		ETA:              time.Unix(eta, 0),
  		Payload:          &internal.TriageJobStateTask{JobId: jobID},
  	})
  	if err != nil {
  		return err
  	}
  	logging.Infof(c, "Scheduled the triage task")
  
  	// Best effort in setting dedup memcache flag. No big deal if it fails.
  	if err := memcache.Set(c, itm); err != nil {
  		logging.WithError(err).Warningf(c, "Failed to set memcache triage flag")
  	}
  
  	return nil
  }
docs: ////////////////////////////////////////////////////////////////////////////////
  // Triage procedure.
  // kickTriageNow enqueues a task to perform a triage for some job, if no such
  // task was enqueued recently.
  //
  // Does it even if the job no longer exists or has been disabled. Such triage
  // will just be skipped later.
  //
  // Uses named tasks and memcache internally, thus can't be part of a
  // transaction. If you want to kick the triage transactionally, use
  // kickTriageLater().