दिलचस्प पोस्ट
एपीआई द्वारा विकिपीडिया पृष्ठ की मुख्य तस्वीर तक पहुंचना PHP में क्लाइंट आईपी पता कैसे प्राप्त करें? रुबी के डबल-बृहदान्त्र `::` क्या है? एंड्रॉइड के लिए एक Gluon मोबाइल एप्लिकेशन को परिनियोजित करने के लिए मैं "एंड्रॉइड सपोर्ट लाइब्रेरी" कैसे स्थापित कर सकता हूं? सी -11 में सिंथेट और _जनर का नमूना उपयोग ओपन एक्सएमएल एसडीके 2.0 – स्प्रैडशीट में एक सेल कैसे अपडेट करें? GB2312 को यूटीएफ -8 में कनवर्ट करें एमएस एक्सेस क्वेरी में सिस्टम उपयोगकर्ता नाम का उपयोग कैसे करें? Xcode का उपयोग करते हुए "ऐसा कोई मॉड्यूल" त्रुटि नहीं मिल रही है, लेकिन फ़्रेमवर्क यहां है जावास्क्रिप्ट: डॉम लोड इवेंट्स, एक्जिक्यूटशन अनुक्रम, और $ (डॉक्यूमेंट) .ready () जेपीए का उपयोग कर अंतिम स्थायी इकाई का आईडी कैसे प्राप्त करें I डाटाबेस में भंडारण एरेज़: JSON बनाम क्रमानुसार सरणी मैं एचटीएमएल / जावास्क्रिप्ट के साथ डाउनलोड कैसे करूँ? jquery के बिना jquery 'ट्रिगर' विधि के बराबर क्या है? सार्वजनिक-कुंजी क्रिप्टोग्राफी का उपयोग करके जावास्क्रिप्ट में एन्क्रिप्ट करें, PHP में डिक्रिप्ट करें

एंड्रॉइड – लॉगकेट संदेशों की अधिकतम लंबाई निर्धारित करें

डिफ़ॉल्ट रूप से, ऐसा लगता है कि लॉगकट किसी भी लॉग संदेश को छोटा करेगा जो इसे "बहुत लंबा" मानता है यह दोनों ग्रहण के अंदर होता है और जब कमांड लाइन पर adb -d logcat का उपयोग करते हुए logcat चलाते हैं, और कुछ महत्वपूर्ण डिबगिंग संदेशों को कम कर रहे हैं

क्या डीबग की जानकारी को कम करने के लिए लॉग-मेट द्वारा समर्थित अधिकतम स्ट्रिंग लम्बाई बढ़ाने का कोई तरीका है? आधिकारिक प्रलेखन का अर्थ है कि ऐसा नहीं हो सकता है, लेकिन हो सकता है कि लॉबैटैक ऐसे कुछ अतिरिक्त विकल्पों का समर्थन करता है जो वहां उल्लेख नहीं किए गए हैं?

Solutions Collecting From Web of "एंड्रॉइड – लॉगकेट संदेशों की अधिकतम लंबाई निर्धारित करें"

बाइनरी लॉग ( /dev/log/events ) के लिए लॉगकट में एक निश्चित आकार बफर है और यह सीमा 1024 बाइट्स है गैर बाइनरी लॉग के लिए एक सीमा भी है:

 #define LOGGER_ENTRY_MAX_LEN (4*1024) #define LOGGER_ENTRY_MAX_PAYLOAD (LOGGER_ENTRY_MAX_LEN - sizeof(struct logger_entry)) 

इसलिए द्विआधारी और गैर-द्विआधारी लॉग दोनों के लिए वास्तविक संदेश आकार ~ 4076 बाइट्स है। कर्नेल लॉगर इंटरफ़ेस इस LOGGER_ENTRY_MAX_PAYLOAD सीमा को लागू करता है

Liblog स्रोत (लॉगकट द्वारा उपयोग किया गया) भी कहते हैं:

  • संदेश कर्नेल लॉग ड्राइवर द्वारा छोटा किया जा सकता है।

मैं आपको nxlog उपकरण की सलाह देता हूं जो कि लॉजबैक बाइनरी का उपयोग नहीं करता है, लेकिन कर्नेल की सीमाओं के कारण मुझे संदेह है कि यह आपकी समस्या का समाधान करेगा। फिर भी, यह एक कोशिश के लायक हो सकता है (अस्वीकरण: मैं लेखक हूं।)

ठीक है, रोचक मुझे यह देखने के लिए निराश था कि जवाब "आप वास्तव में इसका विस्तार नहीं कर सकते" मेरा शुरुआती विचार यह तोड़ना था ताकि मैं पूरी चीज को देख सकूं, इसलिए मैं यहां आपके साथ साझा करता हूं कि मैं कैसे ऐसा करता हूं (ऐसा नहीं है कि यह कुछ भी नुकीला है और न ही वह कुशल है, लेकिन यह एक चुटकी में किया जाता है):

 if (sb.length() > 4000) { Log.v(TAG, "sb.length = " + sb.length()); int chunkCount = sb.length() / 4000; // integer division for (int i = 0; i <= chunkCount; i++) { int max = 4000 * (i + 1); if (max >= sb.length()) { Log.v(TAG, "chunk " + i + " of " + chunkCount + ":" + sb.substring(4000 * i)); } else { Log.v(TAG, "chunk " + i + " of " + chunkCount + ":" + sb.substring(4000 * i, max)); } } } else { Log.v(TAG, sb.toString()); } 

अंतिम स्ट्रिंग दिखाने के लिए संपादित!

कई टुकड़ों में इसे पुनरावर्तित करें

 public static void largeLog(String tag, String content) { if (content.length() > 4000) { Log.d(tag, content.substring(0, 4000)); largeLog(tag, content.substring(4000)); } else { Log.d(tag, content); } } 
 for( String line : logMesg.split("\n") ) { Log.d( TAG, line ); } 

यहां कोड है जो मैं उपयोग करता हूं – यह पंक्तियां 4000 की सीमा पर लाइनों को तोड़ देती है जबकि लाइन की मिडल के बजाय नई लाइनों पर लाइन को तोड़ती है। लॉग फ़ाइल को पढ़ने में आसान बनाता है।

उपयोग:

 Logger.debugEntire("...."); 

कार्यान्वयन:

 package ...; import android.util.Log; import java.util.Arrays; public class Logger { private static final String LOG_TAG = "MyRockingApp"; /** @see <a href="http://stackoverflow.com/a/8899735" /> */ private static final int ENTRY_MAX_LEN = 4000; /** * @param args If the last argument is an exception than it prints out the stack trace, and there should be no {} * or %s placeholder for it. */ public static void d(String message, Object... args) { log(Log.DEBUG, false, message, args); } /** * Display the entire message, showing multiple lines if there are over 4000 characters rather than truncating it. */ public static void debugEntire(String message, Object... args) { log(Log.DEBUG, true, message, args); } public static void i(String message, Object... args) { log(Log.INFO, false, message, args); } public static void w(String message, Object... args) { log(Log.WARN, false, message, args); } public static void e(String message, Object... args) { log(Log.ERROR, false, message, args); } private static void log(int priority, boolean ignoreLimit, String message, Object... args) { String print; if (args != null && args.length > 0 && args[args.length-1] instanceof Throwable) { Object[] truncated = Arrays.copyOf(args, args.length -1); Throwable ex = (Throwable) args[args.length-1]; print = formatMessage(message, truncated) + '\n' + android.util.Log.getStackTraceString(ex); } else { print = formatMessage(message, args); } if (ignoreLimit) { while (!print.isEmpty()) { int lastNewLine = print.lastIndexOf('\n', ENTRY_MAX_LEN); int nextEnd = lastNewLine != -1 ? lastNewLine : Math.min(ENTRY_MAX_LEN, print.length()); String next = print.substring(0, nextEnd /*exclusive*/); android.util.Log.println(priority, LOG_TAG, next); if (lastNewLine != -1) { // Don't print out the \n twice. print = print.substring(nextEnd+1); } else { print = print.substring(nextEnd); } } } else { android.util.Log.println(priority, LOG_TAG, print); } } private static String formatMessage(String message, Object... args) { String formatted; try { /* * {} is used by SLF4J so keep it compatible with that as it's easy to forget to use %s when you are * switching back and forth between server and client code. */ formatted = String.format(message.replaceAll("\\{\\}", "%s"), args); } catch (Exception ex) { formatted = message + Arrays.toString(args); } return formatted; } } 

हमें यह पेजिंग तर्क

  /* * StringBuffer sb - long text which want to show in multiple lines * int lenth - lenth of line need */ public static void showInPage(StringBuffer sb, int lenth) { System.out.println("sb.length = " + sb.length()); if (sb.length() > lenth) { int chunkCount = sb.length() / lenth; // integer division if ((chunkCount % lenth) > 1) chunkCount++; for (int i = 0; i < chunkCount; i++) { int max = lenth * (i + 1); if (max >= sb.length()) { System.out.println(""); System.out.println("chunk " + i + " of " + chunkCount + ":" + sb.substring(lenth * i)); } else { System.out.println(""); System.out.println("chunk " + i + " of " + chunkCount + ":" + sb.substring(lenth * i, max)); } } } } 

ट्रैविस के समाधान पर अपना खुद का लेना,

 void d(String msg) { println(Log.DEBUG, msg); } private void println(int priority, String msg) { int l = msg.length(); int c = Log.println(priority, TAG, msg); if (c < l) { return c + println(priority, TAG, msg.substring(c+1)); } else { return c; } } 

इस तथ्य का लाभ उठाएं कि Log.println() हार्डकोडिंग "4000" से बचने के लिए लिखा बाइट्स की संख्या देता है फिर, अपने आप को उस संदेश के उस भाग पर पुनः रूप से कॉल करें, जो तब तक नहीं दर्ज किया जा सकता जब तक कि कुछ भी नहीं बचा।

यदि आपका लॉग बहुत लंबा है (जैसे डीबगिंग कारणों आदि के लिए आपके डेटाबेस के संपूर्ण डंप लॉगिंग)। ऐसा हो सकता है कि लॉगकट अत्यधिक लॉगिंग को रोकता है इसके आस-पास काम करने के लिए आप एक टाइमआउट ईरामी एक्स मिलिसेकंड जोड़ सकते हैं।

 /** * Used for very long messages, splits it into equal chunks and logs each individual to * work around the logcat max message length. Will log with {@link Log#d(String, String)}. * * @param tag used in for logcat * @param message long message to log */ public static void longLogDebug(final String tag, @NonNull String message) { int i = 0; final int maxLogLength = 1000; while (message.length() > maxLogLength) { Log.d(tag, message.substring(0, maxLogLength)); message = message.substring(maxLogLength); i++; if (i % 100 == 0) { StrictMode.noteSlowCall("wait to flush logcat"); SystemClock.sleep(32); } } Log.d(tag, message); } 

सावधान रहें, केवल उद्देश्य डीबग करने के लिए इसका उपयोग करें क्योंकि यह मुख्य थ्रेड को अवरुद्ध कर सकता है

मैं किसी भी विकल्प को तर्कसंगत लंबाई बढ़ाने के लिए नहीं जानता, लेकिन हम मुख्य लॉग, इवेंट लॉग इत्यादि जैसे विभिन्न लॉग पा सकते हैं। मुख्य लॉग में आमतौर पर सभी चीजें होती हैं जो इसकी लंबाई 4 एमबी तक जाती है .. इसलिए आप जो कुछ खो गए हैं लॉग टर्मिनल में पथ है: \ data \ logger