Włącz rejestrowanie w SDK Mowy

Rejestrowanie w pliku jest opcjonalną funkcją zestawu SDK dla usługi Mowy. Podczas rozwoju rejestrowanie dostarcza dodatkowych informacji i danych diagnostycznych z podstawowych składników Speech SDK. Można ją włączyć, ustawiając Speech_LogFilename właściwość obiektu konfiguracji mowy na lokalizację i nazwę pliku dziennika. Rejestrowanie jest obsługiwane przez klasę statyczną w natywnej bibliotece zestawu SPEECH SDK. Możesz włączyć rejestrowanie dla dowolnej instancji rozpoznawania lub syntezatora w ramach Speech SDK. Wszystkie wystąpienia w tym samym procesie zapisują wpisy dziennika w tym samym pliku dziennika.

Przykład

Nazwa pliku dziennika jest określona w obiekcie konfiguracji. Biorąc SpeechConfig jako przykład i zakładając, że utworzono wystąpienie o nazwie speechConfig:

speechConfig.SetProperty(PropertyId.Speech_LogFilename, "LogfilePathAndName");

speechConfig.setProperty(PropertyId.Speech_LogFilename, "LogfilePathAndName");

speechConfig->SetProperty(PropertyId::Speech_LogFilename, "LogfilePathAndName");

speech_config.set_property(speechsdk.PropertyId.Speech_LogFilename, "LogfilePathAndName")

[speechConfig setPropertyTo:@"LogfilePathAndName" byId:SPXSpeechLogFilename];

import ("github.com/Microsoft/cognitive-services-speech-sdk-go/common")

speechConfig.SetProperty(common.SpeechLogFilename, "LogfilePathAndName")

Rozpoznawacz można utworzyć z obiektu konfiguracji. Umożliwia to rejestrowanie dla wszystkich rejestratorów.

Uwaga

Jeśli utworzysz obiekt SpeechSynthesizer z obiektu konfiguracji, nie włączy rejestrowania. Jeśli jednak logowanie jest włączone, uzyskasz również diagnostykę z programu SpeechSynthesizer.

JavaScript jest wyjątkiem, w którym rejestrowanie jest włączone za pośrednictwem diagnostyki zestawu SDK, jak pokazano w poniższym fragmencie kodu:

sdk.Diagnostics.SetLoggingLevel(sdk.LogLevel.Debug);
sdk.Diagnostics.SetLogOutputPath("LogfilePathAndName");

Tworzenie pliku dziennika na różnych platformach

W przypadku systemu Windows lub Linux plik dziennika może znajdować się w dowolnej ścieżce, dla którego użytkownik ma uprawnienia do zapisu. Uprawnienia do zapisu w lokalizacjach systemu plików w innych systemach operacyjnych mogą być domyślnie ograniczone lub zablokowane.

Platforma uniwersalna systemu Windows (UWP)

Aplikacje UWP powinny umieszczać pliki dziennika w jednej z lokalizacji danych aplikacji (lokalnej, roamingowej lub tymczasowej). Plik dziennika można utworzyć w folderze aplikacji lokalnej:

StorageFolder storageFolder = ApplicationData.Current.LocalFolder;
StorageFile logFile = await storageFolder.CreateFileAsync("logfile.txt", CreationCollisionOption.ReplaceExisting);
speechConfig.SetProperty(PropertyId.Speech_LogFilename, logFile.Path);

W aplikacji UWP stworzonej w Unity można utworzyć plik dziennika, używając folderu zawierającego trwałą ścieżkę danych aplikacji, w następujący sposób:

#if ENABLE_WINMD_SUPPORT
    string logFile = Application.persistentDataPath + "/logFile.txt";
    speechConfig.SetProperty(PropertyId.Speech_LogFilename, logFile);
#endif

Aby uzyskać więcej informacji na temat uprawnień dostępu do plików w aplikacjach platformy UWP, zobacz Uprawnienia dostępu do plików.

Android

Plik dziennika można zapisać w magazynie wewnętrznym, magazynie zewnętrznym lub katalogu pamięci podręcznej. Pliki utworzone w magazynie wewnętrznym lub katalogu pamięci podręcznej są prywatne dla aplikacji. Preferowane jest utworzenie pliku dziennika w pamięci zewnętrznej.

File dir = context.getExternalFilesDir(null);
File logFile = new File(dir, "logfile.txt");
speechConfig.setProperty(PropertyId.Speech_LogFilename, logFile.getAbsolutePath());

Kod powyżej zapisze plik dziennika w zewnętrznej pamięci w katalogu głównym specyficznym dla aplikacji. Użytkownik może uzyskać dostęp do pliku za pomocą menedżera plików (zazwyczaj w pliku Android/data/ApplicationName/logfile.txt). Plik jest usuwany po odinstalowaniu aplikacji.

Należy również zażądać WRITE_EXTERNAL_STORAGE uprawnień w pliku manifestu:

<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="...">
  ...
  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
  ...
</manifest>

W aplikacji Unity dla systemu Android plik dziennika można utworzyć, używając folderu ścieżki do trwałych danych aplikacji w następujący sposób:

string logFile = Application.persistentDataPath + "/logFile.txt";
speechConfig.SetProperty(PropertyId.Speech_LogFilename, logFile);

Ponadto należy również ustawić uprawnienie do zapisu w ustawieniach odtwarzacza Unity dla systemu Android na opcję "Zewnętrzna (SDCard)". Dziennik jest zapisywany w katalogu, który można uzyskać za pomocą narzędzia, takiego jak AndroidStudio Device Eksplorator plików. Dokładna ścieżka katalogu może się różnić między urządzeniami z systemem Android. Lokalizacja to zazwyczaj sdcard/Android/data/your-app-packagename/files katalog.

Więcej informacji o danych i magazynie plików dla aplikacji systemu Android jest dostępnych tutaj.

iOS

Dostępne są tylko katalogi w piaskownicy aplikacji. Pliki można tworzyć w dokumentach, bibliotece i katalogach tymczasowych. Pliki w katalogu dokumentów można udostępnić użytkownikowi.

Jeśli używasz języka Objective-C w systemie iOS, użyj następującego fragmentu kodu, aby utworzyć plik dziennika w katalogu dokumentów aplikacji:

NSString *filePath = [
  [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject]
    stringByAppendingPathComponent:@"logfile.txt"];
[speechConfig setPropertyTo:filePath byId:SPXSpeechLogFilename];

Aby uzyskać dostęp do utworzonego pliku, dodaj poniższe właściwości do Info.plist listy właściwości aplikacji:

<key>UIFileSharingEnabled</key>
<true/>
<key>LSSupportsOpeningDocumentsInPlace</key>
<true/>

Jeśli używasz usługi Swift w systemie iOS, użyj następującego fragmentu kodu, aby włączyć dzienniki:

let documentsDirectoryPathString = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true).first!
let documentsDirectoryPath = NSURL(string: documentsDirectoryPathString)!
let logFilePath = documentsDirectoryPath.appendingPathComponent("swift.log")
self.speechConfig!.setPropertyTo(logFilePath!.absoluteString, by: SPXPropertyId.speechLogFilename)

Więcej informacji na temat systemu plików systemu iOS jest dostępne tutaj.

Rejestrowanie za pomocą wielu rozpoznawania

Mimo że ścieżka wyjściowa pliku dziennika jest określana jako właściwość konfiguracji do SpeechRecognizer obiektu lub innego obiektu zestawu SDK, rejestrowanie zestawu SDK jest pojedynczym obiektem obejmującym cały proces bez pojęcia poszczególnych wystąpień. Można to traktować jako SpeechRecognizer konstruktor (lub podobny), niejawnie wywołujący statyczną i wewnętrzną procedurę "Configure Global Logging" z danymi właściwościami dostępnymi w odpowiadającym obiekcie SpeechConfig.

Oznacza to, że na przykład nie można skonfigurować sześciu równoległych rozpoznawaczy do jednoczesnego generowania danych wyjściowych do sześciu oddzielnych plików. Zamiast tego najnowszy stworzony rozpoznawacz skonfiguruje globalne wystąpienie rejestrowania, aby kierować dane wyjściowe do pliku określonego we właściwościach konfiguracji, a wszystkie logi SDK są wysyłane do tego pliku.

Oznacza to również, że okres istnienia obiektu skonfigurowanego rejestrowania nie jest powiązany z czasem trwania rejestrowania. Rejestrowanie nie zostanie zatrzymane w odpowiedzi na wydanie obiektu zestawu SDK i będzie kontynuowane tak długo, jak nie podano nowej konfiguracji rejestrowania. Po rozpoczęciu rejestrowanie całego procesu można zatrzymać, ustawiając ścieżkę pliku dziennika na pusty ciąg podczas tworzenia nowego obiektu.

Aby zmniejszyć potencjalne zamieszanie podczas konfigurowania rejestrowania dla wielu wystąpień, może być przydatne abstrahowanie kontroli rejestrowania od obiektów, które wykonują rzeczywistą pracę. Przykładowa para procedur pomocnika:

void EnableSpeechSdkLogging(const char* relativePath)
{
	auto configForLogging = SpeechConfig::FromSubscription("unused_key", "unused_region");
	configForLogging->SetProperty(PropertyId::Speech_LogFilename, relativePath);
	auto emptyAudioConfig = AudioConfig::FromStreamInput(AudioInputStream::CreatePushStream());
	auto temporaryRecognizer = SpeechRecognizer::FromConfig(configForLogging, emptyAudioConfig);
}

void DisableSpeechSdkLogging()
{
	EnableSpeechSdkLogging("");
}

Rejestrowanie za pomocą rejestratora plików, rejestratora pamięci i rejestratora zdarzeń

Dzięki zestawowi Speech SDK w wersji 1.43.0 mechanizm rejestrowania jest rozszerzony o więcej typów rejestratorów: File loggeri Memory loggerEvent logger.

• File logger to najprostsze rozwiązanie do rejestrowania, odpowiednie do diagnozowania większości problemów na urządzeniu podczas korzystania z SDK do usługi Mowa.

• Memory logger to rozwiązanie do rejestrowania, które przechowuje komunikaty dziennika w pamięci. Nadaje się do diagnozowania problemów występujących w krótkim czasie. Jeśli na przykład używasz rozpoznawania mowy, możesz chcieć zrzucić rejestrator pamięci po otrzymaniu zdarzenia wskazującego, że rozpoznawanie zostało anulowane z powodu błędu. Rozmiar buforu pamięci jest stały na 2 MB i nie można go zmienić. Jest to bufor "pierścieniowy", czyli nowe wprowadzone ciągi dziennika zastępują najstarsze w buforze.

• Event logger to rozwiązanie do rejestrowania, które wysyła komunikaty dziennika do programu obsługi zdarzeń udostępnianego przez dewelopera. Nadaje się do diagnozowania problemów, gdy tylko niektóre nowe ciągi dziennika staną się dostępne i wymagają dalszego przetwarzania. Na przykład zintegrowanie dzienników Speech SDK z istniejącym systemem zbierania dzienników.

Rejestrator plików, rejestrator pamięci i rejestrator zdarzeń mają mechanizm, który filtruje, rejestrując tylko niektóre komunikaty. Ponadto te rejestratory są konstrukcjami o szerokim zakresie procesów. Oznacza to, że jeśli (na przykład) masz wiele obiektów rozpoznawania mowy uruchomionych równolegle, istnieje jeden plik dziennika zawierający przeplatane wiersze dzienników ze wszystkich funkcji rozpoznawania. Nie można uzyskać oddzielnego rejestratora plików dla każdej rozpoznawarki. Podobnie istnieje jeden bufor pamięci zawierający przeplatane dzienniki ze wszystkich funkcji rozpoznawania i można zarejestrować tylko jedną procedurę obsługi zdarzeń jako funkcję wywołania zwrotnego w celu odbierania przeplatanych dzienników ze wszystkich funkcji rozpoznawania. Nie można uzyskać oddzielnego rejestratora pamięci dla każdego aparatu rozpoznawania i nie można zarejestrować programu obsługi zdarzeń dla każdego aparatu rozpoznawania. File logger, memory logger and event logger Może jednak współistnieć w tym samym procesie lub w tym samym rozpoznawaniu.

Przykłady

using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Diagnostics.Logging;

class Program 
{
    public static void FileLoggerWithoutFilters()
    {
        FileLogger.Start("LogfilePathAndName");

        // Other Speech SDK calls

        FileLogger.Stop();
    }

    public static void FileLoggerWithFilters()
    {
        string[] filters = { "YourFirstString", "YourSecondString" };
        FileLogger.SetFilters(filters);
        FileLogger.Start("LogfilePathAndName");

        // Other Speech SDK calls
        
        FileLogger.Stop();
        FileLogger.SetFilters();
    }

    public static void MemoryLoggerWithoutFilters()
    {
        MemoryLogger.Start();

        // Other Speech SDK calls

        // At any time (whether logging is stopped) you can dump the traces in memory to a file
        MemoryLogger.Dump("LogfilePathAndName");

        // Or dump to any object that is derived from System.IO.TextWriter. For example, System.Console.Out
        MemoryLogger.Dump(System.Console.Out);

        // Or dump to a vector of strings
        List<string> messages = MemoryLogger.Dump().ToList<string>();

        MemoryLogger.Stop();
    }

    // These variables and method are used by the EvenLogger sample below.
    private static readonly object lockObject = new object();
    private static List<string> eventMessages = new List<string>();
    private static void OnMessageEvent(object sender, string message)
    {
        lock (lockObject)
        {
            // Store the message for later processing. Better not processing it in the event thread
            eventMessages.Add(message);
        }
    }

    public static void EventLoggerWithoutFilters()
    {
        // Subscribe an event that will get invoked by Speech SDK on every new log message
        EventLogger.OnMessage += OnMessageEvent;

        // Other Speech SDK calls

        // Unsubscribe to stop getting events
        EventLogger.OnMessage -= OnMessageEvent;
    }
}

Dzięki zestawowi Speech SDK w wersji 1.43.0 mechanizm rejestrowania jest rozszerzony o więcej typów rejestratorów: File loggeri Memory loggerEvent logger.

• File logger to najprostsze rozwiązanie do rejestrowania, które nadaje się do diagnozowania większości problemów na urządzeniu przy uruchamianiu SDK funkcji mowy.

• Memory logger to rozwiązanie do rejestrowania, które przechowuje komunikaty dziennika w pamięci. Nadaje się do diagnozowania problemów występujących w krótkim czasie. Jeśli na przykład używasz rozpoznawania mowy, możesz chcieć zrzucić rejestrator pamięci po otrzymaniu zdarzenia wskazującego, że rozpoznawanie zostało anulowane z powodu błędu. Rozmiar buforu pamięci jest stały na 2 MB i nie można go zmienić. Jest to bufor pierścieniowy, czyli nowe zapisane ciągi dziennika zastąpią w buforze najstarsze z nich.

• Event logger to rozwiązanie do rejestrowania, które wysyła komunikaty dziennika do programu obsługi zdarzeń udostępnianego przez dewelopera. Nadaje się do diagnozowania kwestii, gdy tylko nowe ciągi dziennika stają się dostępne i potrzebują dalszego przetwarzania. Na przykład zintegrowanie dzienników zestawu SPEECH SDK z istniejącym systemem zbierania dzienników rejestrowania.

Rejestrator plików, rejestrator pamięci i rejestrator zdarzeń mają mechanizm filtrowania umożliwiający rejestrowanie tylko niektórych komunikatów tekstowych. Ponadto te rejestratory są konstrukcjami o szerokim zakresie procesów. Oznacza to, że jeśli (na przykład) masz wiele obiektów rozpoznawania mowy uruchomionych równolegle, istnieje jeden plik dziennika zawierający przeplatane wiersze dzienników ze wszystkich funkcji rozpoznawania. Nie można uzyskać oddzielnego rejestratora plików dla każdego rozpoznawacza. Podobnie istnieje jeden bufor pamięci zawierający przeplatane dzienniki ze wszystkich funkcji rozpoznawania i można zarejestrować tylko jedną procedurę obsługi zdarzeń jako funkcję wywołania zwrotnego w celu odbierania przeplatanych dzienników ze wszystkich funkcji rozpoznawania. Nie można uzyskać oddzielnego rejestratora pamięci dla każdego aparatu rozpoznawania i nie można zarejestrować programu obsługi zdarzeń dla każdego aparatu rozpoznawania. File logger, memory logger and event logger Może jednak współistnieć w tym samym procesie lub w tym samym rozpoznawaniu.

Przykłady

using namespace Microsoft::CognitiveServices::Speech;
using namespace Microsoft::CognitiveServices::Speech::Diagnostics::Logging;

void FileLoggerWithoutFilters()
{
    FileLogger::Start("LogfilePathAndName");

    // Other Speech SDK calls

    FileLogger::Stop();
}

void FileLoggerWithFilters()
{
    std::initializer_list<std::string> filters = { "YourFirstString", "YourSecondString" };
    FileLogger::SetFilters(filters);
    FileLogger::Start("LogfilePathAndName");

    // Other Speech SDK calls
    
    FileLogger::Stop();
    FileLogger::SetFilters();
}

void MemoryLoggerWithoutFilters()
{
    MemoryLogger::Start();

    // Other Speech SDK calls

    // At any time (whether logging is stopped) you can dump the traces in memory to a file
    MemoryLogger::Dump("LogfilePathAndName");

    // Or dump to any stream object that is derived from std::ostream. For example, std::cout
    MemoryLogger::Dump(std::cout);

    // Or dump to a vector of strings
    std::vector<std::string> messages = MemoryLogger::Dump();

    MemoryLogger::Stop();
}

void EventLoggerWithoutFilters()
{
    std::mutex mtx;
    std::vector<std::string> messages;

    // Register a callback that will get invoked by Speech SDK on every new log message
    EventLogger::SetCallback([&messages, &mtx](std::string message) {
        // Store the message for later processing. Better not processing it in the event thread
        std::unique_lock<std::mutex> lock(mtx);
        messages.push_back(message);
    });

    // Other Speech SDK calls

    // Stop logging by setting an empty callback
    EventLogger::SetCallback();
}

Dzięki zestawowi Speech SDK w wersji 1.43.0 mechanizm rejestrowania jest rozszerzony o więcej typów rejestratorów: File loggeri Memory loggerEvent logger.

• File logger to najprostsze rozwiązanie do logowania i jest odpowiednie do diagnozowania większości problemów na urządzeniu podczas uruchamiania Speech SDK.

• Memory logger to rozwiązanie do rejestrowania, które przechowuje komunikaty dziennika w pamięci. Nadaje się do diagnozowania problemów występujących w krótkim czasie. Jeśli na przykład używasz rozpoznawania mowy, możesz chcieć zrzucić rejestrator pamięci po otrzymaniu zdarzenia wskazującego, że rozpoznawanie zostało anulowane z powodu błędu. Rozmiar buforu pamięci jest stały na 2 MB i nie można go zmienić. Jest to bufor pierścieniowy, czyli nowe ciągi dziennika zastępują w nim najstarsze.

• Event logger to rozwiązanie do rejestrowania, które wysyła komunikaty dziennika do programu obsługi zdarzeń udostępnianego przez dewelopera. Nadaje się do diagnozowania problemów, gdy niektóre nowe ciągi dziennika są już dostępne i wymagają dalszego przetwarzania. Na przykład zintegrowanie dzienników zestawu Speech SDK z istniejącym systemem gromadzenia dzienników.

Rejestrator plików, rejestrator pamięci i rejestrator zdarzeń mają mechanizm filtrowania, rejestrując tylko określone komunikaty tekstowe. Ponadto te rejestratory są konstrukcjami o szerokim zakresie procesów. Oznacza to, że jeśli (na przykład) masz wiele obiektów rozpoznawania mowy uruchomionych równolegle, istnieje jeden plik dziennika zawierający przeplatane wiersze dzienników ze wszystkich funkcji rozpoznawania. Nie można uzyskać oddzielnego rejestratora plików dla każdego rozpoznawacza. Podobnie istnieje jeden bufor pamięci zawierający przeplatane dzienniki ze wszystkich funkcji rozpoznawania i można zarejestrować tylko jedną procedurę obsługi zdarzeń jako funkcję wywołania zwrotnego w celu odbierania przeplatanych dzienników ze wszystkich funkcji rozpoznawania. Nie można uzyskać oddzielnego rejestratora pamięci dla każdego aparatu rozpoznawania i nie można zarejestrować programu obsługi zdarzeń dla każdego aparatu rozpoznawania. File logger, memory logger and event logger Może jednak współistnieć w tym samym procesie lub w tym samym rozpoznawaniu.

Przykłady

import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.diagnostics.logging.EventLogger;
import com.microsoft.cognitiveservices.speech.diagnostics.logging.FileLogger;
import com.microsoft.cognitiveservices.speech.diagnostics.logging.MemoryLogger;

public class SpeechLoggingSamples {
    public static void fileLoggerWithoutFilters()
    {
        FileLogger.start("LogfilePathAndName");

        // Other Speech SDK calls

        FileLogger.stop();
    }

    public static void FileLoggerWithFilters()
    {
        String[] filters = { "YourFirstString", "YourSecondString" };
        FileLogger.setFilters(filters);
        FileLogger.start("LogfilePathAndName");

        // Other Speech SDK calls
        
        FileLogger.stop();
        FileLogger.setFilters();
    }

    public static void memoryLoggerWithoutFilters()
    {
        MemoryLogger.start();

        // Other Speech SDK calls

        // At any time (whether logging is stopped) you can dump the traces in memory to a file
        MemoryLogger.dump("LogfilePathAndName");

        // Or dump to any object that is derived from java.io.Writer. For example, System.out
        MemoryLogger.dump(System.out);

        // Or dump to a list of strings
        List<String> messages = MemoryLogger.dump();

        MemoryLogger.stop();
    }

    public static void eventLoggerWithoutFilters()
    {
        final Object lockObject = new Object();
        List<String> messages = new ArrayList<>();

        // Register a callback that will get invoked by Speech SDK on every new log message
        EventLogger.setCallback((message) -> {
            // Store the message for later processing. Better not processing it in the event thread
            synchronized (lockObject) {
                messages.add(message);
            }
        });

        // Other Speech SDK calls

        // Stop logging by setting an empty callback
        EventLogger.setCallback();
    }
}

Dzięki zestawowi Speech SDK w wersji 1.43.0 mechanizm rejestrowania jest rozszerzony o więcej typów rejestratorów: File loggeri Memory loggerEvent logger.

• File logger to najprostsze rozwiązanie do logowania i odpowiednie do diagnozowania większości problemów na urządzeniu przy użyciu SDK Mowy.

• Memory logger to rozwiązanie do rejestrowania, które przechowuje komunikaty dziennika w pamięci. Nadaje się do diagnozowania problemów występujących w krótkim czasie. Jeśli na przykład używasz rozpoznawania mowy, możesz chcieć zrzucić rejestrator pamięci po otrzymaniu zdarzenia wskazującego, że rozpoznawanie zostało anulowane z powodu błędu. Rozmiar buforu pamięci jest stały na 2 MB i nie można go zmienić. Jest to bufor pierścieniowy, czyli nowe ciągi dziennika zapisane zastępują najstarsze w buforze.

• Event logger to rozwiązanie do rejestrowania, które wysyła komunikaty dziennika do programu obsługi zdarzeń udostępnianego przez dewelopera. Nadaje się do diagnozowania problemów, gdy tylko nowe ciągi dziennika staną się dostępne i wymagają dalszego przetwarzania. Na przykład zintegrowanie logów Speech SDK z istniejącym systemem zbierania logów.

Rejestrator plików, rejestrator pamięci i rejestrator zdarzeń mają mechanizm filtrowania, rejestrując tylko niektóre komunikaty tekstowe. Ponadto te rejestratory są konstrukcjami o szerokim zakresie procesów. Oznacza to, że jeśli (na przykład) masz wiele obiektów rozpoznawania mowy uruchomionych równolegle, istnieje jeden plik dziennika zawierający przeplatane wiersze dzienników ze wszystkich funkcji rozpoznawania. Nie można uzyskać oddzielnego logera plików dla każdego rozpoznawacza. Podobnie istnieje jeden bufor pamięci zawierający przeplatane dzienniki ze wszystkich funkcji rozpoznawania i można zarejestrować tylko jedną procedurę obsługi zdarzeń jako funkcję wywołania zwrotnego w celu odbierania przeplatanych dzienników ze wszystkich funkcji rozpoznawania. Nie można uzyskać oddzielnego rejestratora pamięci dla każdego aparatu rozpoznawania i nie można zarejestrować programu obsługi zdarzeń dla każdego aparatu rozpoznawania. File logger, memory logger and event logger Może jednak współistnieć w tym samym procesie lub w tym samym rozpoznawaniu.

Przykłady

- (void)fileLoggerWithoutFilters {
    NSString *logFileName = @"speech_sdk.log";
    NSString *logFile = [[NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject]
                         stringByAppendingPathComponent:logFileName];
    [SPXFileLogger start:logFile];
    
    // Other Speech SDK calls

    [SPXFileLogger stop];
}

- (void)fileLoggerWithFilters {
    NSString *logFileName = @"speech_sdk.log";
    NSString *logFile = [[NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject]
                         stringByAppendingPathComponent:logFileName];
    NSArray *filters = @[@"YourFirstString", @"YourSecondString"];
    [SPXFileLogger setFilters:filters];
    [SPXFileLogger start:logFile];
    
    // Other Speech SDK calls

    [SPXFileLogger stop];
    [SPXFileLogger setFilters:nil];
}

- (void)memoryLoggerWithoutFilters {
    NSString *logFileName = @"speech_sdk.log";
    NSString *logFile = [[NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject]
                         stringByAppendingPathComponent:logFileName];

    [SPXMemoryLogger start];
    
    // Other Speech SDK calls

    // At any time (whether logging is stopped) you can dump the traces in memory to a file
    [SPXMemoryLogger dumpToFile:logFile];

    [SPXMemoryLogger stop];
}

- (void)eventLoggingWithoutFilters {
    __block NSMutableArray *eventMsgs = [NSMutableArray array];

    // Register a callback that will get invoked by Speech SDK on every new log message
    [SPXEventLogger setCallback:^(NSString *message) {
        @synchronized(self) {
            [eventMsgs addObject:message];
        }
    }];
    
    // Other Speech SDK calls

    // Stop event logging 
    [SPXEventLogger setCallback:nil];
}

Dzięki zestawowi Speech SDK w wersji 1.43.0 mechanizm rejestrowania jest rozszerzony o więcej typów rejestratorów: File loggeri Memory loggerEvent logger.

• File logger to najprostsze rozwiązanie do logowania i doskonale nadaje się do diagnozowania większości problemów na urządzeniu podczas używania zestawu SDK dla usług mowy.

• Memory logger to rozwiązanie do rejestrowania, które przechowuje komunikaty dziennika w pamięci. Nadaje się do diagnozowania problemów występujących w krótkim czasie. Jeśli na przykład używasz rozpoznawania mowy, możesz chcieć zrzucić rejestrator pamięci po otrzymaniu zdarzenia wskazującego, że rozpoznawanie zostało anulowane z powodu błędu. Rozmiar buforu pamięci jest stały na 2 MB i nie można go zmienić. Jest to bufor cykliczny, czyli nowe ciągi dziennika zapisane w buforze zastępują jego najstarsze elementy.

• Event logger to rozwiązanie do rejestrowania, które wysyła komunikaty dziennika do programu obsługi zdarzeń udostępnianego przez dewelopera. Nadaje się do diagnozowania problemów, gdy tylko niektóre nowe ciągi dzienników staną się dostępne i wymagają dalszego przetwarzania. Na przykład zintegrowanie dzienników Speech SDK z istniejącym systemem rejestrowania.

Rejestrator plików, pamięci i zdarzeń są wyposażone w mechanizm filtrowania, który pozwala rejestrować tylko określone komunikaty tekstowe. Ponadto te rejestratory są konstrukcjami o szerokim zakresie procesów. Oznacza to, że jeśli (na przykład) masz wiele obiektów rozpoznawania mowy uruchomionych równolegle, istnieje jeden plik dziennika zawierający przeplatane wiersze dzienników ze wszystkich funkcji rozpoznawania. Nie można uzyskać oddzielnego rejestratora plików dla każdego rozpoznawacza. Podobnie istnieje jeden bufor pamięci zawierający przeplatane dzienniki ze wszystkich funkcji rozpoznawania i można zarejestrować tylko jedną procedurę obsługi zdarzeń jako funkcję wywołania zwrotnego w celu odbierania przeplatanych dzienników ze wszystkich funkcji rozpoznawania. Nie można uzyskać oddzielnego rejestratora pamięci dla każdego aparatu rozpoznawania i nie można zarejestrować programu obsługi zdarzeń dla każdego aparatu rozpoznawania. File logger, memory logger and event logger Może jednak współistnieć w tym samym procesie lub w tym samym rozpoznawaniu.

Przykłady

import azure.cognitiveservices.speech as speechsdk
import azure.cognitiveservices.speech.diagnostics.logging as speechsdk_logging


def file_logger_without_filters():
    speechsdk_logging.FileLogger.start("LogfilePathAndName")
    # Other Speech SDK calls
    speechsdk_logging.FileLogger.stop()


def file_logger_with_filters():
    filters = { "YourFirstString", "YourSecondString" }
    speechsdk_logging.FileLogger.set_filters(filters)
    speechsdk_logging.FileLogger.start("LogfilePathAndName")
    # Other Speech SDK calls
    speechsdk_logging.FileLogger.stop()
    speechsdk_logging.FileLogger.set_filters()


def memory_logger_without_filter():
    speechsdk_logging.MemoryLogger.start()
    #
    # Other Speech SDK calls
    #
    # At any time (whether logging is stopped) you can dump the traces in memory to a file
    speechsdk_logging.MemoryLogger.dump("LogfilePathAndName")
    # Or dump to any object that is derived from IOBase. For example, sys.stdout
    speechsdk_logging.MemoryLogger.dump_to_stream(sys.stdout)
    # Or dump to a list of strings
    messages = speechsdk_logging.MemoryLogger.dump_to_list()
    speechsdk_logging.MemoryLogger.stop()


def event_logger_without_filter():
    messages = []
    lock = threading.Lock()
    # Register a callback that will get invoked by Speech SDK on every new log message
    def on_log(msg):
        with lock:
            # Store the message for later processing. Better not processing it in the event thread
            messages.append(msg)
    speechsdk_logging.EventLogger.set_callback(on_log)
    #
    # Other Speech SDK calls
    #
    # Stop logging by setting an empty callback
    speechsdk_logging.EventLogger.set_callback()

Następne kroki

Zapoznaj się z przykładami w usłudze GitHub