È buona norma registrare qualcosa relativo ad un oggetto dal callee?

Question

È buona norma registrare qualcosa relativo ad un oggetto dal callee?

#1 da (1 voti)
#2 da (1 voti)

1

Sto progettando una classe il cui oggetto è istaniato con un idn utente che crea un pdf con i dettagli specifici dell'utente. Dovrebbe registrare qualcosa in base al successo o all'errore che può essere determinato solo dal chiamante poiché il successo o l'errore dipende da se non è stato appena creato ma inviato dal chiamante.

Tuttavia, due problemi che riesco a vedere in questo modello di progettazione sono:

Sembra un po 'strano che il chiamante debba registrarlo dall'esterno. Cosa succede se l'init stesso fallisce?

Il modo in cui sto pensando di loggare come metodo se questa classe è probabilmente sbagliata? Ma non sembra così dal momento che condivide lo stato, cioè l'utente. Qualche raccomandazione su questo disegno?

Library Code

class create_pdf():
    """
    Class
    """
    def __init__(self, user):
        """
        """
        user
        db_calls_to_get_full_user_details(user)


    def fetch_pdf_dms(self):
        """
        Fetch from DMS
        """
        logic

    def fetch_pdf_engine(self):
        """
        Fetch from a PDF Generator
        """
        # logic that fetches the blob


    def log(self, error = None):
        """
        """
        # If there was no failure and it was a fetch_pdf_engine
        # event then I store the blob into dms for the first time.
        # If the event failed I capture the exception. Finally I 
        #  log the event in the database.

    def fetch_pdf(self):

        pdf = fetch_pdf_dms
        if pdf:
            return pdf
        return fetch_pdf_engine # which also stores to dms first time!


Consumer Code:

method = REQUEST['method']
for each user in users:
    try:
        object = create_pdf(user)
        object.do_something()
        dispatch(method)
        object.log()
    except:
        object.log(error=exception)

object-oriented python

posta Nishant 29.03.2016 - 14:00

fonte

2 risposte

1

I log sono usati per rintracciare cosa è successo, di solito perché qualcosa è andato terribilmente storto.

Pertanto, proprio come le eccezioni, la registrazione dovrebbe avvenire molto vicino al codice pertinente. Non voglio dover scavare attraverso uno stack di chiamate lungo un miglio per trovare il codice che accompagna un messaggio di errore. La registrazione dovrebbe avvenire nel momento in cui sai che qualcosa deve essere registrato.

Quando si tratta di registrare le eccezioni, il modo migliore (usando i criteri di cui sopra) è catturare, registrare e rilanciare le eccezioni. Piena divulgazione: non parlo fluentemente Python, ma sono abbastanza sicuro che questo è il modo in cui hai ripreso.

Library Code

class create_pdf():
    """
    Class
    """
    def __init__(self, user):
        """
        """
        try:
          user
          db_calls_to_get_full_user_details(user)
        except:
          # log
          raise

    def fetch_pdf_dms(self):
        """
        try:
          Fetch from DMS
          """
          logic
        except
          #log
          raise

    def fetch_pdf_engine(self):
        """
        try:
          Fetch from a PDF Generator
          """
          # logic that fetches the blob
        except
          #log
          raise


    def log(self, error = None):
        """
        """
        # If there was no failure and it was a fetch_pdf_engine
        # event then I store the blob into dms for the first time.
        # I further the event as failure depending on failure.

    def fetch_pdf(self):
        try:   
          pdf = fetch_pdf_dms
          if pdf:
              return pdf
          return fetch_pdf_engine # which also stores to dms first time!
        except:
          #log
          raise


Consumer Code:

method = REQUEST['method']
for each user in users:
    try:
        object = create_pdf(user)
        object.do_something()
        dispatch(method)
        object.log()
    except:
       #If the consumer code can deal with the exception, handle them here.
       #If not, eliminate the try-catch and let them bubble up the call stack.

risposta data 29.03.2016 - 14:54

fonte

Leggi altre domande sui tag object-oriented python

Hotfixing con un ramo di rilascio aperto mentre questa versione è attualmente testata Migliori pratiche e concetti di categorizzazione degli annunci

score 1 · Accepted Answer

La tua classe di creazione di PDF non dovrebbe accedere, infatti, non dovrebbe avere alcuna conoscenza del tuo log. Dovrebbe creare quel pdf e segnalare eventuali problemi al suo creatore / chiamante. Il creatore / chiamante dovrebbe quindi decidere cosa fare con esso (scrivere sulla console, scrivere in un file di log, riprovare, ignorare, qualunque cosa). Il tuo pdf creatore è un dominio problematico e dovrebbe avere una singola responsabilità con un minimo di dipendenze.