h.currentMinute = serviceRTTMinuteStats{
		statsTime: currReqMinute,
	}
}

func (h *metrics) accumRequestRTT(reqStartTime time.Time, rttMs float64, isSuccess bool) {
	h.Lock()
	defer h.Unlock()

	// Update connectivity times
	if isSuccess {
		if reqStartTime.After(h.LastCheckSuccess) {
			h.LastCheckSuccess = reqStartTime
		}
	} else {
		if reqStartTime.After(h.LastCheckFailure) {

                        if (lastResult.isSuccess() && composePath.isPresent()) {
                            isComposeAvailable = runCommand(composePath.get(), "version").isSuccess();
                        }
                    }
                }
            }

            boolean isAvailable = isVersionHighEnough && lastResult != null && lastResult.isSuccess();

                request.setFlags(registration.getFlags());
                
                WitnessRegisterResponse response = rpcClient.register(request);
                
                if (response.isSuccess()) {
                    registration.setState(WitnessRegistrationState.REGISTERED);
                    registrations.put(registration.getRegistrationId(), registration);

    public ArtifactResolutionResult setUnresolvedArtifacts(final List<Artifact> unresolvedArtifacts) {
        this.missingArtifacts = unresolvedArtifacts;

        return this;
    }

    public boolean isSuccess() {
        return !(hasMissingArtifacts() || hasExceptions());
    }

    // ------------------------------------------------------------------------
    // Exceptions

        lenient().when(registerResponse.isSuccess()).thenReturn(true);
        lenient().when(registerResponse.getRegistrationId()).thenReturn("test-reg-123");

        // Setup successful unregistration
        WitnessUnregisterResponse unregisterResponse = mock(WitnessUnregisterResponse.class);
        lenient().when(unregisterResponse.isSuccess()).thenReturn(true);

            // Create response from RPC message results
            WitnessRegisterResponse response = new WitnessRegisterResponse();
            response.setReturnCode(message.getReturnCode());

            if (message.isSuccess()) {
                // Generate registration ID from context handle
                byte[] contextHandle = message.getContextHandle();

                request.setFlags(registration.getFlags());

                WitnessRegisterResponse response = rpcClient.register(request);

                if (response != null && response.isSuccess()) {
                    registration.setState(WitnessRegistrationState.REGISTERED);
                    registration.setContextHandle(response.getContextHandle());

            return info;
        }
        return null;
    }
    
    public void completeReconnect(String path, boolean success) {
        HandleInfo info = handles.get(path);
        if (info != null) {
            if (success) {
                info.updateAccessTime();
                info.reconnecting = false;
            } else {
                // Remove failed handle

    
    public void recordOperation(String channelId, long bytes, long latency, boolean success) {
        ChannelStatistics stats = channelStats.computeIfAbsent(channelId, 
            k -> new ChannelStatistics());
            
        stats.operations.incrementAndGet();
        stats.latencyTotal.addAndGet(latency);
        
        if (success) {
            stats.bytesReceived.addAndGet(bytes);
        } else {

        // TODO: Integration point - send request through session.send()
        // Smb2IoctlResponse response = (Smb2IoctlResponse) session.send(request);
        // if (response.isSuccess()) {
        //     parseNetworkInterfaces(response.getOutputData());
        // }

        log.debug("FSCTL_QUERY_NETWORK_INTERFACE_INFO prepared but needs session integration");
    }