docs: public boolean lock(KeyColumn kc, T requestor, Instant expires) {
          assert null != kc;
          assert null != requestor;
  
          final StackTraceElement[] acquiredAt = log.isTraceEnabled() ?
                  new Throwable("Lock acquisition by " + requestor).getStackTrace() : null;
  
          AuditRecord<T> audit = new AuditRecord<T>(requestor, expires, acquiredAt);
          AuditRecord<T> inmap = locks.putIfAbsent(kc, audit);
  
          boolean success = false;
  
          if (null == inmap) {
              // Uncontended lock succeeded
              if (log.isTraceEnabled()) {
                  log.trace("New local lock created: {} namespace={} txn={}",
                          new Object[]{kc, name, requestor});
              }
              success = true;
          } else if (inmap.equals(audit)) {
              // requestor has already locked kc; update expiresAt
              success = locks.replace(kc, inmap, audit);
              if (log.isTraceEnabled()) {
                  if (success) {
                      log.trace(
                              "Updated local lock expiration: {} namespace={} txn={} oldexp={} newexp={}",
                              new Object[]{kc, name, requestor, inmap.expires,
                                      audit.expires});
                  } else {
                      log.trace(
                              "Failed to update local lock expiration: {} namespace={} txn={} oldexp={} newexp={}",
                              new Object[]{kc, name, requestor, inmap.expires,
                                      audit.expires});
                  }
              }
          } else if (0 > inmap.expires.compareTo(times.getTime())) {
              // the recorded lock has expired; replace it
              success = locks.replace(kc, inmap, audit);
              if (log.isTraceEnabled()) {
                  log.trace(
                          "Discarding expired lock: {} namespace={} txn={} expired={}",
                          new Object[]{kc, name, inmap.holder, inmap.expires});
              }
          } else {
              // we lost to a valid lock
              if (log.isTraceEnabled()) {
                  log.trace(
                          "Local lock failed: {} namespace={} txn={} (already owned by {})",
                          new Object[]{kc, name, requestor, inmap});
                  log.trace("Owner stacktrace:\n        {}", Joiner.on("\n        ").join(inmap.acquiredAt));
              }
          }
  
          return success;
      }