¿Es posible obtener por código la línea o posición en donde se ha detectado un error?
 

Buenas a todos los foristas

Tengo una simple duda: ¿Es posible obtener la línea o posición en donde se ha lanzado una excepción, mediante código?

Me explicaré con mayor profundidad: en la Cara Oculta de Delphi 4, hay un ejemplo de como implementar, de forma sencilla, un log de errores... pues... yo lo estuve viendo y me decidí tratar de mejorarlo... sacarle más provecho. Y me he hecho esa pregunta, pues... quisiera llevar en dicho log, no sólo la hora, el tipo de excepción, su mensaje, quien la "disparó", sino también (y muy importante para mí) la línea en donde se detectó.

Todo esto quiero hacerlo con el fin de ir implementando mis propios procesos de testeo, etc... llevar un mejor control de mis errores, y obtener métricas que me permitan determinar rendimientos, etc. En pocas: hacer ingeniería de software (al menos una parte).

Desde ya muchas gracias...

Saludos

No estoy 100% seguro, pero creo que estos hilos te pueden ayudar. Con la ayuda de Lepe

http://www.clubdelphi.com/foros/showthread.php?t=25840
http://www.clubdelphi.com/foros/showthread.php?t=24363

Muchas gracias!
 

Pues lo que me diste es oro para mí... gracias vtdeleon, estoy leyendo a "vuelo" los links que me diste... y hasta el momento... es lo que necesito. Ya lo tengo guardadito para poder continuar leyendo bien tranquilo en otro momento...

Muchas gracias, seguiré investigando en esto...

vtdeleon:

La verdad es que de lo que leí, se comenta que se hace con componentes de la JEDI, y no hago uso de esas librerías, ya que hasta el momento no tuve necesidad de usarlas...

Yo cuento por el momento este código:

Código Delphi [-]
unit UErrorLog;
{******************************************************************************
 * UERRORLOG 1.0                                                              *
 ******************************************************************************
 Unidad: UErrorLog
 Versión: 1.0
 Fecha-Hora: 29/04/2006 - 03:33 pm
 Para: Delphi 6
 Autor: Delphius
 ******************************************************************************
 Descripción:
   La unidad UErrorLog permite llevar un registro de todas las excepciones y/o
 errores que se detectaron en una aplicación determinada. Dicho registro tiene
 una estructura como la siguiente:
 hh:mm:ss NombreExcepcion: DescripciónExcepcion

   Para hacer empleo de esta unidad, sólo hay que indicar en que parte del pro-
 grama se desea comenzar a detectar las excepciones mediante el procedimiento
 StartLog(), el cual recibe el directorio completo de donde se desea guardar el
 mismo.

   Esta unidad fue extraída de "La Cara Oculta de Delphi 4", escrita por Ian
 Marteens; ¡Espero que sepas perdonarme Ian! Por lo que se agradece el gesto
 de "querer compartir" tus ejemplos a muchos... por lo menos a mí éste me viene
 al pelo para llevar un control de mi "productividad"  y la calidad de los sis-
 temas que hago.
 ******************************************************************************
 Historial:
   - versión 1.0
 ******************************************************************************}

interface
  {* Procedimientos incorporados *}
  procedure StartLog(const AFileName: string);
  procedure StopLog;

implementation

uses
  SysUtils, Forms;

type
  {* Estructura del log *}
  TExceptionLog = class
    protected
      {** Declaraciones protegidas **}
      SavedHandler: TExceptionEvent;
      FileName: string;
      procedure ExceptionHandler(Sender: TObject; E: Exception);
    public
      {** Declaraciones públicas **}
      constructor Create(const AFileName: string);
      destructor Destroy; override;
  end; {* Fin TExceptionLog *}

var
  Log: TExceptionLog = Nil;

procedure StartLog(const AFileName: string);
{******************************************************************************
 Inicia el log que será guardado en un directorio específico.
 * Parámetro *
   AFileName: Directorio en donde guardar el log
 ******************************************************************************}
begin
  if NOT Assigned(Log)
     then Log := TExceptionLog.Create(AFileName);
end; {* Fin P. StartLog *}

procedure StopLog;
{******************************************************************************
 Detiene la ejecución del log.
 ******************************************************************************}
begin
  if Assigned(Log)
     then begin
            Log.Free;
            Log := Nil;
          end;
end; {* Fin P. StopLog *}

{* ---- TExceptionLog ---- *}
procedure TExceptionLog.ExceptionHandler(Sender: TObject; E: Exception);
{******************************************************************************
 Crea un registro en el log al capturar una excepción y/o error.
 * Parámetro *
 Sender: Objeto que levanta la excepción.
 E: Tipo de excepción levantada
 ******************************************************************************}
var Txt: TextFile;
begin
 Application.ShowException(E);
 try
   AssignFile(Txt,FileName);
   try
     Append(Txt);
   except
     Rewrite(Txt);
   end;
   try
     writeln(Txt, FormatDateTime('hh:nn:ss',Now)+' '+ E.ClassName +': '+E.Message +' - '+Sender.ClassName);
   finally
     CloseFile(Txt);
   end;
 except
 end;
end; {* Fin P. ExceptionLog.ExceptionHandler *}

constructor TExceptionLog.Create(const AFileName: string);
{******************************************************************************
 Crea un objeto de la clase TExceptionLog.
 * Parámetro *
 AFileName: Directorio en donde llevar a cabo el log.
 ******************************************************************************}
begin
  inherited Create;
  FileName := AFileName;
  SavedHandler := Application.OnException;
  Application.OnException := ExceptionHandler;
end; {* Fin C. TExceptionLog-Create *}

destructor TExceptionLog.Destroy;
{******************************************************************************
 Destruye un objeto de la clase TExceptionLog.
 ******************************************************************************}
begin
  Application.OnException := SavedHandler;
  inherited Destroy;
end; {* Fin D. TExceptionLog-Destroy *}

Initialization
  // Nada

Finalization
  // Al finalizar... detener el registro del log
  StopLog;

end.

Como podrás observar, es demasiado simple... estuve viendo que más le puedo sacar al Exception y del Sender... y por el momento no se me ocurre nada...

Realmente me gustaría poder capturar muchas de las cosas que ofrece el componente de la JEDI... pero lo que he leído del hilo que me mandaste, esa info (en parte) va junto al exe,... y no se... me gustaría evitarme eso.

Estaba pensando en descargar la JEDI Library... como para chequear un poco, pero me gustaría saber si hay alguna manera de sacar alguna (por lo menos) de la info que ofrece ese componente... mediante algún código más o menos sencillo sin tener que andar descargandolo. ¿Me explico? A ver, ¿Es posible obtener información parecida a lo que ofrece el componente, sin tener que hacer uso del mismo, por código? No quisiera decargar toda una librería si lo que quiero se puede hacer sin componente... no quiere decir que esté en contra de la librería (estoy seguro de que le sacaría provecho), ¿pero mientras me pueda valer de los componentes estándar (y/o propios)... para que más?

Desde ya muchas gracias.

Hola Delphius,

Cuando planteaste el tema lo primero que hize fue sorprenderme porque Delphi no contara con los "macros" conque cuenta C, como "__FILE__", "__LINE__", etc., etc. Bueno. Unas cosas por otras, imagino.

Me puse a buscar y lo que encontré es lo que habéis vosotros mencionado, es decir, referencias a la librería JCL de la Jedi Library. Ahí me puse un poco a investigar en cuanto me di cuenta de que efectivamente en alguna unidad de esas librerías (las dedicadas al "Debug") se implementaba algo parecido a los macros susomentados.

No conseguí enterarme de mucho, la verdad, pero, lo que trato de decir es que, efectivamente, el código fuente de la JCL está ahí... y parece que consigue lo que necesitas... así que, dándole vueltas... digo yo que encontrarás ahí la manera de quedarte con lo que te haga falta, de entre todo lo que ofrece la JCL para temas de "Debug".

Sí, ya sé, esto ni es respuesta ni es nada. Pero, yo desde luego no sabría cómo plantear el asunto si no es partiendo del código contenido en la JCL, y esto debe ser cuestión de ponerse a ello y tratar comprender al menos las partes del código que puedan interesarnos.

Va. Disculpa tanto rollo para no decir nada que ya no supieras... ;)

Solo comentar que pertenece a la JCL y no tiene que descargarse la JVCL, son 2 paquetes totalmente distintos:
- JCL --> conjunto de rutinas, clases para llamarlas desde código.
- JVCL --> Componentes a instalar en la Paleta de Delphi.

De hecho, para instalar la JVCL, se necesita primero instalar la JCL por separado ;).

No puedo asegurarlo al 100 % porque siempre he instalado ambas cosas.

Saludos.

Hola,

Llevas razón Lepe. No sólo no es necesario la JVCL, sino que ni siquiera es preciso la JCL al completo, sino únicamente las unidades que se precise utilizar y las dependencias de estas, claro está.

Muchas gracias...
 

Pues, gracias Dec y Lepe, por aclarme eso. Al final, instalaré ambas cosas, completas... para no hacerme líos y evitarme posibles dolores de cabeza.:rolleyes::D

Veré que más me pueden ofrecer estas librerías,... seguro de que son un buen "Migral" para muchos problemas o dificultades, he visto y leído miles de foros que avalan la calidad de dichas herramientas. Así que para algo me van a servir;):cool:

Muchas gracias,