2011-01-29 13 views
7

अद्यतन: हल हो गया !!!
कृपया जवाब मैंस्कैला लॉगिंग लाइन नंबर - slf4s/slf4j?

नीचे जुड़ते देख

किसी को भी अगर वहाँ प्रवेश कि कंसोल के लिए असली लाइन नंबर आउटपुट करने के लिए एक तरीका है पता है? मैं यहां स्कैला में जाने की कोशिश कर रहा हूं, लेकिन इस तरह की बुनियादी चीजें पाने में सक्षम होने के बिना मैं निर्भर करता हूं, बहुत कुछ करना मुश्किल है।

मैंने slf4j - log4j - jcl-over-slf4j के साथ लपेटने के लिए slf4s सेट अप किया है। समस्या यह है कि मुझे लाइन नंबर मिलते हैं जो बिल्कुल मेल नहीं खाते हैं। स्कैला वर्ग की तुलना में बहुत अधिक लाइन संख्याएं भी शामिल हैं। क्या ऐसा इसलिए है क्योंकि रेखा संख्या वास्तव में जावा-इंटरमीडिएट लाइन नंबर हैं?

वहाँ प्रवेश कि इन आवश्यकताओं ?:

  1. परस्पर संचालन को पूरा करती है, दोनों जावा & स्केला के साथ काम करने की स्थापना के लिये किसी भी आसान रास्ता नहीं है
  2. के रूप में व्यक्ति की लॉगिंग स्तर को बदलने के लिए आसान पैकेज को आसानी से लॉग 4j
  3. सटीक लाइन नंबर प्रदान करता है।

धन्यवाद!

जेमी

उत्तर

6

मैं ने पाया है कि logback (Ceki Gülcü द्वारा) अच्छा काम करता है और लाइन नंबर भी बरकरार रखता है !
(और यह log4j के लिए एक स्थानापन्न के रूप में काम करता है:! बहुत बढ़िया)

import ch.qos.logback._ 
import org.slf4j._ 

object Main { 

    def logger = LoggerFactory.getLogger("Main") 
    var thingy = { 
     x:Int => 
     logger.info("x=" + x) 
     x + 1 
    } 
    def main(args: Array[String]) { 
     logger.info("Hello.") 
     logger.info("Hello again!") 

     val myInts : List[Int] = List(-25,1,5,20) 

     val myInts2 : List[Int] = myInts.filter { x:Int => x > 0 } 

     logger.info("my ints2:" + myInts2) 

     val myInts3 = myInts2.map(p => p * 2) 
     logger.info("my ints3:" + myInts3) 

     logger.info(thingy(1) + "") 
    } 
} 

स्काला के साथ आरंभ करने के लिए संघर्ष कर किसी को भी के लिए, यह है कि मैं क्या बुनियादी कंकाल उठना किया है:

1) Download sbt-launcher.jar और यह किसी ऐसे स्थान पर रखा /opt/
मैं इस्तेमाल किया "sbt-launch-0.7.5.RC0.jar"

2) nano /opt/bin/sbt में एसबीटी लांचर के लिए एक शॉर्टकट के रूप में एक bash स्क्रिप्ट बनाएं तरह:

012,351,
#!/bin/bash 
java -jar /opt/sbt-launch-0.7.5.RC0.jar "[email protected]" 

(यह निष्पादन योग्य बनाने के)

$ sudo chmod ug+x ./sbt 

यकीन है कि यह अपने रास्ते में भी है सुनिश्चित करें।

3) बनाएँ और एसबीटी परियोजना कॉन्फ़िगर करें:

$ mkdir ./sc01 
$ cd ./sc01 
$ sbt 
$ mkdir ./project/build</pre> 
$ nano ./project/build/Project.scala</pre> 

वहाँ में डाल इस:

import sbt._ 

class sc01(info: ProjectInfo) extends DefaultProject(info) 
{ 
    // dependencies 
    val logback_core = "ch.qos.logback" % "logback-core" % "0.9.24" % "compile" //LGPL 2.1 
    val logback_classic = "ch.qos.logback" % "logback-classic" % "0.9.24" % "compile" //LGPL 2.1 
    val log4j_over_slf4j = "org.slf4j" % "log4j-over-slf4j" % "1.6.1" 


    // if you are going to have any unmanaged (manually-added) jars 
    // def baseDirectories = "lib" 
    // def extraJars = descendents(baseDirectories, "*.jar") 
    // override def unmanagedClasspath = super.unmanagedClasspath +++ extraJars 

    // tasks - easy to define 
    lazy val hi = task { println("Hello World"); None } 

    // classpath 
    //override def mainScalaSourcePath = "src" 

} 

4) मुख्य में ऊपर से सामान पेस्ट करें:

$ nano ./src/main/scala/Main.scala 

5) मैं लगभग भूल ही गया था! /src/main/resources/logback.xml
में रखते (यह लाइन नंबर प्राप्त करने के लिए आवश्यक है)

<configuration> 

    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"> 
     <!-- encoders are assigned the type 
    ch.qos.logback.classic.encoder.PatternLayoutEncoder by default --> 
     <encoder> 
      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} %line --- %msg%n</pattern> 
     </encoder> 
    </appender> 

    <root level="debug"> 
     <appender-ref ref="STDOUT" /> 
    </root> 
</configuration> 

6) $ sbt

अब आप अपने खोल में sbt कंसोल में होना चाहिए:

> update 
> compile 
> run 

आशा इस मदद करता है.

+0

दिलचस्प प्रतिक्रिया। मै उसे करने की एक कोशिश तो करूंगा। +1 (यह न भूलें कि आप आधिकारिक के रूप में अपना उत्तर चुन सकते हैं) – VonC

+1

आप स्पष्टीकरण यहां एसएसटी दस्तावेज के बाद _so_ बेहतर हैं। इच्छा है कि मुझे यह जवाब जल्द ही मिल गया था। – srparish

+0

@srparish मुझे खुशी है कि यह आपकी मदद करता है! मुझे ब्लॉग पोस्ट/स्टैक ओवरफ़्लो/मेलिंग सूचियों से मेरे अपेक्षाकृत कम प्रोग्रामिंग कैरियर में इतनी मदद मिली है कि मैं जो भी पेशकश कर सकता हूं उसे वापस योगदान करने में सक्षम होने में मुझे खुशी हो रही है। – jpswain

2

आप Scala logging प्रश्न में टिप्पणी कर रहे हैं के रूप में, स्काला में सटीक लाइन नंबर जानकारी प्राप्त करने कठिन है।

  • scalac जरूरतों को कम से कम -g line या -g vars
  • इस सुविधा के साथ इस्तेमाल किया जा करने के लिए बहुत ज्यादा है in discussion for amelioration
  • क्यों स्काला सिर्फ सहेजकर मौजूदा बुनियादी ढांचे को ओवरलोड नहीं है LineNumberTable में लाइन संख्याओं के बजाय पूर्ण ऑफसेट्स?
    संबोधित करने का एक और तरीका स्रोत फ़ाइलों में वास्तविक ऑफसेट के बजाय टोकन को संख्याबद्ध करके किया जा सकता है।
  • जबकि मुझे टोकन द्वारा अनुक्रमणित करने का विचार पसंद है, इसका मतलब है कि डीबग जानकारी का उपयोग करने में सक्षम किसी भी उपकरण को पूर्ण पार्सर तक पहुंच की आवश्यकता होगी।
    नियमों के सख्ती से परिभाषित सेट के अनुसार फ़ाइल को दोबारा सुधारना एक और संभावना है, और फिर लाइन नंबरिंग का उपयोग करना जारी रखें।
  • मैंने स्कैला कार्यक्रमों के लिए डिबगिंग अनुभव में सुधार करने के लिए काम करना शुरू किया, और दुखद बिंदुओं में से एक वास्तव में लाइन संख्या है। आदर्श रूप से केवल लाइन संख्याओं से अधिक के लिए समर्थन होगा। मैं JSR 45 देख रहा हूं (अन्य भाषाओं के लिए समर्थन डिबगिंग)। मुझे अभी तक यकीन नहीं है कि यह पर्याप्त है, लेकिन हो सकता है कि एक स्कैला स्ट्रैटम आपकी योजना का उपयोग कर सके।
    मुझे लगता है कि classfile विशेषताओं या एनोटेशन में अतिरिक्त, स्कैला विशिष्ट, डिबगिंग जानकारी प्रदान करने का बेहतर तरीका है। जहां तक ​​मुझे पता है, जेडीआई classfile विशेषताओं तक पहुंच नहीं देता है, न ही एनोटेशन के लिए, लेकिन कुछ चालें हैं जिनका उपयोग हम उन्हें प्राप्त करने के लिए कर सकते हैं।इस तरह हम मौजूदा कार्यक्षमता को संरक्षित करेंगे, और स्केल विशेषताओं के बारे में जानते समय उपकरण को और अधिक करने की अनुमति देते हैं।

(नोट: Scalate रिपोर्ट स्रोत फ़ाइलों का एक अलग तरह के लिए scalate-24 में एक समान काम के बाद)

2

अद्यतन 2016: lihaoyi/sourcecode की तरह एक पुस्तकालय के लिए एक नया दृष्टिकोण के साथ एक logging use case शामिल होते हैं:

आप लॉग कार्यों कि स्वचालित रूप से उनकी लाइन नंबर और फ़ाइल नाम

कब्जा परिभाषित करने के लिए sourcecode.File और sourcecode.Line उपयोग कर सकते हैं
def log(foo: String)(implicit line: sourcecode.Line, file: sourcecode.File) = { 
    println(s"${file.value}:${line.value} $foo") 
} 

log("Foooooo") // sourcecode/shared/src/test/scala/sourcecode/Tests.scala:86 Fooooo 

इस दे जैसा कि आप देख जहां लॉग लाइनों उबाते एक अनूठा उपसर्ग के साथ हर लॉग बयान टैगिंग के बिना, से आ रहे हैं के लिए आसान हो सकता है।
इसके अलावा, यह संकलन समय पर होता है, और इस प्रकार स्टैक निशान उत्पन्न करके इस जानकारी को प्राप्त करने से अधिक तीव्रता के आदेश होते हैं, और Scala.js पर काम करता है जहां स्टैक-निरीक्षण नहीं है।
आखिरकार, यदि आप अपने लॉगिंग फ़ंक्शन को प्रदान करने के लिए विधि नाम, कक्षा नाम या पैकेज जैसी अतिरिक्त जानकारी चाहते हैं, तो आप आसानी से sourcecode.Name या sourcecode.FullName या sourcecode.Pkg implicits पूछकर ऐसा कर सकते हैं।

0

मैं स्क्रिप्ट पर एक नज़र डालने की सिफारिश करता हूं। यह लाइन नंबरों और संकलन समय पर अन्य जानकारी उत्पन्न करने के लिए मैक्रोज़ का उपयोग करके स्कैला के लिए एक पूर्ण लॉगिंग समाधान है, इसलिए गति में कोई कमी नहीं है, और यह अंतर्निहित है इसलिए आपको sourcecode जैसे कुछ का उपयोग करने की आवश्यकता नहीं है और इसे मैन्युअल रूप से एकीकृत करें:

https://github.com/outr/scribe

संबंधित मुद्दे