Mantenimiento de archivos de registro de un cierto tamaño

Question

Tengo una aplicación que se ejecuta en una PC con panel independiente en un kiosco (C#/WPF). Realiza algunas operaciones típicas de registro en un archivo de texto. La PC tiene una cantidad limitada de espacio en disco para almacenar estos registros a medida que crecen.

Lo que necesito hacer es poder especificar el tamaño máximo que un archivo de registro puede tener. Si, al intentar escribir en el registro, se excede el tamaño máximo, se escribirán nuevos datos al final del registro y los datos más antiguos se purgarán desde el principio.

Obtener el tamaño del archivo no es un problema, pero ¿hay alguna técnica típica de manipulación de archivos para mantener un archivo de cierto tamaño?

Answer 1

Una técnica para manejar esto es tener dos archivos de registro que son la mitad del tamaño máximo de cada uno. Simplemente gira entre los dos al alcanzar el tamaño máximo de cada archivo. Al girar a un archivo, se sobrescribe con un nuevo archivo.

Un marco de registro como log4net tiene esta funcionalidad incorporada.

Answer 2

No hay manera fácil de pelar los datos desde el principio del archivo. Entonces tiene varias opciones:

1. Mantenga el registro en varios archivos de registro más pequeños y elimine los "fragmentos" más antiguos si el tamaño total de todos los archivos de registro excede su límite. Esto es similar a lo que desea hacer, pero en un nivel diferente
2. Cambie el nombre del archivo de registro a "log.date" e inicie un nuevo registro. Similar a (1) pero no es una opción si tiene espacio de disco limitado.
3. SI tiene suficiente RAM y su tamaño de registro es relativamente pequeño para caber en la memoria, puede hacer lo siguiente: mapear todo el archivo en memoria utilizando un archivo mapeado en memoria, luego realizar la operación de movimiento tomando los datos del centro de el archivo y moverlos al principio. Luego trunca el archivo. Esta es la única forma de eliminar fácilmente los datos desde el comienzo del archivo de registro sin crear una copia.

Answer 3

Linux OS: consulta logrotate - http://www.cyberciti.biz/faq/how-do-i-rotate-log-files/

sistema operativo WINDOWS: tratar googlear ventanas logrotate. por ejemplo: http://blog.arithm.com/2008/02/07/windows-log-file-rotation/

Answer 4

Trate de usar Log4net

http://www.codeproject.com/KB/aspnet/log4net.aspx

Answer 5

yo no usaría esto para un archivo destinado a ser más decir 1 Meg y no es muy eficiente, pero funciona bien si es necesario resuelve un problema molesto de cuando necesitas un archivo de registro que no puedes mantener cómodamente. Asegúrese de que el archivo de registro exista antes de usar esto ... o podría agregar código para él así como también verificar la ubicación, etc.

// This is how to call it 
private void buttonLog_Click(object sender, EventArgs e) 
{ 
    c_Log.writeToFile(textBoxMessages.Text, "../../log.log", 1); 
} 


public static class c_Log 
{ 
    static int iMaxLogLength = 15000; // Probably should be bigger, say 200,000 
    static int iTrimmedLogLength = -1000; // minimum of how much of the old log to leave 

    static public void writeToFile(string strNewLogMessage, string strFile, int iLogLevel) 
    { 
     try 
     { 
      FileInfo fi = new FileInfo(strFile); 

      Byte[] bytesSavedFromEndOfOldLog = null; 

      if (fi.Length > iMaxLogLength) // if the log file length is already too long 
      { 
       using (BinaryReader br = new BinaryReader(File.Open(strFile, FileMode.Open))) 
       { 
        // Seek to our required position of what you want saved. 
        br.BaseStream.Seek(iTrimmedLogLength, SeekOrigin.End); 

        // Read what you want to save and hang onto it. 
        bytesSavedFromEndOfOldLog = br.ReadBytes((-1 * iTrimmedLogLength)); 
       } 
      } 

      byte[] newLine = System.Text.ASCIIEncoding.ASCII.GetBytes(Environment.NewLine); 

      FileStream fs = null; 
      // If the log file is less than the max length, just open it at the end to write there 
      if (fi.Length < iMaxLogLength) 
       fs = new FileStream(strFile, FileMode.Append, FileAccess.Write, FileShare.Read); 
      else // If the log file is more than the max length, just open it empty 
       fs = new FileStream(strFile, FileMode.Create, FileAccess.Write, FileShare.Read); 

      using (fs) 
      { 
       // If you are trimming the file length, write what you saved. 
       if (bytesSavedFromEndOfOldLog != null) 
       { 
        Byte[] lineBreak = Encoding.ASCII.GetBytes("### " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + " *** *** *** Old Log Start Position *** *** *** *** ###"); 
        fs.Write(newLine, 0, newLine.Length); 
        fs.Write(newLine, 0, newLine.Length); 
        fs.Write(lineBreak, 0, lineBreak.Length); 
        fs.Write(newLine, 0, newLine.Length); 
        fs.Write(bytesSavedFromEndOfOldLog, 0, bytesSavedFromEndOfOldLog.Length); 
        fs.Write(newLine, 0, newLine.Length); 
       } 
       Byte[] sendBytes = Encoding.ASCII.GetBytes(strNewLogMessage); 
       // Append your last log message. 
       fs.Write(sendBytes, 0, sendBytes.Length); 
       fs.Write(newLine, 0, newLine.Length); 
      } 
     } 
     catch (Exception ex) 
     { 
      ; // Nothing to do... 
       //writeEvent("writeToFile() Failed to write to logfile : " + ex.Message + "...", 5); 
     } 
    } 
}