Enterprise PACS Issues

Advanced issues encountered in enterprise PACS environments.

TLS/Security Certificate Issues

Symptom: DICOM connections fail with SSL/TLS errors

Root Causes:

• Expired certificates
• Hostname mismatch
• Missing intermediate CA certificates
• TLS version incompatibility

Diagnostic Script:

public class TlsDiagnostics
{
    public void DiagnoseConnection(string host, int port)
    {
        Console.WriteLine("=== TLS Connection Diagnostics ===\n");

        try
        {
            using (var client = new TcpClient(host, port))
            using (var sslStream = new SslStream(client.GetStream(), false,
                ValidateCertificate))
            {
                Console.WriteLine("1. Testing TLS connection...");

                try
                {
                    sslStream.AuthenticateAsClient(host);
                    Console.WriteLine("   TLS connection successful");
                    Console.WriteLine($"   Protocol: {sslStream.SslProtocol}");
                    Console.WriteLine($"   Cipher: {sslStream.CipherAlgorithm}");
                }
                catch (AuthenticationException ex)
                {
                    Console.WriteLine($"   TLS failed: {ex.Message}");
                    ProvideTlsGuidance(ex);
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Connection failed: {ex.Message}");
        }
    }

    private bool ValidateCertificate(object sender, X509Certificate certificate,
        X509Chain chain, SslPolicyErrors errors)
    {
        if (errors == SslPolicyErrors.None)
        {
            Console.WriteLine("   Certificate validation: PASSED");
            return true;
        }

        Console.WriteLine($"   Certificate errors: {errors}");

        if ((errors & SslPolicyErrors.RemoteCertificateChainErrors) != 0)
        {
            Console.WriteLine("   Chain status:");
            foreach (var status in chain.ChainStatus)
            {
                Console.WriteLine($"      - {status.StatusInformation}");
            }
        }

        if ((errors & SslPolicyErrors.RemoteCertificateNameMismatch) != 0)
        {
            Console.WriteLine($"   Certificate CN doesn't match hostname");
        }

        return false;
    }

    private void ProvideTlsGuidance(AuthenticationException ex)
    {
        if (ex.Message.Contains("expired"))
        {
            Console.WriteLine("   Fix: Renew the certificate");
        }
        else if (ex.Message.Contains("name mismatch"))
        {
            Console.WriteLine("   Fix: Use correct hostname or update certificate SAN");
        }
        else if (ex.Message.Contains("chain"))
        {
            Console.WriteLine("   Fix: Install intermediate CA certificates");
        }
    }
}

Database Performance Issues

Symptom: Slow queries, timeouts when searching for studies

Root Causes:

• Missing indexes
• Large tables without partitioning
• Statistics not updated
• Inefficient queries

Optimization Script:

-- Create indexes for common DICOM queries
CREATE INDEX IX_Studies_PatientID ON Studies(PatientID);
CREATE INDEX IX_Studies_StudyDate ON Studies(StudyDate);
CREATE INDEX IX_Studies_Modality ON Studies(ModalitiesInStudy);
CREATE INDEX IX_Studies_AccessionNumber ON Studies(AccessionNumber);

-- Composite index for common search patterns
CREATE INDEX IX_Studies_DateModality
ON Studies(StudyDate DESC, ModalitiesInStudy)
INCLUDE (PatientName, PatientID, StudyDescription, NumberOfInstances);

-- Partitioning by date for large tables
CREATE PARTITION FUNCTION PF_StudyDate (DATE)
AS RANGE RIGHT FOR VALUES (
    '2020-01-01', '2021-01-01', '2022-01-01',
    '2023-01-01', '2024-01-01', '2025-01-01'
);

CREATE PARTITION SCHEME PS_StudyDate
AS PARTITION PF_StudyDate ALL TO ([PRIMARY]);

-- Monitor slow queries
SELECT TOP 20
    qs.total_elapsed_time / qs.execution_count AS avg_elapsed_time,
    qs.execution_count,
    SUBSTRING(qt.text, qs.statement_start_offset/2 + 1,
        (CASE WHEN qs.statement_end_offset = -1
              THEN LEN(CONVERT(NVARCHAR(MAX), qt.text)) * 2
              ELSE qs.statement_end_offset
         END - qs.statement_start_offset) / 2 + 1) AS query_text
FROM sys.dm_exec_query_stats qs
CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) qt
WHERE qt.text LIKE '%Studies%'
ORDER BY avg_elapsed_time DESC;

Cloud Storage Cost Optimization

Symptom: High cloud storage costs for PACS archive

Solution - Lifecycle Policies:

public class CloudStorageOptimizer
{
    // AWS S3 Lifecycle Policy Example
    public string GetS3LifecyclePolicy()
    {
        return @"{
            'Rules': [
                {
                    'ID': 'PACS-Archive-Policy',
                    'Status': 'Enabled',
                    'Filter': { 'Prefix': 'dicom/' },
                    'Transitions': [
                        {
                            'Days': 90,
                            'StorageClass': 'STANDARD_IA'
                        },
                        {
                            'Days': 365,
                            'StorageClass': 'GLACIER'
                        },
                        {
                            'Days': 2555,
                            'StorageClass': 'DEEP_ARCHIVE'
                        }
                    ]
                }
            ]
        }";
    }

    // Azure Blob Lifecycle Policy
    public string GetAzureLifecyclePolicy()
    {
        return @"{
            'rules': [
                {
                    'name': 'PACS-Archive-Rule',
                    'enabled': true,
                    'type': 'Lifecycle',
                    'definition': {
                        'actions': {
                            'baseBlob': {
                                'tierToCool': { 'daysAfterModificationGreaterThan': 90 },
                                'tierToArchive': { 'daysAfterModificationGreaterThan': 365 }
                            }
                        },
                        'filters': {
                            'blobTypes': ['blockBlob'],
                            'prefixMatch': ['dicom/']
                        }
                    }
                }
            ]
        }";
    }
}

Storage Tier Comparison:

Memory Leak Prevention

Symptom: Application memory grows over time, eventual crashes

Prevention Patterns:

public class MemoryEfficientDicomHandler : IDisposable
{
    private bool disposed = false;

    // GOOD: Proper resource disposal
    public void ProcessFilesCorrectly(List<string> files)
    {
        foreach (string file in files)
        {
            // Each image is disposed after processing
            using (DicomImage image = new DicomImage(file))
            {
                ProcessImage(image);
            } // Disposed here
        }
    }

    // BAD: Memory leak pattern (don't do this)
    public void ProcessFilesWithLeak(List<string> files)
    {
        var images = new List<DicomImage>();

        foreach (string file in files)
        {
            // Images accumulate in memory!
            images.Add(new DicomImage(file));
        }

        // Even if you process them, memory isn't released
        foreach (var image in images)
        {
            ProcessImage(image);
            // No disposal!
        }
    }

    // GOOD: Association disposal
    public void SendWithProperCleanup(string file)
    {
        DicomAssociation association = null;
        try
        {
            association = new DicomAssociation
            {
                CallingAETitle = "SCU",
                CalledAETitle = "SCP",
                Host = "localhost",
                Port = 104
            };

            association.Open();
            // ... send operations ...
        }
        finally
        {
            // Always close and dispose
            if (association?.IsOpen == true)
            {
                association.Close();
            }
            association?.Dispose();
        }
    }

    private void ProcessImage(DicomImage image) { /* ... */ }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                // Dispose managed resources
            }
            disposed = true;
        }
    }
}

Multi-Site PACS Routing

Symptom: Images not routing correctly between sites

Solution:

public class MultiSiteRouter
{
    private Dictionary<string, List<DicomDestination>> routingTable;

    public MultiSiteRouter()
    {
        // Configure routing based on modality/site
        routingTable = new Dictionary<string, List<DicomDestination>>
        {
            ["CT"] = new List<DicomDestination>
            {
                new DicomDestination("PACS_MAIN", "192.168.1.100", 104),
                new DicomDestination("PACS_DR", "192.168.2.100", 104)
            },
            ["MR"] = new List<DicomDestination>
            {
                new DicomDestination("PACS_MAIN", "192.168.1.100", 104),
                new DicomDestination("NEURO_PACS", "192.168.3.100", 104)
            }
        };
    }

    public async Task RouteStudy(DicomDataSet study)
    {
        string modality = study[DicomTag.Modality]?.Value?.ToString() ?? "OT";

        if (!routingTable.ContainsKey(modality))
        {
            Console.WriteLine($"No routing rule for modality: {modality}");
            return;
        }

        var destinations = routingTable[modality];

        // Send to all configured destinations in parallel
        var tasks = destinations.Select(async dest =>
        {
            try
            {
                await SendToDestination(study, dest);
                Console.WriteLine($"Sent to {dest.AETitle}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Failed to send to {dest.AETitle}: {ex.Message}");
                // Queue for retry
                QueueForRetry(study, dest);
            }
        });

        await Task.WhenAll(tasks);
    }

    private async Task SendToDestination(DicomDataSet study, DicomDestination dest)
    {
        // Implementation
    }

    private void QueueForRetry(DicomDataSet study, DicomDestination dest)
    {
        // Implementation
    }
}

public class DicomDestination
{
    public string AETitle { get; set; }
    public string Host { get; set; }
    public int Port { get; set; }

    public DicomDestination(string aeTitle, string host, int port)
    {
        AETitle = aeTitle;
        Host = host;
        Port = port;
    }
}

Summary

Enterprise PACS management requires attention to security, performance, and cost optimization.