Memory Leak In C# Windows Service

I'm not a big fan of posting code, but I'm having a terrible time determining where the memory leak is coming from in this Windows Service that I'm writing.  What the service is doing, is pulling a list of records from a database about some images, then goes and does some moving of the images/resizing and gets the info from them (height, width, size, etc.) and puts that data in a different table.  However, as the title explains, there's a memory leak somewhere in here and I don't know what else to do.  I've tried disposing and getting rid of all the objects I can, but maybe I'm doing it wrong or just missing something.  Here's the service code:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.ServiceProcess;
using System.Text;
using NHibernate;
using NHibernate.Expression;
using System.Configuration;
using System.IO;
using System.Reflection;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Timers;

namespace RodunuPhlogger
{
    public partial class Service1 : ServiceBase
    {
        private static TraceSwitch _DebugLevel = new TraceSwitch("DebugLevel", "The output level of tracing");
        private static string logfile;
        private static ISession m_Session;
        private static System.Collections.IList aReadyToMove = null;
        private static Timer phlogTimer = null;

        // set values from config file
        private static string LOGS = ConfigurationManager.AppSettings["LogDirectory"];
        private static string RODUNU_USERS_DIR = ConfigurationManager.AppSettings["RodunuUsersDir"]; //"C:\\Rodunu\\Users\\";
        private static string UTEMP_PHLOG_DIR = ConfigurationManager.AppSettings["UTempPhlogDir"];
        private static string UPROD_PHLOG_DIR = ConfigurationManager.AppSettings["UProdPhlogDir"];
        private static int MAX_PROCESS = Convert.ToInt32(ConfigurationManager.AppSettings["MaxProcess"]);

        public Service1()
        {
            InitializeComponent();
        }

        protected override void OnStart(string[] args)
        {
            StartPhlogger();
        }

        protected override void OnStop()
        {
            // TODO: Add code here to perform any tear-down necessary to stop your service.
        }

        public static void StartPhlogger()
        {
            if (!Directory.Exists(LOGS))
            {
                Directory.CreateDirectory(LOGS);
            }

            logfile = Path.Combine(LOGS, "PhloggerLogger.txt");
            Trace.AutoFlush = true;
            Trace.Listeners.Add(new TextWriterTraceListener(logfile, "RodunuListener"));
            Trace.WriteLineIf(_DebugLevel.TraceVerbose, string.Format("{0}: Application startup.", DateTime.Now));

            StartTimer();
        }

        private static void StartTimer()
        {
            if (phlogTimer == null)
            {
                phlogTimer = new Timer(Convert.ToInt32(ConfigurationManager.AppSettings["TimerInterval"]));
                phlogTimer.Elapsed += new ElapsedEventHandler(ProcessImages);
                phlogTimer.Enabled = true;
            }
           
            phlogTimer.Start();
        }

        private static void StopTimer()
        {
            phlogTimer.Stop();
        }

        private static void ProcessImages(object sender, ElapsedEventArgs e)
        {
            StopTimer();

            m_Session = DBHelper.LoadSession();
            aReadyToMove = m_Session.CreateCriteria(typeof(ModulePhlogPending))
                .Add(Expression.Eq("Mppprocessed", 1))
                .AddOrder(Order.Asc("Mppedate"))
                .SetMaxResults(MAX_PROCESS)
                .List();

            m_Session.Close();
            m_Session.Dispose();

            foreach (ModulePhlogPending mppRecord in aReadyToMove)
            {
                if (File.Exists(RODUNU_USERS_DIR + mppRecord.Mppfpath + UTEMP_PHLOG_DIR + mppRecord.Mppimgfilename))
                {
                    string tempFilePath = RODUNU_USERS_DIR + mppRecord.Mppfpath + UTEMP_PHLOG_DIR;
                    string prodFilePath = RODUNU_USERS_DIR + mppRecord.Mppfpath + UPROD_PHLOG_DIR;
                    StreamReader mainSR = null;
                    StreamReader thumbSR = null;
                    Image mainImage = null;
                    Image thumbImage = null;
                    long mainFileSize = 0;
                    long thumbFileSize = 0;
                    long totalFileSize = 0;

                    if (!Directory.Exists(prodFilePath))
                    {
                        Directory.CreateDirectory(prodFilePath);
                    }

                    try
                    {
                        int extLength = 0;

                        // quickly slap "_thumb.jpg" at the end.
                        if (mppRecord.Mppimgfilename.Contains(".jpg") || mppRecord.Mppimgfilename.Contains(".gif"))
                        {
                            extLength = 4;
                        }
                        else if (mppRecord.Mppimgfilename.Contains(".jpeg"))
                        {
                            extLength = 5;
                        }

                        string FileName = mppRecord.Mppimgfilename.ToLower();
                        string NewFileName = FileName.Substring(0, (FileName.Length - extLength)) + "_thumb.jpg";

                        File.Move(tempFilePath + FileName, prodFilePath + FileName);

                        // call our thumbnail function
                        QuickSnip.ResizeImage(150, 150, prodFilePath + FileName, prodFilePath + NewFileName);

                        // get filesize of our main image
                        mainSR = new StreamReader(prodFilePath + FileName);
                        mainFileSize = mainSR.BaseStream.Length;

                        // get filesize of our thumbnail
                        thumbSR = new StreamReader(prodFilePath + NewFileName);
                        thumbFileSize = thumbSR.BaseStream.Length;

                        // get total disk space being used
                        totalFileSize = mainFileSize + thumbFileSize;

                        // create our new image files
                        mainImage = Image.FromStream(mainSR.BaseStream);
                        thumbImage = Image.FromStream(thumbSR.BaseStream);

                        // get height and width of images
                        int mainImageWidth = mainImage.Width;
                        int mainImageHeight = mainImage.Height;
                        int thumbImageWidth = thumbImage.Width;
                        int thumbImageHeight = thumbImage.Height;

                        // start our first transaction session
                        m_Session = DBHelper.LoadSession();
                        ITransaction it = m_Session.BeginTransaction();

                        try
                        {
                            // now we create a new record in the database
                            ModulePhlog mpPhlog = new ModulePhlog();

                            mpPhlog.Mpfilepath = mppRecord.Mppfpath;
                            mpPhlog.Mpfilesize = mainFileSize;
                            mpPhlog.Mptotalfilesize = totalFileSize;
                            mpPhlog.Mpheight = mainImageHeight;
                            mpPhlog.Mpwidth = mainImageWidth;
                            mpPhlog.Mpimagename = FileName;
                            mpPhlog.Mppdate = DateTime.Now;
                            mpPhlog.Mptext = mppRecord.Mpptext;
                            mpPhlog.Uid = mppRecord.Uid;
                            mpPhlog.Mpthumbfilesize = thumbFileSize;
                            mpPhlog.Mpthumbheight = thumbImageHeight;
                            mpPhlog.Mpthumbwidth = thumbImageWidth;

                            m_Session.Save(mpPhlog);
                        }
                        catch (Exception ex)
                        {
                            // log the error
                            Trace.TraceError("{0}: [class]: {1} " + Environment.NewLine +
                                             "\t[method]: {2} " + Environment.NewLine +
                                             "\t[message]: {3} " + Environment.NewLine +
                                             "\t[stack]: {4}",
                                new object[]
                                    {
                                        DateTime.Now, // when did the error happen
                                        MethodInfo.GetCurrentMethod().DeclaringType.Name, // the class name
                                        MethodInfo.GetCurrentMethod().Name, // the method name
                                        ex.Message, // the error message
                                        ex.StackTrace // the stack trace information
                                    });
                        }
                        finally
                        {
                            CleanUp(ref it, ref m_Session);
                        }

                        ISession m_SessionNew = DBHelper.LoadSession();
                        ITransaction itNew = m_SessionNew.BeginTransaction();

                        try
                        {
                            mppRecord.Mppprocessed = 2;
                            m_SessionNew.Update(mppRecord, mppRecord.Mppid);
                            m_SessionNew.Save(mppRecord);
                        }
                        catch (Exception ex)
                        {
                            // log the error
                            Trace.TraceError("{0}: [class]: {1} " + Environment.NewLine +
                                             "\t[method]: {2} " + Environment.NewLine +
                                             "\t[message]: {3} " + Environment.NewLine +
                                             "\t[stack]: {4}",
                                new object[]
                                    {
                                        DateTime.Now, // when did the error happen
                                        MethodInfo.GetCurrentMethod().DeclaringType.Name, // the class name
                                        MethodInfo.GetCurrentMethod().Name, // the method name
                                        ex.Message, // the error message
                                        ex.StackTrace // the stack trace information
                                    });
                        }
                        finally
                        {
                            CleanUp(ref itNew, ref m_SessionNew);
                        }
                    }
                    catch (System.Exception ex)
                    {
                        // log the error
                        Trace.TraceError("{0}: [class]: {1} " + Environment.NewLine +
                                         "\t[method]: {2} " + Environment.NewLine +
                                         "\t[message]: {3} " + Environment.NewLine +
                                         "\t[stack]: {4}",
                            new object[]
                                    {
                                        DateTime.Now, // when did the error happen
                                        MethodInfo.GetCurrentMethod().DeclaringType.Name, // the class name
                                        MethodInfo.GetCurrentMethod().Name, // the method name
                                        ex.Message, // the error message
                                        ex.StackTrace // the stack trace information
                                    });
                    }
                    finally
                    {
                        // release mainSR StreamReader
                        mainSR.Close();
                        mainSR.Dispose();
                        mainSR = null;

                        // release thumbSR StreamReader
                        thumbSR.Close();
                        thumbSR.Dispose();
                        thumbSR = null;

                        // reset longs
                        mainFileSize = 0;
                        thumbFileSize = 0;
                        totalFileSize = 0;
                    }
                }
            }
            StartTimer();
        }

        private static void CleanUp(ref ITransaction it, ref ISession session)
        {
            if (it != null)
            {
                it.Commit();
                it.Dispose();
                it = null;
            }

            if (session != null)
            {
                session.Close();
                session.Dispose();
                session = null;
            }
        }
    }
}