Dynamic java logging properties file

Hello,
I am looking for a dynamic way to set a property in a java logging properties file.
For example something like this:
java.util.logging.FileHandler.pattern = ${log.dir}/logfile%u.log
..where log.dir is a system property. But this does not work. Any other way to do it?
Thanks in advance,
Rohnny

This pattern doesn't work ? here is the content of my
logging.properties file.
java.util.logging.FileHandler.pattern = LOGFILE.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
java.util.logging.FileHandler.formatter =
java.util.logging.SimpleFormatter
FIRST_LOGGER.Handler = java.util.logging.FileHandler
FIRST_LOGGER.level = ALL
SECOND_LOGGER.Handler =
java.util.logging.FileHandler
SECOND_LOGGER.level = ALLIt seems like you're not thoroughly reading the spec on this stuff.
I don't think ".Handler" is even a valid property on a logger.
Loggers aren't typically initialized with a complex configuration out of a configuration file...unless you write your own custom format. For instance, FileHandler is a class, so when you define java.util.logging.FileHandler.pattern in the config file, you're defining it for every default instance of FileHandler...so naturally both your loggers that use FileHandlers will write to the same file.
I've never done this before, but here's what I came up with after reading the spec:
1) define 1 subclass of FileHandler for each file you want to write to... let's call them FileHandlerA and FileHandlerB. All they have to do is extend FileHandler, nothing else.
2) define the patterns for each subclass in the config file. You can also define any other properties you want for each handler, such as .level, .limit, .count, etc.
mypackage.myhandlers.FileHandlerA.pattern = LogFile-A.log
mypackage.myhandlers.FileHandlerB.pattern = LogFile-B.log
// ... more config here
3) define the loggers in the config file and specify the handlers to use on each:
FIRST_LOGGER.handlers = mypackage.myhandlers.FileHandlerA
SECOND_LOGGER.handlers = mypackage.myhandlers.FileHandlerB
4) create your Loggers in your code:
Logger firstLog = Logger.getLogger("FIRST_LOGGER");
Logger secondLog = Logger.getLogger("SECOND_LOGGER");
Good luck.

Similar Messages

  • Use environment variables in logging.properties file

    is there a way to use environment variables in logging.properties file?
    like this -
    java.util.logging.FileHandler.pattern = {$MY_BASE_LOG_FOLDER}/myapp1/log/123%g.logdo I have to write a custom logging.properties loader? if yes, then are there any examples on this?

    I'm sorry, but don't you think your answer is useless?
    Maybe I haven't made my question clear enough. I need to know if java.util.logging recognizes environment variables in logging.properties files.
    If it does not, then there should be a well-known class to use instead of standard loader for logging.properties (java api mention one briefly).

  • Java Internationalization and .properties files

    Hi everyone,
    Isn't it problematic that the way to internationalize your java apps ( .properties files ) doesn't support UTF-8 and you have to user gibberish looking unicode escapes. Some will say that you don't need to write and the converters or editors will handle the ascii conversion but the requirement for such a intermediate process doesn't seem right. Sometime you have to edit some string on the server and it should be human readable using text editors that support UTF-8. I thought loadFromXML and storeToXML methods that came with java 1.5 seemed to solve the problem but than noticed that PropertyResourceBundle doesn't support xml properties files. Is backwards compatibility the reason that properties files aren't utf-8 by default?
    Thanks
    Bilgehan

    Try PRBeditor (http://prbeditor.dev.java.net).

  • How do I read properties file kept in the source folder in weblogic workshop

    I want to have a log.properties file in the folder of the source java code which
    is reading this properties file. When I build the code the properties file also
    should go with the generated .class files.
    I am using class.getResourceAsStream("log.properties")
    I tries different ways to make the class to read the file, but it failed to find
    the properties file. Is there any way to keep the configuration files in the same
    directory of the source java code ? This is the problem of weblogic workshop 8.1.
    This thing runs fine in Tomcat.

    Did you try and add the path where the .properties file is located in the CLASSPATH?

  • Specify handler for a logger in properties file

    Hello All,
    Is there a way of specifying a specific handler for a specific logger within the logging.properties file? I have not been able to find any documentation on the logging.properties file settings. I am looking for something like this:
    com.eric.program.handlers = java.util.logging.ConsoleHandler
    com.frank.handlers = java.util.logging.FileHandler
    I would rather keep all my settings within this properties file instead of coding it. If you know where I can find some documentation, please let me know. I am using J2SE 1.4.1.
    Thanks.

    Well, after failing to assign a handler to a specific logger, I checked the LogManager source code and, alas, it only supports assigning handlers to the root logger.
    What a bummer ... I think this is a real flaw in the LogManager design, especially since log4j supports assigning appenders to specific logger.
    The (more or less) good news is that LogManager is designed for subclassing (by j2ee container apps, but hey) ... so you can try to add this functionality to your own LogManager and use that through the system property java.util.logging.manager.
    import java.io.*;
    import java.security.*;
    import java.util.*;
    import java.util.logging.*;
    * All properties whose names end with ".handlers" are assumed to define a
    * whitespace separated list of class names for handler classes to load and
    * register as handlers on the logger (whose name corresponds to the property
    * prefix). Each class name must be for a Handler class which has a default
    * constructor.
    public class CustomLogManager extends LogManager
        public CustomLogManager()
            super();
         * Overwritten to also add handlers
        public synchronized boolean addLogger(Logger logger)
            final boolean res = super.addLogger(logger);
            final String property = logger.getName() + ".handlers";
            if ( null != getProperty(property) )
                setHandlers(logger, property);
            return res;
        // Taken from java/util/logging/LogManager.java#initializeGlobalHandlers()
        private void setHandlers(final Logger logger, final String property)
            // We need to raise privilege here.  All our decisions will
            // be made based on the logging configuration, which can
            // only be modified by trusted code.
            AccessController.doPrivileged(new PrivilegedAction() {
                public Object run() {
                    // Add new global handlers.
                    String names[] = parseClassNames(property);
                    for (int i = 0; i < names.length; i++) {
                        String word = names;
    try {
    Class clz = ClassLoader.getSystemClassLoader().loadClass(word);
    Handler h = (Handler) clz.newInstance();
    try {
    // Check if there is a property defining the
    // handler's level.
    String levs = getProperty(word + ".level");
    if (levs != null) {
    h.setLevel(Level.parse(levs));
    } catch (Exception ex) {
    System.err.println("Can't set level for " + word);
    // Probably a bad level. Drop through.
    logger.addHandler(h);
    } catch (Exception ex) {
    System.err.println("Can't load log handler \"" + word + "\"");
    System.err.println("" + ex);
    ex.printStackTrace();
    return null;
    // Taken from java/util/logging/LogManager.java
    // get a list of whitespace separated classnames from a property.
    private String[] parseClassNames(String propertyName) {
    String hands = getProperty(propertyName);
    if (hands == null) {
    return new String[0];
    hands = hands.trim();
    int ix = 0;
    Vector result = new Vector();
    while (ix < hands.length()) {
    int end = ix;
    while (end < hands.length()) {
    if (Character.isWhitespace(hands.charAt(end))) {
    break;
    if (hands.charAt(end) == ',') {
    break;
    end++;
    String word = hands.substring(ix, end);
    ix = end+1;
    word = word.trim();
    if (word.length() == 0) {
    continue;
    result.add(word);
    return (String[]) result.toArray(new String[result.size()]);
    On the other hand, it might be possible to write a reusable config class which does that kind of initialization, too.

  • Using logging.properties in weblogic 10.3.6

    Hi
    I have created logging.properties under Middleware Home and the content of property file is below
    ####################Logging.properties file content####################
    handlers = java.util.logging.ConsoleHandler,java.util.logging.FileHandler.level=INFO
    # Handler specific properties.
    # Describes specific configuration info for Handlers.
    ############################################################# default file output is in user's home directory.
    java.util.logging.FileHandler.pattern =/apps/Oracle/debug.log
    java.util.logging.FileHandler.limit = 10MB
    java.util.logging.FileHandler.count = 10
    java.util.logging.FileHandler.formatter =java.util.logging.SimpleFormatter
    java.util.logging.ConsoleHandler.level = FINE
    java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
    # Facility specific properties.
    # Provides extra control for each logger.
    # For example, set the com.xyz.foo logger to only log SEVERE
    # messages:
    oracle.oes.common.level=FINEST
    oracle.jps.authorization.level=FINEST
    oracle.jps.authorization.debugstore.level=FINESTThen I edited startWeblogic.sh under <domain_home>/bin and added the following entries to it.
    if [ "${WLS_REDIRECT_LOG}" = "" ] ; then
    echo "Starting WLS with line:"
    echo "${JAVA_HOME}/bin/java ${JAVA_VM} ${MEM_ARGS} -Dweblogic.Name=${SERVER_NAME} -Djava.security.policy=${WL_HOME}/server/lib/weblogic.policy
    ${JAVA_OPTIONS} -Djava.util.logging.config.file=/apps/Oracle/Middleware/logging.properties -Duser.home=/home/oracle ${PROXY_SETTINGS} ${SERVER_CLASS}"
    ${JAVA_HOME}/bin/java ${JAVA_VM} ${MEM_ARGS} -Dweblogic.Name=${SERVER_NAME} -Djava.security.policy=${WL_HOME}/server/lib/weblogic.policy ${JAVA_OPTIONS}
    ${PROXY_SETTINGS} ${SERVER_CLASS}
    else
    echo "Redirecting output from WLS window to ${WLS_REDIRECT_LOG}"
    ${JAVA_HOME}/bin/java ${JAVA_VM} ${MEM_ARGS} -Dweblogic.Name=${SERVER_NAME} -Djava.security.policy=${WL_HOME}/server/lib/weblogic.policy ${JAVA_OPTIONS} ->> Djava.util.logging.config.file=/apps/Oracle/Middleware/logging.properties -Duser.home=/home/oracle ${PROXY_SETTINGS} ${SERVER_CLASS} >"${WLS_REDIRECT_LOG}" 2>&1
    fiI restarted weblogic server and was hoping to see the log file in the location i specified in logging.properties. But I couldn't see the log file being generated.
    Any Help!!!

    Hi,
    The --component flag is missing.
    Solution
    Use the following command for Archiving Logs by File Size:
    beectl> modify_property --component CURRENTsite:LoggingProperties name MaxFileSize value <log_file_size>
    or
    Use the following command for Archiving Logs by Directory Size:
    beectl> modify_property --component CURRENTsite:LoggingProperties name MaxLogSize value <log_directory_size>
    Regards,
    Kal

  • Logging properties in EJB

    We are writing a new application using Sun Application server version 8. The examples in the J2EE tutorial use java.util.logging. Where is the logging properties file I need to edit to allow the use of an application specific log file rather than using the domain server.log file

    We have not tried using log4j. We are trying not to use any "third party" code even though it is freely available. I guess the question is since J2SE uses the logging.properties file why is it different in J2EE - if in fact it is different. There is nothing in the J2EE tutorial about logging although some of the examples use java.util.logging. We will investigate log4j. Thanks to one and all

  • Logging.properties

    hi,
    i used a message-driven bean for logging. logs are generated quite well. i am explicitly defining the FileHandler and Formatter in my MDB code. but i decided to use the default logging.properites file in the jre/lib directory and commented out my FileHandler and Formatter in my code. i followed the procedures in setting up the properties file but it just won't work. i tried using the properties file in an application and it works fine. do i have to configure a property when dealing with EJB's and MDB's? thanks.
    #logging.properties file
    handlers= java.util.logging.FileHandler, java.util.logging.ConsoleHandler
    .level= ALL
    java.util.logging.FileHandler.pattern = %h/com.mycom%u.log
    java.util.logging.FileHandler.limit = 50000
    java.util.logging.FileHandler.count = 1
    java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter
    java.util.logging.ConsoleHandler.level = INFO
    java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatterregards,
    andrew

    I have the same problem. the log file is created but the file is empty.
    i seem to be missing something.

  • Logging Properties issue

    sorry for the cross posting, i made a mistake in posting in the wrong forum chapter!!
    I have a small app that generates logs using jdk 1.4.2 logging api.
    I have the configurations loaded from my logging.properties file and no other configurations take place inside the code.
    The output that i get looks something like this
    Jan 11, 2002 10:05:21 AM MyClass myMethod
    SEVERE: my severe message
    How can i change the format of this printed log statement, so that I can see only the relevant portion of the log my severe message
    from changing some formatting only from the properties file. I cannot add any additional code or modify the existing logging infrastructure from my application. I have to change that setting using only the properties file.
    Thanks!

    This pattern doesn't work ? here is the content of my
    logging.properties file.
    java.util.logging.FileHandler.pattern = LOGFILE.log
    java.util.logging.FileHandler.limit = 50000
    java.util.logging.FileHandler.count = 1
    java.util.logging.FileHandler.formatter =
    java.util.logging.SimpleFormatter
    FIRST_LOGGER.Handler = java.util.logging.FileHandler
    FIRST_LOGGER.level = ALL
    SECOND_LOGGER.Handler =
    java.util.logging.FileHandler
    SECOND_LOGGER.level = ALLIt seems like you're not thoroughly reading the spec on this stuff.
    I don't think ".Handler" is even a valid property on a logger.
    Loggers aren't typically initialized with a complex configuration out of a configuration file...unless you write your own custom format. For instance, FileHandler is a class, so when you define java.util.logging.FileHandler.pattern in the config file, you're defining it for every default instance of FileHandler...so naturally both your loggers that use FileHandlers will write to the same file.
    I've never done this before, but here's what I came up with after reading the spec:
    1) define 1 subclass of FileHandler for each file you want to write to... let's call them FileHandlerA and FileHandlerB. All they have to do is extend FileHandler, nothing else.
    2) define the patterns for each subclass in the config file. You can also define any other properties you want for each handler, such as .level, .limit, .count, etc.
    mypackage.myhandlers.FileHandlerA.pattern = LogFile-A.log
    mypackage.myhandlers.FileHandlerB.pattern = LogFile-B.log
    // ... more config here
    3) define the loggers in the config file and specify the handlers to use on each:
    FIRST_LOGGER.handlers = mypackage.myhandlers.FileHandlerA
    SECOND_LOGGER.handlers = mypackage.myhandlers.FileHandlerB
    4) create your Loggers in your code:
    Logger firstLog = Logger.getLogger("FIRST_LOGGER");
    Logger secondLog = Logger.getLogger("SECOND_LOGGER");
    Good luck.

  • LOGGING.Properties(Srikanth)

    hi all
    i got two applications running on my tomcat webserver and getting logs mixed alternative among the application.i have implemented java.util.logging in de application and having a logging.properties file in my server .did any one can clear my problem to get my logs at its particular context path.,,and moreover the context is mixed with same AccessControlFilter name will it have any problem of having same filtenames for all de applications..get me a solution for this
    regards
    srikanth

    I would guess something like this:
    java.util.logging.FileHandler.formatter = etc.CustomFormatter
    Of course you have to put in the fully qualified name of the class, i.e. including the package name.

  • Logging.properties change for Applets

    I'm trying to change the property java.util.logging.FileHandler.formatter in the logging.properties file. I've specified the name of the class which extends Formatter, and changed the CLASSPATH environment variable to locate the class.
    However, the default XMLFormatter is still being used.
    I've also had problems setting Preferences and LoggingPermission permissions in the policy file. Does anyone have any success with getting this to work?
    Thanks in advance for any help you may be able to provide.

    John L. wrote:
    I'm trying to change the property java.util.logging.FileHandler.formatter in the logging.properties file. I've specified the name of the class which extends Formatter, and changed the CLASSPATH environment variable to locate the class.
    Applets in a browser run in a sandbox. And I am rather certain that the OS env classpath variable has no impact on that. I could be wrong though.
    You might want to research how applets work in general from that you might be able to determine the best way to approach your problem.

  • Question on logging to file

    I am doing java logging to file using the logger class. In order to write logs to the file, a file handler was created using the 'append' mode.
    However, when the
    log entries are written to the log file, they are all entered on a single line.
    How do I make each new log entry start on a new line?
    boolean append = true;
    FileHandler filehandler = new FileHandler(errorFile,append);
    Logger logger = Logger.getLogger("Logging");
    logger.addHandler(filehandler);
    logger.log(Level.INFO,"Unable to zip file:");

    1)Do you view the file in Microsoft Windows?
    If you are using MS Windows, please open the log file with wordpad.
    If you still find all your result are on a single line in wordpad.
    2)You can try this
    String nl = System.getProperty ( "line.separator" );
    logger.log(Level.INFO,"Unable to zip file:"+nl);

  • Best way to load messages - properties file or database?

    Hi Guys,
    I have a debate with my colleague about best way to load/keep GUI messages.
    As we known, all those messages are in properties file, web tier will handle the messages loading to GUI.
    However, my colleague suggested, we could save all the messages in a database table, when application starts up, it will load all the messages from database.
    Please help me figure out pros/cons for both ways? What's the best to deal with message loading?
    Thanks

    allemande wrote:
    Please help me figure out pros/cons for both ways?There is no big difference with regard to performance and memory use. Both are after all cached in memory at any way. I wouldn't worry about it.
    The biggest difference is in the maintainability and reusability. Propertiesfiles are just textbased files. You can just edit the messages using any text editor. It is only a bit harder to wrap it in a UI like thing, but you can achieve a lot using java.util.Properties API with its load() and store() methods. Another concern is that it cannot be used anymore if you switch from platform language (e.g. Java --> C# or so) without writing some custom tool to read Java style properties files at any way. Databases, on the other hand, require SQL knowledge or some UI tool to edit the contents. So you have to create a UI like thing at any way if you want to let someone with less knowledge edit the messages. This is more time consuming. But it can universally be used by any application/platform by just using SQL standard.

  • Log.properties

    below is the log.properties file but this is not able to generate new log file every hour.
    so please help me to point out what modification should be needed.
    # This file is to configure the logs that xellerate produces via log4j.
    # this file is used by Websphere and Weblogic. If JBoss is used
    # to host Xellerate, the file that needs to be modified is jboss-log4j.xml under
    # the JBoss directory: <jboss_home>/server/default/conf. Since
    # this file is used for the whole JBoss log configuration, a Xellerate
    # tag is used to define the level to log:
    # <category name="XELLERATE">
    # <priority value="WARN"/>
    # </category>
    # That is equivalent to the line below:
    # log4j.logger.XELLERATE=WARN
    # If specific categories need to be logged as in the case of the commented
    # categories below, a new category can be added after the "XELLERATE" category
    # in the jboss-log4j.xml file for JBoss. For instance "XELLERATE.ACCOUNTMANAGEMENT"
    # as below, would be like the following in jboss-log4j.xml:
    # <category name="XELLERATE.ACCOUNTMANAGEMENT">
    # <priority value="DEBUG"/>
    # </category>
    # In the case of Weblogic or Weblogic, uncommenting the category below would
    # be enough.
    # Any changes to the log configuration need to be follow by a restart of the
    # Application Server.
    # For more information about log4j, please refer to http://logging.apache.org/log4j/docs/
    # The below configuration sets the output of the log to be to the
    # standard output. In the case of JBoss it is to the console and
    # for Websphere and Weblogic to the log file.
    # Commentted below is "logfile" in addition to stdout. If you want
    # the output to be sent to a specific file un-comment the line below
    # and comment the one without the "logfile" entry.
    log4j.rootLogger=WARN,stdout,logfile
    #log4j.rootLogger=WARN,stdout
    # Console Appender
    # The configuration below is to configure the way the log will be formatted
    # when it is output to the console.
    log4j.appender.stdout=org.apache.log4j.ConsoleAppender
    log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
    log4j.appender.stdout.layout.ConversionPattern=%5p,%d{dd MMM yyyy HH:mm:ss,SSS},[%c],%m%n
    # File Appender
    # Uncomment if you want to output to a file and change the file name and path
    log4j.appender.logfile=org.apache.log4j.DailyRollingFileAppender
    log4j.appender.logfile.DatePattern='.'yyyy-MM-dd-HH
    log4j.appender.logfile.File=F:/OIM/oimserver/logs/OIMLOG.log
    log4j.appender.logfile.MaxBackupIndex=20
    log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
    log4j.appender.logfile.layout.ConversionPattern=%p %t %c - %m%n
    # Below are the different categories supported by Xellerate
    # commented out. The Root Category, .XELLERATE, is not commented
    # out and it's set to WARN. This means that every category is set
    # to WARN level unless specifically changed. Each category can be
    # uncommented and the level can be changed individually while
    # the root is still on WARN (for all other categories with log level
    # not defined).
    # The following are the accepted levels:
    # DEBUG - The DEBUG Level designates fine-grained informational events
    # that are most useful to debug an application.
    # INFO - The INFO level designates informational messages that highlight
    # the progress of the application at coarse-grained level.
    # WARN - The WARN level designates potentially harmful situations.
    # ERROR - The ERROR level designates error events that might still allow
    # the application to continue running.
    # FATAL - The FATAL level designates very severe error events that will
    # presumably lead the application to abort.
    # Special Levels:
    # ALL - The ALL Level has the lowest possible rank and is intended to turn on all logging.
    # OFF - The OFF Level has the highest possible rank and is intended to turn off logging.
    # XELLERATE #
    log4j.logger.XELLERATE=WARN
    # We would like to have DDM operations at the DEBUG level
    # as we may not have a second chance to perform the same
    # operation if something fails
    log4j.logger.XELLERATE.DDM=DEBUG
    #log4j.logger.XELLERATE.ACCOUNTMANAGEMENT=DEBUG
    #log4j.logger.XELLERATE.SERVER=DEBUG
    #log4j.logger.XELLERATE.RESOURCEMANAGEMENT=DEBUG
    #log4j.logger.XELLERATE.REQUESTS=DEBUG
    #log4j.logger.XELLERATE.WORKFLOW=DEBUG
    #log4j.logger.XELLERATE.WEBAPP=DEBUG
    #log4j.logger.XELLERATE.SCHEDULER=DEBUG
    #log4j.logger.XELLERATE.SCHEDULER.Task=DEBUG
    #log4j.logger.XELLERATE.ADAPTERS=DEBUG
    #log4j.logger.XELLERATE.JAVACLIENT=DEBUG
    #log4j.logger.XELLERATE.POLICIES=DEBUG
    #log4j.logger.XELLERATE.RULES=DEBUG
    #log4j.logger.XELLERATE.DATABASE=DEBUG
    #log4j.logger.XELLERATE.APIS=DEBUG
    #log4j.logger.XELLERATE.OBJECTMANAGEMENT=DEBUG
    #log4j.logger.XELLERATE.JMS=DEBUG
    #log4j.logger.XELLERATE.REMOTEMANAGER=DEBUG
    #log4j.logger.XELLERATE.CACHEMANAGEMENT=DEBUG
    #log4j.logger.XELLERATE.ATTESTATION=DEBUG
    #log4j.logger.XELLERATE.AUDITOR=DEBUG
    #log4j.logger.XELLERATE.PERFORMANCE=DEBUG
    # SPML Webservice #
    log4j.logger.SPMLWS=WARN
    log4j.logger.SPMLWS.OIMEvent=DEBUG
    # Nexaweb #
    log4j.logger.com.nexaweb.server=WARN
    # OSCache #
    log4j.logger.com.opensymphony.oscache=ERROR

    Why are you expecting to generate a new log file every hour ? It will keep updating the same log file and archive it ...
    Thanks
    Suren

  • Specifying a path to loada properties file

    I'm trying to load a properties file in java, the properties file is located in
    META-INF/sample.properties
    the class that loads the properties is in
    WEB-INF/classes/com/pkg1/pkg2/pkg3/pkg4/samplepgm.java
    how do I specify the path to load the properties file...

    you can only add images by using the place-function
    so you need to address the rectangle where the image is placed in.
    you can use use scriptlabels and then you can use something in the terms of
    document.Rectangles.Item("image").place(linktoyourfile)

Maybe you are looking for

  • How to display 2 lines of fieldcat in alv

    hi,all.    I wonder how to display 2 lines of fieldcat in alv,no matter grid,list ,oo.   whatever.    thanks in anvance.

  • Regd. Detailed steps for creating BS,TechSys, SWC etc in SLD

    Hi Experts ! Can some one share a good detailed document on  the steps performed in SLD  like creation of product, software componet and how to create and link the Technical system and business systems. What are the various dependencies to be maintai

  • RME Fireface 800 iMac G5

    I recently purchased an RME FF 800 to use with my home recording projects. I use it to mainly record myself playing guitar with added loops in logic pro. The Total MIx to me is hard to undrstand. I was also told recently to disable software monitorin

  • Oracle9iAS and .swf flash from Macromedia

    I received a .swf file with connection via .ASP pages to a SQL-Server Database and want to change the environment to an Oracle 9iAS 8.1.7.3 Database. Since .ASP pages do not work in Oracle 9iAS : How can I manage to access the Oracle Database on the

  • Microsoft Messenger or Ebuddy connects and disconnects

    Hello I've just bought my iPhone 4 a month ago. I'm very happy with it (formerly a BlackBerry user) but there's an issue that is driving me crazy. I've installed Microsoft Messenger and it connects and disconnects every 3 minutes. Also I've tried wit